From 6845b5d6929d1ed5ca0a00d6a75fc622d8ad54c2 Mon Sep 17 00:00:00 2001 From: zorkow Date: Wed, 3 Jun 2020 12:46:26 +0100 Subject: [PATCH 001/142] Adds ip command. --- ts/input/tex/physics/PhysicsMappings.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index e8efecd76..758d9b946 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -224,6 +224,7 @@ new CommandMap('Physics-bra-ket-macros', { 'bra': 'Bra', 'ket': 'Ket', 'innerproduct': 'BraKet', + 'ip': 'BraKet', 'braket': 'BraKet', 'outerproduct': 'KetBra', 'dyad': 'KetBra', From a44ad182b1ac6dd8c0ba89a6facac3ad459db847 Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 1 Oct 2020 00:57:43 +0100 Subject: [PATCH 002/142] Conversion of mathtools. --- .../tex/mathtools/MathtoolsConfiguration.ts | 200 ++++++++++++++++++ 1 file changed, 200 insertions(+) create mode 100644 ts/input/tex/mathtools/MathtoolsConfiguration.ts diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts new file mode 100644 index 000000000..a1fe06467 --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -0,0 +1,200 @@ +/************************************************************* + * Copyright (c) 2019-2020 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +import {ArrayItem} from '../base/BaseItems.js'; +import {MultlineItem} from '../ams/AmsItems.js'; +import {StackItem} from '../StackItem.js'; +import ParseUtil from '../ParseUtil.js'; +import ParseMethods from '../ParseMethods.js'; +import {Configuration} from '../Configuration.js'; +import {ParseMethod} from '../Types.js'; +import {AmsMethods} from '../ams/AmsMethods.js'; +import BaseMethods from '../base/BaseMethods.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; +import {CommandMap, EnvironmentMap} from '../SymbolMap.js'; +import NodeUtil from '../NodeUtil.js'; +import {TexConstant} from '../TexConstants.js'; + + +let MathtoolsMethods: Record = {}; + +export class MultlinedItem extends MultlineItem { + + /** + * @override + */ + get kind() { + return 'multlined'; + } + + + /** + * @override + */ + public EndTable() { + if (this.Size() || this.row.length) { + this.EndEntry(); + this.EndRow(); + } + if (this.table.length) { + let first = NodeUtil.getChildren(this.table[0])[0]; + let m = this.table.length - 1; + if (NodeUtil.getAttribute(first, 'columnalign') !== TexConstant.Align.RIGHT) { + first.appendChild( + this.create('node', 'mspace', [], + { width: this.factory.configuration.options['MultlineGap'] || '2em' }) + ); + } + let last = NodeUtil.getChildren(this.table[m])[0]; + if (NodeUtil.getAttribute( + last, 'columnalign') !== TexConstant.Align.LEFT) { + let top = last.childNodes[0] as MmlNode; + top.childNodes.unshift(null); + NodeUtil.setChild(top, 0, + this.create('node', 'mspace', [], + { width: this.factory.configuration.options['MultlineGap'] || '2em' }) + ); + } + } + super.EndTable.call(this); + } + +} + + +MathtoolsMethods.MtMatrix = function(parser: TexParser, begin: StackItem, open, close) { + const align = parser.GetBrackets('\\begin{' + begin.getName() + '}') || 'c'; + return BaseMethods.Array(parser, begin, open, close, align); +}, + +MathtoolsMethods.MtSmallMatrix = function(parser: TexParser, begin: StackItem, open, close, align) { + if (!align) { + align = parser.GetBrackets('\\begin{' + begin.getName() + '}') || 'c'; + } + return BaseMethods.Array(parser, begin, + open, + close, + align, + ParseUtil.Em(1 / 3), + '.2em', + 'S', + 1 + ); +}, + +MathtoolsMethods.MtMultlined = function(parser: TexParser, begin: StackItem) { + let pos = parser.GetBrackets('\\begin{' + begin.getName() + '}') || ''; + let width = pos ? parser.GetBrackets('\\begin{' + begin.getName() + '}') : null; + if (!pos.match(/^[cbt]$/)) { + let tmp = width; + width = pos; + pos = tmp; + } + parser.Push(begin); + let item = parser.itemFactory.create('multlined', parser, begin) as ArrayItem; + item.arraydef = { + displaystyle: true, + rowspacing: '.5em', + width: width || parser.options['multlineWidth'], + columnwidth: '100%', + }; + return ParseUtil.setArrayAlign(item as ArrayItem, pos || 'c'); +}; + +MathtoolsMethods.HandleShove = function(parser: TexParser, name: string, shove: string) { + let top = parser.stack.Top(); + if (top.kind !== 'multline' && top.kind !== 'multlined') { + throw new TexError( + 'CommandInMultlined', + '%1 can only appear within the multline or multlined environments', + name); + } + if (top.Size()) { + throw new TexError( + 'CommandAtTheBeginingOfLine', + '%1 must come at the beginning of the line', + name); + } + top.setProperty('shove', shove); + let shift = parser.GetBrackets(name); + let mml = parser.ParseArg(name); + if (shift) { + let mrow = parser.create('node', 'mrow', []); + let mspace = parser.create('node', 'mspace', [], { width: shift }); + if (shove === 'left') { + mrow.appendChild(mspace); + mrow.appendChild(mml); + } else { + mrow.appendChild(mml); + mrow.appendChild(mspace); + } + mml = mrow; + } + parser.Push(mml); +}; + + +MathtoolsMethods.Array = BaseMethods.Array; +MathtoolsMethods.Macro = BaseMethods.Macro; +MathtoolsMethods.xArrow = AmsMethods.xArrow; + + +new CommandMap('mathtools-macros', { + shoveleft: ['HandleShove', TexConstant.Align.LEFT], + shoveright: ['HandleShove', TexConstant.Align.RIGHT], + + coloneqq: ['Macro', '\\mathrel{≔}'], + xleftrightarrow: ['xArrow', 0x2194, 7, 6] +}, MathtoolsMethods); + + +new EnvironmentMap('mathtools-environment', ParseMethods.environment, { + dcases: ['Array', null, '\\{', '.', 'll', null, '.2em', 'D'], + 'matrix*': ['MtMatrix', null, null, null], + 'pmatrix*': ['MtMatrix', null, '(', ')'], + 'bmatrix*': ['MtMatrix', null, '[', ']'], + 'Bmatrix*': ['MtMatrix', null, '\\{', '\\}'], + 'vmatrix*': ['MtMatrix', null, '\\vert', '\\vert'], + 'Vmatrix*': ['MtMatrix', null, '\\Vert', '\\Vert'], + + 'smallmatrix*': ['MtSmallMatrix', null, null, null], + psmallmatrix: ['MtSmallMatrix', null, '(', ')', 'c'], + 'psmallmatrix*': ['MtSmallMatrix', null, '(', ')'], + bsmallmatrix: ['MtSmallMatrix', null, '[', ']', 'c'], + 'bsmallmatrix*': ['MtSmallMatrix', null, '[', ']'], + Bsmallmatrix: ['MtSmallMatrix', null, '\\{', '\\}', 'c'], + 'Bsmallmatrix*': ['MtSmallMatrix', null, '\\{', '\\}'], + vsmallmatrix: ['MtSmallMatrix', null, '\\vert', '\\vert', 'c'], + 'vsmallmatrix*': ['MtSmallMatrix', null, '\\vert', '\\vert'], + Vsmallmatrix: ['MtSmallMatrix', null, '\\Vert', '\\Vert', 'c'], + 'Vsmallmatrix*': ['MtSmallMatrix', null, '\\Vert', '\\Vert'], + + multlined: 'MtMultlined', +}, MathtoolsMethods); + + +export const MathtoolsConfiguration = Configuration.create( + 'mathtools', { + handler: { + macro: ['mathtools-macros'], + environment: ['mathtools-environment'] + }, + items: {[MultlinedItem.prototype.kind]: MultlinedItem} + } +); From a2f836495005abdad94452e864278387b14f5c1b Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 1 Oct 2020 01:08:45 +0100 Subject: [PATCH 003/142] Correction and cleanup. --- .../tex/mathtools/MathtoolsConfiguration.ts | 22 +++++++------------ 1 file changed, 8 insertions(+), 14 deletions(-) diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts index a1fe06467..1c900dddd 100644 --- a/ts/input/tex/mathtools/MathtoolsConfiguration.ts +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -66,10 +66,10 @@ export class MultlinedItem extends MultlineItem { last, 'columnalign') !== TexConstant.Align.LEFT) { let top = last.childNodes[0] as MmlNode; top.childNodes.unshift(null); - NodeUtil.setChild(top, 0, - this.create('node', 'mspace', [], - { width: this.factory.configuration.options['MultlineGap'] || '2em' }) - ); + const space = this.create( + 'node', 'mspace', [], + { width: this.factory.configuration.options['MultlineGap'] || '2em' }); + NodeUtil.setChild(top, 0, space); } } super.EndTable.call(this); @@ -83,19 +83,13 @@ MathtoolsMethods.MtMatrix = function(parser: TexParser, begin: StackItem, open, return BaseMethods.Array(parser, begin, open, close, align); }, -MathtoolsMethods.MtSmallMatrix = function(parser: TexParser, begin: StackItem, open, close, align) { +MathtoolsMethods.MtSmallMatrix = function( + parser: TexParser, begin: StackItem, open, close, align) { if (!align) { align = parser.GetBrackets('\\begin{' + begin.getName() + '}') || 'c'; } - return BaseMethods.Array(parser, begin, - open, - close, - align, - ParseUtil.Em(1 / 3), - '.2em', - 'S', - 1 - ); + return BaseMethods.Array( + parser, begin, open, close, align, ParseUtil.Em(1 / 3), '.2em', 'S', 1); }, MathtoolsMethods.MtMultlined = function(parser: TexParser, begin: StackItem) { From 7c4f3af883d78944adc2e152ca4b4d5f1b59b29d Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 1 Oct 2020 01:29:13 +0100 Subject: [PATCH 004/142] Adds two missing case macros. --- ts/input/tex/mathtools/MathtoolsConfiguration.ts | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts index 1c900dddd..6faf3f4fb 100644 --- a/ts/input/tex/mathtools/MathtoolsConfiguration.ts +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -160,6 +160,8 @@ new CommandMap('mathtools-macros', { new EnvironmentMap('mathtools-environment', ParseMethods.environment, { dcases: ['Array', null, '\\{', '.', 'll', null, '.2em', 'D'], + rcases: ['Array', null, '.', '\\}', 'll', null, '.2em', 'D'], + drcases: ['Array', null, '\\{', '\\}', 'll', null, '.2em', 'D'], 'matrix*': ['MtMatrix', null, null, null], 'pmatrix*': ['MtMatrix', null, '(', ')'], 'bmatrix*': ['MtMatrix', null, '[', ']'], From b93a19c2d609464effa01cc98d0dd0fba575b769 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 23 Feb 2021 16:27:03 -0500 Subject: [PATCH 005/142] Add empheq and numcases environments --- .../input/tex/extensions/empheq/build.json | 4 + .../src/input/tex/extensions/empheq/empheq.js | 1 + .../tex/extensions/empheq/webpack.config.js | 12 + .../input/tex/extensions/numcases/build.json | 4 + .../input/tex/extensions/numcases/numcases.js | 1 + .../tex/extensions/numcases/webpack.config.js | 14 + ts/input/tex/empheq/EmpheqConfiguration.ts | 262 ++++++++++++++++++ .../tex/numcases/NumcasesConfiguration.ts | 167 +++++++++++ 8 files changed, 465 insertions(+) create mode 100644 components/src/input/tex/extensions/empheq/build.json create mode 100644 components/src/input/tex/extensions/empheq/empheq.js create mode 100644 components/src/input/tex/extensions/empheq/webpack.config.js create mode 100644 components/src/input/tex/extensions/numcases/build.json create mode 100644 components/src/input/tex/extensions/numcases/numcases.js create mode 100644 components/src/input/tex/extensions/numcases/webpack.config.js create mode 100644 ts/input/tex/empheq/EmpheqConfiguration.ts create mode 100644 ts/input/tex/numcases/NumcasesConfiguration.ts diff --git a/components/src/input/tex/extensions/empheq/build.json b/components/src/input/tex/extensions/empheq/build.json new file mode 100644 index 000000000..681da096b --- /dev/null +++ b/components/src/input/tex/extensions/empheq/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/empheq", + "targets": ["input/tex/empheq"] +} diff --git a/components/src/input/tex/extensions/empheq/empheq.js b/components/src/input/tex/extensions/empheq/empheq.js new file mode 100644 index 000000000..35d50ed09 --- /dev/null +++ b/components/src/input/tex/extensions/empheq/empheq.js @@ -0,0 +1 @@ +import './lib/empheq.js'; diff --git a/components/src/input/tex/extensions/empheq/webpack.config.js b/components/src/input/tex/extensions/empheq/webpack.config.js new file mode 100644 index 000000000..5befec567 --- /dev/null +++ b/components/src/input/tex/extensions/empheq/webpack.config.js @@ -0,0 +1,12 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'empheq', // the package to build + '../../../../../js', // location of the compiled js files + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); + diff --git a/components/src/input/tex/extensions/numcases/build.json b/components/src/input/tex/extensions/numcases/build.json new file mode 100644 index 000000000..412c9d56f --- /dev/null +++ b/components/src/input/tex/extensions/numcases/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/numcases", + "targets": ["input/tex/numcases"] +} diff --git a/components/src/input/tex/extensions/numcases/numcases.js b/components/src/input/tex/extensions/numcases/numcases.js new file mode 100644 index 000000000..f383ce4ae --- /dev/null +++ b/components/src/input/tex/extensions/numcases/numcases.js @@ -0,0 +1 @@ +import './lib/numcases.js'; diff --git a/components/src/input/tex/extensions/numcases/webpack.config.js b/components/src/input/tex/extensions/numcases/webpack.config.js new file mode 100644 index 000000000..5c000550d --- /dev/null +++ b/components/src/input/tex/extensions/numcases/webpack.config.js @@ -0,0 +1,14 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'numcases', // the package to build + '../../../../../js', // location of the compiled js files + [ // packages to link to (relative to Mathjax components) + 'components/src/input/tex-base/lib', + 'components/src/input/tex/extensions/ams/lib', + 'components/src/input/tex/extensions/empheq/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); + diff --git a/ts/input/tex/empheq/EmpheqConfiguration.ts b/ts/input/tex/empheq/EmpheqConfiguration.ts new file mode 100644 index 000000000..8b310e8c5 --- /dev/null +++ b/ts/input/tex/empheq/EmpheqConfiguration.ts @@ -0,0 +1,262 @@ +import {Configuration} from '../Configuration.js'; +import {CommandMap, EnvironmentMap} from '../SymbolMap.js'; +import ParseUtil from '../ParseUtil.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import {AbstractTags} from '../Tags.js'; +import {BeginItem} from '../base/BaseItems.js'; +import {StackItem} from '../StackItem.js'; +import {AbstractMmlNode, MmlNode, TextNode} from '../../../core/MmlTree/MmlNode.js'; +import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; +import {MmlMtd} from '../../../core/MmlTree/MmlNodes/mtd.js'; + +export class EmpheqBeginItem extends BeginItem { + public options = {}; + + public get kind() { + return 'empheq-begin'; + } + + public checkItem(item: StackItem) { + if (item.isKind('end') && item.getName() === this.getName()) { + this.setProperty('end', false); + } + return super.checkItem(item); + } +} + +export const EmpheqUtil = { + + environment(parser: TexParser, env: string, func: Function, args: any[]) { + const name = args[0]; + const item = parser.itemFactory.create(name + '-begin').setProperties({name: env, end: name}); + parser.Push(func(parser, item, ...args.slice(1))); + }, + + copyMml(node: MmlNode) { + if (!node) return null; + const mml = (node as AbstractMmlNode).factory.create(node.kind); + if (node.isKind('text')) { + (mml as TextNode).setText((node as TextNode).getText()); + return mml; + } + if (node.attributes) { + const attributes = node.attributes.getAllAttributes(); + for (const name of Object.keys(attributes)) { + if (name !== 'id') { + mml.attributes.set(name, attributes[name]); + } + } + } + if (node.childNodes && node.childNodes.length) { + let children = node.childNodes; + if (children.length === 1 && children[0].isKind('inferredMrow')) { + children = children[0].childNodes; + } + for (const child of children) { + if (child) mml.appendChild(this.copyMml(child)); + } + } + return mml; + }, + + splitOptions(text: string, allowed: {[key: string]: number} = null) { + return ParseUtil.keyvalOptions(text, allowed, true); + }, + + columnCount(table: MmlMtable) { + let m = 0; + for (const row of table.childNodes) { + const n = row.childNodes.length - (row.isKind('mlabeledtr') ? 1 : 0); + if (n > m) m = n; + } + return m; + }, + + cellBlock(tex: string, table: MmlMtable, parser: TexParser, env: string) { + const mpadded = parser.create('node', 'mpadded', [], {height: 0, depth: 0, voffset: '-1height'}); + const result = new TexParser(tex, parser.stack.env, parser.configuration); + const mml = result.mml(); + if (env && result.configuration.tags.label) { + (result.configuration.tags.currentTag as any).env = env; + (result.configuration.tags as AbstractTags).getTag(true); + } + for (const child of (mml.isInferred ? mml.childNodes : [mml])) { + mpadded.appendChild(child); + } + mpadded.appendChild(parser.create('node', 'mphantom', [ + parser.create('node', 'mpadded', [table], {width: 0}) + ])); + return mpadded; + }, + + topRowTable(original: MmlMtable, parser: TexParser) { + const table = this.copyMml(original); + table.setChildren(table.childNodes.slice(0, 1)); + table.attributes.set('align', 'baseline 1'); + return original.factory.create('mphantom', {}, [parser.create('node', 'mpadded', [table], {width: 0})]); + }, + + rowspanCell(mtd: MmlMtd, tex: string, table: MmlMtable, parser: TexParser, env: string) { + mtd.appendChild( + parser.create('node', 'mpadded', [ + this.cellBlock(tex, this.copyMml(table), parser, env), + this.topRowTable(table, parser) + ], {height: 0, depth: 0, voffset: 'height'}) + ); + }, + + left(table: MmlMtable, original: MmlMtable, left: string, parser: TexParser, env: string = '') { + table.attributes.set('columnalign', 'right ' + (table.attributes.get('columnalign') || '')); + table.attributes.set('columnspacing', '0em ' + (table.attributes.get('columnspacing') || '')); + let mtd; + for (const row of table.childNodes.slice(0).reverse()) { + mtd = parser.create('node', 'mtd'); + row.childNodes.unshift(mtd); + row.replaceChild(mtd, mtd); // make sure parent is set + if (row.isKind('mlabeledtr')) { + row.childNodes[0] = row.childNodes[1]; + row.childNodes[1] = mtd; + } + } + this.rowspanCell(mtd, left, original, parser, env); + }, + + right(table: MmlMtable, original: MmlMtable, right: string, parser: TexParser, env: string = '') { + if (table.childNodes.length === 0) { + table.appendChild(parser.create('node', 'mtr')); + } + const m = EmpheqUtil.columnCount(table); + const row = table.childNodes[0]; + while (row.childNodes.length < m) row.appendChild(parser.create('node', 'mtd')); + const mtd = row.appendChild(parser.create('node', 'mtd')) as MmlMtd; + EmpheqUtil.rowspanCell(mtd, right, original, parser, env); + table.attributes.set( + 'columnalign', + (table.attributes.get('columnalign') as string || '').split(/ /).slice(0, m).join(' ') + ' left' + ); + table.attributes.set( + 'columnspacing', + (table.attributes.get('columnspacing') as string || '').split(/ /).slice(0, m - 1).join(' ') + ' 0em' + ); + }, + + adjustTable(empheq: EmpheqBeginItem, parser: TexParser) { + const options = empheq.options as {left: string, right: string}; + if (options.left || options.right) { + const table = empheq.Last; + const original = this.copyMml(table); + if (options.left) this.left(table, original, options.left, parser); + if (options.right) this.right(table, original, options.right, parser); + } + }, + + allowEnv: { + equation: true, + align: true, + gather: true, + flalign: true, + alignat: true, + multline: true + }, + + checkEnv(env: string) { + return this.allowEnv[env.replace(/\*$/, '')] || false; + } + +}; + +export const EmpheqMethods = { + Empheq(parser: TexParser, begin: EmpheqBeginItem) { + if (parser.stack.env.closing === begin.getName()) { + delete parser.stack.env.closing; + parser.Push(parser.itemFactory.create('end').setProperty('name', parser.stack.global.empheq)); + parser.stack.global.empheq = ''; + const empheq = parser.stack.Top() as EmpheqBeginItem; + EmpheqUtil.adjustTable(empheq, parser); + parser.Push(parser.itemFactory.create('end').setProperty('name', 'empheq')); + } else { + ParseUtil.checkEqnEnv(parser); + delete parser.stack.global.eqnenv; + const opts = parser.GetBrackets('\\begin{' + begin.getName() + '}') || ''; + const [env, n] = (parser.GetArgument('\\begin{' + begin.getName() + '}') || '').split(/=/); + if (!EmpheqUtil.checkEnv(env)) { + throw new TexError('UnknownEnv', 'Unknown environment "%1"', env); + } + begin.options = (opts ? EmpheqUtil.splitOptions(opts, {left: 1, right: 1}) : {}); + parser.stack.global.empheq = env; + parser.string = '\\begin{' + env + '}' + (n ? '{' + n + '}' : '') + parser.string.slice(parser.i); + parser.i = 0; + parser.Push(begin); + } + }, + + EmpheqMO(parser: TexParser, _name: string, c: string) { + parser.Push(parser.create('token', 'mo', {}, c)); + }, + + EmpheqDelim(parser: TexParser, name: string) { + const c = parser.GetDelimiter(name); + parser.Push(parser.create('token', 'mo', {stretchy: true, symmetric: true}, c)); + } + +}; + +// +// Define an environment map to add the new empheq environment +// +new EnvironmentMap('empheq-env', EmpheqUtil.environment, { + empheq: ['Empheq', 'empheq'], +}, EmpheqMethods); + +new CommandMap('empheq-macros', { + empheqlbrace: ['EmpheqMO', '{'], + empheqrbrace: ['EmpheqMO', '}'], + empheqlbrack: ['EmpheqMO', '['], + empheqrbrack: ['EmpheqMO', ']'], + empheqlangle: ['EmpheqMO', '\u27E8'], + empheqrangle: ['EmpheqMO', '\u27E9'], + empheqlparen: ['EmpheqMO', '('], + empheqrparen: ['EmpheqMO', ')'], + empheqlvert: ['EmpheqMO', '|'], + empheqrvert: ['EmpheqMO', '|'], + empheqlVert: ['EmpheqMO', '\u2016'], + empheqrVert: ['EmpheqMO', '\u2016'], + empheqlfloor: ['EmpheqMO', '\u230A'], + empheqrfloor: ['EmpheqMO', '\u230B'], + empheqlceil: ['EmpheqMO', '\u2308'], + empheqrceil: ['EmpheqMO', '\u2309'], + empheqbiglbrace: ['EmpheqMO', '{'], + empheqbigrbrace: ['EmpheqMO', '}'], + empheqbiglbrack: ['EmpheqMO', '['], + empheqbigrbrack: ['EmpheqMO', ']'], + empheqbiglangle: ['EmpheqMO', '\u27E8'], + empheqbigrangle: ['EmpheqMO', '\u27E9'], + empheqbiglparen: ['EmpheqMO', '('], + empheqbigrparen: ['EmpheqMO', ')'], + empheqbiglvert: ['EmpheqMO', '|'], + empheqbigrvert: ['EmpheqMO', '|'], + empheqbiglVert: ['EmpheqMO', '\u2016'], + empheqbigrVert: ['EmpheqMO', '\u2016'], + empheqbiglfloor: ['EmpheqMO', '\u230A'], + empheqbigrfloor: ['EmpheqMO', '\u230B'], + empheqbiglceil: ['EmpheqMO', '\u2308'], + empheqbigrceil: ['EmpheqMO', '\u2309'], + empheql: 'EmpheqDelim', + empheqr: 'EmpheqDelim', + empheqbigl: 'EmpheqDelim', + empheqbigr: 'EmpheqDelim' +}, EmpheqMethods); + +// +// Define the package for our new environment +// +export const empheqConfiguration = Configuration.create('empheq', { + handler: { + macro: ['empheq-macros'], + environment: ['empheq-env'], + }, + items: { + [EmpheqBeginItem.prototype.kind]: EmpheqBeginItem + } +}); diff --git a/ts/input/tex/numcases/NumcasesConfiguration.ts b/ts/input/tex/numcases/NumcasesConfiguration.ts new file mode 100644 index 000000000..58b3ff8da --- /dev/null +++ b/ts/input/tex/numcases/NumcasesConfiguration.ts @@ -0,0 +1,167 @@ +import {Configuration} from '../Configuration.js'; +import {EnvironmentMap, MacroMap} from '../SymbolMap.js'; +import ParseUtil from '../ParseUtil.js'; +import BaseMethods from '../base/BaseMethods.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import {BeginItem, EqnArrayItem} from '../base/BaseItems.js'; +import {AmsTags} from '../ams/AmsConfiguration.js'; +import {StackItem, CheckType} from '../StackItem.js'; +import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; +import {EmpheqUtil} from '../empheq/EmpheqConfiguration.js'; + +export class CasesBeginItem extends BeginItem { + + get kind() { + return 'cases-begin'; + } + + public checkItem(item: StackItem) { + if (item.isKind('end') && item.getName() === this.getName()) { + if (this.getProperty('end')) { + this.setProperty('end', false); + return [[], true] as CheckType; + } + } + return super.checkItem(item); + } +} + +class CasesTags extends AmsTags { + protected subcounter = 0; + + public start(env: string, taggable: boolean, defaultTags: boolean) { + this.subcounter = 0; + super.start(env, taggable, defaultTags); + } + + public autoTag() { + if (this.currentTag.tag != null) return; + if (this.currentTag.env === 'subnumcases') { + if (this.subcounter === 0) this.counter++; + this.subcounter++; + this.tag(this.formatNumber(this.counter, this.subcounter), false); + } else { + if (this.subcounter === 0 || this.currentTag.env !== 'numcases-left') this.counter++; + this.tag(this.formatNumber(this.counter), false); + } + } + + public formatNumber(n: number, m: number = null) { + return n.toString() + (m === null ? '' : String.fromCharCode(0x60 + m)); + } + +} + +new EnvironmentMap('numcases-env', EmpheqUtil.environment, { + numcases: ['NumCases', 'cases'], + subnumcases: ['NumCases', 'cases'] +}, { + NumCases(parser: TexParser, begin: CasesBeginItem) { + if (parser.stack.env.closing === begin.getName()) { + delete parser.stack.env.closing; + parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); // finish eqnarray + const cases = parser.stack.Top(); + const table = cases.Last as MmlMtable; + const original = EmpheqUtil.copyMml(table) as MmlMtable; + const left = cases.getProperty('left'); + EmpheqUtil.left(table, original, left + '\\empheqlbrace\\,', parser, 'numcases-left'); + parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); + return null; + } else { + const left = parser.GetArgument('\\begin{' + begin.getName() + '}'); + begin.setProperty('left', left); + const array = BaseMethods.EqnArray(parser, begin, true, true, 'll', ) as EqnArrayItem; + array.arraydef.displaystyle = false; + array.arraydef.rowspacing = '.2em'; + array.setProperty('numCases', true); + parser.Push(begin); + return array; + } + } +}); + +new MacroMap('numcases-macros', { + '&': 'Entry' +}, { + Entry(parser: TexParser, name: string) { + if (!parser.stack.Top().getProperty('numCases')) { + return BaseMethods.Entry(parser, name); + } + parser.Push(parser.itemFactory.create('cell').setProperties({isEntry: true, name: name})); + // + // Make second column be in \text{...} + // + const tex = parser.string; + let braces = 0, i = parser.i, m = tex.length; + // + // Look through the string character by character... + // + while (i < m) { + const c = tex.charAt(i); + if (c === '{') { + // + // Increase the nested brace count and go on + // + braces++; + i++; + } else if (c === '}') { + // + // If there are too many close braces, just end (we will get an + // error message later when the rest of the string is parsed) + // Otherwise + // decrease the nested brace count, + // go on to the next character. + // + if (braces === 0) { + break; + } else { + braces--; + i++; + } + } else if (c === '&' && braces === 0) { + // + // Extra alignment tabs are not allowed in cases + // + throw new TexError('ExtraCasesAlignTab', 'Extra alignment tab in text for numcase environment'); + } else if (c === '\\' && braces === 0) { + // + // If the macro is \cr or \\, end the search, otherwise skip the macro + // (multi-letter names don't matter, as we will skip the rest of the + // characters in the main loop) + // + const cs = (tex.slice(i + 1).match(/^[a-z]+|./i) || [])[0]; + if (cs === '\\' || cs === 'cr' || cs === 'end' || cs === 'label') { + break; + } else { + i += cs.length; + } + } else { + // + // Go on to the next character + // + i++; + } + } + // + // Process the second column as text and continue parsing from there, + // + const text = tex.substr(parser.i, i - parser.i); + parser.PushAll(ParseUtil.internalMath(parser, text, 0)); + parser.i = i; + } +}); + +// +// Define the package for our new environment +// +Configuration.create('numcases', { + handler: { + environment: ['numcases-env'], + character: ['numcases-macros'] + }, + items: { + [CasesBeginItem.prototype.kind]: CasesBeginItem + }, + tags: {'numcases': CasesTags} +}); From 63b8563fd7a532bf1ba6a964b6c0f394caa6f702 Mon Sep 17 00:00:00 2001 From: Peter Krautzberger Date: Wed, 24 Feb 2021 09:39:31 +0100 Subject: [PATCH 006/142] numcases: export Configuration.create --- ts/input/tex/numcases/NumcasesConfiguration.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/numcases/NumcasesConfiguration.ts b/ts/input/tex/numcases/NumcasesConfiguration.ts index 58b3ff8da..8f1730058 100644 --- a/ts/input/tex/numcases/NumcasesConfiguration.ts +++ b/ts/input/tex/numcases/NumcasesConfiguration.ts @@ -155,7 +155,7 @@ new MacroMap('numcases-macros', { // // Define the package for our new environment // -Configuration.create('numcases', { +export const numcasesConfiguration = Configuration.create('numcases', { handler: { environment: ['numcases-env'], character: ['numcases-macros'] From f4a6d2879df32319efa803d170a348712c3d3d9f Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 24 Feb 2021 10:32:18 -0500 Subject: [PATCH 007/142] Change configuration exports to initial upper-case, and export the Numcases mthods --- ts/input/tex/empheq/EmpheqConfiguration.ts | 2 +- .../tex/numcases/NumcasesConfiguration.ts | 27 ++++++++++--------- 2 files changed, 16 insertions(+), 13 deletions(-) diff --git a/ts/input/tex/empheq/EmpheqConfiguration.ts b/ts/input/tex/empheq/EmpheqConfiguration.ts index 8b310e8c5..f1d8bdee5 100644 --- a/ts/input/tex/empheq/EmpheqConfiguration.ts +++ b/ts/input/tex/empheq/EmpheqConfiguration.ts @@ -251,7 +251,7 @@ new CommandMap('empheq-macros', { // // Define the package for our new environment // -export const empheqConfiguration = Configuration.create('empheq', { +export const EmpheqConfiguration = Configuration.create('empheq', { handler: { macro: ['empheq-macros'], environment: ['empheq-env'], diff --git a/ts/input/tex/numcases/NumcasesConfiguration.ts b/ts/input/tex/numcases/NumcasesConfiguration.ts index 8f1730058..bdf80fc75 100644 --- a/ts/input/tex/numcases/NumcasesConfiguration.ts +++ b/ts/input/tex/numcases/NumcasesConfiguration.ts @@ -27,7 +27,7 @@ export class CasesBeginItem extends BeginItem { } } -class CasesTags extends AmsTags { +export class CasesTags extends AmsTags { protected subcounter = 0; public start(env: string, taggable: boolean, defaultTags: boolean) { @@ -53,10 +53,7 @@ class CasesTags extends AmsTags { } -new EnvironmentMap('numcases-env', EmpheqUtil.environment, { - numcases: ['NumCases', 'cases'], - subnumcases: ['NumCases', 'cases'] -}, { +export const NumcasesMethods = { NumCases(parser: TexParser, begin: CasesBeginItem) { if (parser.stack.env.closing === begin.getName()) { delete parser.stack.env.closing; @@ -78,12 +75,8 @@ new EnvironmentMap('numcases-env', EmpheqUtil.environment, { parser.Push(begin); return array; } - } -}); + }, -new MacroMap('numcases-macros', { - '&': 'Entry' -}, { Entry(parser: TexParser, name: string) { if (!parser.stack.Top().getProperty('numCases')) { return BaseMethods.Entry(parser, name); @@ -150,12 +143,22 @@ new MacroMap('numcases-macros', { parser.PushAll(ParseUtil.internalMath(parser, text, 0)); parser.i = i; } -}); + +}; + +new EnvironmentMap('numcases-env', EmpheqUtil.environment, { + numcases: ['NumCases', 'cases'], + subnumcases: ['NumCases', 'cases'] +}, NumcasesMethods); + +new MacroMap('numcases-macros', { + '&': 'Entry' +}, NumcasesMethods); // // Define the package for our new environment // -export const numcasesConfiguration = Configuration.create('numcases', { +export const NumcasesConfiguration = Configuration.create('numcases', { handler: { environment: ['numcases-env'], character: ['numcases-macros'] From 86f40005d3be66d6b59e4c310e500128a99041c4 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 23 Mar 2021 13:57:02 -0400 Subject: [PATCH 008/142] Improve handling of arbitrary Unicode in TeX input. --- ts/core/MmlTree/MmlNodes/mo.ts | 30 +------- ts/core/MmlTree/OperatorDictionary.ts | 94 ++++++++++++++++++-------- ts/input/tex/base/BaseConfiguration.ts | 15 ++-- 3 files changed, 77 insertions(+), 62 deletions(-) diff --git a/ts/core/MmlTree/MmlNodes/mo.ts b/ts/core/MmlTree/MmlNodes/mo.ts index 72006bdad..d903146b8 100644 --- a/ts/core/MmlTree/MmlNodes/mo.ts +++ b/ts/core/MmlTree/MmlNodes/mo.ts @@ -25,7 +25,7 @@ import {PropertyList} from '../../Tree/Node.js'; import {AbstractMmlTokenNode, MmlNode, AttributeList, TEXCLASS} from '../MmlNode.js'; import {MmlMrow} from './mrow.js'; import {MmlMover, MmlMunder, MmlMunderover} from './munderover.js'; -import {OperatorList, OPTABLE, RangeDef, RANGES, MMLSPACING} from '../OperatorDictionary.js'; +import {OperatorList, OPTABLE, getRange, MMLSPACING} from '../OperatorDictionary.js'; /*****************************************************************/ /** @@ -63,11 +63,6 @@ export class MmlMo extends AbstractMmlTokenNode { indentshiftlast: 'indentshift' }; - /** - * Unicode ranges and their default TeX classes - */ - public static RANGES = RANGES; - /** * The MathML spacing values for the TeX classes */ @@ -314,7 +309,7 @@ export class MmlMo extends AbstractMmlTokenNode { this.lspace = (def[0] + 1) / 18; this.rspace = (def[1] + 1) / 18; } else { - let range = this.getRange(mo); + let range = getRange(mo); if (range) { if (this.getProperty('texClass') === undefined) { this.texClass = range[2]; @@ -363,25 +358,4 @@ export class MmlMo extends AbstractMmlTokenNode { return forms; } - /** - * @param {string} mo The character to look up in the range table - * @return {RangeDef} The unicode range in which the character falls, or null - */ - protected getRange(mo: string): RangeDef { - if (!mo.match(/^[\uD800-\uDBFF]?.$/)) { - return null; - } - let n = mo.codePointAt(0); - let ranges = (this.constructor as typeof MmlMo).RANGES; - for (const range of ranges) { - if (range[0] <= n && n <= range[1]) { - return range; - } - if (n < range[0]) { - return null; - } - } - return null; - } - } diff --git a/ts/core/MmlTree/OperatorDictionary.ts b/ts/core/MmlTree/OperatorDictionary.ts index 9733a2af0..a7b570a31 100644 --- a/ts/core/MmlTree/OperatorDictionary.ts +++ b/ts/core/MmlTree/OperatorDictionary.ts @@ -80,36 +80,74 @@ export const MO = { * The default TeX classes for the various unicode blocks, and their names */ export const RANGES: RangeDef[] = [ - [0x20, 0x7F, TEXCLASS.REL, 'BasicLatin'], - [0xA0, 0xFF, TEXCLASS.ORD, 'Latin1Supplement'], - [0x100, 0x17F, TEXCLASS.ORD, 'LatinExtendedA'], - [0x180, 0x24F, TEXCLASS.ORD, 'LatinExtendedB'], - [0x2B0, 0x2FF, TEXCLASS.ORD, 'SpacingModLetters'], - [0x300, 0x36F, TEXCLASS.ORD, 'CombDiacritMarks'], - [0x370, 0x3FF, TEXCLASS.ORD, 'GreekAndCoptic'], - [0x1E00, 0x1EFF, TEXCLASS.ORD, 'LatinExtendedAdditional'], - [0x2000, 0x206F, TEXCLASS.PUNCT, 'GeneralPunctuation'], - [0x2070, 0x209F, TEXCLASS.ORD, 'SuperAndSubscripts'], - [0x20A0, 0x20CF, TEXCLASS.ORD, 'Currency'], - [0x20D0, 0x20FF, TEXCLASS.ORD, 'CombDiactForSymbols'], - [0x2100, 0x214F, TEXCLASS.ORD, 'LetterlikeSymbols'], - [0x2150, 0x218F, TEXCLASS.ORD, 'NumberForms'], - [0x2190, 0x21FF, TEXCLASS.REL, 'Arrows'], - [0x2200, 0x22FF, TEXCLASS.BIN, 'MathOperators'], - [0x2300, 0x23FF, TEXCLASS.ORD, 'MiscTechnical'], - [0x2460, 0x24FF, TEXCLASS.ORD, 'EnclosedAlphaNums'], - [0x2500, 0x259F, TEXCLASS.ORD, 'BoxDrawing'], - [0x25A0, 0x25FF, TEXCLASS.ORD, 'GeometricShapes'], - [0x2700, 0x27BF, TEXCLASS.ORD, 'Dingbats'], - [0x27C0, 0x27EF, TEXCLASS.ORD, 'MiscMathSymbolsA'], - [0x27F0, 0x27FF, TEXCLASS.REL, 'SupplementalArrowsA'], - [0x2900, 0x297F, TEXCLASS.REL, 'SupplementalArrowsB'], - [0x2980, 0x29FF, TEXCLASS.ORD, 'MiscMathSymbolsB'], - [0x2A00, 0x2AFF, TEXCLASS.BIN, 'SuppMathOperators'], - [0x2B00, 0x2BFF, TEXCLASS.ORD, 'MiscSymbolsAndArrows'], - [0x1D400, 0x1D7FF, TEXCLASS.ORD, 'MathAlphabets'] + [0x0020, 0x007F, TEXCLASS.REL, 'mo'], // Basic Latin + [0x00A0, 0x024F, TEXCLASS.ORD, 'mi'], // Latin-1 Supplement, Latin Extended-A, Latin Extended-B + [0x02B0, 0x036F, TEXCLASS.ORD, 'mo'], // Spacing modifier letters, Combining Diacritical Marks + [0x0370, 0x1A20, TEXCLASS.ORD, 'mi'], // Greek and Coptic (through) Tai Tham + [0x1AB0, 0x1AFF, TEXCLASS.ORD, 'mo'], // Combining Diacritical Marks Extended + [0x1B00, 0x1DBF, TEXCLASS.ORD, 'mi'], // Balinese (through) Phonetic Extensions Supplement + [0x1DC0, 0x1DFF, TEXCLASS.ORD, 'mo'], // Combining Diacritical Marks Supplement + [0x1E00, 0x1FFF, TEXCLASS.ORD, 'mi'], // Latin Extended Additional, Greek Extended + [0x2000, 0x206F, TEXCLASS.ORD, 'mo'], // General Punctuation + [0x2070, 0x209F, TEXCLASS.ORD, 'mo'], // Superscript and Subscripts (through) Combining Diacritical Marks for Symbols + [0x2100, 0x214F, TEXCLASS.ORD, 'mi'], // Letterlike Symbols + [0x2150, 0x218F, TEXCLASS.ORD, 'mn'], // Number Forms + [0x2190, 0x21FF, TEXCLASS.REL, 'mo'], // Arrows + [0x2200, 0x22FF, TEXCLASS.BIN, 'mo'], // Mathematical Operators + [0x2300, 0x23FF, TEXCLASS.ORD, 'mo'], // Miscellaneous Technical + [0x2460, 0x24FF, TEXCLASS.ORD, 'mn'], // Enclosed Alphanumerics + [0x2500, 0x27EF, TEXCLASS.ORD, 'mo'], // Box Drawing (though) Miscellaneous Math Symbols-A + [0x27F0, 0x27FF, TEXCLASS.REL, 'mo'], // Supplemental Arrows-A + [0x2800, 0x28FF, TEXCLASS.ORD, 'mtext'], // Braille Patterns + [0x2900, 0x297F, TEXCLASS.REL, 'mo'], // Supplemental Arrows-B + [0x2980, 0x29FF, TEXCLASS.ORD, 'mo'], // Miscellaneous Math Symbols-B + [0x2A00, 0x2AFF, TEXCLASS.BIN, 'mo'], // Supplemental Math Operators + [0x2B00, 0x2B2F, TEXCLASS.ORD, 'mo'], // Miscellaneous Symbols and Arrows + [0x2B30, 0x2B4F, TEXCLASS.REL, 'mo'], // Arrows from above + [0x2B50, 0x2BFF, TEXCLASS.ORD, 'mo'], // Rest of above + [0x2C00, 0x2DE0, TEXCLASS.ORD, 'mi'], // Glagolitic (through) Ethipoc Extended + [0x2E00, 0x2E7F, TEXCLASS.ORD, 'mo'], // Supplemental Punctuation + [0x2E80, 0x2FDF, TEXCLASS.ORD, 'mi'], // CJK Radicals Supplement (through) Kangxi Radicals + [0x2FF0, 0x303F, TEXCLASS.ORD, 'mo'], // Ideographic Desc. Characters, CJK Symbols and Punctuation + [0x3040, 0xA82F, TEXCLASS.ORD, 'mi'], // Hiragana (through) Syloti Nagri + [0xA830, 0xA83F, TEXCLASS.ORD, 'mn'], // Common Indic Number FormsArabic Presentation Forms-A + [0xA840, 0xD7FF, TEXCLASS.ORD, 'mi'], // Phags-pa (though) Hangul Jamo Extended-B + [0xF900, 0xFDFF, TEXCLASS.ORD, 'mi'], // CJK Compatibility Ideographs (though) Arabic Presentation Forms-A + [0xFE00, 0xFE6F, TEXCLASS.ORD, 'mo'], // Variation Selector (through) Small Form Variants + [0xFE70, 0x100FF, TEXCLASS.ORD, 'mi'], // Arabic Presentation Forms-B (through) Linear B Ideograms + [0x10100, 0x1018F, TEXCLASS.ORD, 'mn'], // Aegean Numbers, Ancient Greek Numbers + [0x10190, 0x123FF, TEXCLASS.ORD, 'mi'], // Ancient Symbols (through) Cuneiform + [0x12400, 0x1247F, TEXCLASS.ORD, 'mn'], // Cuneiform Numbers and Punctuation + [0x12480, 0x1BC9F, TEXCLASS.ORD, 'mi'], // Early Dynastic Cuneiform (through) Duployan + [0x1BCA0, 0x1D25F, TEXCLASS.ORD, 'mo'], // Shorthand Format Controls (through) TaiXuan Jing Symbols + [0x1D360, 0x1D37F, TEXCLASS.ORD, 'mn'], // Counting Rod Numerals + [0x1D400, 0x1D7CD, TEXCLASS.ORD, 'mi'], // Math Alphanumeric Symbols + [0x1D7CE, 0x1D7FF, TEXCLASS.ORD, 'mn'], // Numerals from above + [0x1DF00, 0x1F7FF, TEXCLASS.ORD, 'mo'], // Mahjong Tiles (through) Geometric Shapes Extended + [0x1F800, 0x1F8FF, TEXCLASS.REL, 'mo'], // Supplemental Arrows-C + [0x1F900, 0x1F9FF, TEXCLASS.ORD, 'mo'], // Supplemental Symbols and Pictographs + [0x20000, 0x2FA1F, TEXCLASS.ORD, 'mi'], // CJK Unified Ideographs Ext. B (through) CJK Sompatibility Ideographs Supp. ]; +/** + * Get the Unicode range for the first character of a string + * + * @param {string} text The character to check + * @return {RangeDef|null} The range containing that character, or null + */ +export function getRange(text: string): RangeDef | null { + const n = text.codePointAt(0); + for (const range of RANGES) { + if (n <= range[1]) { + if (n >= range[0]) { + return range; + } + break; + } + } + return null; +} + /** * The default MathML spacing for the various TeX classes. */ diff --git a/ts/input/tex/base/BaseConfiguration.ts b/ts/input/tex/base/BaseConfiguration.ts index 5a683c9c8..61a3496f1 100644 --- a/ts/input/tex/base/BaseConfiguration.ts +++ b/ts/input/tex/base/BaseConfiguration.ts @@ -31,7 +31,7 @@ import {CharacterMap} from '../SymbolMap.js'; import * as bitem from './BaseItems.js'; import {AbstractTags} from '../Tags.js'; import './BaseMappings.js'; - +import {getRange} from '../../../core/MmlTree/OperatorDictionary.js'; /** * Remapping some ASCII characters to their Unicode operator equivalent. @@ -53,13 +53,16 @@ export function Other(parser: TexParser, char: string) { let def = font ? // @test Other Font {mathvariant: parser.stack.env['font']} : {}; - const remap = (MapHandler.getMap('remap') as CharacterMap). - lookup(char); + const remap = (MapHandler.getMap('remap') as CharacterMap).lookup(char); + const range = getRange(char); + const type = (range ? range[3] : 'mo'); // @test Other // @test Other Remap - let mo = parser.create('token', 'mo', def, (remap ? remap.char : char)); - NodeUtil.setProperty(mo, 'fixStretchy', true); - parser.configuration.addNode('fixStretchy', mo); + let mo = parser.create('token', type, def, (remap ? remap.char : char)); + if (type === 'mo') { + NodeUtil.setProperty(mo, 'fixStretchy', true); + parser.configuration.addNode('fixStretchy', mo); + } parser.Push(mo); } From e64196c073441c449aa30a0b662122438f77ca35 Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 25 Mar 2021 00:30:35 +0000 Subject: [PATCH 009/142] Adds the textcomp package. --- components/src/dependencies.js | 2 + .../input/tex/extensions/textcomp/build.json | 4 + .../input/tex/extensions/textcomp/textcomp.js | 1 + .../tex/extensions/textcomp/webpack.config.js | 12 ++ ts/input/tex/AllPackages.ts | 3 + .../tex/textcomp/TextcompConfiguration.ts | 45 +++++ ts/input/tex/textcomp/TextcompMappings.ts | 175 ++++++++++++++++++ .../tex/textmacros/TextMacrosConfiguration.ts | 2 +- 8 files changed, 243 insertions(+), 1 deletion(-) create mode 100644 components/src/input/tex/extensions/textcomp/build.json create mode 100644 components/src/input/tex/extensions/textcomp/textcomp.js create mode 100644 components/src/input/tex/extensions/textcomp/webpack.config.js create mode 100644 ts/input/tex/textcomp/TextcompConfiguration.ts create mode 100644 ts/input/tex/textcomp/TextcompMappings.ts diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..0b70050f1 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -25,6 +25,7 @@ export const dependencies = { '[tex]/physics': ['input/tex-base'], '[tex]/require': ['input/tex-base'], '[tex]/tagformat': ['input/tex-base'], + '[tex]/textcomp': ['input/tex-base', '[tex]/textmacros'], '[tex]/textmacros': ['input/tex-base'], '[tex]/unicode': ['input/tex-base'], '[tex]/verb': ['input/tex-base'] @@ -56,6 +57,7 @@ const allPackages = [ '[tex]/physics', '[tex]/require', '[tex]/tagformat', + '[tex]/textcomp', '[tex]/textmacros', '[tex]/unicode', '[tex]/verb' diff --git a/components/src/input/tex/extensions/textcomp/build.json b/components/src/input/tex/extensions/textcomp/build.json new file mode 100644 index 000000000..fe61189ae --- /dev/null +++ b/components/src/input/tex/extensions/textcomp/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/textcomp", + "targets": ["input/tex/textcomp"] +} diff --git a/components/src/input/tex/extensions/textcomp/textcomp.js b/components/src/input/tex/extensions/textcomp/textcomp.js new file mode 100644 index 000000000..23fc668bd --- /dev/null +++ b/components/src/input/tex/extensions/textcomp/textcomp.js @@ -0,0 +1 @@ +import './lib/textcomp.js'; diff --git a/components/src/input/tex/extensions/textcomp/webpack.config.js b/components/src/input/tex/extensions/textcomp/webpack.config.js new file mode 100644 index 000000000..364a539ef --- /dev/null +++ b/components/src/input/tex/extensions/textcomp/webpack.config.js @@ -0,0 +1,12 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/textcomp', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex/extensions/textmacros/lib', + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..b45892996 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -42,6 +42,7 @@ import './noerrors/NoErrorsConfiguration.js'; import './noundefined/NoUndefinedConfiguration.js'; import './physics/PhysicsConfiguration.js'; import './tagformat/TagFormatConfiguration.js'; +import './textcomp/TextcompConfiguration.js'; import './textmacros/TextMacrosConfiguration.js'; import './unicode/UnicodeConfiguration.js'; import './verb/VerbConfiguration.js'; @@ -71,6 +72,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/verb', '[tex]/configmacros', '[tex]/tagformat', + '[tex]/textcomp', '[tex]/textmacros' ); } @@ -97,5 +99,6 @@ export const AllPackages: string[] = [ 'verb', 'configmacros', 'tagformat', + 'textcomp', 'textmacros' ]; diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts new file mode 100644 index 000000000..56f6d471a --- /dev/null +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -0,0 +1,45 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the textcomp package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + */ + +import {Configuration} from '../Configuration.js'; +import './TextcompMappings.js'; + +// import {TeX} from '../../tex.js'; +// import {TextParser} from '../textmacros/TextParser.js'; +// import {TextMacrosConfiguration} from '../textmacros/TextMacrosConfiguration.js'; + + +export const TextcompConfiguration = Configuration.create( + 'textcomp', { + // config(config: ParserConfiguration, jax: TeX) { + // try { + // TextMacrosConfiguration.config(config, jax); + // } catch (e) { + // console.log(e); + // } + // }, + handler: {macro: ['textcomp']}, + } +); + diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts new file mode 100644 index 000000000..01f728de8 --- /dev/null +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -0,0 +1,175 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Mappings for the textcomp package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + */ + + +import ParseMethods from '../ParseMethods.js'; +import {CharacterMap} from '../SymbolMap.js'; +import {TexConstant} from '../TexConstants.js'; + + +/** + * Identifiers from the Textcomp package. + */ +new CharacterMap('textcomp', ParseMethods.mathchar0mi, { + + // Table 3: Predefined LATEX 2ε Text-Mode Commands + 'textasciicircum': ['\u005E', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciitilde': ['\u007E', {mathvariant: TexConstant.Variant.NORMAL}], +// 'textasteriskcentered' + 'textbackslash': ['\u005C', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbar': ['\u007C', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbraceleft': ['\u007B', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbraceright': ['\u007D', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbullet': ['\u2022', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdagger': ['\u2020', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdaggerdbl': ['\u2021', {mathvariant: TexConstant.Variant.NORMAL}], + 'textellipsis': ['\u2026', {mathvariant: TexConstant.Variant.NORMAL}], + 'textemdash': ['\u2014', {mathvariant: TexConstant.Variant.NORMAL}], + 'textendash': ['\u2013', {mathvariant: TexConstant.Variant.NORMAL}], + 'textexclamdown': ['\u00A1', {mathvariant: TexConstant.Variant.NORMAL}], + 'textgreater': ['\u003E', {mathvariant: TexConstant.Variant.NORMAL}], + 'textless': ['\u003C', {mathvariant: TexConstant.Variant.NORMAL}], + 'textordfeminine': ['\u00AA', {mathvariant: TexConstant.Variant.NORMAL}], + 'textordmasculine': ['\u00BA', {mathvariant: TexConstant.Variant.NORMAL}], + 'textparagraph': ['\u00B6', {mathvariant: TexConstant.Variant.NORMAL}], + 'textperiodcentered': ['\u00B7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textquestiondown': ['\u00BF', {mathvariant: TexConstant.Variant.NORMAL}], + 'textquotedblleft': ['\u201C', {mathvariant: TexConstant.Variant.NORMAL}], + 'textquotedblright': ['\u201D', {mathvariant: TexConstant.Variant.NORMAL}], + 'textquoteleft': ['\u2018', {mathvariant: TexConstant.Variant.NORMAL}], + 'textquoteright': ['\u2019', {mathvariant: TexConstant.Variant.NORMAL}], + 'textsection': ['\u00A7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textunderscore': ['\u005F', {mathvariant: TexConstant.Variant.NORMAL}], + 'textvisiblespace': ['\u2423', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 12: textcomp Diacritics + 'textacutedbl': ['\u02DD', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciiacute': ['\u00B4', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciibreve': ['\u02D8', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciicaron': ['\u02C7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciidieresis': ['\u00A8', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciimacron': ['\u00AF', {mathvariant: TexConstant.Variant.NORMAL}], + 'textgravedbl': ['\u02F5', {mathvariant: TexConstant.Variant.NORMAL}], + 'texttildelow': ['\u02F7', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 13: textcomp Currency Symbols + 'textbaht': ['\u0E3F', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcent': ['\u00A2', {mathvariant: TexConstant.Variant.NORMAL}], + // This is not the correct glyph + 'textcentoldstyle': ['$', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textcolonmonetary': ['\u20A1', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcurrency': ['\u00A4', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdollar': ['\u0024', {mathvariant: TexConstant.Variant.NORMAL}], + // This is not the correct glyph + 'textdollaroldstyle': ['$', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textdong': ['\u20AB', {mathvariant: TexConstant.Variant.NORMAL}], + 'texteuro': ['\u20AC', {mathvariant: TexConstant.Variant.NORMAL}], + 'textflorin': ['\u0192', {mathvariant: TexConstant.Variant.NORMAL}], + 'textguarani': ['\u20B2', {mathvariant: TexConstant.Variant.NORMAL}], + 'textlira': ['\u20A4', {mathvariant: TexConstant.Variant.NORMAL}], + 'textnaira': ['\u20A6', {mathvariant: TexConstant.Variant.NORMAL}], + 'textpeso': ['\u20B1', {mathvariant: TexConstant.Variant.NORMAL}], + 'textsterling': ['\u00A3', {mathvariant: TexConstant.Variant.NORMAL}], + 'textwon': ['\u20A9', {mathvariant: TexConstant.Variant.NORMAL}], + 'textyen': ['\u00A5', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 15: textcomp Legal Symbols + 'textcircledP': ['\u2117', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcompwordmark': ['\u200C', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcopyleft': ['\u1F12F', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcopyright': ['\u00A9', {mathvariant: TexConstant.Variant.NORMAL}], + 'textregistered': ['\u00AE', {mathvariant: TexConstant.Variant.NORMAL}], + 'textservicemark': ['\u2120', {mathvariant: TexConstant.Variant.NORMAL}], + 'texttrademark': ['\u2122', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 16: textcomp Old-Style Numerals + 'textzerooldstyle': ['0', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textoneoldstyle': ['1', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'texttwooldstyle': ['2', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textthreeoldstyle': ['3', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textfouroldstyle': ['4', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textfiveoldstyle': ['5', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textsixoldstyle': ['6', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textsevenoldstyle': ['7', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'texteightoldstyle': ['8', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textnineoldstyle': ['9', {mathvariant: TexConstant.Variant.OLDSTYLE}], + + // Table 20: Miscellaneous textcomp Symbol + 'textbardbl': ['\u2016', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbigcircle': ['\u25EF', {mathvariant: TexConstant.Variant.NORMAL}], + 'textblank': ['\u2422', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbrokenbar': ['\u00A6', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdiscount': ['\u2052', {mathvariant: TexConstant.Variant.NORMAL}], + 'textestimated': ['\u212E', {mathvariant: TexConstant.Variant.NORMAL}], + 'textinterrobang': ['\u203D', {mathvariant: TexConstant.Variant.NORMAL}], + 'textinterrobangdown': ['\u2E18', {mathvariant: TexConstant.Variant.NORMAL}], + 'textmusicalnote': ['\u266A', {mathvariant: TexConstant.Variant.NORMAL}], + 'textnumero': ['\u2116', {mathvariant: TexConstant.Variant.NORMAL}], + 'textopenbullet': ['\u25E6', {mathvariant: TexConstant.Variant.NORMAL}], + 'textpertenthousand': ['\u2031', {mathvariant: TexConstant.Variant.NORMAL}], + 'textperthousand': ['\u2030', {mathvariant: TexConstant.Variant.NORMAL}], + 'textrecipe': ['\u211E', {mathvariant: TexConstant.Variant.NORMAL}], + 'textreferencemark': ['\u203B', {mathvariant: TexConstant.Variant.NORMAL}], + // 'textthreequartersemdash' + // 'texttwelveudash' + + // Table 51: textcomp Text-Mode Delimiters + 'textlangle': ['\u2329', {mathvariant: TexConstant.Variant.NORMAL}], + 'textrangle': ['\u232A', {mathvariant: TexConstant.Variant.NORMAL}], + 'textlbrackdbl': ['\u27E6', {mathvariant: TexConstant.Variant.NORMAL}], + 'textrbrackdbl': ['\u27E7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textlquill': ['\u2045', {mathvariant: TexConstant.Variant.NORMAL}], + 'textrquill': ['\u2046', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 62: textcomp Text-Mode Math and Science Symbols + 'textcelsius': ['\u2103', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdegree': ['\u00B0', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdiv': ['\u00F7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdownarrow': ['\u2193', {mathvariant: TexConstant.Variant.NORMAL}], + 'textfractionsolidus': ['\u2044', {mathvariant: TexConstant.Variant.NORMAL}], + 'textleftarrow': ['\u2190', {mathvariant: TexConstant.Variant.NORMAL}], + 'textlnot': ['\u00AC', {mathvariant: TexConstant.Variant.NORMAL}], + 'textmho': ['\u2127', {mathvariant: TexConstant.Variant.NORMAL}], + 'textminus': ['\u2212', {mathvariant: TexConstant.Variant.NORMAL}], + 'textmu': ['\u00B5', {mathvariant: TexConstant.Variant.NORMAL}], + 'textohm': ['\u2126', {mathvariant: TexConstant.Variant.NORMAL}], + 'textonehalf': ['\u00BD', {mathvariant: TexConstant.Variant.NORMAL}], + 'textonequarter': ['\u00BC', {mathvariant: TexConstant.Variant.NORMAL}], + 'textonesuperior': ['\u00B9', {mathvariant: TexConstant.Variant.NORMAL}], + 'textpm': ['\u00B1', {mathvariant: TexConstant.Variant.NORMAL}], + 'textrightarrow': ['\u2192', {mathvariant: TexConstant.Variant.NORMAL}], + 'textsurd': ['\u221A', {mathvariant: TexConstant.Variant.NORMAL}], + 'textthreequarters': ['\u00BE', {mathvariant: TexConstant.Variant.NORMAL}], + 'textthreesuperior': ['\u00B3', {mathvariant: TexConstant.Variant.NORMAL}], + 'texttimes': ['\u00D7', {mathvariant: TexConstant.Variant.NORMAL}], + 'texttwosuperior': ['\u00B2', {mathvariant: TexConstant.Variant.NORMAL}], + 'textuparrow': ['\u2191', {mathvariant: TexConstant.Variant.NORMAL}], + + // Table 110: textcomp Genealogical Symbols + 'textborn': ['\u002A', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdied': ['\u2020', {mathvariant: TexConstant.Variant.NORMAL}], + 'textdivorced': ['\u26AE', {mathvariant: TexConstant.Variant.NORMAL}], + // 'textleaf' + 'textmarried': ['\u26AD', {mathvariant: TexConstant.Variant.NORMAL}] +}); diff --git a/ts/input/tex/textmacros/TextMacrosConfiguration.ts b/ts/input/tex/textmacros/TextMacrosConfiguration.ts index adb6d1482..721de9d1f 100644 --- a/ts/input/tex/textmacros/TextMacrosConfiguration.ts +++ b/ts/input/tex/textmacros/TextMacrosConfiguration.ts @@ -114,7 +114,7 @@ export const TextMacrosConfiguration = Configuration.create('textmacros', { parseOptions.tags.configuration = parseOptions; // // Share the TeX input jax's parseOptions packageData object - // so that require and other packagses will work in both parsers, + // so that require and other packages will work in both parsers, // set the textmacros data (texParser will be filled in later), // and replace the internalMath function with our own. // From 3107f18efbd4956897a51a1fde95ad9660de8e2e Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 25 Mar 2021 01:13:43 +0000 Subject: [PATCH 010/142] Adds the upgreek package. --- .../input/tex/extensions/upgreek/build.json | 4 + .../input/tex/extensions/upgreek/upgreek.js | 1 + .../tex/extensions/upgreek/webpack.config.js | 11 +++ ts/input/tex/AllPackages.ts | 3 + ts/input/tex/upgreek/UpgreekConfiguration.ts | 84 +++++++++++++++++++ 5 files changed, 103 insertions(+) create mode 100644 components/src/input/tex/extensions/upgreek/build.json create mode 100644 components/src/input/tex/extensions/upgreek/upgreek.js create mode 100644 components/src/input/tex/extensions/upgreek/webpack.config.js create mode 100644 ts/input/tex/upgreek/UpgreekConfiguration.ts diff --git a/components/src/input/tex/extensions/upgreek/build.json b/components/src/input/tex/extensions/upgreek/build.json new file mode 100644 index 000000000..2bda780bf --- /dev/null +++ b/components/src/input/tex/extensions/upgreek/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/upgreek", + "targets": ["input/tex/upgreek"] +} diff --git a/components/src/input/tex/extensions/upgreek/upgreek.js b/components/src/input/tex/extensions/upgreek/upgreek.js new file mode 100644 index 000000000..dad786a63 --- /dev/null +++ b/components/src/input/tex/extensions/upgreek/upgreek.js @@ -0,0 +1 @@ +import './lib/upgreek.js'; diff --git a/components/src/input/tex/extensions/upgreek/webpack.config.js b/components/src/input/tex/extensions/upgreek/webpack.config.js new file mode 100644 index 000000000..d47c688b0 --- /dev/null +++ b/components/src/input/tex/extensions/upgreek/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/upgreek', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..e631fc9fa 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -43,6 +43,7 @@ import './noundefined/NoUndefinedConfiguration.js'; import './physics/PhysicsConfiguration.js'; import './tagformat/TagFormatConfiguration.js'; import './textmacros/TextMacrosConfiguration.js'; +import './upgreek/UpgreekConfiguration.js'; import './unicode/UnicodeConfiguration.js'; import './verb/VerbConfiguration.js'; @@ -67,6 +68,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/noerrors', '[tex]/noundefined', '[tex]/physics', + '[tex]/upgreek', '[tex]/unicode', '[tex]/verb', '[tex]/configmacros', @@ -93,6 +95,7 @@ export const AllPackages: string[] = [ 'newcommand', 'noerrors', 'noundefined', + 'upgreek', 'unicode', 'verb', 'configmacros', diff --git a/ts/input/tex/upgreek/UpgreekConfiguration.ts b/ts/input/tex/upgreek/UpgreekConfiguration.ts new file mode 100644 index 000000000..2c78e31c2 --- /dev/null +++ b/ts/input/tex/upgreek/UpgreekConfiguration.ts @@ -0,0 +1,84 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the upgreek package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + */ + +import {Configuration} from '../Configuration.js'; +import ParseMethods from '../ParseMethods.js'; +import {CharacterMap} from '../SymbolMap.js'; + + +/** + * Upright Greek characters. + */ +new CharacterMap('upgreek', ParseMethods.mathchar7, { + upalpha: '\u03B1', + upbeta: '\u03B2', + upgamma: '\u03B3', + updelta: '\u03B4', + upepsilon: '\u03F5', + upzeta: '\u03B6', + upeta: '\u03B7', + uptheta: '\u03B8', + upiota: '\u03B9', + upkappa: '\u03BA', + uplambda: '\u03BB', + upmu: '\u03BC', + upnu: '\u03BD', + upxi: '\u03BE', + upomicron: '\u03BF', + uppi: '\u03C0', + uprho: '\u03C1', + upsigma: '\u03C3', + uptau: '\u03C4', + upupsilon: '\u03C5', + upphi: '\u03D5', + upchi: '\u03C7', + uppsi: '\u03C8', + upomega: '\u03C9', + upvarepsilon: '\u03B5', + upvartheta: '\u03D1', + upvarpi: '\u03D6', + upvarrho: '\u03F1', + upvarsigma: '\u03C2', + upvarphi: '\u03C6', + + Upgamma: '\u0393', + Updelta: '\u0394', + Uptheta: '\u0398', + Uplambda: '\u039B', + Upxi: '\u039E', + Uppi: '\u03A0', + Upsigma: '\u03A3', + Upupsilon: '\u03A5', + Upphi: '\u03A6', + Uppsi: '\u03A8', + Upomega: '\u03A9', +}); + + +export const UpgreekConfiguration = Configuration.create( + 'upgreek', { + handler: {macro: ['upgreek']}, + } +); + From 1031ba3a8897c12370d161b60762fdf3b0936aaa Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 25 Mar 2021 01:42:31 +0000 Subject: [PATCH 011/142] Adds the gensymb package. --- .../input/tex/extensions/gensymb/build.json | 4 ++ .../input/tex/extensions/gensymb/gensymb.js | 1 + .../tex/extensions/gensymb/webpack.config.js | 11 +++++ ts/input/tex/AllPackages.ts | 3 ++ ts/input/tex/gensymb/GensymbConfiguration.ts | 48 +++++++++++++++++++ 5 files changed, 67 insertions(+) create mode 100644 components/src/input/tex/extensions/gensymb/build.json create mode 100644 components/src/input/tex/extensions/gensymb/gensymb.js create mode 100644 components/src/input/tex/extensions/gensymb/webpack.config.js create mode 100644 ts/input/tex/gensymb/GensymbConfiguration.ts diff --git a/components/src/input/tex/extensions/gensymb/build.json b/components/src/input/tex/extensions/gensymb/build.json new file mode 100644 index 000000000..0d976916e --- /dev/null +++ b/components/src/input/tex/extensions/gensymb/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/gensymb", + "targets": ["input/tex/gensymb"] +} diff --git a/components/src/input/tex/extensions/gensymb/gensymb.js b/components/src/input/tex/extensions/gensymb/gensymb.js new file mode 100644 index 000000000..13ef4b411 --- /dev/null +++ b/components/src/input/tex/extensions/gensymb/gensymb.js @@ -0,0 +1 @@ +import './lib/gensymb.js'; diff --git a/components/src/input/tex/extensions/gensymb/webpack.config.js b/components/src/input/tex/extensions/gensymb/webpack.config.js new file mode 100644 index 000000000..808daa560 --- /dev/null +++ b/components/src/input/tex/extensions/gensymb/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/gensymb', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..7134402a1 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -35,6 +35,7 @@ import './colorv2/ColorV2Configuration.js'; import './configmacros/ConfigMacrosConfiguration.js'; import './enclose/EncloseConfiguration.js'; import './extpfeil/ExtpfeilConfiguration.js'; +import './gensymb/GensymbConfiguration.js'; import './html/HtmlConfiguration.js'; import './mhchem/MhchemConfiguration.js'; import './newcommand/NewcommandConfiguration.js'; @@ -61,6 +62,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/colorv2', '[tex]/enclose', '[tex]/extpfeil', + '[tex]/gensymb', '[tex]/html', '[tex]/mhchem', '[tex]/newcommand', @@ -88,6 +90,7 @@ export const AllPackages: string[] = [ 'color', 'enclose', 'extpfeil', + 'gensymb', 'html', 'mhchem', 'newcommand', diff --git a/ts/input/tex/gensymb/GensymbConfiguration.ts b/ts/input/tex/gensymb/GensymbConfiguration.ts new file mode 100644 index 000000000..2e1ea65c0 --- /dev/null +++ b/ts/input/tex/gensymb/GensymbConfiguration.ts @@ -0,0 +1,48 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the gensymb package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + */ + +import {Configuration} from '../Configuration.js'; +import ParseMethods from '../ParseMethods.js'; +import {TexConstant} from '../TexConstants.js'; +import {CharacterMap} from '../SymbolMap.js'; + + +/** + * Upright Greek characters. + */ +new CharacterMap('gensymb', ParseMethods.mathchar7, { + degree: '\u00B0', + celsius: '\u2103', + perthousand: '\u2030', + ohm: ['\u03A9', {mathvariant: TexConstant.Variant.NORMAL}], + micro: ['\u00B5', {mathvariant: TexConstant.Variant.NORMAL}] +}); + + +export const GensymbConfiguration = Configuration.create( + 'gensymb', { + handler: {macro: ['gensymb']}, + } +); + From 9dfa6f18ab24517d22222314bb89c06e8c097d57 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 25 Mar 2021 11:35:28 -0400 Subject: [PATCH 012/142] Add ability to specify additional textmacros packages. --- ts/input/tex/textmacros/TextMacrosConfiguration.ts | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/ts/input/tex/textmacros/TextMacrosConfiguration.ts b/ts/input/tex/textmacros/TextMacrosConfiguration.ts index adb6d1482..d7eedbd07 100644 --- a/ts/input/tex/textmacros/TextMacrosConfiguration.ts +++ b/ts/input/tex/textmacros/TextMacrosConfiguration.ts @@ -37,7 +37,7 @@ import './TextMacrosMappings.js'; /** * The base text macro configuration (used in the TextParser) */ -export const textBase = Configuration.local({ +export const textBase = Configuration.create('text-base', { handler: { character: ['command', 'text-special'], macro: ['text-macros'] @@ -103,8 +103,7 @@ export const TextMacrosConfiguration = Configuration.create('textmacros', { // Create the configuration and parseOptions objects for the // internal TextParser and add the textBase configuration. // - const textConf = new ParserConfiguration([]); - textConf.append(textBase); + const textConf = new ParserConfiguration(jax.parseOptions.options.textmacros.packages); textConf.init(); const parseOptions = new ParseOptions(textConf, []); parseOptions.options = jax.parseOptions.options; // share the TeX options @@ -129,5 +128,10 @@ export const TextMacrosConfiguration = Configuration.create('textmacros', { // const config = data.data.packageData.get('textmacros'); config.parseOptions.nodeFactory.setMmlFactory(config.jax.mmlFactory); - }] + }], + options: { + textmacros: { + packages: ['text-base'] // textmacro packages to load + } + } }); From 6dcd66f04e3e897c916b5299c5e94459ca0bf3bb Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 25 Mar 2021 17:50:32 +0000 Subject: [PATCH 013/142] Uses correct insert method. --- ts/input/tex/Configuration.ts | 2 +- .../tex/textcomp/TextcompConfiguration.ts | 15 +- ts/input/tex/textcomp/TextcompMappings.ts | 255 +++++++++--------- 3 files changed, 134 insertions(+), 138 deletions(-) diff --git a/ts/input/tex/Configuration.ts b/ts/input/tex/Configuration.ts index 0fd53b30d..b4894ac48 100644 --- a/ts/input/tex/Configuration.ts +++ b/ts/input/tex/Configuration.ts @@ -318,7 +318,7 @@ export class ParserConfiguration { } /** - * Retrieves and adds configuration for a pacakge with priority. + * Retrieves and adds configuration for a package with priority. * @param {(string | [string, number]} pkg Package with priority. */ public addPackage(pkg: (string | [string, number])) { diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts index 56f6d471a..d9dc89083 100644 --- a/ts/input/tex/textcomp/TextcompConfiguration.ts +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -25,21 +25,8 @@ import {Configuration} from '../Configuration.js'; import './TextcompMappings.js'; -// import {TeX} from '../../tex.js'; -// import {TextParser} from '../textmacros/TextParser.js'; -// import {TextMacrosConfiguration} from '../textmacros/TextMacrosConfiguration.js'; - export const TextcompConfiguration = Configuration.create( - 'textcomp', { - // config(config: ParserConfiguration, jax: TeX) { - // try { - // TextMacrosConfiguration.config(config, jax); - // } catch (e) { - // console.log(e); - // } - // }, - handler: {macro: ['textcomp']}, - } + 'textcomp', {handler: {macro: ['textcomp-macros', 'textcomp-oldstyle']}} ); diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index 01f728de8..33f9ff02f 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -24,152 +24,161 @@ import ParseMethods from '../ParseMethods.js'; -import {CharacterMap} from '../SymbolMap.js'; +import {CharacterMap, CommandMap} from '../SymbolMap.js'; import {TexConstant} from '../TexConstants.js'; +import {TextMacrosMethods} from '../textmacros/TextMacrosMethods.js'; /** * Identifiers from the Textcomp package. */ -new CharacterMap('textcomp', ParseMethods.mathchar0mi, { +new CommandMap('textcomp-macros', { // Table 3: Predefined LATEX 2ε Text-Mode Commands - 'textasciicircum': ['\u005E', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciitilde': ['\u007E', {mathvariant: TexConstant.Variant.NORMAL}], -// 'textasteriskcentered' - 'textbackslash': ['\u005C', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbar': ['\u007C', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbraceleft': ['\u007B', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbraceright': ['\u007D', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbullet': ['\u2022', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdagger': ['\u2020', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdaggerdbl': ['\u2021', {mathvariant: TexConstant.Variant.NORMAL}], - 'textellipsis': ['\u2026', {mathvariant: TexConstant.Variant.NORMAL}], - 'textemdash': ['\u2014', {mathvariant: TexConstant.Variant.NORMAL}], - 'textendash': ['\u2013', {mathvariant: TexConstant.Variant.NORMAL}], - 'textexclamdown': ['\u00A1', {mathvariant: TexConstant.Variant.NORMAL}], - 'textgreater': ['\u003E', {mathvariant: TexConstant.Variant.NORMAL}], - 'textless': ['\u003C', {mathvariant: TexConstant.Variant.NORMAL}], - 'textordfeminine': ['\u00AA', {mathvariant: TexConstant.Variant.NORMAL}], - 'textordmasculine': ['\u00BA', {mathvariant: TexConstant.Variant.NORMAL}], - 'textparagraph': ['\u00B6', {mathvariant: TexConstant.Variant.NORMAL}], - 'textperiodcentered': ['\u00B7', {mathvariant: TexConstant.Variant.NORMAL}], - 'textquestiondown': ['\u00BF', {mathvariant: TexConstant.Variant.NORMAL}], - 'textquotedblleft': ['\u201C', {mathvariant: TexConstant.Variant.NORMAL}], - 'textquotedblright': ['\u201D', {mathvariant: TexConstant.Variant.NORMAL}], - 'textquoteleft': ['\u2018', {mathvariant: TexConstant.Variant.NORMAL}], - 'textquoteright': ['\u2019', {mathvariant: TexConstant.Variant.NORMAL}], - 'textsection': ['\u00A7', {mathvariant: TexConstant.Variant.NORMAL}], - 'textunderscore': ['\u005F', {mathvariant: TexConstant.Variant.NORMAL}], - 'textvisiblespace': ['\u2423', {mathvariant: TexConstant.Variant.NORMAL}], + 'textasciicircum': ['Insert', '\u005E'], + 'textasciitilde': ['Insert', '\u007E'], + 'textasteriskcentered': ['Insert', '\u002A'], + 'textbackslash': ['Insert', '\u005C'], + 'textbar': ['Insert', '\u007C'], + 'textbraceleft': ['Insert', '\u007B'], + 'textbraceright': ['Insert', '\u007D'], + 'textbullet': ['Insert', '\u2022'], + 'textdagger': ['Insert', '\u2020'], + 'textdaggerdbl': ['Insert', '\u2021'], + 'textellipsis': ['Insert', '\u2026'], + 'textemdash': ['Insert', '\u2014'], + 'textendash': ['Insert', '\u2013'], + 'textexclamdown': ['Insert', '\u00A1'], + 'textgreater': ['Insert', '\u003E'], + 'textless': ['Insert', '\u003C'], + 'textordfeminine': ['Insert', '\u00AA'], + 'textordmasculine': ['Insert', '\u00BA'], + 'textparagraph': ['Insert', '\u00B6'], + 'textperiodcentered': ['Insert', '\u00B7'], + 'textquestiondown': ['Insert', '\u00BF'], + 'textquotedblleft': ['Insert', '\u201C'], + 'textquotedblright': ['Insert', '\u201D'], + 'textquoteleft': ['Insert', '\u2018'], + 'textquoteright': ['Insert', '\u2019'], + 'textsection': ['Insert', '\u00A7'], + 'textunderscore': ['Insert', '\u005F'], + 'textvisiblespace': ['Insert', '\u2423'], // Table 12: textcomp Diacritics - 'textacutedbl': ['\u02DD', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciiacute': ['\u00B4', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciibreve': ['\u02D8', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciicaron': ['\u02C7', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciidieresis': ['\u00A8', {mathvariant: TexConstant.Variant.NORMAL}], - 'textasciimacron': ['\u00AF', {mathvariant: TexConstant.Variant.NORMAL}], - 'textgravedbl': ['\u02F5', {mathvariant: TexConstant.Variant.NORMAL}], - 'texttildelow': ['\u02F7', {mathvariant: TexConstant.Variant.NORMAL}], + 'textacutedbl': ['Insert', '\u02DD'], + 'textasciiacute': ['Insert', '\u00B4'], + 'textasciibreve': ['Insert', '\u02D8'], + 'textasciicaron': ['Insert', '\u02C7'], + 'textasciidieresis': ['Insert', '\u00A8'], + 'textasciimacron': ['Insert', '\u00AF'], + 'textgravedbl': ['Insert', '\u02F5'], + 'texttildelow': ['Insert', '\u02F7'], // Table 13: textcomp Currency Symbols - 'textbaht': ['\u0E3F', {mathvariant: TexConstant.Variant.NORMAL}], - 'textcent': ['\u00A2', {mathvariant: TexConstant.Variant.NORMAL}], - // This is not the correct glyph - 'textcentoldstyle': ['$', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textcolonmonetary': ['\u20A1', {mathvariant: TexConstant.Variant.NORMAL}], - 'textcurrency': ['\u00A4', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdollar': ['\u0024', {mathvariant: TexConstant.Variant.NORMAL}], - // This is not the correct glyph - 'textdollaroldstyle': ['$', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textdong': ['\u20AB', {mathvariant: TexConstant.Variant.NORMAL}], - 'texteuro': ['\u20AC', {mathvariant: TexConstant.Variant.NORMAL}], - 'textflorin': ['\u0192', {mathvariant: TexConstant.Variant.NORMAL}], - 'textguarani': ['\u20B2', {mathvariant: TexConstant.Variant.NORMAL}], - 'textlira': ['\u20A4', {mathvariant: TexConstant.Variant.NORMAL}], - 'textnaira': ['\u20A6', {mathvariant: TexConstant.Variant.NORMAL}], - 'textpeso': ['\u20B1', {mathvariant: TexConstant.Variant.NORMAL}], - 'textsterling': ['\u00A3', {mathvariant: TexConstant.Variant.NORMAL}], - 'textwon': ['\u20A9', {mathvariant: TexConstant.Variant.NORMAL}], - 'textyen': ['\u00A5', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbaht': ['Insert', '\u0E3F'], + 'textcent': ['Insert', '\u00A2'], + 'textcolonmonetary': ['Insert', '\u20A1'], + 'textcurrency': ['Insert', '\u00A4'], + 'textdollar': ['Insert', '\u0024'], + 'textdong': ['Insert', '\u20AB'], + 'texteuro': ['Insert', '\u20AC'], + 'textflorin': ['Insert', '\u0192'], + 'textguarani': ['Insert', '\u20B2'], + 'textlira': ['Insert', '\u20A4'], + 'textnaira': ['Insert', '\u20A6'], + 'textpeso': ['Insert', '\u20B1'], + 'textsterling': ['Insert', '\u00A3'], + 'textwon': ['Insert', '\u20A9'], + 'textyen': ['Insert', '\u00A5'], // Table 15: textcomp Legal Symbols - 'textcircledP': ['\u2117', {mathvariant: TexConstant.Variant.NORMAL}], - 'textcompwordmark': ['\u200C', {mathvariant: TexConstant.Variant.NORMAL}], - 'textcopyleft': ['\u1F12F', {mathvariant: TexConstant.Variant.NORMAL}], - 'textcopyright': ['\u00A9', {mathvariant: TexConstant.Variant.NORMAL}], - 'textregistered': ['\u00AE', {mathvariant: TexConstant.Variant.NORMAL}], - 'textservicemark': ['\u2120', {mathvariant: TexConstant.Variant.NORMAL}], - 'texttrademark': ['\u2122', {mathvariant: TexConstant.Variant.NORMAL}], - - // Table 16: textcomp Old-Style Numerals - 'textzerooldstyle': ['0', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textoneoldstyle': ['1', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'texttwooldstyle': ['2', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textthreeoldstyle': ['3', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textfouroldstyle': ['4', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textfiveoldstyle': ['5', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textsixoldstyle': ['6', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textsevenoldstyle': ['7', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'texteightoldstyle': ['8', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textnineoldstyle': ['9', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textcircledP': ['Insert', '\u2117'], + 'textcompwordmark': ['Insert', '\u200C'], + 'textcopyleft': ['Insert', '\u1F12F'], + 'textcopyright': ['Insert', '\u00A9'], + 'textregistered': ['Insert', '\u00AE'], + 'textservicemark': ['Insert', '\u2120'], + 'texttrademark': ['Insert', '\u2122'], // Table 20: Miscellaneous textcomp Symbol - 'textbardbl': ['\u2016', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbigcircle': ['\u25EF', {mathvariant: TexConstant.Variant.NORMAL}], - 'textblank': ['\u2422', {mathvariant: TexConstant.Variant.NORMAL}], - 'textbrokenbar': ['\u00A6', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdiscount': ['\u2052', {mathvariant: TexConstant.Variant.NORMAL}], - 'textestimated': ['\u212E', {mathvariant: TexConstant.Variant.NORMAL}], - 'textinterrobang': ['\u203D', {mathvariant: TexConstant.Variant.NORMAL}], - 'textinterrobangdown': ['\u2E18', {mathvariant: TexConstant.Variant.NORMAL}], - 'textmusicalnote': ['\u266A', {mathvariant: TexConstant.Variant.NORMAL}], - 'textnumero': ['\u2116', {mathvariant: TexConstant.Variant.NORMAL}], - 'textopenbullet': ['\u25E6', {mathvariant: TexConstant.Variant.NORMAL}], - 'textpertenthousand': ['\u2031', {mathvariant: TexConstant.Variant.NORMAL}], - 'textperthousand': ['\u2030', {mathvariant: TexConstant.Variant.NORMAL}], - 'textrecipe': ['\u211E', {mathvariant: TexConstant.Variant.NORMAL}], - 'textreferencemark': ['\u203B', {mathvariant: TexConstant.Variant.NORMAL}], + 'textbardbl': ['Insert', '\u2016'], + 'textbigcircle': ['Insert', '\u25EF'], + 'textblank': ['Insert', '\u2422'], + 'textbrokenbar': ['Insert', '\u00A6'], + 'textdiscount': ['Insert', '\u2052'], + 'textestimated': ['Insert', '\u212E'], + 'textinterrobang': ['Insert', '\u203D'], + 'textinterrobangdown': ['Insert', '\u2E18'], + 'textmusicalnote': ['Insert', '\u266A'], + 'textnumero': ['Insert', '\u2116'], + 'textopenbullet': ['Insert', '\u25E6'], + 'textpertenthousand': ['Insert', '\u2031'], + 'textperthousand': ['Insert', '\u2030'], + 'textrecipe': ['Insert', '\u211E'], + 'textreferencemark': ['Insert', '\u203B'], // 'textthreequartersemdash' // 'texttwelveudash' // Table 51: textcomp Text-Mode Delimiters - 'textlangle': ['\u2329', {mathvariant: TexConstant.Variant.NORMAL}], - 'textrangle': ['\u232A', {mathvariant: TexConstant.Variant.NORMAL}], - 'textlbrackdbl': ['\u27E6', {mathvariant: TexConstant.Variant.NORMAL}], - 'textrbrackdbl': ['\u27E7', {mathvariant: TexConstant.Variant.NORMAL}], - 'textlquill': ['\u2045', {mathvariant: TexConstant.Variant.NORMAL}], - 'textrquill': ['\u2046', {mathvariant: TexConstant.Variant.NORMAL}], + 'textlangle': ['Insert', '\u2329'], + 'textrangle': ['Insert', '\u232A'], + 'textlbrackdbl': ['Insert', '\u27E6'], + 'textrbrackdbl': ['Insert', '\u27E7'], + 'textlquill': ['Insert', '\u2045'], + 'textrquill': ['Insert', '\u2046'], // Table 62: textcomp Text-Mode Math and Science Symbols - 'textcelsius': ['\u2103', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdegree': ['\u00B0', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdiv': ['\u00F7', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdownarrow': ['\u2193', {mathvariant: TexConstant.Variant.NORMAL}], - 'textfractionsolidus': ['\u2044', {mathvariant: TexConstant.Variant.NORMAL}], - 'textleftarrow': ['\u2190', {mathvariant: TexConstant.Variant.NORMAL}], - 'textlnot': ['\u00AC', {mathvariant: TexConstant.Variant.NORMAL}], - 'textmho': ['\u2127', {mathvariant: TexConstant.Variant.NORMAL}], - 'textminus': ['\u2212', {mathvariant: TexConstant.Variant.NORMAL}], - 'textmu': ['\u00B5', {mathvariant: TexConstant.Variant.NORMAL}], - 'textohm': ['\u2126', {mathvariant: TexConstant.Variant.NORMAL}], - 'textonehalf': ['\u00BD', {mathvariant: TexConstant.Variant.NORMAL}], - 'textonequarter': ['\u00BC', {mathvariant: TexConstant.Variant.NORMAL}], - 'textonesuperior': ['\u00B9', {mathvariant: TexConstant.Variant.NORMAL}], - 'textpm': ['\u00B1', {mathvariant: TexConstant.Variant.NORMAL}], - 'textrightarrow': ['\u2192', {mathvariant: TexConstant.Variant.NORMAL}], - 'textsurd': ['\u221A', {mathvariant: TexConstant.Variant.NORMAL}], - 'textthreequarters': ['\u00BE', {mathvariant: TexConstant.Variant.NORMAL}], - 'textthreesuperior': ['\u00B3', {mathvariant: TexConstant.Variant.NORMAL}], - 'texttimes': ['\u00D7', {mathvariant: TexConstant.Variant.NORMAL}], - 'texttwosuperior': ['\u00B2', {mathvariant: TexConstant.Variant.NORMAL}], - 'textuparrow': ['\u2191', {mathvariant: TexConstant.Variant.NORMAL}], + 'textcelsius': ['Insert', '\u2103'], + 'textdegree': ['Insert', '\u00B0'], + 'textdiv': ['Insert', '\u00F7'], + 'textdownarrow': ['Insert', '\u2193'], + 'textfractionsolidus': ['Insert', '\u2044'], + 'textleftarrow': ['Insert', '\u2190'], + 'textlnot': ['Insert', '\u00AC'], + 'textmho': ['Insert', '\u2127'], + 'textminus': ['Insert', '\u2212'], + 'textmu': ['Insert', '\u00B5'], + 'textohm': ['Insert', '\u2126'], + 'textonehalf': ['Insert', '\u00BD'], + 'textonequarter': ['Insert', '\u00BC'], + 'textonesuperior': ['Insert', '\u00B9'], + 'textpm': ['Insert', '\u00B1'], + 'textrightarrow': ['Insert', '\u2192'], + 'textsurd': ['Insert', '\u221A'], + 'textthreequarters': ['Insert', '\u00BE'], + 'textthreesuperior': ['Insert', '\u00B3'], + 'texttimes': ['Insert', '\u00D7'], + 'texttwosuperior': ['Insert', '\u00B2'], + 'textuparrow': ['Insert', '\u2191'], // Table 110: textcomp Genealogical Symbols - 'textborn': ['\u002A', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdied': ['\u2020', {mathvariant: TexConstant.Variant.NORMAL}], - 'textdivorced': ['\u26AE', {mathvariant: TexConstant.Variant.NORMAL}], + 'textborn': ['Insert', '\u002A'], + 'textdied': ['Insert', '\u2020'], + 'textdivorced': ['Insert', '\u26AE'], // 'textleaf' - 'textmarried': ['\u26AD', {mathvariant: TexConstant.Variant.NORMAL}] + 'textmarried': ['Insert', '\u26AD'] +}, TextMacrosMethods); + + +/** + * Identifiers from the Textcomp package. + */ +new CharacterMap('textcomp-oldstyle', ParseMethods.mathchar0mi, { + + // This is not the correct glyph + 'textcentoldstyle': ['\u00A2', {mathvariant: TexConstant.Variant.OLDSTYLE}], + // This is not the correct glyph + 'textdollaroldstyle': ['\u0024', {mathvariant: TexConstant.Variant.OLDSTYLE}], + + // Table 16: textcomp Old-Style Numerals + 'textzerooldstyle': ['0', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textoneoldstyle': ['1', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'texttwooldstyle': ['2', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textthreeoldstyle': ['3', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textfouroldstyle': ['4', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textfiveoldstyle': ['5', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textsixoldstyle': ['6', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textsevenoldstyle': ['7', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'texteightoldstyle': ['8', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textnineoldstyle': ['9', {mathvariant: TexConstant.Variant.OLDSTYLE}] }); From af1cf84f45fab2c509b9a4b4077da47698b196b6 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 26 Mar 2021 10:58:40 -0400 Subject: [PATCH 014/142] Add support for restricting packages to particular named parsers (using list of names on ParserConfiguration constructor) --- ts/input/tex.ts | 2 +- ts/input/tex/Configuration.ts | 46 ++++++++++++++----- ts/input/tex/require/RequireConfiguration.ts | 2 +- .../tex/textmacros/TextMacrosConfiguration.ts | 5 +- 4 files changed, 40 insertions(+), 15 deletions(-) diff --git a/ts/input/tex.ts b/ts/input/tex.ts index 740f1c0ab..6471552de 100644 --- a/ts/input/tex.ts +++ b/ts/input/tex.ts @@ -105,7 +105,7 @@ export class TeX extends AbstractInputJax { * @return {Configuration} The configuration object. */ protected static configure(packages: (string | [string, number])[]): ParserConfiguration { - let configuration = new ParserConfiguration(packages); + let configuration = new ParserConfiguration(packages, ['tex']); configuration.init(); return configuration; } diff --git a/ts/input/tex/Configuration.ts b/ts/input/tex/Configuration.ts index 0fd53b30d..03eb6e8b6 100644 --- a/ts/input/tex/Configuration.ts +++ b/ts/input/tex/Configuration.ts @@ -74,6 +74,7 @@ export class Configuration { init?: ProtoProcessor, config?: ProtoProcessor, priority?: number, + parser?: string, } = {}): Configuration { let priority = config.priority || PrioritizedList.DEFAULTPRIORITY; let init = config.init ? this.makeProcessor(config.init, priority) : null; @@ -82,6 +83,7 @@ export class Configuration { pre => this.makeProcessor(pre, priority)); let postprocessors = (config.postprocessors || []).map( post => this.makeProcessor(post, priority)); + let parser = config.parser || 'tex'; return new Configuration( name, config.handler || {}, @@ -90,7 +92,8 @@ export class Configuration { config.tags || {}, config.options || {}, config.nodes || {}, - preprocessors, postprocessors, init, conf, priority + preprocessors, postprocessors, init, conf, priority, + parser ); } @@ -113,6 +116,7 @@ export class Configuration { * * _init_ init method and optionally its priority. * * _config_ config method and optionally its priority. * * _priority_ default priority of the configuration. + * * _parser_ the name of the parser that this configuration targets. * @return {Configuration} The newly generated configuration. */ public static create(name: string, @@ -127,6 +131,7 @@ export class Configuration { init?: ProtoProcessor, config?: ProtoProcessor, priority?: number, + parser?: string, } = {}): Configuration { let configuration = Configuration._create(name, config); ConfigurationHandler.set(name, configuration); @@ -150,6 +155,7 @@ export class Configuration { init?: ProtoProcessor, config?: ProtoProcessor, priority?: number, + parser?: string, } = {}): Configuration { return Configuration._create('', config); } @@ -169,7 +175,8 @@ export class Configuration { readonly postprocessors: ProcessorList = [], readonly initMethod: Processor = null, readonly configMethod: Processor = null, - public priority: number + public priority: number, + readonly parser: string ) { this.handler = Object.assign( {character: [], delimiter: [], macro: [], environment: []}, handler); @@ -254,6 +261,11 @@ export class ParserConfiguration { */ protected configurations: PrioritizedList = new PrioritizedList(); + /** + * The list of parsers this configuration targets + */ + protected parsers: string[] = []; + /** * The subhandlers for this configuration. * @type {SubHandlers} @@ -284,13 +296,14 @@ export class ParserConfiguration { */ public nodes: {[key: string]: any} = {}; - /** * @constructor * @param {(string|[string,number])[]} packages A list of packages with * optional priorities. + * @parm {string[]} parsers The names of the parsers whose packages are supported */ - constructor(packages: (string | [string, number])[]) { + constructor(packages: (string | [string, number])[], parsers: string[] = ['tex']) { + this.parsers = parsers; for (const pkg of packages.slice().reverse()) { this.addPackage(pkg); } @@ -323,22 +336,20 @@ export class ParserConfiguration { */ public addPackage(pkg: (string | [string, number])) { const name = typeof pkg === 'string' ? pkg : pkg[0]; - let conf = ConfigurationHandler.get(name); - if (conf) { - this.configurations.add( - conf, typeof pkg === 'string' ? conf.priority : pkg[1]); - } + const conf = this.getPackage(name); + conf && this.configurations.add(conf, typeof pkg === 'string' ? conf.priority : pkg[1]); } /** * Adds a configuration after the input jax is created. (Used by \require.) * Sets items, nodes and runs configuration method explicitly. * - * @param {Configuration} config The configuration to be registered in this one + * @param {string} name The name of the package to add * @param {TeX} jax The TeX jax where it is being registered * @param {OptionList=} options The options for the configuration. */ - public add(config: Configuration, jax: TeX, options: OptionList = {}) { + public add(name: string, jax: TeX, options: OptionList = {}) { + const config = this.getPackage(name); this.append(config); this.configurations.add(config, config.priority); this.init(); @@ -356,6 +367,19 @@ export class ParserConfiguration { } } + /** + * Find a package and check that it is for the targeted parser + * + * @param {string} name The name of the package to check + * @return {Configuration} The configuration for the package + */ + protected getPackage(name: string): Configuration { + const config = ConfigurationHandler.get(name); + if (config && this.parsers.indexOf(config.parser) < 0) { + throw Error(`Package ${name} doesn't target the proper parser`); + } + return config; + } /** * Appends a configuration to the overall configuration object. diff --git a/ts/input/tex/require/RequireConfiguration.ts b/ts/input/tex/require/RequireConfiguration.ts index effc717ef..2c529b6d8 100644 --- a/ts/input/tex/require/RequireConfiguration.ts +++ b/ts/input/tex/require/RequireConfiguration.ts @@ -72,7 +72,7 @@ function RegisterExtension(jax: TeX, name: string) { // // Register the extension with the jax's configuration // - (jax as any).configuration.add(handler, jax, options); + (jax as any).configuration.add(extension, jax, options); // // If there are preprocessors, restart so that they run // (we don't have access to the document or MathItem needed to call diff --git a/ts/input/tex/textmacros/TextMacrosConfiguration.ts b/ts/input/tex/textmacros/TextMacrosConfiguration.ts index d7eedbd07..29274d8a2 100644 --- a/ts/input/tex/textmacros/TextMacrosConfiguration.ts +++ b/ts/input/tex/textmacros/TextMacrosConfiguration.ts @@ -37,7 +37,8 @@ import './TextMacrosMappings.js'; /** * The base text macro configuration (used in the TextParser) */ -export const textBase = Configuration.create('text-base', { +export const TextBaseConfiguration = Configuration.create('text-base', { + parser: 'text', handler: { character: ['command', 'text-special'], macro: ['text-macros'] @@ -103,7 +104,7 @@ export const TextMacrosConfiguration = Configuration.create('textmacros', { // Create the configuration and parseOptions objects for the // internal TextParser and add the textBase configuration. // - const textConf = new ParserConfiguration(jax.parseOptions.options.textmacros.packages); + const textConf = new ParserConfiguration(jax.parseOptions.options.textmacros.packages, ['tex', 'text']); textConf.init(); const parseOptions = new ParseOptions(textConf, []); parseOptions.options = jax.parseOptions.options; // share the TeX options From 12beff45a57d34dc4f6180f851395d786e973121 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 26 Mar 2021 17:29:29 +0000 Subject: [PATCH 015/142] Uses correct parsing method for upgreek package. --- ts/input/tex/upgreek/UpgreekConfiguration.ts | 85 ++++++++++---------- 1 file changed, 43 insertions(+), 42 deletions(-) diff --git a/ts/input/tex/upgreek/UpgreekConfiguration.ts b/ts/input/tex/upgreek/UpgreekConfiguration.ts index 2c78e31c2..8bd96b307 100644 --- a/ts/input/tex/upgreek/UpgreekConfiguration.ts +++ b/ts/input/tex/upgreek/UpgreekConfiguration.ts @@ -24,55 +24,56 @@ import {Configuration} from '../Configuration.js'; import ParseMethods from '../ParseMethods.js'; +import {TexConstant} from '../TexConstants.js'; import {CharacterMap} from '../SymbolMap.js'; /** * Upright Greek characters. */ -new CharacterMap('upgreek', ParseMethods.mathchar7, { - upalpha: '\u03B1', - upbeta: '\u03B2', - upgamma: '\u03B3', - updelta: '\u03B4', - upepsilon: '\u03F5', - upzeta: '\u03B6', - upeta: '\u03B7', - uptheta: '\u03B8', - upiota: '\u03B9', - upkappa: '\u03BA', - uplambda: '\u03BB', - upmu: '\u03BC', - upnu: '\u03BD', - upxi: '\u03BE', - upomicron: '\u03BF', - uppi: '\u03C0', - uprho: '\u03C1', - upsigma: '\u03C3', - uptau: '\u03C4', - upupsilon: '\u03C5', - upphi: '\u03D5', - upchi: '\u03C7', - uppsi: '\u03C8', - upomega: '\u03C9', - upvarepsilon: '\u03B5', - upvartheta: '\u03D1', - upvarpi: '\u03D6', - upvarrho: '\u03F1', - upvarsigma: '\u03C2', - upvarphi: '\u03C6', +new CharacterMap('upgreek', ParseMethods.mathchar0mi, { + upalpha: ['\u03B1', {mathvariant: TexConstant.Variant.NORMAL}], + upbeta: ['\u03B2', {mathvariant: TexConstant.Variant.NORMAL}], + upgamma: ['\u03B3', {mathvariant: TexConstant.Variant.NORMAL}], + updelta: ['\u03B4', {mathvariant: TexConstant.Variant.NORMAL}], + upepsilon: ['\u03F5', {mathvariant: TexConstant.Variant.NORMAL}], + upzeta: ['\u03B6', {mathvariant: TexConstant.Variant.NORMAL}], + upeta: ['\u03B7', {mathvariant: TexConstant.Variant.NORMAL}], + uptheta: ['\u03B8', {mathvariant: TexConstant.Variant.NORMAL}], + upiota: ['\u03B9', {mathvariant: TexConstant.Variant.NORMAL}], + upkappa: ['\u03BA', {mathvariant: TexConstant.Variant.NORMAL}], + uplambda: ['\u03BB', {mathvariant: TexConstant.Variant.NORMAL}], + upmu: ['\u03BC', {mathvariant: TexConstant.Variant.NORMAL}], + upnu: ['\u03BD', {mathvariant: TexConstant.Variant.NORMAL}], + upxi: ['\u03BE', {mathvariant: TexConstant.Variant.NORMAL}], + upomicron: ['\u03BF', {mathvariant: TexConstant.Variant.NORMAL}], + uppi: ['\u03C0', {mathvariant: TexConstant.Variant.NORMAL}], + uprho: ['\u03C1', {mathvariant: TexConstant.Variant.NORMAL}], + upsigma: ['\u03C3', {mathvariant: TexConstant.Variant.NORMAL}], + uptau: ['\u03C4', {mathvariant: TexConstant.Variant.NORMAL}], + upupsilon: ['\u03C5', {mathvariant: TexConstant.Variant.NORMAL}], + upphi: ['\u03D5', {mathvariant: TexConstant.Variant.NORMAL}], + upchi: ['\u03C7', {mathvariant: TexConstant.Variant.NORMAL}], + uppsi: ['\u03C8', {mathvariant: TexConstant.Variant.NORMAL}], + upomega: ['\u03C9', {mathvariant: TexConstant.Variant.NORMAL}], + upvarepsilon: ['\u03B5', {mathvariant: TexConstant.Variant.NORMAL}], + upvartheta: ['\u03D1', {mathvariant: TexConstant.Variant.NORMAL}], + upvarpi: ['\u03D6', {mathvariant: TexConstant.Variant.NORMAL}], + upvarrho: ['\u03F1', {mathvariant: TexConstant.Variant.NORMAL}], + upvarsigma: ['\u03C2', {mathvariant: TexConstant.Variant.NORMAL}], + upvarphi: ['\u03C6', {mathvariant: TexConstant.Variant.NORMAL}], - Upgamma: '\u0393', - Updelta: '\u0394', - Uptheta: '\u0398', - Uplambda: '\u039B', - Upxi: '\u039E', - Uppi: '\u03A0', - Upsigma: '\u03A3', - Upupsilon: '\u03A5', - Upphi: '\u03A6', - Uppsi: '\u03A8', - Upomega: '\u03A9', + Upgamma: ['\u0393', {mathvariant: TexConstant.Variant.NORMAL}], + Updelta: ['\u0394', {mathvariant: TexConstant.Variant.NORMAL}], + Uptheta: ['\u0398', {mathvariant: TexConstant.Variant.NORMAL}], + Uplambda: ['\u039B', {mathvariant: TexConstant.Variant.NORMAL}], + Upxi: ['\u039E', {mathvariant: TexConstant.Variant.NORMAL}], + Uppi: ['\u03A0', {mathvariant: TexConstant.Variant.NORMAL}], + Upsigma: ['\u03A3', {mathvariant: TexConstant.Variant.NORMAL}], + Upupsilon: ['\u03A5', {mathvariant: TexConstant.Variant.NORMAL}], + Upphi: ['\u03A6', {mathvariant: TexConstant.Variant.NORMAL}], + Uppsi: ['\u03A8', {mathvariant: TexConstant.Variant.NORMAL}], + Upomega: ['\u03A9', {mathvariant: TexConstant.Variant.NORMAL}] }); From 5794b48f30205e3628e663fd30a4111612358774 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 26 Mar 2021 17:56:06 +0000 Subject: [PATCH 016/142] Replicated exact (good) behaviour of gensymb. --- ts/input/tex/gensymb/GensymbConfiguration.ts | 21 +++++++++++++------- 1 file changed, 14 insertions(+), 7 deletions(-) diff --git a/ts/input/tex/gensymb/GensymbConfiguration.ts b/ts/input/tex/gensymb/GensymbConfiguration.ts index 2e1ea65c0..03102a652 100644 --- a/ts/input/tex/gensymb/GensymbConfiguration.ts +++ b/ts/input/tex/gensymb/GensymbConfiguration.ts @@ -29,20 +29,27 @@ import {CharacterMap} from '../SymbolMap.js'; /** - * Upright Greek characters. + * Ohm symbol as in gensymb. Usually upright, but can be affected by fonts. */ -new CharacterMap('gensymb', ParseMethods.mathchar7, { - degree: '\u00B0', - celsius: '\u2103', - perthousand: '\u2030', - ohm: ['\u03A9', {mathvariant: TexConstant.Variant.NORMAL}], +new CharacterMap('gensymb-ohm', ParseMethods.mathchar7, { + ohm: '\u03A9' +}); + + +/** + * Remaining symbols from the gensymb package are all in \rm font only. + */ +new CharacterMap('gensymb-rest', ParseMethods.mathchar0mo, { + degree: ['\u00B0', {mathvariant: TexConstant.Variant.NORMAL}], + celsius: ['\u2103', {mathvariant: TexConstant.Variant.NORMAL}], + perthousand: ['\u2030', {mathvariant: TexConstant.Variant.NORMAL}], micro: ['\u00B5', {mathvariant: TexConstant.Variant.NORMAL}] }); export const GensymbConfiguration = Configuration.create( 'gensymb', { - handler: {macro: ['gensymb']}, + handler: {macro: ['gensymb-ohm', 'gensymb-rest']}, } ); From 6e9ecd8b5fc64e411ad1c5b02fcbe7c94bc45e4a Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Mon, 8 Mar 2021 15:49:33 +0100 Subject: [PATCH 017/142] [LinkedList, PrioritizedList] Clean up some legacy code --- ts/input/tex/MapHandler.ts | 2 +- ts/util/LinkedList.ts | 13 ------------- ts/util/PrioritizedList.ts | 14 -------------- 3 files changed, 1 insertion(+), 28 deletions(-) diff --git a/ts/input/tex/MapHandler.ts b/ts/input/tex/MapHandler.ts index a044c4e6d..9aac54ffd 100644 --- a/ts/input/tex/MapHandler.ts +++ b/ts/input/tex/MapHandler.ts @@ -105,7 +105,7 @@ export class SubHandler { } } let [env, symbol] = input; - this._fallback.toArray()[0].item(env, symbol); + Array.from(this._fallback)[0].item(env, symbol); } diff --git a/ts/util/LinkedList.ts b/ts/util/LinkedList.ts index 856e84256..83d093a03 100644 --- a/ts/util/LinkedList.ts +++ b/ts/util/LinkedList.ts @@ -100,19 +100,6 @@ export class LinkedList { this.push(...args); } - /** - * Typescript < 2.3 targeted at ES5 doesn't handle - * - * for (const x of this) {...} - * - * so use toArray() to convert to array, when needed - * - * @return {DataClass[]} The list converted to an array - */ - public toArray(): DataClass[] { - return Array.from(this); - } - /** * Used for sorting and merging lists (Overridden by subclasses) * diff --git a/ts/util/PrioritizedList.ts b/ts/util/PrioritizedList.ts index b856d6ff7..90efce135 100644 --- a/ts/util/PrioritizedList.ts +++ b/ts/util/PrioritizedList.ts @@ -113,18 +113,4 @@ export class PrioritizedList { this.items.splice(i, 1); } } - - /** - * Typescript < 2.3 targeted at ES5 doesn't handle - * - * for (const x of this) {...} - * - * so use toArray() to convert to array, when needed - * - * @return {PrioritizedListItem[]} The list converted to an array - */ - public toArray(): PrioritizedListItem[] { - return Array.from(this); - } - } From 4d767ba367f7b7cffc3e7b48f3a86bf725371ee0 Mon Sep 17 00:00:00 2001 From: Ramkumar Ramachandra Date: Tue, 9 Mar 2021 17:23:54 +0100 Subject: [PATCH 018/142] [LinkedList] Modernize iterators --- ts/util/LinkedList.ts | 56 ++++++++++++++----------------------------- 1 file changed, 18 insertions(+), 38 deletions(-) diff --git a/ts/util/LinkedList.ts b/ts/util/LinkedList.ts index 83d093a03..c04994754 100644 --- a/ts/util/LinkedList.ts +++ b/ts/util/LinkedList.ts @@ -63,12 +63,11 @@ export class ListItem { * @param {any} data The data to be stored in the list item * @constructor */ - constructor (data: any = null) { + constructor(data: any = null) { this.data = data; } } - /*****************************************************************/ /** * Implements the generic LinkedList class @@ -77,7 +76,6 @@ export class ListItem { */ export class LinkedList { - /** * The linked list */ @@ -211,48 +209,31 @@ export class LinkedList { } /** - * Make the list iterable and return the data from the items in the list + * An iterator for the list in forward order * - * @return {{next: Function}} The object containing the iterator's next() function + * @yield {DataClass} The next item in the iteration sequence */ - public [Symbol.iterator](): Iterator { - let current = this.list; - return { - /* tslint:disable-next-line:jsdoc-require */ - next() { - current = current.next; - return (current.data === END ? - {value: null, done: true} : - {value: current.data, done: false}) as IteratorResult; - } - }; + public *[Symbol.iterator](): IterableIterator { + let current = this.list.next; + + while (current.data !== END) { + yield current.data as DataClass; + current = current.next; + } } /** * An iterator for the list in reverse order * - * @return {Object} The iterator for walking the list in reverse + * @yield {DataClass} The previous item in the iteration sequence */ - /* tslint:disable-next-line:jsdoc-require */ - public reversed(): IterableIterator | {toArray(): DataClass[]} { - let current = this.list; - return { - /* tslint:disable-next-line:jsdoc-require */ - [Symbol.iterator](): IterableIterator { - return this; - }, - /* tslint:disable-next-line:jsdoc-require */ - next() { - current = current.prev; - return (current.data === END ? - {value: null, done: true} : - {value: current.data, done: false}) as IteratorResult; - }, - /* tslint:disable-next-line:jsdoc-require */ - toArray() { - return Array.from(this) as DataClass[]; - } - }; + public *reversed(): IterableIterator { + let current = this.list.prev; + + while (current.data !== END) { + yield current.data as DataClass; + current = current.prev; + } } /** @@ -369,5 +350,4 @@ export class LinkedList { } return this; } - } From f941979faa9609d2cd27e313f4c70b9f4fae9210 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 15 Apr 2021 13:25:31 -0400 Subject: [PATCH 019/142] Implement lazy complile/typeset extension --- components/src/source.js | 1 + components/src/ui/lazy/build.json | 5 + components/src/ui/lazy/lazy.js | 7 + components/src/ui/lazy/webpack.config.js | 10 + ts/core/MathDocument.ts | 7 +- ts/ui/lazy/LazyHandler.js | 248 +++++++++++++++ ts/ui/lazy/LazyHandler.ts | 385 +++++++++++++++++++++++ 7 files changed, 661 insertions(+), 2 deletions(-) create mode 100644 components/src/ui/lazy/build.json create mode 100644 components/src/ui/lazy/lazy.js create mode 100644 components/src/ui/lazy/webpack.config.js create mode 100644 ts/ui/lazy/LazyHandler.js create mode 100644 ts/ui/lazy/LazyHandler.ts diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..50dfe3f2f 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -45,6 +45,7 @@ export const source = { 'a11y/explorer': `${src}/a11y/explorer/explorer.js`, '[sre]': (typeof window === 'undefined' ? `${src}/../../js/a11y/sre-node.js` : `${src}/../../node_modules/speech-rule-engine/lib/sre_browser.js`), + 'ui/lazy': `${src}/ui/lazy/lazy.js`, 'ui/menu': `${src}/ui/menu/menu.js`, 'ui/safe': `${src}/ui/safe/safe.js`, 'mml-chtml': `${src}/mml-chtml/mml-chtml.js`, diff --git a/components/src/ui/lazy/build.json b/components/src/ui/lazy/build.json new file mode 100644 index 000000000..118dae50f --- /dev/null +++ b/components/src/ui/lazy/build.json @@ -0,0 +1,5 @@ +{ + "component": "ui/lazy", + "targets": ["ui/lazy"] +} + diff --git a/components/src/ui/lazy/lazy.js b/components/src/ui/lazy/lazy.js new file mode 100644 index 000000000..b75c44bbe --- /dev/null +++ b/components/src/ui/lazy/lazy.js @@ -0,0 +1,7 @@ +import './lib/lazy.js'; + +import {LazyHandler} from '../../../../js/ui/lazy/LazyHandler.js'; + +if (MathJax.startup) { + MathJax.startup.extendHandler(handler => LazyHandler(handler)); +} diff --git a/components/src/ui/lazy/webpack.config.js b/components/src/ui/lazy/webpack.config.js new file mode 100644 index 000000000..ce8209ecc --- /dev/null +++ b/components/src/ui/lazy/webpack.config.js @@ -0,0 +1,10 @@ +const PACKAGE = require('../../../webpack.common.js'); + +module.exports = PACKAGE( + 'ui/lazy', // the package to build + '../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/ts/core/MathDocument.ts b/ts/core/MathDocument.ts index 61b71d943..08dc99318 100644 --- a/ts/core/MathDocument.ts +++ b/ts/core/MathDocument.ts @@ -476,8 +476,9 @@ export interface MathDocument { * associated MathItems) * * @param {ContainerList} elements The container DOM elements whose math items are to be removed + * @return {MathItem[]} The removed MathItems */ - clearMathItemsWithin(containers: ContainerList): void; + clearMathItemsWithin(containers: ContainerList): MathItem[]; /** * Get the typeset MathItems that are within a given container. @@ -953,7 +954,9 @@ export abstract class AbstractMathDocument implements MathDocument) { - this.math.remove(...this.getMathItemsWithin(containers)); + const items = this.getMathItemsWithin(containers); + this.math.remove(...items); + return items; } /** diff --git a/ts/ui/lazy/LazyHandler.js b/ts/ui/lazy/LazyHandler.js new file mode 100644 index 000000000..953d371e5 --- /dev/null +++ b/ts/ui/lazy/LazyHandler.js @@ -0,0 +1,248 @@ +"use strict"; +/************************************************************* + * + * Copyright (c) 2019 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.AssistiveMmlHandler = exports.AssistiveMmlMathDocumentMixin = exports.AssistiveMmlMathItemMixin = exports.LimitedMmlVisitor = void 0; +var MathItem_js_1 = require("../core/MathItem.js"); +var SerializedMmlVisitor_js_1 = require("../core/MmlTree/SerializedMmlVisitor.js"); +var Options_js_1 = require("../util/Options.js"); +/*==========================================================================*/ +var LimitedMmlVisitor = /** @class */ (function (_super) { + __extends(LimitedMmlVisitor, _super); + function LimitedMmlVisitor() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + * @override + */ + LimitedMmlVisitor.prototype.getAttributes = function (node) { + /** + * Remove id from attribute output + */ + return _super.prototype.getAttributes.call(this, node).replace(/ ?id=".*?"/, ''); + }; + return LimitedMmlVisitor; +}(SerializedMmlVisitor_js_1.SerializedMmlVisitor)); +exports.LimitedMmlVisitor = LimitedMmlVisitor; +/*==========================================================================*/ +/** + * Add STATE value for having assistive MathML (after TYPESETTING) + */ +MathItem_js_1.newState('ASSISTIVEMML', 153); +/** + * The mixin for adding assistive MathML to MathItems + * + * @param {B} BaseMathItem The MathItem class to be extended + * @return {AssistiveMathItem} The augmented MathItem class + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + * @template B The MathItem class to extend + */ +function AssistiveMmlMathItemMixin(BaseMathItem) { + return /** @class */ (function (_super) { + __extends(class_1, _super); + function class_1() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + * @param {MathDocument} document The MathDocument for the MathItem + * @param {boolean} force True to force assistive MathML evenif enableAssistiveMml is false + */ + class_1.prototype.assistiveMml = function (document, force) { + if (force === void 0) { force = false; } + if (this.state() >= MathItem_js_1.STATE.ASSISTIVEMML) + return; + if (!this.isEscaped && (document.options.enableAssistiveMml || force)) { + var adaptor = document.adaptor; + // + // Get the serialized MathML + // + var mml = document.toMML(this.root).replace(/\n */g, '').replace(//g, ''); + // + // Parse is as HTML and retrieve the element + // + var mmlNodes = adaptor.firstChild(adaptor.body(adaptor.parse(mml, 'text/html'))); + // + // Create a container for the hidden MathML + // + var node = adaptor.node('mjx-assistive-mml', { + unselectable: 'on', display: (this.display ? 'block' : 'inline') + }, [mmlNodes]); + // + // Hide the typeset math from assistive technology and append the MathML that is visually + // hidden from other users + // + adaptor.setAttribute(adaptor.firstChild(this.typesetRoot), 'aria-hidden', 'true'); + adaptor.setStyle(this.typesetRoot, 'position', 'relative'); + adaptor.append(this.typesetRoot, node); + } + this.state(MathItem_js_1.STATE.ASSISTIVEMML); + }; + return class_1; + }(BaseMathItem)); +} +exports.AssistiveMmlMathItemMixin = AssistiveMmlMathItemMixin; +/** + * The mixin for adding assistive MathML to MathDocuments + * + * @param {B} BaseDocument The MathDocument class to be extended + * @return {AssistiveMmlMathDocument} The Assistive MathML MathDocument class + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + * @template B The MathDocument class to extend + */ +function AssistiveMmlMathDocumentMixin(BaseDocument) { + var _a; + return _a = /** @class */ (function (_super) { + __extends(BaseClass, _super); + /** + * Augment the MathItem class used for this MathDocument, and create the serialization visitor. + * + * @override + * @constructor + */ + function BaseClass() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var _this = _super.apply(this, args) || this; + var CLASS = _this.constructor; + var ProcessBits = CLASS.ProcessBits; + if (!ProcessBits.has('assistive-mml')) { + ProcessBits.allocate('assistive-mml'); + } + _this.visitor = new LimitedMmlVisitor(_this.mmlFactory); + _this.options.MathItem = + AssistiveMmlMathItemMixin(_this.options.MathItem); + if ('addStyles' in _this) { + _this.addStyles(CLASS.assistiveStyles); + } + return _this; + } + /** + * @param {MmlNode} node The node to be serializes + * @return {string} The serialization of the node + */ + BaseClass.prototype.toMML = function (node) { + return this.visitor.visitTree(node); + }; + /** + * Add assistive MathML to the MathItems in this MathDocument + */ + BaseClass.prototype.assistiveMml = function () { + if (!this.processed.isSet('assistive-mml')) { + for (var _i = 0, _a = this.math; _i < _a.length; _i++) { + var math = _a[_i]; + math.assistiveMml(this); + } + this.processed.set('assistive-mml'); + } + return this; + }; + /** + * @override + */ + BaseClass.prototype.state = function (state, restore) { + if (restore === void 0) { restore = false; } + _super.prototype.state.call(this, state, restore); + if (state < MathItem_js_1.STATE.ASSISTIVEMML) { + this.processed.clear('assistive-mml'); + } + return this; + }; + return BaseClass; + }(BaseDocument)), + /** + * @override + */ + _a.OPTIONS = __assign(__assign({}, BaseDocument.OPTIONS), { enableAssistiveMml: true, renderActions: Options_js_1.expandable(__assign(__assign({}, BaseDocument.OPTIONS.renderActions), { assistiveMml: [MathItem_js_1.STATE.ASSISTIVEMML] })) }), + /** + * styles needed for the hidden MathML + */ + _a.assistiveStyles = { + 'mjx-assistive-mml': { + position: 'absolute !important', + top: '0px', left: '0px', + clip: 'rect(1px, 1px, 1px, 1px)', + padding: '1px 0px 0px 0px !important', + border: '0px !important', + display: 'block !important', + width: 'auto !important', + overflow: 'hidden !important', + /* + * Don't allow the assistive MathML to become part of the selection + */ + '-webkit-touch-callout': 'none', + '-webkit-user-select': 'none', + '-khtml-user-select': 'none', + '-moz-user-select': 'none', + '-ms-user-select': 'none', + 'user-select': 'none' + }, + 'mjx-assistive-mml[display="block"]': { + width: '100% !important' + } + }, + _a; +} +exports.AssistiveMmlMathDocumentMixin = AssistiveMmlMathDocumentMixin; +/*==========================================================================*/ +/** + * Add assitive MathML support a Handler instance + * + * @param {Handler} handler The Handler instance to enhance + * @return {Handler} The handler that was modified (for purposes of chainging extensions) + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + */ +function AssistiveMmlHandler(handler) { + handler.documentClass = + AssistiveMmlMathDocumentMixin(handler.documentClass); + return handler; +} +exports.AssistiveMmlHandler = AssistiveMmlHandler; diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts new file mode 100644 index 000000000..bab23dc8d --- /dev/null +++ b/ts/ui/lazy/LazyHandler.ts @@ -0,0 +1,385 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Mixin that implements lazy typesetting + * + * @author dpvc@mathjax.org (Davide Cervone) + */ + +import {Handler} from '../../core/Handler.js'; +import {MathDocument, AbstractMathDocument, + MathDocumentConstructor, ContainerList} from '../../core/MathDocument.js'; +import {MathItem, AbstractMathItem, STATE} from '../../core/MathItem.js'; +import {handleRetriesFor} from '../../util/Retries.js'; + +/** + * Add the needed function to the window object. + */ +declare const window: { + requestIdleCallback: (callback: () => void) => void; +}; + +/** + * Generic constructor for Mixins + */ +export type Constructor = new(...args: any[]) => T; + +/*==========================================================================*/ + +/** + * The data to map expression marker IDs back to their MathItem. + */ +export class LazyList { + + /** + * The next ID to use + */ + protected id: number = 0; + + /** + * The map from IDs to MathItems + */ + protected items: Map> = new Map(); + + /** + * Add a MathItem to the list and return its ID + * + * @param {LazyMathItem} math The item to add + * @return {string} The id for the newly added item + */ + public add(math: LazyMathItem): string { + const id = String(this.id++); + this.items.set(id, math); + return id; + } + + /** + * Get the MathItem with the given ID + * + * @param {string} id The ID of the MathItem to get + * @return {LazyMathItem} The MathItem having that ID (if any) + */ + public get(id: string): LazyMathItem { + return this.items.get(id); + } + + /** + * Remove an item from the map + * + * @param {string} id The ID of the MathItem to remove + */ + public delete(id: string) { + return this.items.delete(id); + } + +} + +/*==========================================================================*/ + +/** + * The attribute to use for the ID on the marker node + */ +export const LAZYID = 'data-mjx-lazy'; + +/** + * The properties added to MathItem for lazy typesetting + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + */ +export interface LazyMathItem extends MathItem { + + /** + * True when the MathItem needs to be lazy compiled + */ + lazyCompile: boolean; + + /** + * True when the MathItem needs to be lazy displayed + */ + lazyTypeset: boolean; + + /** + * The DOM node used to mark the location of the math to be lazy typeset + */ + lazyMarker: N; + + /** + * The state to use when rerednering the math item (COMPILED vs TYPESET) + */ + lazyState: number; + + /** + * True if this item is a TeX MathItem + */ + lazyTex: boolean; + +} + +/** + * The mixin for adding laxy typesetting to MathItems + * + * @param {B} BaseMathItem The MathItem class to be extended + * @return {AssistiveMathItem} The augmented MathItem class + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + * @template B The MathItem class to extend + */ +export function LazyMathItemMixin>>( + BaseMathItem: B +): Constructor> & B { + + return class extends BaseMathItem { + + public lazyCompile: boolean = true; + public lazyTypeset: boolean = true; + public lazyMarker: N; + public lazyState: number = STATE.COMPILED; + public lazyTex: boolean = false; + + /** + * Initially don't compile math, just use an empty math item, + * then when the math comes into view (or is before something + * that comes into view), compile it properly and mark the item + * as only needing to be typeset. + * + * @override + */ + public compile(document: LazyMathDocument) { + if (this.lazyCompile) { + if (this.state() < STATE.COMPILED) { + this.lazyTex = (this.inputJax.name === 'TeX'); + this.root = document.mmlFactory.create('math'); + this.state(STATE.COMPILED); + } + } else { + super.compile(document); + this.lazyState = STATE.TYPESET; + } + } + + /** + * Initially, just insert a marker for where the math will go, and + * track it in the lazy list. Then, when it comes into view, + * typeset it properly. + * + * @override + */ + public typeset(document: LazyMathDocument) { + if (this.lazyTypeset) { + if (this.state() < STATE.TYPESET) { + const adaptor = document.adaptor; + if (!this.lazyMarker) { + const id = document.lazyList.add(this); + this.lazyMarker = adaptor.node('mjx-lazy', {[LAZYID]: id}); + this.typesetRoot = adaptor.node('mjx-container', {}, [this.lazyMarker]); + } + this.state(STATE.TYPESET); + } + } else { + super.typeset(document); + } + } + + /** + * When the MathItem is added to the page, set the observer to watch + * for it coming into view so that it can be typeset. + * + * @override + */ + public updateDocument(document: LazyMathDocument) { + super.updateDocument(document); + if (this.lazyTypeset) { + document.lazyObserver.observe(this.lazyMarker as any as Element); + } + } + + }; + +} +/*==========================================================================*/ + +/** + * The properties added to MathDocument for lazy typesetting + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + */ +export interface LazyMathDocument extends AbstractMathDocument { + + /** + * The Intersection Observer used to track the appearance of the expression markers + */ + lazyObserver: IntersectionObserver; + + /** + * The mapping of markers to MathItems + */ + lazyList: LazyList; + +} + +/** + * The mixin for adding lazy typesetting to MathDocuments + * + * @param {B} BaseDocument The MathDocument class to be extended + * @return {LazyMathDocument} The Lazy MathDocument class + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + * @template B The MathDocument class to extend + */ +export function LazyMathDocumentMixin>>( + BaseDocument: B +): MathDocumentConstructor> & B { + + return class BaseClass extends BaseDocument { + + /** + * The Intersection Observer used to track the appearance of the expression markers + */ + public lazyObserver: IntersectionObserver; + + /** + * The mapping of markers to MathItems + */ + public lazyList: LazyList; + + /** + * A promise to make sure our compiling/typesetting is sequential + */ + protected lazyPromise: Promise = Promise.resolve(); + + /** + * Augment the MathItem class used for this MathDocument, + * then create the intersection observer and laxzy list. + * + * @override + * @constructor + */ + constructor(...args: any[]) { + super(...args); + this.options.MathItem = + LazyMathItemMixin>>(this.options.MathItem); + this.lazyObserver = new IntersectionObserver(this.observe.bind(this)); + this.lazyList = new LazyList(); + } + + /** + * The function used by the IntersectionObserver to monitor the markers coming into view. + * When one (or more) does, use an idle callback to process the marker: + * Get the id of the marker and look up the associated MathItem; + * Remove the item from the list (it will be typeset from now on); + * Compile any previous TeX expressions (since they may contain definitions, automatic numbering, etc.); + * Remove the lazy markers from the math item so it will compile and typeset as usual; + * Rerender the math (in order, and handing retries as needed for loading extensions). + * + * @param {IntersectionObserverEntry[]} entries The markers that have come into or out of view. + */ + public observe(entries: IntersectionObserverEntry[]) { + for (const entry of Array.from(entries).reverse()) { + if (entry.isIntersecting) { + this.lazyObserver.unobserve(entry.target); + window.requestIdleCallback(() => { + const id = this.adaptor.getAttribute(entry.target as any as N, LAZYID); + const math = this.lazyList.get(id); + if (!math) return; + this.lazyList.delete(id); + this.compileEarlier(math); + math.lazyMarker = null; + math.lazyTypeset = math.lazyCompile = false; + this.lazyPromise = this.lazyPromise.then(() => { + return handleRetriesFor(() => math.rerender(this, math.lazyState)); + }); + }); + } + } + } + + /** + * If this is a TeX item, look through the math list for any earlier math + * that needs to be compiled and rerender it (it will be compiled, but + * its marker will be reinserted into the page). + */ + public compileEarlier(math: LazyMathItem) { + if (!math.lazyTex) return; + for (const item of this.math) { + if (item === math) break; + const earlier = item as LazyMathItem; + if (earlier.lazyTex && earlier.lazyCompile) { + earlier.lazyCompile = false; + earlier.lazyMarker && this.lazyObserver.unobserve(earlier.lazyMarker as any as Element); + this.lazyPromise = this.lazyPromise.then(() => { + return handleRetriesFor(() => earlier.rerender(this, STATE.COMPILED)); + }); + } + } + } + + /** + * If any of the removed items are observed or in the lazy list, remove them. + * + * @override + */ + public clearMathItemsWithin(containers: ContainerList) { + const items = super.clearMathItemsWithin(containers) as LazyMathItem[]; + for (const math of items) { + const marker = math.lazyMarker; + if (marker) { + this.lazyObserver.unobserve(marker as any as Element); + this.lazyList.delete(this.adaptor.getAttribute(marker, LAZYID)); + } + } + return items; + } + + }; + +} + +/*==========================================================================*/ + +/** + * Add lazy typesetting support a Handler instance + * + * @param {Handler} handler The Handler instance to enhance + * @return {Handler} The handler that was modified (for purposes of chaining extensions) + * + * @template N The HTMLElement node class + * @template T The Text node class + * @template D The Document class + */ +export function LazyHandler(handler: Handler): Handler { + // + // Only update the document class if we can handle IntersectionObservers and idle callbacks + // + if (typeof window !== 'undefined' && window.requestIdleCallback && + typeof IntersectionObserver !== 'undefined') { + handler.documentClass = + LazyMathDocumentMixin>>( + handler.documentClass + ); + } + return handler; +} From df88bab65ec35f9ed55dfe955b1ba57193d045cb Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 16 Apr 2021 11:37:40 -0400 Subject: [PATCH 020/142] Improve chunking of updates by using a set of equations to update and only one idle callback per set. Use the document render() method rather than individually rerendering each math item (which caused multiple page reflows and CSS updates. Still klunky in Chrome CHTML output but good everywhere else. --- ts/ui/lazy/LazyHandler.ts | 188 +++++++++++++++++++++++++++++--------- 1 file changed, 143 insertions(+), 45 deletions(-) diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts index bab23dc8d..f12f53ce5 100644 --- a/ts/ui/lazy/LazyHandler.ts +++ b/ts/ui/lazy/LazyHandler.ts @@ -21,10 +21,11 @@ * @author dpvc@mathjax.org (Davide Cervone) */ -import {Handler} from '../../core/Handler.js'; -import {MathDocument, AbstractMathDocument, - MathDocumentConstructor, ContainerList} from '../../core/MathDocument.js'; -import {MathItem, AbstractMathItem, STATE} from '../../core/MathItem.js'; +import {MathDocumentConstructor, ContainerList} from '../../core/MathDocument.js'; +import {MathItem, STATE} from '../../core/MathItem.js'; +import {HTMLMathItem} from '../../handlers/html/HTMLMathItem.js'; +import {HTMLDocument} from '../../handlers/html/HTMLDocument.js'; +import {HTMLHandler} from '../../handlers/html/HTMLHandler.js'; import {handleRetriesFor} from '../../util/Retries.js'; /** @@ -39,6 +40,11 @@ declare const window: { */ export type Constructor = new(...args: any[]) => T; +/** + * A set of lazy MathItems + */ +export type LazySet = Set; + /*==========================================================================*/ /** @@ -143,7 +149,7 @@ export interface LazyMathItem extends MathItem { * @template D The Document class * @template B The MathItem class to extend */ -export function LazyMathItemMixin>>( +export function LazyMathItemMixin>>( BaseMathItem: B ): Constructor> & B { @@ -212,9 +218,20 @@ export function LazyMathItemMixin extends AbstractMathDocument { +export interface LazyMathDocument extends HTMLDocument { /** * The Intersection Observer used to track the appearance of the expression markers @@ -250,9 +267,9 @@ export interface LazyMathDocument extends AbstractMathDocument * @template B The MathDocument class to extend */ export function LazyMathDocumentMixin>>( +B extends MathDocumentConstructor>>( BaseDocument: B -): MathDocumentConstructor> & B { +): MathDocumentConstructor> & B { return class BaseClass extends BaseDocument { @@ -271,9 +288,27 @@ B extends MathDocumentConstructor>>( */ protected lazyPromise: Promise = Promise.resolve(); + /** + * The function used to typeset a set of lazy MathItems. + * (uses requestIdleCallback if available, or setTimeout otherwise) + */ + protected lazyProcessSet: () => void; + + /** + * True when a set of MathItems is queued for being processed + */ + protected lazyIdle: boolean = false; + + /** + * The set of items that have come into view + */ + protected lazySet: LazySet = new Set(); + /** * Augment the MathItem class used for this MathDocument, - * then create the intersection observer and laxzy list. + * then create the intersection observer and lazy list, + * and bind the lazyProcessSet function to this instance + * so it can be used as a callback more easily. * * @override * @constructor @@ -281,60 +316,124 @@ B extends MathDocumentConstructor>>( constructor(...args: any[]) { super(...args); this.options.MathItem = - LazyMathItemMixin>>(this.options.MathItem); - this.lazyObserver = new IntersectionObserver(this.observe.bind(this)); + LazyMathItemMixin>>(this.options.MathItem); + this.lazyObserver = new IntersectionObserver(this.lazyObserve.bind(this)); this.lazyList = new LazyList(); + const callback = this.lazyHandleSet.bind(this); + this.lazyProcessSet = (typeof window !== 'undefined' && window.requestIdleCallback ? + () => window.requestIdleCallback(callback) : + () => setTimeout(callback, 10)); } /** * The function used by the IntersectionObserver to monitor the markers coming into view. - * When one (or more) does, use an idle callback to process the marker: - * Get the id of the marker and look up the associated MathItem; - * Remove the item from the list (it will be typeset from now on); - * Compile any previous TeX expressions (since they may contain definitions, automatic numbering, etc.); - * Remove the lazy markers from the math item so it will compile and typeset as usual; - * Rerender the math (in order, and handing retries as needed for loading extensions). + * When one (or more) does, add it to or remove it from the set to be processed, and + * if added to the set, queue an idle task, if one isn't already pending. * * @param {IntersectionObserverEntry[]} entries The markers that have come into or out of view. */ - public observe(entries: IntersectionObserverEntry[]) { - for (const entry of Array.from(entries).reverse()) { + protected lazyObserve(entries: IntersectionObserverEntry[]) { + for (const entry of entries) { + const id = this.adaptor.getAttribute(entry.target as any as N, LAZYID); + const math = this.lazyList.get(id); + if (!math) return; if (entry.isIntersecting) { - this.lazyObserver.unobserve(entry.target); - window.requestIdleCallback(() => { - const id = this.adaptor.getAttribute(entry.target as any as N, LAZYID); - const math = this.lazyList.get(id); - if (!math) return; - this.lazyList.delete(id); - this.compileEarlier(math); - math.lazyMarker = null; - math.lazyTypeset = math.lazyCompile = false; - this.lazyPromise = this.lazyPromise.then(() => { - return handleRetriesFor(() => math.rerender(this, math.lazyState)); - }); - }); + this.lazySet.add(id); + if (!this.lazyIdle) { + this.lazyIdle = true; + this.lazyProcessSet(); + } + } else { + this.lazySet.delete(id); } } } /** - * If this is a TeX item, look through the math list for any earlier math - * that needs to be compiled and rerender it (it will be compiled, but - * its marker will be reinserted into the page). + * Mark the MathItems in the set as needing compiling or typesetting, + * and for TeX items, make sure the earlier TeX items are typeset + * (in case they have automatic numbers, or define macros, etc.). + * Then rerender the page to update the visible equations. */ - public compileEarlier(math: LazyMathItem) { - if (!math.lazyTex) return; + protected lazyHandleSet() { + const set = this.lazySet; + this.lazySet = new Set(); + this.lazyPromise = this.lazyPromise.then(() => { + let state = this.compileEarlierItems(set) ? STATE.COMPILED : STATE.TYPESET; + state = this.resetStates(set, state); + this.state(state - 1, null); // reset processed bits to allow reprocessing + return handleRetriesFor(() => { + this.render(); + this.lazyIdle = false; + }); + }); + } + + /** + * Set the states of the MathItems in the set, depending on + * whether they need compiling or just typesetting, and + * update the state needed for the page rerendering. + * + * @param {LazySet} set The set of math items to update + * @param {number} state The state needed for the items + * @return {number} The updated state based on the items + */ + protected resetStates(set: LazySet, state: number): number { + for (const id of set.values()) { + const math = this.lazyList.get(id); + if (math.lazyCompile) { + math.state(STATE.COMPILED - 1); + state = STATE.COMPILED; + } else { + math.state(STATE.TYPESET - 1); + } + math.lazyCompile = math.lazyTypeset = false; + math.lazyMarker && this.lazyObserver.unobserve(math.lazyMarker as any as Element); + } + return state; + } + + /** + * Mark any TeX items (earlier than the ones in the set) to be compiled. + * + * @param {LazySet} set The set of items that are newly visible + * @return {boolean} True if there are TeX items to be typeset + */ + protected compileEarlierItems(set: LazySet): boolean { + let math = this.earliestTex(set); + if (!math) return false; + let compile = false; for (const item of this.math) { if (item === math) break; const earlier = item as LazyMathItem; if (earlier.lazyTex && earlier.lazyCompile) { earlier.lazyCompile = false; earlier.lazyMarker && this.lazyObserver.unobserve(earlier.lazyMarker as any as Element); - this.lazyPromise = this.lazyPromise.then(() => { - return handleRetriesFor(() => earlier.rerender(this, STATE.COMPILED)); - }); + earlier.state(STATE.COMPILED - 1); + compile = true; + } + } + return compile; + } + + /** + * Find the earliest TeX math item in the set, if any. + * + * @param {LazySet} set The set of newly visble math items + * @return {LazyMathItem} The earliest TeX math item in the set, if any + */ + protected earliestTex(set: LazySet): LazyMathItem { + let min: number = null; + let minMath = null; + for (const id of set.values()) { + const math = this.lazyList.get(id); + if (!math.lazyTex) continue; + if (min === null || parseInt(id) < min) { + min = parseInt(id); + minMath = math; } } + return minMath; } /** @@ -370,16 +469,15 @@ B extends MathDocumentConstructor>>( * @template T The Text node class * @template D The Document class */ -export function LazyHandler(handler: Handler): Handler { +export function LazyHandler(handler: HTMLHandler): HTMLHandler { // // Only update the document class if we can handle IntersectionObservers and idle callbacks // - if (typeof window !== 'undefined' && window.requestIdleCallback && - typeof IntersectionObserver !== 'undefined') { + if (typeof IntersectionObserver !== 'undefined') { handler.documentClass = - LazyMathDocumentMixin>>( + LazyMathDocumentMixin>>( handler.documentClass - ); + ) as typeof HTMLDocument; } return handler; } From 0cdd30cb65fcf6dfd41c811519ffe3fe9bc3209e Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 19 Apr 2021 10:57:10 -0400 Subject: [PATCH 021/142] Update the adaptive CSS process to insert new rules into the existing stylesheet rather than completely replacing it. Update how usage data is stored. --- ts/adaptors/HTMLAdaptor.ts | 10 +++ ts/adaptors/liteAdaptor.ts | 7 ++ ts/core/DOMAdaptor.ts | 11 ++++ ts/output/chtml.ts | 70 +++++++++++++++----- ts/output/chtml/FontData.ts | 89 ++++++++++++++++---------- ts/output/chtml/Usage.ts | 76 ++++++++++++++++++++++ ts/output/chtml/Wrapper.ts | 14 +--- ts/output/chtml/Wrappers/TextNode.ts | 2 +- ts/output/chtml/Wrappers/mo.ts | 2 +- ts/output/chtml/Wrappers/msubsup.ts | 10 --- ts/output/chtml/Wrappers/mtr.ts | 9 ++- ts/output/chtml/Wrappers/munderover.ts | 10 +++ ts/output/common/OutputJax.ts | 34 ++++++---- ts/util/StyleList.ts | 9 ++- 14 files changed, 265 insertions(+), 88 deletions(-) create mode 100644 ts/output/chtml/Usage.ts diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index d6e8794b3..d2ab22d70 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -69,6 +69,7 @@ export interface MinHTMLElement { className: string; classList: DOMTokenList; style: OptionList; + sheet?: {insertRule: (rule: string) => void}; childNodes: (N | T)[] | NodeList; firstChild: N | T | Node; @@ -512,6 +513,15 @@ AbstractDOMAdaptor implements MinHTMLAdaptor { return node.style.cssText; } + /** + * @override + */ + public insertRules(node: N, rules: string[]) { + for (const rule of rules.reverse()) { + node.sheet.insertRule(rule); + } + } + /** * @override */ diff --git a/ts/adaptors/liteAdaptor.ts b/ts/adaptors/liteAdaptor.ts index ed828f1ff..558cd4371 100644 --- a/ts/adaptors/liteAdaptor.ts +++ b/ts/adaptors/liteAdaptor.ts @@ -582,6 +582,13 @@ export class LiteAdaptor extends AbstractDOMAdaptor { */ allStyles(node: N): string; + /** + * @param {N} node The stylesheet node where the rule will be added + * @param {string[]} rules The rule to add at the beginning of the stylesheet + */ + insertRules(node: N, rules: string[]): void; + /** * @param {N} node The HTML node whose font size is to be determined * @return {number} The font size (in pixels) of the node @@ -634,6 +640,11 @@ export abstract class AbstractDOMAdaptor implements DOMAdaptor */ public abstract allStyles(node: N): string; + /** + * @override + */ + public abstract insertRules(node: N, rules: string[]): void; + /** * @override */ diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index 53c42901c..e8ba411c8 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -24,7 +24,7 @@ import {CommonOutputJax} from './common/OutputJax.js'; import {CommonWrapper} from './common/Wrapper.js'; import {StyleList} from '../util/Styles.js'; -import {StyleList as CssStyleList} from '../util/StyleList.js'; +import {StyleList as CssStyleList, CssStyles} from '../util/StyleList.js'; import {OptionList} from '../util/Options.js'; import {MathDocument} from '../core/MathDocument.js'; import {MathItem} from '../core/MathItem.js'; @@ -32,6 +32,7 @@ import {MmlNode} from '../core/MmlTree/MmlNode.js'; import {CHTMLWrapper} from './chtml/Wrapper.js'; import {CHTMLWrapperFactory} from './chtml/WrapperFactory.js'; import {CHTMLFontData} from './chtml/FontData.js'; +import {Usage} from './chtml/Usage.js'; import {TeXFont} from './chtml/fonts/tex.js'; import * as LENGTHS from '../util/lengths.js'; import {unicodeChars} from '../util/string.js'; @@ -121,11 +122,15 @@ CommonOutputJax, CHTMLWrapperFactory, CH public static STYLESHEETID = 'MJX-CHTML-styles'; /** - * Used to store the CHTMLWrapper factory, - * the FontData object, and the CssStyles object. + * Used to store the CHTMLWrapper factory. */ public factory: CHTMLWrapperFactory; + /** + * The usage information for the wrapper classes + */ + public wrapperUsage: Usage; + /** * The CHTML stylesheet, once it is constructed */ @@ -138,6 +143,7 @@ CommonOutputJax, CHTMLWrapperFactory, CH constructor(options: OptionList = null) { super(options, CHTMLWrapperFactory as any, TeXFont); this.font.adaptiveCSS(this.options.adaptiveCSS); + this.wrapperUsage = new Usage(); } /** @@ -152,31 +158,62 @@ CommonOutputJax, CHTMLWrapperFactory, CH * @override */ public styleSheet(html: MathDocument) { - if (this.chtmlStyles && !this.options.adaptiveCSS) { + if (this.chtmlStyles) { + if (this.options.adaptiveCSS) { + // + // Update the style sheet rules + // + const styles = new CssStyles(); + this.addWrapperStyles(styles); + this.updateFontStyles(styles); + this.adaptor.insertRules(this.chtmlStyles, styles.getStyleRules()); + } return this.chtmlStyles; // stylesheet is already added to the document } const sheet = this.chtmlStyles = super.styleSheet(html); this.adaptor.setAttribute(sheet, 'id', CHTML.STYLESHEETID); + this.wrapperUsage.update(); return sheet; } + /** + * @param {CssStyles} styles The styles to update with newly used character styles + */ + protected updateFontStyles(styles: CssStyles) { + styles.addStyles(this.font.updateStyles()); + } + /** * @override */ - protected addClassStyles(CLASS: typeof CommonWrapper) { - if (!this.options.adaptiveCSS || (CLASS as typeof CHTMLWrapper).used) { - if ((CLASS as typeof CHTMLWrapper).autoStyle && CLASS.kind !== 'unknown') { - this.cssStyles.addStyles({ - ['mjx-' + CLASS.kind]: { - display: 'inline-block', - 'text-align': 'left' - } - }); + protected addWrapperStyles(styles: CssStyles) { + if (this.options.adaptiveCSS) { + for (const kind of this.wrapperUsage.update()) { + const wrapper = this.factory.getNodeClass(kind) as any as typeof CommonWrapper; + wrapper && this.addClassStyles(wrapper, styles); } - super.addClassStyles(CLASS); + } else { + super.addWrapperStyles(styles); } } + /** + * @override + */ + protected addClassStyles(wrapper: typeof CommonWrapper, styles: CssStyles) { + const CLASS = wrapper as typeof CHTMLWrapper; + if (CLASS.autoStyle && CLASS.kind !== 'unknown') { + styles.addStyles({ + ['mjx-' + CLASS.kind]: { + display: 'inline-block', + 'text-align': 'left' + } + }); + } + this.wrapperUsage.add(CLASS.kind); + super.addClassStyles(wrapper, styles); + } + /** * @param {MmlNode} math The MML node whose HTML is to be produced * @param {N} parent The HTML node to contain the HTML @@ -191,9 +228,8 @@ CommonOutputJax, CHTMLWrapperFactory, CH public clearCache() { this.cssStyles.clear(); this.font.clearCache(); - for (const kind of this.factory.getKinds()) { - this.factory.getNodeClass(kind).used = false; - } + this.wrapperUsage.clear(); + this.chtmlStyles = null; } /** diff --git a/ts/output/chtml/FontData.ts b/ts/output/chtml/FontData.ts index 8241897be..292173c0c 100644 --- a/ts/output/chtml/FontData.ts +++ b/ts/output/chtml/FontData.ts @@ -22,6 +22,7 @@ */ import {CharMap, CharOptions, CharData, VariantData, DelimiterData, FontData, DIRECTION} from '../common/FontData.js'; +import {Usage} from './Usage.js'; import {StringMap} from './Wrapper.js'; import {StyleList, StyleData} from '../../util/StyleList.js'; import {em} from '../../util/lengths.js'; @@ -36,7 +37,6 @@ export * from '../common/FontData.js'; export interface CHTMLCharOptions extends CharOptions { c?: string; // the content value (for css) f?: string; // the font postfix (for css) - used?: boolean; // true when the character has been used on the page } /** @@ -57,7 +57,6 @@ export interface CHTMLVariantData extends VariantData { * The extra data needed for a Delimiter in CHTML output */ export interface CHTMLDelimiterData extends DelimiterData { - used?: boolean; // true when this delimiter has been used on the page } /****************************************************************************/ @@ -104,6 +103,20 @@ export class CHTMLFontData extends FontData = new Usage<[string, number]>(); + + /** + * Data about the delimiters used (for adpative CSS) + */ + public delimUsage: Usage = new Usage(); + + /***********************************************************************/ + /** * @override */ @@ -124,24 +137,9 @@ export class CHTMLFontData extends FontData, but that doesn't work for compiling to ES2015). + */ +export class Usage { + + /** + * The used items. + */ + protected used: Set = new Set(); + + /** + * The items marked as used since last update. + */ + protected needsUpdate: T[] = []; + + /** + * @param {T} item The item that has been used + */ + public add(item: T) { + if (!this.used.has(item)) { + this.needsUpdate.push(item); + } + this.used.add(item); + } + + /** + * @param {T} item The item to check for being used + * @return {boolean} True if the item has been used + */ + public has(item: T): boolean { + return this.used.has(item); + } + + /** + * Clear the usage information + */ + public clear() { + this.used.clear(); + this.needsUpdate = []; + } + + /** + * Get the items marked as used since the last update. + */ + public update() { + const update = this.needsUpdate; + this.needsUpdate = []; + return update; + } + +} + diff --git a/ts/output/chtml/Wrapper.ts b/ts/output/chtml/Wrapper.ts index f43c185e9..caeb7c8c0 100644 --- a/ts/output/chtml/Wrapper.ts +++ b/ts/output/chtml/Wrapper.ts @@ -80,12 +80,6 @@ export interface CHTMLWrapperClass extends AnyWrapperClass { */ autoStyle: boolean; - /** - * True when an instance of this class has been typeset - * (used to control whether the styles for this class need to be output) - */ - used: boolean; - } /*****************************************************************/ @@ -117,12 +111,6 @@ CommonWrapper< */ public static autoStyle = true; - /** - * True when an instance of this class has been typeset - * (used to control whether the styles for this class need to be output) - */ - public static used: boolean = false; - /** * @override */ @@ -181,7 +169,7 @@ CommonWrapper< * Mark this class as having been typeset (so its styles will be output) */ public markUsed() { - (this.constructor as CHTMLWrapperClass).used = true; + this.jax.wrapperUsage.add(this.kind); } /** diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index b1a61931e..c499fb44f 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -81,7 +81,7 @@ CommonTextNodeMixin>(CHTMLWrapper) { this.jax.unknownText(String.fromCodePoint(n), variant) : this.html('mjx-c', {class: this.char(n) + font})); adaptor.append(parent, node); - data.used = true; + this.font.charUsage.add([variant, n]); } } } diff --git a/ts/output/chtml/Wrappers/mo.ts b/ts/output/chtml/Wrappers/mo.ts index 8d398a4fb..d9a3391fd 100644 --- a/ts/output/chtml/Wrappers/mo.ts +++ b/ts/output/chtml/Wrappers/mo.ts @@ -157,8 +157,8 @@ CommonMoMixin>(CHTMLWrapper) { */ protected stretchHTML(chtml: N) { const c = this.getText().codePointAt(0); + this.font.delimUsage.add(c); const delim = this.stretch; - delim.used = true; const stretch = delim.stretch; const content: N[] = []; // diff --git a/ts/output/chtml/Wrappers/msubsup.ts b/ts/output/chtml/Wrappers/msubsup.ts index 7e0c06206..98103ca2c 100644 --- a/ts/output/chtml/Wrappers/msubsup.ts +++ b/ts/output/chtml/Wrappers/msubsup.ts @@ -99,16 +99,6 @@ CommonMsubsupMixin, Constructor, Constructor).labels, row); } } + /** + * @override + */ + public markUsed() { + super.markUsed(); + this.jax.wrapperUsage.add(CHTMLmtr.kind); + } + } diff --git a/ts/output/chtml/Wrappers/munderover.ts b/ts/output/chtml/Wrappers/munderover.ts index ad336e894..c413c5fc4 100644 --- a/ts/output/chtml/Wrappers/munderover.ts +++ b/ts/output/chtml/Wrappers/munderover.ts @@ -221,4 +221,14 @@ CommonMunderoverMixin, Constructor Date: Tue, 27 Apr 2021 11:21:29 -0400 Subject: [PATCH 022/142] Fix problem with detecting whether ex-height can be computed, and don't use the broken getComputedStyle() function in jsdom. --- ts/adaptors/jsdomAdaptor.ts | 28 ++++++++++++++++++++++++++++ ts/output/common/OutputJax.ts | 5 +++-- 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/ts/adaptors/jsdomAdaptor.ts b/ts/adaptors/jsdomAdaptor.ts index d41e6d5b5..d22ca6ca4 100644 --- a/ts/adaptors/jsdomAdaptor.ts +++ b/ts/adaptors/jsdomAdaptor.ts @@ -30,6 +30,8 @@ export class JsdomAdaptor extends HTMLAdaptor { * The default options */ public static OPTIONS: OptionList = { + fontSize: 16, // We can't compute the font size, so always use this + fontFamily: 'Times', // We can't compute the font family, so always use this cjkCharWidth: 1, // Width (in em units) of full width characters unknownCharWidth: .6, // Width (in em units) of unknown (non-full-width) characters unknownCharHeight: .8, // Height (in em units) of unknown characters @@ -74,6 +76,32 @@ export class JsdomAdaptor extends HTMLAdaptor { this.options = userOptions(defaultOptions({}, CLASS.OPTIONS), options); } + /** + * JSDOM's getComputedStyle() implementation is badly broken, and only + * return the styles explicitly set on the given node, not the + * inherited values frmo the cascading style sheets (so it is pretty + * useless). This is somethig we can't really work around, so use + * the default value given in the options instead. Sigh + * + * @override + */ + public fontSize(_node: HTMLElement) { + return this.options.fontSize; + } + + /** + * JSDOM's getComputedStyle() implementation is badly broken, and only + * return the styles explicitly set on the given node, not the + * inherited values frmo the cascading style sheets (so it is pretty + * useless). This is somethig we can't really work around, so use + * the default value given in the options instead. Sigh + * + * @override + */ + public fontFamily(_node: HTMLElement) { + return this.options.fontFamily; + } + /** * @override */ diff --git a/ts/output/common/OutputJax.ts b/ts/output/common/OutputJax.ts index 98ff83cb7..1900c49e3 100644 --- a/ts/output/common/OutputJax.ts +++ b/ts/output/common/OutputJax.ts @@ -423,8 +423,9 @@ export abstract class CommonOutputJax< const adaptor = this.adaptor; const family = (getFamily ? adaptor.fontFamily(node) : ''); const em = adaptor.fontSize(node); - const ex = (adaptor.nodeSize(adaptor.childNode(node, 1) as N)[1] / 60) || (em * this.options.exFactor); - const containerWidth = (adaptor.getStyle(node, 'display') === 'table' ? + const [w, h] = adaptor.nodeSize(adaptor.childNode(node, 1) as N); + const ex = (w ? h / 60 : em * this.options.exFactor); + const containerWidth = (!w ? 1000000 : adaptor.getStyle(node, 'display') === 'table' ? adaptor.nodeSize(adaptor.lastChild(node) as N)[0] - 1 : adaptor.nodeBBox(adaptor.lastChild(node) as N).left - adaptor.nodeBBox(adaptor.firstChild(node) as N).left - 2); From 84f3c05123ce3e2ba93a2fde99bcc37e3fe80d83 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 27 Apr 2021 12:52:33 -0400 Subject: [PATCH 023/142] Only return a DOCTYPE if there is one --- ts/adaptors/HTMLAdaptor.ts | 2 +- ts/adaptors/lite/Document.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index d6e8794b3..f5305e092 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -247,7 +247,7 @@ AbstractDOMAdaptor implements MinHTMLAdaptor { * @override */ public doctype(doc: D) { - return ``; + return (doc.doctype ? `` : ''); } /** diff --git a/ts/adaptors/lite/Document.ts b/ts/adaptors/lite/Document.ts index 1adf393f5..c0ebe8fe1 100644 --- a/ts/adaptors/lite/Document.ts +++ b/ts/adaptors/lite/Document.ts @@ -61,6 +61,6 @@ export class LiteDocument { this.head = new LiteElement('head'), this.body = new LiteElement('body') ]); - this.type = ''; + this.type = ''; } } From 4e07aa85e8e1e4acf00fd8ecb8de04bcd57de610 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 3 May 2021 21:08:07 -0400 Subject: [PATCH 024/142] Fix error where a second use of \| delim causes the wrong size to be used. --- ts/output/common/Wrappers/mo.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/output/common/Wrappers/mo.ts b/ts/output/common/Wrappers/mo.ts index 75dc252dd..1c292da85 100644 --- a/ts/output/common/Wrappers/mo.ts +++ b/ts/output/common/Wrappers/mo.ts @@ -273,7 +273,7 @@ export function CommonMoMixin(Base: T): MoConstruc this.variant = this.font.getSizeVariant(c, i); this.size = i; if (delim.schar && delim.schar[i]) { - this.stretch.c = delim.schar[i]; + this.stretch = {...this.stretch, c: delim.schar[i]}; } return; } From 7a531fe9f2c003e470f9b0a612eff3957c9b5a02 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 5 May 2021 20:35:19 -0400 Subject: [PATCH 025/142] Add support for shifting combining-character accents into place --- ts/output/common/FontData.ts | 1 + ts/output/common/Wrapper.ts | 5 +++-- ts/output/common/Wrappers/TextNode.ts | 1 + ts/output/common/Wrappers/scriptbase.ts | 3 ++- ts/util/BBox.ts | 3 ++- 5 files changed, 9 insertions(+), 4 deletions(-) diff --git a/ts/output/common/FontData.ts b/ts/output/common/FontData.ts index 21ae2b263..29104c962 100644 --- a/ts/output/common/FontData.ts +++ b/ts/output/common/FontData.ts @@ -33,6 +33,7 @@ import {StyleList} from '../../util/StyleList.js'; export interface CharOptions { ic?: number; // italic correction value sk?: number; // skew value + dx?: number; // offset for combining characters unknown?: boolean; // true if not found in the given variant smp?: number; // Math Alphanumeric codepoint this char is mapped to } diff --git a/ts/output/common/Wrapper.ts b/ts/output/common/Wrapper.ts index 8d718fc35..dd606acde 100644 --- a/ts/output/common/Wrapper.ts +++ b/ts/output/common/Wrapper.ts @@ -375,8 +375,9 @@ export class CommonWrapper< */ protected copySkewIC(bbox: BBox) { const first = this.childNodes[0]; - if (first && first.bbox.sk) { - bbox.sk = first.bbox.sk; + if (first) { + first.bbox.sk && (bbox.sk = first.bbox.sk); + first.bbox.dx && (bbox.dx = first.bbox.dx); } const last = this.childNodes[this.childNodes.length - 1]; if (last && last.bbox.ic) { diff --git a/ts/output/common/Wrappers/TextNode.ts b/ts/output/common/Wrappers/TextNode.ts index 67a26d543..f7cad70e1 100644 --- a/ts/output/common/Wrappers/TextNode.ts +++ b/ts/output/common/Wrappers/TextNode.ts @@ -93,6 +93,7 @@ export function CommonTextNodeMixin(Base: T): Text if (d > bbox.d) bbox.d = d; bbox.ic = data.ic || 0; bbox.sk = data.sk || 0; + bbox.dx = data.dx || 0; } if (chars.length > 1) { bbox.sk = 0; diff --git a/ts/output/common/Wrappers/scriptbase.ts b/ts/output/common/Wrappers/scriptbase.ts index 5abf91faf..1f5b685f3 100644 --- a/ts/output/common/Wrappers/scriptbase.ts +++ b/ts/output/common/Wrappers/scriptbase.ts @@ -635,7 +635,7 @@ export function CommonScriptbaseMixin< const widths = boxes.map(box => box.w * box.rscale); widths[0] -= (this.baseRemoveIc && !this.baseCore.node.attributes.get('largeop') ? this.baseIc : 0); const w = Math.max(...widths); - const dw = []; + const dw = [] as number[]; let m = 0; for (const i of widths.keys()) { dw[i] = (align === 'center' ? (w - widths[i]) / 2 : @@ -649,6 +649,7 @@ export function CommonScriptbaseMixin< dw[i] += m; } } + [1, 2].map(i => dw[i] += (boxes[i] ? boxes[i].dx * boxes[0].scale : 0)); return dw; } diff --git a/ts/util/BBox.ts b/ts/util/BBox.ts index 73d7a6065..4d16b6d68 100644 --- a/ts/util/BBox.ts +++ b/ts/util/BBox.ts @@ -71,6 +71,7 @@ export class BBox { public pwidth: string; // percentage width (for tables) public ic: number; // italic correction public sk: number; // skew + public dx: number; // offset for combining characters as accents /* tslint:enable */ /** @@ -96,7 +97,7 @@ export class BBox { this.w = def.w || 0; this.h = ('h' in def ? def.h : -BIGDIMEN); this.d = ('d' in def ? def.d : -BIGDIMEN); - this.L = this.R = this.ic = this.sk = 0; + this.L = this.R = this.ic = this.sk = this.dx = 0; this.scale = this.rscale = 1; this.pwidth = ''; } From 3d5fe943de16ab70f3b3219f40af4caa9a467235 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 6 May 2021 06:02:28 -0400 Subject: [PATCH 026/142] Update node-main for webpack 5 --- components/src/node-main/webpack.config.js | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/components/src/node-main/webpack.config.js b/components/src/node-main/webpack.config.js index 506001ff2..ea41c8c12 100644 --- a/components/src/node-main/webpack.config.js +++ b/components/src/node-main/webpack.config.js @@ -7,6 +7,11 @@ const package = PACKAGE( __dirname // our directory ); -package.output.libraryTarget = 'this'; // make node-main.js exports available to caller +// make node-main.js exports available to caller +package.output.library = { + name: 'init', + type: 'commonjs', + export: 'init' +}; module.exports = package; From d27024fc3fd98c7158b7cbca539aa145b3e347c4 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 6 May 2021 06:25:19 -0400 Subject: [PATCH 027/142] Make mathtools component and add its source, dependencies, and package --- components/src/dependencies.js | 2 ++ .../src/input/tex/extensions/mathtools/build.json | 4 ++++ .../src/input/tex/extensions/mathtools/mathtools.js | 1 + .../input/tex/extensions/mathtools/webpack.config.js | 12 ++++++++++++ components/src/source.js | 1 + ts/input/tex/AllPackages.ts | 3 +++ 6 files changed, 23 insertions(+) create mode 100644 components/src/input/tex/extensions/mathtools/build.json create mode 100644 components/src/input/tex/extensions/mathtools/mathtools.js create mode 100644 components/src/input/tex/extensions/mathtools/webpack.config.js diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..177519a7a 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -18,6 +18,7 @@ export const dependencies = { '[tex]/enclose': ['input/tex-base'], '[tex]/extpfeil': ['input/tex-base', '[tex]/newcommand', '[tex]/ams'], '[tex]/html': ['input/tex-base'], + '[tex]/mathtools': ['input/tex-base', '[tex]/ams'], '[tex]/mhchem': ['input/tex-base', '[tex]/ams'], '[tex]/newcommand': ['input/tex-base'], '[tex]/noerrors': ['input/tex-base'], @@ -49,6 +50,7 @@ const allPackages = [ '[tex]/enclose', '[tex]/extpfeil', '[tex]/html', + '[tex]/mathtools', '[tex]/mhchem', '[tex]/newcommand', '[tex]/noerrors', diff --git a/components/src/input/tex/extensions/mathtools/build.json b/components/src/input/tex/extensions/mathtools/build.json new file mode 100644 index 000000000..22021cfd5 --- /dev/null +++ b/components/src/input/tex/extensions/mathtools/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/mathtools", + "targets": ["input/tex/mathtools"] +} diff --git a/components/src/input/tex/extensions/mathtools/mathtools.js b/components/src/input/tex/extensions/mathtools/mathtools.js new file mode 100644 index 000000000..ec95d66b6 --- /dev/null +++ b/components/src/input/tex/extensions/mathtools/mathtools.js @@ -0,0 +1 @@ +import './lib/mathtools.js'; diff --git a/components/src/input/tex/extensions/mathtools/webpack.config.js b/components/src/input/tex/extensions/mathtools/webpack.config.js new file mode 100644 index 000000000..0c901481f --- /dev/null +++ b/components/src/input/tex/extensions/mathtools/webpack.config.js @@ -0,0 +1,12 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/mathtools', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex/extensions/ams/lib', + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..c729908f1 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -22,6 +22,7 @@ export const source = { '[tex]/enclose': `${src}/input/tex/extensions/enclose/enclose.js`, '[tex]/extpfeil': `${src}/input/tex/extensions/extpfeil/extpfeil.js`, '[tex]/html': `${src}/input/tex/extensions/html/html.js`, + '[tex]/mathtools': `${src}/input/tex/extensions/mathtools/mathtools.js`, '[tex]/mhchem': `${src}/input/tex/extensions/mhchem/mhchem.js`, '[tex]/newcommand': `${src}/input/tex/extensions/newcommand/newcommand.js`, '[tex]/noerrors': `${src}/input/tex/extensions/noerrors/noerrors.js`, diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..233a61ab5 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -36,6 +36,7 @@ import './configmacros/ConfigMacrosConfiguration.js'; import './enclose/EncloseConfiguration.js'; import './extpfeil/ExtpfeilConfiguration.js'; import './html/HtmlConfiguration.js'; +import './mathtools/MathtoolsConfiguration.js'; import './mhchem/MhchemConfiguration.js'; import './newcommand/NewcommandConfiguration.js'; import './noerrors/NoErrorsConfiguration.js'; @@ -62,6 +63,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/enclose', '[tex]/extpfeil', '[tex]/html', + '[tex]/mathtools', '[tex]/mhchem', '[tex]/newcommand', '[tex]/noerrors', @@ -89,6 +91,7 @@ export const AllPackages: string[] = [ 'enclose', 'extpfeil', 'html', + 'mathtools', 'mhchem', 'newcommand', 'noerrors', From 4fe02399c2059226650f6ea6f9798eb04120876e Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 6 May 2021 06:28:18 -0400 Subject: [PATCH 028/142] Fix padding used for extra cells added to make all rows the same size in CHTML --- ts/output/chtml/Wrappers/mtable.ts | 2 +- ts/output/chtml/Wrappers/mtd.ts | 13 ++++++++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/ts/output/chtml/Wrappers/mtable.ts b/ts/output/chtml/Wrappers/mtable.ts index 6316e5f63..b33a1ba97 100644 --- a/ts/output/chtml/Wrappers/mtable.ts +++ b/ts/output/chtml/Wrappers/mtable.ts @@ -199,7 +199,7 @@ CommonMtableMixin, CHTMLmtr, CHTMLConstru const adaptor = this.adaptor; for (const row of adaptor.childNodes(this.itable) as N[]) { while (adaptor.childNodes(row).length < this.numCols) { - adaptor.append(row, this.html('mjx-mtd')); + adaptor.append(row, this.html('mjx-mtd', {'extra': true})); } } } diff --git a/ts/output/chtml/Wrappers/mtd.ts b/ts/output/chtml/Wrappers/mtd.ts index ac56da3fa..6f2f1cc5b 100644 --- a/ts/output/chtml/Wrappers/mtd.ts +++ b/ts/output/chtml/Wrappers/mtd.ts @@ -75,19 +75,22 @@ CommonMtdMixin>(CHTMLWrapper) { 'mjx-labels[align="right"] > mjx-mtr > mjx-mtd': { 'text-align': 'right' }, - 'mjx-mtr mjx-mtd[rowalign="top"], mjx-mlabeledtr mjx-mtd[rowalign="top"]': { + 'mjx-mtd[extra]': { + padding: 0 + }, + 'mjx-mtd[rowalign="top"]': { 'vertical-align': 'top' }, - 'mjx-mtr mjx-mtd[rowalign="center"], mjx-mlabeledtr mjx-mtd[rowalign="center"]': { + 'mjx-mtd[rowalign="center"]': { 'vertical-align': 'middle' }, - 'mjx-mtr mjx-mtd[rowalign="bottom"], mjx-mlabeledtr mjx-mtd[rowalign="bottom"]': { + 'mjx-mtd[rowalign="bottom"]': { 'vertical-align': 'bottom' }, - 'mjx-mtr mjx-mtd[rowalign="baseline"], mjx-mlabeledtr mjx-mtd[rowalign="baseline"]': { + 'mjx-mtd[rowalign="baseline"]': { 'vertical-align': 'baseline' }, - 'mjx-mtr mjx-mtd[rowalign="axis"], mjx-mlabeledtr mjx-mtd[rowalign="axis"]': { + 'mjx-mtd[rowalign="axis"]': { 'vertical-align': '.25em' } }; From b1915eaf9bf957275886d1f595560abf6a65ddb5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 6 May 2021 06:31:00 -0400 Subject: [PATCH 029/142] Make \xrightarrow consistent with \xleftarrow, and don't redefine these with mhchem. --- ts/input/tex/ams/AmsMappings.ts | 2 +- ts/input/tex/mhchem/MhchemConfiguration.ts | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/ts/input/tex/ams/AmsMappings.ts b/ts/input/tex/ams/AmsMappings.ts index fc7678659..b88930efb 100644 --- a/ts/input/tex/ams/AmsMappings.ts +++ b/ts/input/tex/ams/AmsMappings.ts @@ -98,7 +98,7 @@ new sm.CommandMap('AMSmath-macros', { shoveleft: ['HandleShove', TexConstant.Align.LEFT], shoveright: ['HandleShove', TexConstant.Align.RIGHT], - xrightarrow: ['xArrow', 0x2192, 7, 12], + xrightarrow: ['xArrow', 0x2192, 5, 10], xleftarrow: ['xArrow', 0x2190, 10, 5] }, AmsMethods); diff --git a/ts/input/tex/mhchem/MhchemConfiguration.ts b/ts/input/tex/mhchem/MhchemConfiguration.ts index 94e7e5cd5..c6d3fdfcc 100644 --- a/ts/input/tex/mhchem/MhchemConfiguration.ts +++ b/ts/input/tex/mhchem/MhchemConfiguration.ts @@ -80,8 +80,6 @@ new CommandMap( 'Macro', '\\vphantom{-}\\raise2mu{\\kern2mu\\tiny\\text{-}\\kern1mu\\text{-}\\kern1mu\\text{-}\\kern2mu}' ], - xrightarrow: ['xArrow', 0x2192, 5, 6], - xleftarrow: ['xArrow', 0x2190, 7, 3], xleftrightarrow: ['xArrow', 0x2194, 6, 6], xrightleftharpoons: ['xArrow', 0x21CC, 5, 7], // FIXME: doesn't stretch in HTML-CSS output xRightleftharpoons: ['xArrow', 0x21CC, 5, 7], // FIXME: how should this be handled? From 75e3631109ddfdc559f3cca14defade653916ec5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 6 May 2021 06:35:31 -0400 Subject: [PATCH 030/142] Move UnderOver support to ParseUtil, fix vertical center alignment, add \boxed and \framebox, add a lookup() utility function, and make Entry handle cases environments --- ts/input/tex/ParseUtil.ts | 39 +++++- ts/input/tex/base/BaseMappings.ts | 2 + ts/input/tex/base/BaseMethods.ts | 197 +++++++++++++++--------------- ts/util/Options.ts | 15 +++ 4 files changed, 153 insertions(+), 100 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 9ec8ecc15..39633e24f 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/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 {MmlMunderover} from '../../core/MmlTree/MmlNodes/munderover.js'; namespace ParseUtil { @@ -104,7 +105,7 @@ namespace ParseUtil { * @param {number} m The number. * @return {string} The em dimension string. */ - export function Em(m: number): string { + export function Em(m: number): string { if (Math.abs(m) < .0006) { return '0em'; } @@ -352,6 +353,40 @@ namespace ParseUtil { return parser.create('node', 'mtext', [], def, textNode); } + /** + * Create an munderover node with the given script position. + * @param {TexParser} parser The current TeX parser. + * @param {MmlNode} base The base node. + * @param {MmlNode} script The under- or over-script. + * @param {string} pos Either 'over' or 'under'. + * @param {boolean} stack True if super- or sub-scripts should stack. + * @return {MmlNode} The generated node (MmlMunderover or TeXAtom) + */ + export function underOver(parser: TexParser, base: MmlNode, script: MmlNode, pos: string, stack: boolean): MmlNode { + // @test Overline + const symbol = NodeUtil.getForm(base); + if ((symbol && symbol[3] && symbol[3]['movablelimits']) || NodeUtil.getProperty(base, 'movablelimits')) { + // @test Overline Sum + NodeUtil.setProperties(base, {'movablelimits': false}); + } + if (NodeUtil.isType(base, 'munderover') && NodeUtil.isEmbellished(base)) { + // @test Overline Limits + NodeUtil.setProperties(NodeUtil.getCoreMO(base), {lspace: 0, rspace: 0}); + const mo = parser.create('node', 'mo', [], {rspace: 0}); + base = parser.create('node', 'mrow', [mo, base]); + // TODO? add an empty so it's not embellished any more + } + const mml = parser.create('node', 'munderover', [base]) as MmlMunderover; + NodeUtil.setChild(mml, pos === 'over' ? mml.over : mml.under, script); + let node: MmlNode = mml; + if (stack) { + // @test Overbrace 1 2 3, Underbrace, Overbrace Op 1 2 + node = parser.create('node', 'TeXAtom', [mml], {texClass: TEXCLASS.OP, movesupsub: true}); + } + NodeUtil.setProperty(node, 'subsupOK', true); + return node; + } + /** * Trim spaces from a string. * @param {string} text The string to clean. @@ -383,7 +418,7 @@ namespace ParseUtil { } else if (align === 'b') { array.arraydef.align = 'baseline -1'; } else if (align === 'c') { - array.arraydef.align = 'center'; + array.arraydef.align = 'axis'; } else if (align) { array.arraydef.align = align; } // FIXME: should be an error? diff --git a/ts/input/tex/base/BaseMappings.ts b/ts/input/tex/base/BaseMappings.ts index 405cbdcdd..c191dd208 100644 --- a/ts/input/tex/base/BaseMappings.ts +++ b/ts/input/tex/base/BaseMappings.ts @@ -607,6 +607,8 @@ new sm.CommandMap('macros', { text: 'HBox', mbox: ['HBox', 0], fbox: 'FBox', + boxed: ['Macro', '\\fbox{$\\displaystyle{#1}$}', 1], + framebox: 'FrameBox', strut: 'Strut', mathstrut: ['Macro', '\\vphantom{(}'], diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 3339a3230..9e88b9c18 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -37,6 +37,7 @@ import {MmlMunderover} from '../../../core/MmlTree/MmlNodes/munderover.js'; import {Label} from '../Tags.js'; import {em} from '../../../util/lengths.js'; import {entities} from '../../../util/Entities.js'; +import {lookup} from '../../../util/Options.js'; // Namespace @@ -610,35 +611,11 @@ BaseMethods.Accent = function(parser: TexParser, name: string, accent: string, s * @param {boolean} stack True if stacked operator. */ BaseMethods.UnderOver = function(parser: TexParser, name: string, c: string, stack: boolean) { - // @test Overline - let base = parser.ParseArg(name); - let symbol = NodeUtil.getForm(base); - if ((symbol && symbol[3] && symbol[3]['movablelimits']) - || NodeUtil.getProperty(base, 'movablelimits')) { - // @test Overline Sum - NodeUtil.setProperties(base, {'movablelimits': false}); - } - let mo; - if (NodeUtil.isType(base, 'munderover') && NodeUtil.isEmbellished(base)) { - // @test Overline Limits - NodeUtil.setProperties(NodeUtil.getCoreMO(base), {lspace: 0, rspace: 0}); - mo = parser.create('node', 'mo', [], {rspace: 0}); - base = parser.create('node', 'mrow', [mo, base]); - // TODO? add an empty so it's not embellished any more - } - const mml = parser.create('node', 'munderover', [base]) as MmlMunderover; const entity = NodeUtil.createEntity(c); - mo = parser.create('token', 'mo', {stretchy: true, accent: true}, entity); - - NodeUtil.setChild(mml, name.charAt(1) === 'o' ? mml.over : mml.under, mo); - let node: MmlNode = mml; - if (stack) { - // @test Overbrace 1 2 3, Underbrace, Overbrace Op 1 2 - node = parser.create('node', 'TeXAtom', [mml], - {texClass: TEXCLASS.OP, movesupsub: true}); - } - NodeUtil.setProperty(node, 'subsupOK', true); - parser.Push(node); + const mo = parser.create('token', 'mo', {stretchy: true, accent: true}, entity); + const pos = (name.charAt(1) === 'o' ? 'over' : 'under'); + const base = parser.ParseArg(name); + parser.Push(ParseUtil.underOver(parser, base, mo, pos, stack)); }; @@ -1012,6 +989,27 @@ BaseMethods.FBox = function(parser: TexParser, name: string) { parser.Push(node); }; +/** + * Handle framed boxes with options. + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ +BaseMethods.FrameBox = function(parser: TexParser, name: string) { + const width = parser.GetBrackets(name); + const pos = parser.GetBrackets(name) || 'c'; + let mml = ParseUtil.internalMath(parser, parser.GetArgument(name)); + if (width) { + mml = [parser.create('node', 'mpadded', mml, { + width, + 'data-align': lookup(pos, {l: 'left', r: 'right'}, 'center') + })]; + } + const node = parser.create('node', 'TeXAtom', + [parser.create('node', 'menclose', mml, {notation: 'box'})], + {texClass: TEXCLASS.ORD}); + parser.Push(node); +}; + /** * Handle \\not. @@ -1113,80 +1111,83 @@ BaseMethods.Matrix = function(parser: TexParser, _name: string, */ BaseMethods.Entry = function(parser: TexParser, name: string) { // @test Label, Array, Cross Product Formula - parser.Push( - parser.itemFactory.create('cell').setProperties({isEntry: true, name: name})); - if (parser.stack.Top().getProperty('isCases')) { - // - // Make second column be in \text{...} (unless it is already - // in a \text{...}, for backward compatibility). - // - const str = parser.string; - let braces = 0, close = -1, i = parser.i, m = str.length; - // - // Look through the string character by character... - // - while (i < m) { - const c = str.charAt(i); - if (c === '{') { - // - // Increase the nested brace count and go on - // - braces++; - i++; - } else if (c === '}') { - // - // If there are too many close braces, just end (we will get an - // error message later when the rest of the string is parsed) - // Otherwise - // decrease the nested brace count, - // if it is now zero and we haven't already marked the end of the - // first brace group, record the position (use to check for \text{} later) - // go on to the next character. - // - if (braces === 0) { - m = 0; - } else { - braces--; - if (braces === 0 && close < 0) { - close = i - parser.i; - } - i++; - } - } else if (c === '&' && braces === 0) { - // - // Extra alignment tabs are not allowed in cases - // - // @test ExtraAlignTab - throw new TexError('ExtraAlignTab', 'Extra alignment tab in \\cases text'); - } else if (c === '\\') { - // - // If the macro is \cr or \\, end the search, otherwise skip the macro - // (multi-letter names don't matter, as we will skip the rest of the - // characters in the main loop) - // - if (str.substr(i).match(/^((\\cr)[^a-zA-Z]|\\\\)/)) { - m = 0; - } else { - i += 2; - } + parser.Push(parser.itemFactory.create('cell').setProperties({isEntry: true, name: name})); + const top = parser.stack.Top(); + const env = top.getProperty('casesEnv') as string; + const cases = top.getProperty('isCases'); + if (!cases && !env) return; + // + // Make second column be in \text{...} (unless it is already + // in a \text{...}, for backward compatibility). + // + const str = parser.string; + let braces = 0, close = -1, i = parser.i, m = str.length; + const end = (env ? new RegExp(`^\\\\end\\s*\\{${env.replace(/\*/, '\\*')}\\}`) : null); + // + // Look through the string character by character... + // + while (i < m) { + const c = str.charAt(i); + if (c === '{') { + // + // Increase the nested brace count and go on + // + braces++; + i++; + } else if (c === '}') { + // + // If there are too many close braces, just end (we will get an + // error message later when the rest of the string is parsed) + // Otherwise + // decrease the nested brace count, + // if it is now zero and we haven't already marked the end of the + // first brace group, record the position (use to check for \text{} later) + // go on to the next character. + // + if (braces === 0) { + m = 0; } else { - // - // Go on to the next character - // + braces--; + if (braces === 0 && close < 0) { + close = i - parser.i; + } i++; } + } else if (c === '&' && braces === 0) { + // + // Extra alignment tabs are not allowed in cases + // + // @test ExtraAlignTab + throw new TexError('ExtraAlignTab', 'Extra alignment tab in \\cases text'); + } else if (c === '\\') { + // + // If the macro is \cr or \\, end the search, otherwise skip the macro + // (multi-letter names don't matter, as we will skip the rest of the + // characters in the main loop) + // + const rest = str.substr(i); + if (rest.match(/^((\\cr)[^a-zA-Z]|\\\\)/) || (end && rest.match(end))) { + m = 0; + } else { + i += 2; + } + } else { + // + // Go on to the next character + // + i++; } - // - // Check if the second column text is already in \text{}; - // If not, process the second column as text and continue parsing from there, - // (otherwise process the second column as normal, since it is in \text{} - // - const text = str.substr(parser.i, i - parser.i); - if (!text.match(/^\s*\\text[^a-zA-Z]/) || close !== text.replace(/\s+$/, '').length - 1) { - const internal = ParseUtil.internalMath(parser, text, 0); - parser.PushAll(internal); - parser.i = i; - } + } + // + // Check if the second column text is already in \text{}; + // If not, process the second column as text and continue parsing from there, + // (otherwise process the second column as normal, since it is in \text{} + // + const text = str.substr(parser.i, i - parser.i); + if (!text.match(/^\s*\\text[^a-zA-Z]/) || close !== text.replace(/\s+$/, '').length - 1) { + const internal = ParseUtil.internalMath(parser, ParseUtil.trimSpaces(text), 0); + parser.PushAll(internal); + parser.i = i; } }; diff --git a/ts/util/Options.ts b/ts/util/Options.ts index f64ff2437..43aedf872 100644 --- a/ts/util/Options.ts +++ b/ts/util/Options.ts @@ -324,3 +324,18 @@ export function separateOptions(options: OptionList, ...objects: OptionList[]): results.unshift(options); return results; } + + +/*****************************************************************/ +/** + * Look up a value fromn object literal, being sure it is an + * actual property (not inherited), with a default if not found. + * + * @param {string} name The name of the key to look up. + * @param {OptionList} lookup The list of options to check. + * @param {any} def The default value if the key isn't found. + */ +export function lookup(name: string, lookup: OptionList, def: any = null) { + return (lookup.hasOwnProperty(name) ? lookup[name] : def); +} + From dafcfe171f58d3b0a64bdf242edc401fe5ad819d Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 7 May 2021 13:03:52 -0400 Subject: [PATCH 031/142] Move checking for max macros into a ParseUtil function, and make a service method for setting the row spacing of the current row. --- ts/input/tex/ParseUtil.ts | 20 +++++++++++++ ts/input/tex/base/BaseItems.ts | 23 +++++++++++++++ ts/input/tex/base/BaseMethods.ts | 31 ++++---------------- ts/input/tex/newcommand/NewcommandMethods.ts | 6 +--- ts/input/tex/physics/PhysicsMethods.ts | 6 +--- 5 files changed, 51 insertions(+), 35 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 39633e24f..2517f296e 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -485,6 +485,26 @@ namespace ParseUtil { return s1 + s2; } + /** + * Repoort an error if there are too many macro substitutions. + * @param {TexParser} parser The current TeX parser. + * @param {boolean} isMacro True if we are substituting a macro, false for environment. + */ + export function checkMaxMacros(parser: TexParser, isMacro: boolean = true) { + if (++parser.macroCount <= parser.configuration.options['maxMacros']) { + return; + } + if (isMacro) { + throw new TexError('MaxMacroSub1', + 'MathJax maximum macro substitution count exceeded; ' + + 'is here a recursive macro call?'); + } else { + throw new TexError('MaxMacroSub2', + 'MathJax maximum substitution count exceeded; ' + + 'is there a recursive latex environment?'); + } + } + /** * Check for bad nesting of equation environments diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index f4f8ba42c..a4072c70a 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -1018,6 +1018,29 @@ export class ArrayItem extends BaseItem { } } + /** + * Adds a row-spacing to the current row (padding out the rowspacing if needed to get there). + * + * @param {string} spacing The rowspacing to use for the current row. + */ + public addRowSpacing(spacing: string) { + if (this.arraydef['rowspacing']) { + const rows = (this.arraydef['rowspacing'] as string).split(/ /); + if (!this.getProperty('rowspacing')) { + // @test Array Custom Linebreak + let dimem = ParseUtil.dimen2em(rows[0]); + this.setProperty('rowspacing', dimem); + } + const rowspacing = this.getProperty('rowspacing') as number; + while (rows.length < this.table.length) { + rows.push(ParseUtil.Em(rowspacing)); + } + rows[this.table.length - 1] = ParseUtil.Em( + Math.max(0, rowspacing + ParseUtil.dimen2em(spacing))); + this.arraydef['rowspacing'] = rows.join(' '); + } + } + } diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 9e88b9c18..7b3276e75 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -1231,25 +1231,14 @@ BaseMethods.CrLaTeX = function(parser: TexParser, name: string, nobrackets: bool } } parser.Push( - parser.itemFactory.create('cell').setProperties({isCR: true, name: name, linebreak: true}) ); + parser.itemFactory.create('cell').setProperties({isCR: true, name: name, linebreak: true}) + ); const top = parser.stack.Top(); let node: MmlNode; if (top instanceof sitem.ArrayItem) { // @test Array - if (n && top.arraydef['rowspacing']) { - const rows = (top.arraydef['rowspacing'] as string).split(/ /); - if (!top.getProperty('rowspacing')) { - // @test Array Custom Linebreak - let dimem = ParseUtil.dimen2em(rows[0]); - top.setProperty('rowspacing', dimem); - } - const rowspacing = top.getProperty('rowspacing') as number; - while (rows.length < top.table.length) { - rows.push(ParseUtil.Em(rowspacing)); - } - rows[top.table.length - 1] = ParseUtil.Em( - Math.max(0, rowspacing + ParseUtil.dimen2em(n))); - top.arraydef['rowspacing'] = rows.join(' '); + if (n) { + top.addRowSpacing(n); } } else { if (n) { @@ -1339,11 +1328,7 @@ BaseMethods.BeginEnd = function(parser: TexParser, name: string) { // Remember the user defined environment we are closing. parser.stack.env['closing'] = env; } - if (++parser.macroCount > parser.configuration.options['maxMacros']) { - throw new TexError('MaxMacroSub2', - 'MathJax maximum substitution count exceeded; ' + - 'is there a recursive latex environment?'); - } + ParseUtil.checkMaxMacros(parser, false); parser.parse('environment', [parser, env]); }; @@ -1570,11 +1555,7 @@ BaseMethods.Macro = function(parser: TexParser, name: string, } parser.string = ParseUtil.addArgs(parser, macro, parser.string.slice(parser.i)); parser.i = 0; - if (++parser.macroCount > parser.configuration.options['maxMacros']) { - throw new TexError('MaxMacroSub1', - 'MathJax maximum macro substitution count exceeded; ' + - 'is there a recursive macro call?'); - } + ParseUtil.checkMaxMacros(parser); }; diff --git a/ts/input/tex/newcommand/NewcommandMethods.ts b/ts/input/tex/newcommand/NewcommandMethods.ts index 507a0cd43..86d2a9949 100644 --- a/ts/input/tex/newcommand/NewcommandMethods.ts +++ b/ts/input/tex/newcommand/NewcommandMethods.ts @@ -214,11 +214,7 @@ NewcommandMethods.MacroWithTemplate = function (parser: TexParser, name: string, parser.string = ParseUtil.addArgs(parser, text, parser.string.slice(parser.i)); parser.i = 0; - if (++parser.macroCount > parser.configuration.options['maxMacros']) { - throw new TexError('MaxMacroSub1', - 'MathJax maximum macro substitution count exceeded; ' + - 'is here a recursive macro call?'); - } + ParseUtil.checkMaxMacros(parser); }; diff --git a/ts/input/tex/physics/PhysicsMethods.ts b/ts/input/tex/physics/PhysicsMethods.ts index 877b0b7fe..5d61033dc 100644 --- a/ts/input/tex/physics/PhysicsMethods.ts +++ b/ts/input/tex/physics/PhysicsMethods.ts @@ -291,11 +291,7 @@ PhysicsMethods.StarMacro = function(parser: TexParser, name: string, macro = ParseUtil.substituteArgs(parser, args, macro); parser.string = ParseUtil.addArgs(parser, macro, parser.string.slice(parser.i)); parser.i = 0; - if (++parser.macroCount > parser.configuration.options['maxMacros']) { - throw new TexError('MaxMacroSub1', - 'MathJax maximum macro substitution count exceeded; ' + - 'is there a recursive macro call?'); - } + ParseUtil.checkMaxMacros(parser); }; From 7989667a73228d62567875b7c5ad78378b3dfa97 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 7 May 2021 13:58:59 -0400 Subject: [PATCH 032/142] Make service functions for getting CS name and arg count. --- ts/input/tex/newcommand/NewcommandMethods.ts | 33 ++-------------- ts/input/tex/newcommand/NewcommandUtil.ts | 41 +++++++++++++++++++- 2 files changed, 43 insertions(+), 31 deletions(-) diff --git a/ts/input/tex/newcommand/NewcommandMethods.ts b/ts/input/tex/newcommand/NewcommandMethods.ts index 86d2a9949..a9993e7aa 100644 --- a/ts/input/tex/newcommand/NewcommandMethods.ts +++ b/ts/input/tex/newcommand/NewcommandMethods.ts @@ -44,28 +44,10 @@ let NewcommandMethods: Record = {}; */ NewcommandMethods.NewCommand = function(parser: TexParser, name: string) { // @test Newcommand Simple - let cs = ParseUtil.trimSpaces(parser.GetArgument(name)); - let n = parser.GetBrackets(name); + let cs = NewcommandUtil.GetCsNameArgument(parser, name); + let n = NewcommandUtil.GetArgCount(parser, name); let opt = parser.GetBrackets(name); let def = parser.GetArgument(name); - if (cs.charAt(0) === '\\') { - // @test Newcommand Simple - cs = cs.substr(1); - } - if (!cs.match(/^(.|[a-z]+)$/i)) { - // @test Illegal CS - throw new TexError('IllegalControlSequenceName', - 'Illegal control sequence name for %1', name); - } - if (n) { - // @test Newcommand Optional, Newcommand Arg, Newcommand Arg Optional - n = ParseUtil.trimSpaces(n); - if (!n.match(/^[0-9]+$/)) { - // @test Illegal Argument Number - throw new TexError('IllegalParamNumber', - 'Illegal number of parameters specified in %1', name); - } - } NewcommandUtil.addMacro(parser, cs, NewcommandMethods.Macro, [def, n, opt]); }; @@ -78,19 +60,10 @@ NewcommandMethods.NewCommand = function(parser: TexParser, name: string) { NewcommandMethods.NewEnvironment = function(parser: TexParser, name: string) { // @test Newenvironment Empty, Newenvironment Content let env = ParseUtil.trimSpaces(parser.GetArgument(name)); - let n = parser.GetBrackets(name); + let n = NewcommandUtil.GetArgCount(parser, name); let opt = parser.GetBrackets(name); let bdef = parser.GetArgument(name); let edef = parser.GetArgument(name); - if (n) { - // @test Newenvironment Optional, Newenvironment Arg Optional - n = ParseUtil.trimSpaces(n); - if (!n.match(/^[0-9]+$/)) { - // @test Illegal Parameter Number - throw new TexError('IllegalParamNumber', - 'Illegal number of parameters specified in %1', name); - } - } NewcommandUtil.addEnvironment(parser, env, NewcommandMethods.BeginEnv, [true, bdef, edef, n, opt]); }; diff --git a/ts/input/tex/newcommand/NewcommandUtil.ts b/ts/input/tex/newcommand/NewcommandUtil.ts index b762f1fae..45e2b7a74 100644 --- a/ts/input/tex/newcommand/NewcommandUtil.ts +++ b/ts/input/tex/newcommand/NewcommandUtil.ts @@ -75,7 +75,6 @@ namespace NewcommandUtil { return new Symbol(name, char, attrs); } - /** * Get the next CS name or give an error. * @param {TexParser} parser The calling parser. @@ -94,6 +93,46 @@ namespace NewcommandUtil { return cs.substr(1); } + /** + * Get a control sequence name as an argument (doesn't require the backslash) + * @param {TexParser} parser The calling parser. + * @param {string} name The macro that is getting the name. + * @return {string} The control sequence. + */ + export function GetCsNameArgument(parser: TexParser, name: string): string { + let cs = ParseUtil.trimSpaces(parser.GetArgument(name)); + if (cs.charAt(0) === '\\') { + // @test Newcommand Simple + cs = cs.substr(1); + } + if (!cs.match(/^(.|[a-z]+)$/i)) { + // @test Illegal CS + throw new TexError('IllegalControlSequenceName', + 'Illegal control sequence name for %1', name); + } + return cs; + } + + /** + * Get the number of arguments for a macro definition + * @param {TexParser} parser The calling parser. + * @param {string} name The macro that is getting the argument count. + * @return {string} The number of arguments (or blank). + */ + export function GetArgCount(parser: TexParser, name: string): string { + let n = parser.GetBrackets(name); + if (n) { + // @test Newcommand Optional, Newcommand Arg, Newcommand Arg Optional + // @test Newenvironment Optional, Newenvironment Arg Optional + n = ParseUtil.trimSpaces(n); + if (!n.match(/^[0-9]+$/)) { + // @test Illegal Argument Number + throw new TexError('IllegalParamNumber', + 'Illegal number of parameters specified in %1', name); + } + } + return n; + } /** * Get a \def parameter template. From 46e88ec08eca399a77f57e2a98c0fc23dd2b307e Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 10 May 2021 12:33:02 -0400 Subject: [PATCH 033/142] Don't use cramped style for mtables --- ts/core/MmlTree/MmlNodes/mtable.ts | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/ts/core/MmlTree/MmlNodes/mtable.ts b/ts/core/MmlTree/MmlNodes/mtable.ts index 3e73e03bc..0b94ae881 100644 --- a/ts/core/MmlTree/MmlNodes/mtable.ts +++ b/ts/core/MmlTree/MmlNodes/mtable.ts @@ -106,10 +106,11 @@ export class MmlMtable extends AbstractMmlNode { /** * Make sure all children are mtr or mlabeledtr nodes * Inherit the table attributes, and set the display attribute based on the table's displaystyle attribute + * Reset the prime value to false * * @override */ - protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, prime: boolean) { + protected setChildInheritedAttributes(attributes: AttributeList, display: boolean, level: number, _prime: boolean) { for (const child of this.childNodes) { if (!child.isKind('mtr')) { this.replaceChild(this.factory.create('mtr'), child) @@ -125,7 +126,7 @@ export class MmlMtable extends AbstractMmlNode { const ralign = split(this.attributes.get('rowalign') as string); for (const child of this.childNodes) { attributes.rowalign[1] = ralign.shift() || attributes.rowalign[1]; - child.setInheritedAttributes(attributes, display, level, prime); + child.setInheritedAttributes(attributes, display, level, false); } } From cdc97af33e482b6f1623f40c518d4c9be3048418 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 10 May 2021 17:39:36 -0400 Subject: [PATCH 034/142] Add most missing commands and environments --- .../tex/mathtools/MathtoolsConfiguration.ts | 261 ++++----- ts/input/tex/mathtools/MathtoolsItems.ts | 70 +++ ts/input/tex/mathtools/MathtoolsMappings.ts | 191 +++++++ ts/input/tex/mathtools/MathtoolsMethods.ts | 511 ++++++++++++++++++ ts/input/tex/mathtools/MathtoolsTags.ts | 116 ++++ ts/input/tex/mathtools/MathtoolsUtil.ts | 86 +++ 6 files changed, 1073 insertions(+), 162 deletions(-) create mode 100644 ts/input/tex/mathtools/MathtoolsItems.ts create mode 100644 ts/input/tex/mathtools/MathtoolsMappings.ts create mode 100644 ts/input/tex/mathtools/MathtoolsMethods.ts create mode 100644 ts/input/tex/mathtools/MathtoolsTags.ts create mode 100644 ts/input/tex/mathtools/MathtoolsUtil.ts diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts index 6faf3f4fb..e7449dee5 100644 --- a/ts/input/tex/mathtools/MathtoolsConfiguration.ts +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -1,5 +1,5 @@ /************************************************************* - * Copyright (c) 2019-2020 MathJax Consortium + * Copyright (c) 2020-2021 MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -14,183 +14,120 @@ * limitations under the License. */ +/** + * @fileoverview Configuration file for the mathtools package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + * @author dpvc@mathjax.org (Davide P. Cervone) + */ -import {ArrayItem} from '../base/BaseItems.js'; -import {MultlineItem} from '../ams/AmsItems.js'; -import {StackItem} from '../StackItem.js'; -import ParseUtil from '../ParseUtil.js'; -import ParseMethods from '../ParseMethods.js'; import {Configuration} from '../Configuration.js'; -import {ParseMethod} from '../Types.js'; -import {AmsMethods} from '../ams/AmsMethods.js'; -import BaseMethods from '../base/BaseMethods.js'; -import TexParser from '../TexParser.js'; -import TexError from '../TexError.js'; -import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; -import {CommandMap, EnvironmentMap} from '../SymbolMap.js'; +import {CommandMap} from '../SymbolMap.js'; import NodeUtil from '../NodeUtil.js'; -import {TexConstant} from '../TexConstants.js'; - - -let MathtoolsMethods: Record = {}; +import {expandable} from '../../../util/Options.js'; +import {ParserConfiguration} from '../Configuration.js'; +import {TeX} from '../../tex.js'; +import ParseOptions from '../ParseOptions.js'; + +import './MathtoolsMappings.js'; +import {MathtoolsUtil} from './MathtoolsUtil.js'; +import {MathtoolsTagFormat} from './MathtoolsTags.js'; +import {MultlinedItem} from './MathtoolsItems.js'; + +/** + * The name of the paried-delimiters command map. + */ +export const PAIREDDELIMS = 'mathtools-paired-delims'; -export class MultlinedItem extends MultlineItem { +/** + * Create the paired-delimiters command map, and link it into the configuration. + * @param {ParserConfiguration} config The current configuration. + */ +function initMathtools(config: ParserConfiguration) { + new CommandMap(PAIREDDELIMS, {}, {}); + config.append(Configuration.local({handler: {macro: [PAIREDDELIMS]}, priority: -5})); +} - /** - * @override - */ - get kind() { - return 'multlined'; +/** + * Add any pre-defined paried delimiters, and subclass the configured tag format. + * @param {ParserConfiguration} config The current configuration. + * @param {TeX} jac The TeX input jax + */ +function configMathtools(config: ParserConfiguration, jax: TeX) { + const parser = jax.parseOptions; + const pairedDelims = parser.options.mathtools.pairedDelimiters; + for (const cs of Object.keys(pairedDelims)) { + MathtoolsUtil.addPairedDelims(parser, cs, pairedDelims[cs]); } + MathtoolsTagFormat(config, jax); +} - - /** - * @override - */ - public EndTable() { - if (this.Size() || this.row.length) { - this.EndEntry(); - this.EndRow(); - } - if (this.table.length) { - let first = NodeUtil.getChildren(this.table[0])[0]; - let m = this.table.length - 1; - if (NodeUtil.getAttribute(first, 'columnalign') !== TexConstant.Align.RIGHT) { - first.appendChild( - this.create('node', 'mspace', [], - { width: this.factory.configuration.options['MultlineGap'] || '2em' }) - ); +/** + * A filter to fix up mmultiscripts elements. + * @param {ParseOptions} data The parse options. + */ +export function fixPrescripts({data}: {data: ParseOptions}) { + for (const node of data.getList('mmultiscripts')) { + if (!node.getProperty('fixPrescript')) continue; + const childNodes = NodeUtil.getChildren(node); + let n = 0; + for (const i of [1, 2]) { + if (!childNodes[i]) { + NodeUtil.setChild(node, i, data.nodeFactory.create('node', 'none')); + n++; } - let last = NodeUtil.getChildren(this.table[m])[0]; - if (NodeUtil.getAttribute( - last, 'columnalign') !== TexConstant.Align.LEFT) { - let top = last.childNodes[0] as MmlNode; - top.childNodes.unshift(null); - const space = this.create( - 'node', 'mspace', [], - { width: this.factory.configuration.options['MultlineGap'] || '2em' }); - NodeUtil.setChild(top, 0, space); + } + for (const i of [4, 5]) { + if (NodeUtil.isType(childNodes[i], 'mrow') && NodeUtil.getChildren(childNodes[i]).length === 0) { + NodeUtil.setChild(node, i, data.nodeFactory.create('node', 'none')); } } - super.EndTable.call(this); - } - -} - - -MathtoolsMethods.MtMatrix = function(parser: TexParser, begin: StackItem, open, close) { - const align = parser.GetBrackets('\\begin{' + begin.getName() + '}') || 'c'; - return BaseMethods.Array(parser, begin, open, close, align); -}, - -MathtoolsMethods.MtSmallMatrix = function( - parser: TexParser, begin: StackItem, open, close, align) { - if (!align) { - align = parser.GetBrackets('\\begin{' + begin.getName() + '}') || 'c'; - } - return BaseMethods.Array( - parser, begin, open, close, align, ParseUtil.Em(1 / 3), '.2em', 'S', 1); -}, - -MathtoolsMethods.MtMultlined = function(parser: TexParser, begin: StackItem) { - let pos = parser.GetBrackets('\\begin{' + begin.getName() + '}') || ''; - let width = pos ? parser.GetBrackets('\\begin{' + begin.getName() + '}') : null; - if (!pos.match(/^[cbt]$/)) { - let tmp = width; - width = pos; - pos = tmp; - } - parser.Push(begin); - let item = parser.itemFactory.create('multlined', parser, begin) as ArrayItem; - item.arraydef = { - displaystyle: true, - rowspacing: '.5em', - width: width || parser.options['multlineWidth'], - columnwidth: '100%', - }; - return ParseUtil.setArrayAlign(item as ArrayItem, pos || 'c'); -}; - -MathtoolsMethods.HandleShove = function(parser: TexParser, name: string, shove: string) { - let top = parser.stack.Top(); - if (top.kind !== 'multline' && top.kind !== 'multlined') { - throw new TexError( - 'CommandInMultlined', - '%1 can only appear within the multline or multlined environments', - name); - } - if (top.Size()) { - throw new TexError( - 'CommandAtTheBeginingOfLine', - '%1 must come at the beginning of the line', - name); - } - top.setProperty('shove', shove); - let shift = parser.GetBrackets(name); - let mml = parser.ParseArg(name); - if (shift) { - let mrow = parser.create('node', 'mrow', []); - let mspace = parser.create('node', 'mspace', [], { width: shift }); - if (shove === 'left') { - mrow.appendChild(mspace); - mrow.appendChild(mml); - } else { - mrow.appendChild(mml); - mrow.appendChild(mspace); + if (n === 2) { + childNodes.splice(1, 2); } - mml = mrow; } - parser.Push(mml); -}; - - -MathtoolsMethods.Array = BaseMethods.Array; -MathtoolsMethods.Macro = BaseMethods.Macro; -MathtoolsMethods.xArrow = AmsMethods.xArrow; - - -new CommandMap('mathtools-macros', { - shoveleft: ['HandleShove', TexConstant.Align.LEFT], - shoveright: ['HandleShove', TexConstant.Align.RIGHT], - - coloneqq: ['Macro', '\\mathrel{≔}'], - xleftrightarrow: ['xArrow', 0x2194, 7, 6] -}, MathtoolsMethods); - - -new EnvironmentMap('mathtools-environment', ParseMethods.environment, { - dcases: ['Array', null, '\\{', '.', 'll', null, '.2em', 'D'], - rcases: ['Array', null, '.', '\\}', 'll', null, '.2em', 'D'], - drcases: ['Array', null, '\\{', '\\}', 'll', null, '.2em', 'D'], - 'matrix*': ['MtMatrix', null, null, null], - 'pmatrix*': ['MtMatrix', null, '(', ')'], - 'bmatrix*': ['MtMatrix', null, '[', ']'], - 'Bmatrix*': ['MtMatrix', null, '\\{', '\\}'], - 'vmatrix*': ['MtMatrix', null, '\\vert', '\\vert'], - 'Vmatrix*': ['MtMatrix', null, '\\Vert', '\\Vert'], - - 'smallmatrix*': ['MtSmallMatrix', null, null, null], - psmallmatrix: ['MtSmallMatrix', null, '(', ')', 'c'], - 'psmallmatrix*': ['MtSmallMatrix', null, '(', ')'], - bsmallmatrix: ['MtSmallMatrix', null, '[', ']', 'c'], - 'bsmallmatrix*': ['MtSmallMatrix', null, '[', ']'], - Bsmallmatrix: ['MtSmallMatrix', null, '\\{', '\\}', 'c'], - 'Bsmallmatrix*': ['MtSmallMatrix', null, '\\{', '\\}'], - vsmallmatrix: ['MtSmallMatrix', null, '\\vert', '\\vert', 'c'], - 'vsmallmatrix*': ['MtSmallMatrix', null, '\\vert', '\\vert'], - Vsmallmatrix: ['MtSmallMatrix', null, '\\Vert', '\\Vert', 'c'], - 'Vsmallmatrix*': ['MtSmallMatrix', null, '\\Vert', '\\Vert'], - - multlined: 'MtMultlined', -}, MathtoolsMethods); - +} +/** + * The configuration for the mathtools package + */ export const MathtoolsConfiguration = Configuration.create( 'mathtools', { handler: { - macro: ['mathtools-macros'], - environment: ['mathtools-environment'] + macro: ['mathtools-macros', 'mathtools-delimiters'], + environment: ['mathtools-environments'], + delimiter: ['mathtools-delimiters'], + character: ['mathtools-characters'] }, - items: {[MultlinedItem.prototype.kind]: MultlinedItem} + items: { + [MultlinedItem.prototype.kind]: MultlinedItem + }, + init: initMathtools, + config: configMathtools, + postprocessors: [[fixPrescripts, -6]], + options: { + mathtools: { + 'multlinegap': '1em', // horizontal space for multlined environments + 'multlined-pos': 'c', // default alignment for multlined environments + 'firstline-afterskip': '', // space for first line of multlined (overrides multlinegap) + 'lastline-preskip': '', // space for last line of multlined (overrides multlinegap) + 'smallmatrix-align': 'c', // default alignment for smallmatrix environments + 'shortvdotsadjustabove': '.2em', // space to remove above \shortvdots + 'shortvdotsadjustbelow': '.2em', // space to remove below \shortvdots + 'centercolon': false, // true to have colon automatically centered + 'centercolon-offset': '.04em', // vertical adjustment for centered colons + 'thincolon-dx': '-.04em', // horizontal adjustment for thin colons (e.g., \coloneqq) + 'thincolon-dw': '-.08em', // width adjustment for thin colons + 'use-unicode': false, // true to use unicode characters rather than multi-character + // version for \coloneqq, etc., when possible + 'prescript-sub-format': '', // format for \prescript subscript + 'prescript-sup-format': '', // format for \prescript superscript + 'prescript-arg-format': '', // format for \prescript base + pairedDelimiters: expandable({}), // predefined paired delimiters + // name: [left, right, body, argcount, pre, post] + tagforms: expandable({}), // tag form definitions + // name: [left, right, format] + } + } } ); diff --git a/ts/input/tex/mathtools/MathtoolsItems.ts b/ts/input/tex/mathtools/MathtoolsItems.ts new file mode 100644 index 000000000..7da4970fe --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsItems.ts @@ -0,0 +1,70 @@ +/************************************************************* + * Copyright (c) 2020-2021 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Implementation of items for the mathtools package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import {MultlineItem} from '../ams/AmsItems.js'; +import NodeUtil from '../NodeUtil.js'; +import {TexConstant} from '../TexConstants.js'; + + +/** + * The StackItem for the multlined environment + */ +export class MultlinedItem extends MultlineItem { + + /** + * @override + */ + get kind() { + return 'multlined'; + } + + + /** + * @override + */ + public EndTable() { + if (this.Size() || this.row.length) { + this.EndEntry(); + this.EndRow(); + } + if (this.table.length > 1) { + const options = this.factory.configuration.options.mathtools; + const gap = options.multlinegap; + const firstskip = options['firstline-afterskip'] || gap; + const lastskip = options['lastline-preskip'] || gap; + const first = NodeUtil.getChildren(this.table[0])[0]; + if (NodeUtil.getAttribute(first, 'columnalign') !== TexConstant.Align.RIGHT) { + first.appendChild(this.create('node', 'mspace', [], {width: firstskip})); + } + const last = NodeUtil.getChildren(this.table[this.table.length - 1])[0]; + if (NodeUtil.getAttribute(last, 'columnalign') !== TexConstant.Align.LEFT) { + const top = NodeUtil.getChildren(last)[0]; + top.childNodes.unshift(null); + const space = this.create('node', 'mspace', [], {width: lastskip}); + NodeUtil.setChild(top, 0, space); + } + } + super.EndTable.call(this); + } + +} diff --git a/ts/input/tex/mathtools/MathtoolsMappings.ts b/ts/input/tex/mathtools/MathtoolsMappings.ts new file mode 100644 index 000000000..c6c9b1e13 --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsMappings.ts @@ -0,0 +1,191 @@ +/************************************************************* + * Copyright (c) 2020-2021 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Macro and environment mappings for the mathtools package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import ParseMethods from '../ParseMethods.js'; +import {CommandMap, EnvironmentMap, DelimiterMap} from '../SymbolMap.js'; +import {TexConstant} from '../TexConstants.js'; + +import {MathtoolsMethods} from './MathtoolsMethods.js'; + +// +// Not implemented: +// +// \smashoperator[〈pos〉]{〈operator with limits〉} +// \SwapAboveDisplaySkip +// \noeqref{〈label,label,. . . 〉} +// \intertext{〈text 〉} +// \shortintertext{〈text 〉} +// \reDeclarePairedDelimiterInnerWrapper{〈macro name〉}{〈star or nostarnonscaled or nostarscaled〉}{〈code〉} +// \DeclareMathSizes{〈dimen〉}{〈dimen〉}{〈dimen〉}{〈dimen〉} +// \newgathered{〈name〉}{〈pre_line〉}{〈post_line〉}{〈after〉} +// \renewgathered{〈name〉}{〈pre_line〉}{〈post_line〉}{〈after〉} +// + +new CommandMap('mathtools-macros', { + + shoveleft: ['HandleShove', TexConstant.Align.LEFT], // override AMS version + shoveright: ['HandleShove', TexConstant.Align.RIGHT], // override AMS version + + xleftrightarrow: ['xArrow', 0x2194, 10, 10], + xLeftarrow: ['xArrow', 0x21D0, 12, 7], + xRightarrow: ['xArrow', 0x21D2, 7, 12], + xLeftrightarrow: ['xArrow', 0x21D4, 12, 12], + xhookleftarrow: ['xArrow', 0x21A9, 10, 5], + xhookrightarrow: ['xArrow', 0x21AA, 5, 10], + xmapsto: ['xArrow', 0x21A6, 10, 10], + xrightharpoondown: ['xArrow', 0x21C1, 5, 10], + xleftharpoondown: ['xArrow', 0x21BD, 10, 5], + xrightleftharpoons: ['xArrow', 0x21CC, 10, 10], + xrightharpoonup: ['xArrow', 0x21C0, 5, 10], + xleftharpoonup: ['xArrow', 0x21BC, 10, 5], + xleftrightharpoons: ['xArrow', 0x21CB, 10, 10], + + mathllap: ['MathLap', 'l'], + mathrlap: ['MathLap', 'r'], + mathclap: ['MathLap', 'c'], + clap: ['MtLap', 'c'], + textllap: ['MtLap', 'l'], + textrlap: ['MtLap', 'r'], + textclap: ['MtLap', 'c'], + + // + // We don't currently have control over the texprimestyle, and hboxes and style changes don't + // affect it, so the need for these is limited, but we define them for completeness. + // + cramped: ['Macro', '{#1 #2}', 2, ''], + crampedllap: ['MathLap', 'l'], + crampedrlap: ['MathLap', 'r'], + crampedclap: ['MathLap', 'c'], + + mathmbox: 'MathMBox', + mathmakebox: 'MathMakeBox', + + overbracket: 'UnderOverBracket', + underbracket: 'UnderOverBracket', + + refeq: 'HandleRef', + + MoveEqLeft: ['Macro', '\\hspace{#1em}&\\hspace{-#1em}', 1, '2'], + Aboxed: 'Aboxed', + + ArrowBetweenLines: 'ArrowBetweenLines', + vdotswithin: 'VDotsWithin', + shortvdotswithin: 'ShortVDotsWithin', + MTFlushSpaceAbove: 'FlushSpaceAbove', + MTFlushSpaceBelow: 'FlushSpaceBelow', + + DeclarePairedDelimiters: 'DeclarePairedDelimiters', + DeclarePairedDelimitersX: 'DeclarePairedDelimitersX', + DeclarePairedDelimitersXPP: 'DeclarePairedDelimitersXPP', + + centercolon: ['CenterColon', true, true], + ordinarycolon: ['CenterColon', false], + MTThinColon: ['CenterColon', true, true, true], + + coloneqq: ['Relation', ':=', '\u2254'], + Coloneqq: ['Relation', '::=', '\u2A74'], + coloneq: ['Relation', ':-'], + Coloneq: ['Relation', '::-'], + eqqcolon: ['Relation', '=:', '\u2255'], + Eqqcolon: ['Relation', '=::'], + eqcolon: ['Relation', '-:', '\u2239'], + Eqcolon: ['Relation', '-::'], + colonapprox: ['Relation', ':\\approx'], + Colonapprox: ['Relation', '::\\approx'], + colonsim: ['Relation', ':\\sim'], + Colonsim: ['Relation', '::\\sim'], + dblcolon: ['Relation', '::', '\u2237'], + + nuparrow: ['NArrow', '\u2191', '.06em'], + ndownarrow: ['NArrow', '\u2193', '.25em'], + bigtimes: ['Macro', '\\mathop{\\Large\\kern-.1em\\boldsymbol{\\times}\\kern-.1em}'], + + splitfrac: ['SplitFrac', false], + splitdfrac: ['SplitFrac', true], + + xmathstrut: 'XMathStrut', + + prescript: 'Prescript', + + newtagform: ['NewTagForm', false], + renewtagform: ['NewTagForm', true], + usetagform: 'UseTagForm', + + crampedsubstack: ['Macro', '\\begin{crampedsubarray}{c}#1\\end{crampedsubarray}', 1], + + adjustlimits: [ + 'MacroWithTemplate', + '\\mathop{{#1}\\vphantom{{#3}}}_{{#2}\\vphantom{{#4}}}\\mathop{{#3}\\vphantom{{#1}}}_{{#4}\\vphantom{{#2}}}', + 4, ,'_', , '_' + ] + +}, MathtoolsMethods); + + +new EnvironmentMap('mathtools-environments', ParseMethods.environment, { + dcases: ['Array', null, '\\{', '', 'll', null, '.2em', 'D'], + rcases: ['Array', null, '', '\\}', 'll', null, '.2em'], + drcases: ['Array', null, '', '\\}', 'll', null, '.2em', 'D'], + 'dcases*': ['Cases', null, '{', '', 'D'], + 'rcases*': ['Cases', null, '', '}'], + 'drcases*': ['Cases', null, '', '}', 'D'], + 'cases*': ['Cases', null, '{', ''], + + 'matrix*': ['MtMatrix', null, null, null], + 'pmatrix*': ['MtMatrix', null, '(', ')'], + 'bmatrix*': ['MtMatrix', null, '[', ']'], + 'Bmatrix*': ['MtMatrix', null, '\\{', '\\}'], + 'vmatrix*': ['MtMatrix', null, '\\vert', '\\vert'], + 'Vmatrix*': ['MtMatrix', null, '\\Vert', '\\Vert'], + + 'smallmatrix*': ['MtSmallMatrix', null, null, null], + psmallmatrix: ['MtSmallMatrix', null, '(', ')', 'c'], + 'psmallmatrix*': ['MtSmallMatrix', null, '(', ')'], + bsmallmatrix: ['MtSmallMatrix', null, '[', ']', 'c'], + 'bsmallmatrix*': ['MtSmallMatrix', null, '[', ']'], + Bsmallmatrix: ['MtSmallMatrix', null, '\\{', '\\}', 'c'], + 'Bsmallmatrix*': ['MtSmallMatrix', null, '\\{', '\\}'], + vsmallmatrix: ['MtSmallMatrix', null, '\\vert', '\\vert', 'c'], + 'vsmallmatrix*': ['MtSmallMatrix', null, '\\vert', '\\vert'], + Vsmallmatrix: ['MtSmallMatrix', null, '\\Vert', '\\Vert', 'c'], + 'Vsmallmatrix*': ['MtSmallMatrix', null, '\\Vert', '\\Vert'], + + crampedsubarray: ['Array', null, null, null, null, '0em', '0.1em', 'S', 1], + + multlined: 'MtMultlined', + + spreadlines: ['SpreadLines', true], + + lgathered: ['AmsEqnArray', null, null, null, 'l', null, '.5em', 'D'], + rgathered: ['AmsEqnArray', null, null, null, 'r', null, '.5em', 'D'], + +}, MathtoolsMethods); + +new DelimiterMap('mathtools-delimiters', ParseMethods.delimiter, { + '\\lparen': '(', + '\\rparen': ')' +}); + +new CommandMap('mathtools-characters', { + ':' : ['CenterColon', true] +}, MathtoolsMethods); diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts new file mode 100644 index 000000000..fe2897306 --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -0,0 +1,511 @@ +/************************************************************* + * Copyright (c) 2020-2021 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Macro and environment implementations for the mathtools package. + * + * @author v.sorge@mathjax.org (Volker Sorge) + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + + +import {ArrayItem, EqnArrayItem} from '../base/BaseItems.js'; +import {StackItem} from '../StackItem.js'; +import ParseUtil from '../ParseUtil.js'; +import {ParseMethod} from '../Types.js'; +import {AmsMethods} from '../ams/AmsMethods.js'; +import BaseMethods from '../base/BaseMethods.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import NodeUtil from '../NodeUtil.js'; +import {TEXCLASS} from '../../../core/MmlTree/MmlNode.js'; +import {length2em, em} from '../../../util/lengths.js'; +import {lookup} from '../../../util/Options.js'; +import NewcommandUtil from '../newcommand/NewcommandUtil.js'; +import NewcommandMethods from '../newcommand/NewcommandMethods.js'; + +import {MathtoolsTags} from './MathtoolsTags.js'; +import {MathtoolsUtil} from './MathtoolsUtil.js'; + +/** + * The implementations for the macros and environemtns for the mathtools package. + */ +export const MathtoolsMethods: Record = { + + MtMatrix(parser: TexParser, begin: StackItem, open: string, close: string) { + const align = parser.GetBrackets(`\\begin{${begin.getName()}}`, 'c'); + return MathtoolsMethods.Array(parser, begin, open, close, align); + }, + + MtSmallMatrix(parser: TexParser, begin: StackItem, open: string, close: string, align: string) { + if (!align) { + align = parser.GetBrackets(`\\begin{${begin.getName()}}`, parser.options.mathtools['smallmatrix-align']); + } + return MathtoolsMethods.Array( + parser, begin, open, close, align, ParseUtil.Em(1 / 3), '.2em', 'S', 1 + ); + }, + + MtMultlined(parser: TexParser, begin: StackItem) { + const name = `\\begin{${begin.getName()}}`; + let pos = parser.GetBrackets(name, parser.options.mathtools['multlined-pos'] || 'c'); + let width = pos ? parser.GetBrackets(name, '') : ''; + if (pos && !pos.match(/^[cbt]$/)) { + [width, pos] = [pos, width]; + } + parser.Push(begin); + const item = parser.itemFactory.create('multlined', parser, begin) as ArrayItem; + item.arraydef = { + displaystyle: true, + rowspacing: '.5em', + width: width || 'auto', + columnwidth: '100%', + }; + return ParseUtil.setArrayAlign(item as ArrayItem, pos || 'c'); + }, + + HandleShove(parser: TexParser, name: string, shove: string) { + let top = parser.stack.Top(); + if (top.kind !== 'multline' && top.kind !== 'multlined') { + throw new TexError( + 'CommandInMultlined', + '%1 can only appear within the multline or multlined environments', + name); + } + if (top.Size()) { + throw new TexError( + 'CommandAtTheBeginingOfLine', + '%1 must come at the beginning of the line', + name); + } + top.setProperty('shove', shove); + let shift = parser.GetBrackets(name); + let mml = parser.ParseArg(name); + if (shift) { + let mrow = parser.create('node', 'mrow', []); + let mspace = parser.create('node', 'mspace', [], {width: shift}); + if (shove === 'left') { + mrow.appendChild(mspace); + mrow.appendChild(mml); + } else { + mrow.appendChild(mml); + mrow.appendChild(mspace); + } + mml = mrow; + } + parser.Push(mml); + }, + + SpreadLines(parser: TexParser, begin: StackItem) { + if (parser.stack.env.closing === begin.getName()) { + delete parser.stack.env.closing; + const top = parser.stack.Pop(); + const mml = top.toMml(); + const spread = top.getProperty('spread') as string; + if (mml.isInferred) { + for (const child of NodeUtil.getChildren(mml)) { + MathtoolsUtil.spreadLines(child, spread); + } + } else { + MathtoolsUtil.spreadLines(mml, spread); + } + parser.Push(mml); + } else { + const spread = parser.GetDimen(`\\begin{${begin.getName()}}`); + begin.setProperty('spread', spread); + parser.Push(begin); + } + }, + + /** + * Handle mathrlap, mathllap, mathclap commands. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {string} post The position (l, c, r) of the lapped content + */ + MathLap(parser: TexParser, name: string, pos: string) { + const style = parser.GetBrackets(name); + let mml = parser.create('node', 'mpadded', [parser.ParseArg(name)], {width: 0}); + if (pos !== 'r') { + NodeUtil.setAttribute(mml, 'lspace', pos === 'l' ? '-1width' : '-.5width'); + } + if (style) { + const [display, script] = lookup(style, { + '\\displaystyle': [true, 0], + '\\textstyle': [false, 0], + '\\scriptstyle': [false, 1], + '\\scriptscriptstyle': [false, 2] + }, [null, null]); + if (display !== null) { + mml = parser.create('node', 'mstyle', [mml], {displaystyle: display, scriptlevel: script}); + } + } + const atom = parser.create('node', 'TeXAtom', [mml]); + parser.Push(atom); + }, + + MtLap(parser: TexParser, name: string, pos: string) { + const content = ParseUtil.internalMath(parser, parser.GetArgument(name), 0); + let mml = parser.create('node', 'mpadded', content, {width: 0}); + if (pos !== 'r') { + NodeUtil.setAttribute(mml, 'lspace', pos === 'l' ? '-1width' : '-.5width'); + } + parser.Push(mml); + }, + + MathMakeBox(parser: TexParser, name: string) { + const width = parser.GetBrackets(name); + const pos = parser.GetBrackets(name, 'c'); + const mml = parser.create('node', 'mpadded', [parser.ParseArg(name)]); + if (width) { + NodeUtil.setAttribute(mml, 'width', width); + } + const align = lookup(pos, {c: 'center', r: 'right'}, ''); + if (align) { + NodeUtil.setAttribute(mml, 'data-align', align); + } + parser.Push(mml); + }, + + MathMBox(parser: TexParser, name: string) { + parser.Push(parser.create('node', 'mrow', [parser.ParseArg(name)])); + }, + + UnderOverBracket(parser: TexParser, name: string) { + const thickness = length2em(parser.GetBrackets(name, '.1em'), .1); + const height = parser.GetBrackets(name, '.2em'); + const arg = parser.GetArgument(name); + const [pos, accent, border, side] = ( + name.charAt(1) === 'o' ? + ['over', 'accent', 'bottom', 'height'] : + ['under', 'accentunder', 'top', 'depth'] + ); + const t = em(thickness); + const t2 = em(2 * thickness); + const base = new TexParser(arg, parser.stack.env, parser.configuration).mml(); + const copy = new TexParser(arg, parser.stack.env, parser.configuration).mml(); + const script = parser.create('node', 'mpadded', [ + parser.create('node', 'mpadded', [ + parser.create('node', 'mphantom', [copy]) + ], { + style: `border: ${t} solid; border-${border}: none`, + width: `-${t2}`, + height: height, + depth: 0 + }) + ], { + width: `+${t2}`, + [side]: `+${t}` + }); + const node = ParseUtil.underOver(parser, base, script, pos, true); + const munderover = NodeUtil.getChildAt(NodeUtil.getChildAt(node, 0), 0); // TeXAtom.inferredMrow child 0 + NodeUtil.setAttribute(munderover, accent, true); + parser.Push(node); + }, + + Cases(parser: TexParser, begin: StackItem, open: string, close: string, style: string) { + const array = parser.itemFactory.create('array').setProperty('casesEnv', begin.getName()) as ArrayItem; + array.arraydef = { + rowspacing: '.2em', + columnspacing: '1em', + columnalign: 'left' + }; + if (style === 'D') { + array.arraydef.displaystyle = true; + } + array.setProperties({open, close}); + parser.Push(begin); + return array; + }, + + Aboxed(parser: TexParser, name: string) { + // + // Check that the top item is an alignment, and that we are on an even number of cells + // (othewise add one to make it even). + // + const top = MathtoolsUtil.checkAlignment(parser, name); + if (top.row.length % 2 === 1) { + top.row.push(parser.create('node', 'mtd', [])); + } + // + // Get the argument and the rest of the TeX string. + // + const arg = parser.GetArgument(name); + const rest = parser.string.substr(parser.i); + // + // Put argument back, followed by "&&", which we look for below. + // + parser.string = arg + '&&'; + parser.i = 0; + // + // Get the two parts separated by ampersands, and ignore the rest. + // + const left = parser.GetUpTo(name, '&'); + const right = parser.GetUpTo(name, '&'); + // + // Insert the TeX needed for the boxed content + // + const tex = ParseUtil.substituteArgs( + parser, [left, right], '\\rlap{\\boxed{#1{}#2}}\\kern.267em\\phantom{#1}&\\phantom{{}#2}\\kern.267em' + ); + parser.string = tex + rest; + parser.i = 0; + }, + + ArrowBetweenLines(parser: TexParser, name: string) { + const top = MathtoolsUtil.checkAlignment(parser, name); + if (top.Size() || top.row.length) { + throw new TexError('BetweenLines', '%1 must be on a row by itself', name); + } + const star = parser.GetStar(); + const symbol = parser.GetBrackets(name, '\\Updownarrow'); + if (star) { + top.EndEntry(); + top.EndEntry(); + } + const tex = (star ? '\\quad' + symbol : symbol + '\\quad'); + const mml = new TexParser(tex, parser.stack.env, parser.configuration).mml(); + parser.Push(mml); + top.EndEntry(); + top.EndRow(); + }, + + VDotsWithin(parser: TexParser, name: string) { + const top = parser.stack.Top() as EqnArrayItem; + const isFlush = (top.getProperty('flushspaceabove') === top.table.length); + const arg = '\\mmlToken{mi}{}' + parser.GetArgument(name) + '\\mmlToken{mi}{}'; + const base = new TexParser(arg, parser.stack.env, parser.configuration).mml(); + let mml = parser.create('node', 'mpadded', [ + parser.create('node', 'mpadded', [ + parser.create('node', 'mo', [parser.create('text', '\u22EE')]) + ], {width: 0, lspace: '-.5width', ...(isFlush ? {height: '-.6em', voffset: '-.18em'} : {})}), + parser.create('node', 'mphantom', [base]) + ], {lspace: '.5width'}); + parser.Push(mml); + }, + + ShortVDotsWithin(parser: TexParser, _name: string) { + const top = parser.stack.Top() as EqnArrayItem; + const star = parser.GetStar(); + MathtoolsMethods.FlushSpaceAbove(parser, '\\MTFlushSpaceAbove'); + !star && top.EndEntry(); + MathtoolsMethods.VDotsWithin(parser, '\\vdotswithin'); + star && top.EndEntry(); + MathtoolsMethods.FlushSpaceBelow(parser, '\\MTFlushSpaceBelow'); + }, + + FlushSpaceAbove(parser: TexParser, name: string) { + const top = MathtoolsUtil.checkAlignment(parser, name); + top.setProperty('flushspaceabove', top.table.length); + top.addRowSpacing('-' + parser.options.mathtools['shortvdotsadjustabove']); + }, + + FlushSpaceBelow(parser: TexParser, name: string) { + const top = MathtoolsUtil.checkAlignment(parser, name); + top.Size() && top.EndEntry(); + top.EndRow(); + top.addRowSpacing('-' + parser.options.mathtools['shortvdotsadjustbelow']); + }, + + PairedDelimiters(parser: TexParser, name: string, + open: string, close: string, + body: string = '#1', n: number = 1, + pre: string = '', post: string = '') { + const star = parser.GetStar(); + const size = (star ? '' : parser.GetBrackets(name)); + const [left, right] = (star ? ['\\left', '\\right'] : size ? [size + 'l' , size + 'r'] : ['', '']); + const delim = (star ? '\\middle' : size || ''); + if (n) { + const args: string[] = []; + for (let i = args.length; i < n; i++) { + args.push(parser.GetArgument(name)); + } + body = ParseUtil.substituteArgs(parser, args, body); + } + body = body.replace(/\\delimsize/g, delim); + parser.string = [pre, left, open, body, right, close, post, parser.string.substr(parser.i)] + .reduce((s, part) => ParseUtil.addArgs(parser, s, part), ''); + parser.i = 0; + ParseUtil.checkMaxMacros(parser); + }, + + DeclarePairedDelimiters(parser: TexParser, name: string) { + const cs = NewcommandUtil.GetCsNameArgument(parser, name); + const open = parser.GetArgument(name); + const close = parser.GetArgument(name); + MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close]); + }, + + DeclarePairedDelimitersX(parser: TexParser, name: string) { + const cs = NewcommandUtil.GetCsNameArgument(parser, name); + const n = NewcommandUtil.GetArgCount(parser, name); + const open = parser.GetArgument(name); + const close = parser.GetArgument(name); + const body = parser.GetArgument(name); + MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close, body, n]); + }, + + DeclarePairedDelimitersXPP(parser: TexParser, name: string) { + const cs = NewcommandUtil.GetCsNameArgument(parser, name); + const n = NewcommandUtil.GetArgCount(parser, name); + const pre = parser.GetArgument(name); + const open = parser.GetArgument(name); + const close = parser.GetArgument(name); + const post = parser.GetArgument(name); + const body = parser.GetArgument(name); + MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close, body, n, pre, post]); + }, + + CenterColon(parser: TexParser, _name: string, center: boolean, force: boolean = false, thin: boolean = false) { + const options = parser.options.mathtools; + let mml = parser.create('token', 'mo', {}, ':'); + if (center && (options['centercolon'] || force)) { + const dy = options['centercolon-offset']; + mml = parser.create('node', 'mpadded', [mml], { + voffset: dy, height: `+${dy}`, depth: `-${dy}`, + ...(thin ? {width: options['thincolon-dw'], lspace: options['thincolon-dx']} : {}) + }); + } + parser.Push(mml); + }, + + Relation(parser: TexParser, _name: string, tex: string, unicode?: string) { + const options = parser.options.mathtools; + if (options['use-unicode'] && unicode) { + parser.Push(parser.create('token', 'mo', {texClass: TEXCLASS.REL}, unicode)); + } else { + tex = '\\mathrel{' + tex.replace(/:/g, '\\MTThinColon').replace(/-/g, '\\mathrel{-}') + '}'; + parser.string = ParseUtil.addArgs(parser, tex, parser.string.substr(parser.i)); + parser.i = 0; + } + }, + + NArrow(parser: TexParser, _name: string, c: string, dy: string) { + parser.Push( + parser.create('node', 'TeXAtom', [ + parser.create('token', 'mtext', {}, c), + parser.create('node', 'mpadded', [ + parser.create('node', 'mpadded', [ + parser.create('node', 'menclose', [ + parser.create('node', 'mspace', [], {height: '.2em', depth: 0, width: '.4em'}) + ], {notation: 'updiagonalstrike', 'data-thickness': '.05em', 'data-padding': 0}) + ], {width: 0, lspace: '-.5width', voffset: dy}), + parser.create('node', 'mphantom', [ + parser.create('token', 'mtext', {}, c) + ]) + ], {width: 0, lspace: '-.5width'}) + ], {texClass: TEXCLASS.REL}) + ); + }, + + SplitFrac(parser: TexParser, name: string, display: boolean) { + const num = parser.ParseArg(name); + const den = parser.ParseArg(name); + parser.Push( + parser.create('node', 'mstyle', [ + parser.create('node', 'mfrac', [ + parser.create('node', 'mstyle', [ + num, + parser.create('token', 'mi'), + parser.create('token', 'mspace', {width: '1em'}) + ], {scriptlevel: 0}), + parser.create('node', 'mstyle', [ + parser.create('token', 'mspace', {width: '1em'}), + parser.create('token', 'mi'), + den + ], {scriptlevel: 0}) + ], {linethickness: 0, numalign: 'left', denomalign: 'right'}) + ], {displaystyle: display, scriptlevel: 0}) + ); + }, + + XMathStrut(parser: TexParser, name: string) { + let dd = parser.GetBrackets(name); + let dh = parser.GetArgument(name); + dh = MathtoolsUtil.plusOrMinus(name, dh); + dd = MathtoolsUtil.plusOrMinus(name, dd || dh); + parser.Push( + parser.create('node', 'TeXAtom', [ + parser.create('node', 'mpadded', [ + parser.create('node', 'mphantom', [ + parser.create('token', 'mo', {stretchy: false}, '(') + ]) + ], {width: 0, height: dh + 'height', depth: dd + 'depth'}) + ], {texClass: TEXCLASS.ORD}) + ); + }, + + Prescript(parser: TexParser, name: string) { + const sup = MathtoolsUtil.getScript(parser, name, 'sup'); + const sub = MathtoolsUtil.getScript(parser, name, 'sub'); + const base = MathtoolsUtil.getScript(parser, name, 'arg'); + if (NodeUtil.isType(sup, 'none') && NodeUtil.isType(sub, 'none')) { + parser.Push(base); + return; + } + const mml = parser.create('node', 'mmultiscripts', [base]); + NodeUtil.getChildren(mml).push(null, null); + NodeUtil.appendChildren(mml, [parser.create('node', 'mprescripts'), sub, sup]); + mml.setProperty('fixPrescript', true); + parser.Push(mml); + }, + + NewTagForm(parser: TexParser, name: string, renew: boolean = false) { + const tags = parser.tags as MathtoolsTags; + if (!('mtFormats' in tags)) { + throw new TexError('TagsNotMT', '%1 can only be used with ams or mathtools tags', name); + } + const id = parser.GetArgument(name).trim(); + if (!id) { + throw new TexError('InvalidTagFormID', 'Tag form name can\'t be empty'); + } + const format = parser.GetBrackets(name, ''); + const left = parser.GetArgument(name); + const right = parser.GetArgument(name); + if (!renew && tags.mtFormats.has(id)) { + throw new TexError('DuplicateTagForm', 'Duplicate tag form: %1', id); + } + tags.mtFormats.set(id, [left, right, format]); + }, + + UseTagForm(parser: TexParser, name: string) { + const tags = parser.tags as MathtoolsTags; + if (!('mtFormats' in tags)) { + throw new TexError('TagsNotMT', '%1 can only be used with ams or mathtools tags', name); + } + const id = parser.GetArgument(name).trim(); + if (!id) { + tags.mtCurrent = null; + return; + } + if (!tags.mtFormats.has(id)) { + throw new TexError('UndefinedTagForm', 'Undefined tag form: %1', id); + } + tags.mtCurrent = tags.mtFormats.get(id); + }, + + /** + * Use the Base or AMS methods for these + */ + Array: BaseMethods.Array, + Macro: BaseMethods.Macro, + xArrow: AmsMethods.xArrow, + HandleRef: AmsMethods.HandleRef, + AmsEqnArray: AmsMethods.AmsEqnArray, + MacroWithTemplate: NewcommandMethods.MacroWithTemplate + +}; diff --git a/ts/input/tex/mathtools/MathtoolsTags.ts b/ts/input/tex/mathtools/MathtoolsTags.ts new file mode 100644 index 000000000..48bedf70c --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsTags.ts @@ -0,0 +1,116 @@ +/************************************************************* + * Copyright (c) 2021 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Tags implementation for the mathtools package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import TexError from '../TexError.js'; +import {ParserConfiguration} from '../Configuration.js'; +import {TeX} from '../../tex.js'; +import {AbstractTags, TagsFactory} from '../Tags.js'; + + +/** + * The type for the Mathtools tags (including their data). + */ +export type MathtoolsTags = AbstractTags & { + mtFormats: Map; // name -> [left, right, format] + mtCurrent: [string, string, string]; // [left, right, format] +}; + +/** + * The ID number for the current tag class + */ +let tagID = 0; + +/** + * Creates and registers a subclass of the currently configured tag class + * that handles the formats created by the \newtagform macro. + */ +export function MathtoolsTagFormat(config: ParserConfiguration, jax: TeX) { + /** + * If the tag format is being added by one of the other extensions, + * as is done for the 'ams' tags, make sure it is defined so we can create it. + */ + const tags = jax.parseOptions.options.tags; + if (tags !== 'base' && config.tags.hasOwnProperty(tags)) { + TagsFactory.add(tags, config.tags[tags]); + } + + /** + * The original tag class to be extended (none, ams, or all) + */ + const TagClass = TagsFactory.create(jax.parseOptions.options.tags).constructor as typeof AbstractTags; + + /** + * A Tags object that uses \newtagform to define the formatting + */ + class TagFormat extends TagClass { + + /** + * The defined tag formats + */ + public mtFormats: Map = new Map(); + + /** + * The format currently in use ([left, right, format]), or null for using the default + */ + public mtCurrent: [string, string, string] = null; + + /** + * @override + * @constructor + */ + constructor() { + super(); + const forms = jax.parseOptions.options.mathtools.tagforms; + for (const form of Object.keys(forms)) { + if (!Array.isArray(forms[form]) || forms[form].length !== 3) { + throw new TexError('InvalidTagFormDef', + 'The tag form definition for "%1" should be an array fo three strings', form); + } + this.mtFormats.set(form, forms[form]); + } + } + + /** + * @override + */ + public formatTag(tag: string) { + if (this.mtCurrent) { + const [left, right, format] = this.mtCurrent; + return (format ? `${left}${format}{${tag}}${right}` : `${left}${tag}${right}`); + } + return super.formatTag(tag); + } + } + + // + // Get a unique name for the tag class (since it is tied to the input jax) + // Note: These never get freed, so they will accumulate if you create many + // TeX input jax instances with this extension. + // + tagID++; + const tagName = 'MathtoolsTags-' + tagID; + // + // Register the tag class + // + TagsFactory.add(tagName, TagFormat); + jax.parseOptions.options.tags = tagName; +} diff --git a/ts/input/tex/mathtools/MathtoolsUtil.ts b/ts/input/tex/mathtools/MathtoolsUtil.ts new file mode 100644 index 000000000..4cd73fdde --- /dev/null +++ b/ts/input/tex/mathtools/MathtoolsUtil.ts @@ -0,0 +1,86 @@ +/************************************************************* + * Copyright (c) 2021 MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Utility functions for the mathtools package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import {EqnArrayItem} from '../base/BaseItems.js'; +import ParseUtil from '../ParseUtil.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import {CommandMap} from '../SymbolMap.js'; +import {Macro} from '../Symbol.js'; +import ParseOptions from '../ParseOptions.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; + +import {MathtoolsMethods} from './MathtoolsMethods.js'; +import {PAIREDDELIMS} from './MathtoolsConfiguration.js'; + +/** + * Utility functions for the Mathtools package. + */ +export const MathtoolsUtil = { + + checkAlignment(parser: TexParser, name: string) { + const top = parser.stack.Top() as EqnArrayItem; + if (top.kind !== EqnArrayItem.prototype.kind) { + throw new TexError('NotInAlignment', '%1 can only be used in aligment environments', name); + } + return top; + }, + + addPairedDelims(config: ParseOptions, cs: string, args: string[]) { + const delims = config.handlers.retrieve(PAIREDDELIMS) as CommandMap; + delims.add(cs, new Macro(cs, MathtoolsMethods.PairedDelimiters, args)); + }, + + spreadLines(mtable: MmlNode, spread: string) { + if (!mtable.isKind('mtable')) return; + let rowspacing = mtable.attributes.get('rowspacing') as string; + if (rowspacing) { + const add = ParseUtil.dimen2em(spread); + rowspacing = rowspacing + .split(/ /) + .map(s => ParseUtil.Em(Math.max(0, ParseUtil.dimen2em(s) + add))) + .join(' '); + } else { + rowspacing = spread; + } + mtable.attributes.set('rowspacing', rowspacing); + }, + + plusOrMinus(name: string, n: string) { + n = n.trim(); + if (!n.match(/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)$/)) { + throw new TexError('NotANumber', 'Argument to %1 is not a number', name); + } + return (n.match(/^[-+]/) ? n : '+' + n); + }, + + getScript(parser: TexParser, name: string, pos: string) { + let arg = ParseUtil.trimSpaces(parser.GetArgument(name)); + if (arg === '') { + return parser.create('node', 'none'); + } + const format = parser.options.mathtools[`prescript-${pos}-format`]; + format && (arg = `${format}{${arg}}`); + return new TexParser(arg, parser.stack.env, parser.configuration).mml(); + } + +}; From 435dad23a3ca25afbdaab989ef51ed3a89b8bad1 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 10 May 2021 17:43:47 -0400 Subject: [PATCH 035/142] Update dependencies --- components/src/dependencies.js | 2 +- components/src/input/tex/extensions/mathtools/webpack.config.js | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 177519a7a..d81fcca11 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -18,7 +18,7 @@ export const dependencies = { '[tex]/enclose': ['input/tex-base'], '[tex]/extpfeil': ['input/tex-base', '[tex]/newcommand', '[tex]/ams'], '[tex]/html': ['input/tex-base'], - '[tex]/mathtools': ['input/tex-base', '[tex]/ams'], + '[tex]/mathtools': ['input/tex-base', '[tex]/newcommand', '[tex]/ams'], '[tex]/mhchem': ['input/tex-base', '[tex]/ams'], '[tex]/newcommand': ['input/tex-base'], '[tex]/noerrors': ['input/tex-base'], diff --git a/components/src/input/tex/extensions/mathtools/webpack.config.js b/components/src/input/tex/extensions/mathtools/webpack.config.js index 0c901481f..1b882c5ae 100644 --- a/components/src/input/tex/extensions/mathtools/webpack.config.js +++ b/components/src/input/tex/extensions/mathtools/webpack.config.js @@ -5,6 +5,7 @@ module.exports = PACKAGE( '../../../../../../js', // location of the MathJax js library [ // packages to link to 'components/src/input/tex/extensions/ams/lib', + 'components/src/input/tex/extensions/newcommand/lib', 'components/src/input/tex-base/lib', 'components/src/core/lib' ], From 4a6ecbe5c2a3f29d68ffaa4af725dde0b259d1f2 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 10:35:03 -0400 Subject: [PATCH 036/142] Reset tex prime styles for style changes and in tables, and add data-cramped attribute to control it explicitly --- ts/core/MmlTree/MmlNodes/mstyle.ts | 6 ++++++ ts/core/MmlTree/MmlNodes/mtable.ts | 3 ++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/ts/core/MmlTree/MmlNodes/mstyle.ts b/ts/core/MmlTree/MmlNodes/mstyle.ts index 22636adbf..070dd30f6 100644 --- a/ts/core/MmlTree/MmlNodes/mstyle.ts +++ b/ts/core/MmlTree/MmlNodes/mstyle.ts @@ -75,10 +75,16 @@ export class MmlMstyle extends AbstractMmlLayoutNode { } else { level = parseInt(scriptlevel); } + prime = false; // style change resets tex prime style } let displaystyle = this.attributes.getExplicit('displaystyle') as boolean; if (displaystyle != null) { display = (displaystyle === true); + prime = false; // style change resets tex prime style + } + const cramped = this.attributes.getExplicit('data-cramped') as boolean; // manual control of tex prime style + if (cramped != null) { + prime = cramped; } attributes = this.addInheritedAttributes(attributes, this.attributes.getAllAttributes()); this.childNodes[0].setInheritedAttributes(attributes, display, level, prime); diff --git a/ts/core/MmlTree/MmlNodes/mtable.ts b/ts/core/MmlTree/MmlNodes/mtable.ts index 0b94ae881..870272e98 100644 --- a/ts/core/MmlTree/MmlNodes/mtable.ts +++ b/ts/core/MmlTree/MmlNodes/mtable.ts @@ -123,10 +123,11 @@ export class MmlMtable extends AbstractMmlNode { columnalign: this.attributes.get('columnalign'), rowalign: 'center' }); + const cramped = this.attributes.getExplicit('data-cramped') as boolean; const ralign = split(this.attributes.get('rowalign') as string); for (const child of this.childNodes) { attributes.rowalign[1] = ralign.shift() || attributes.rowalign[1]; - child.setInheritedAttributes(attributes, display, level, false); + child.setInheritedAttributes(attributes, display, level, cramped == null ? false : cramped); } } From 350af34388a4143e01eaa18e4949467bbbcf8727 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 10:35:19 -0400 Subject: [PATCH 037/142] Handle cramped styles better --- ts/input/tex/base/BaseMethods.ts | 4 +++ ts/input/tex/mathtools/MathtoolsMappings.ts | 25 ++++++-------- ts/input/tex/mathtools/MathtoolsMethods.ts | 36 ++++++++++----------- ts/input/tex/mathtools/MathtoolsUtil.ts | 15 +++++++++ 4 files changed, 47 insertions(+), 33 deletions(-) diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 7b3276e75..054c77b7c 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -1386,6 +1386,10 @@ BaseMethods.Array = function(parser: TexParser, begin: StackItem, // @test Cross Product array.setProperty('close', parser.convertDelimiter(close)); } + if (style.charAt(1) === '\'') { + array.arraydef['data-cramped'] = true; + style = style.charAt(0); + } if (style === 'D') { // TODO: This case never seems to occur! No test. array.arraydef['displaystyle'] = true; diff --git a/ts/input/tex/mathtools/MathtoolsMappings.ts b/ts/input/tex/mathtools/MathtoolsMappings.ts index c6c9b1e13..db3f82167 100644 --- a/ts/input/tex/mathtools/MathtoolsMappings.ts +++ b/ts/input/tex/mathtools/MathtoolsMappings.ts @@ -60,22 +60,19 @@ new CommandMap('mathtools-macros', { xleftharpoonup: ['xArrow', 0x21BC, 10, 5], xleftrightharpoons: ['xArrow', 0x21CB, 10, 10], - mathllap: ['MathLap', 'l'], - mathrlap: ['MathLap', 'r'], - mathclap: ['MathLap', 'c'], + mathllap: ['MathLap', 'l', false], + mathrlap: ['MathLap', 'r', false], + mathclap: ['MathLap', 'c', false], clap: ['MtLap', 'c'], textllap: ['MtLap', 'l'], textrlap: ['MtLap', 'r'], textclap: ['MtLap', 'c'], - // - // We don't currently have control over the texprimestyle, and hboxes and style changes don't - // affect it, so the need for these is limited, but we define them for completeness. - // - cramped: ['Macro', '{#1 #2}', 2, ''], - crampedllap: ['MathLap', 'l'], - crampedrlap: ['MathLap', 'r'], - crampedclap: ['MathLap', 'c'], + cramped: 'Cramped', + crampedllap: ['MathLap', 'l', true], + crampedrlap: ['MathLap', 'r', true], + crampedclap: ['MathLap', 'c', true], + crampedsubstack: ['Macro', '\\begin{crampedsubarray}{c}#1\\end{crampedsubarray}', 1], mathmbox: 'MathMBox', mathmakebox: 'MathMakeBox', @@ -131,12 +128,10 @@ new CommandMap('mathtools-macros', { renewtagform: ['NewTagForm', true], usetagform: 'UseTagForm', - crampedsubstack: ['Macro', '\\begin{crampedsubarray}{c}#1\\end{crampedsubarray}', 1], - adjustlimits: [ 'MacroWithTemplate', '\\mathop{{#1}\\vphantom{{#3}}}_{{#2}\\vphantom{{#4}}}\\mathop{{#3}\\vphantom{{#1}}}_{{#4}\\vphantom{{#2}}}', - 4, ,'_', , '_' + 4, , '_', , '_' ] }, MathtoolsMethods); @@ -170,7 +165,7 @@ new EnvironmentMap('mathtools-environments', ParseMethods.environment, { Vsmallmatrix: ['MtSmallMatrix', null, '\\Vert', '\\Vert', 'c'], 'Vsmallmatrix*': ['MtSmallMatrix', null, '\\Vert', '\\Vert'], - crampedsubarray: ['Array', null, null, null, null, '0em', '0.1em', 'S', 1], + crampedsubarray: ['Array', null, null, null, null, '0em', '0.1em', 'S\'', 1], multlined: 'MtMultlined', diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts index fe2897306..082743d82 100644 --- a/ts/input/tex/mathtools/MathtoolsMethods.ts +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -135,29 +135,29 @@ export const MathtoolsMethods: Record = { * * @param {TexParser} parser The calling parser. * @param {string} name The macro name. - * @param {string} post The position (l, c, r) of the lapped content + * @param {string} pos The position (l, c, r) of the lapped content + * @param {boolean} cramped True if the style should be cramped */ - MathLap(parser: TexParser, name: string, pos: string) { - const style = parser.GetBrackets(name); - let mml = parser.create('node', 'mpadded', [parser.ParseArg(name)], {width: 0}); - if (pos !== 'r') { - NodeUtil.setAttribute(mml, 'lspace', pos === 'l' ? '-1width' : '-.5width'); - } - if (style) { - const [display, script] = lookup(style, { - '\\displaystyle': [true, 0], - '\\textstyle': [false, 0], - '\\scriptstyle': [false, 1], - '\\scriptscriptstyle': [false, 2] - }, [null, null]); - if (display !== null) { - mml = parser.create('node', 'mstyle', [mml], {displaystyle: display, scriptlevel: script}); - } - } + MathLap(parser: TexParser, name: string, pos: string, cramped: boolean) { + const style = parser.GetBrackets(name, '').trim(); + let mml = parser.create('node', 'mstyle', [ + parser.create('node', 'mpadded', [parser.ParseArg(name)], { + width: 0, ...(pos === 'r' ? {} : {lspace: (pos === 'l' ? '-1width' : '-.5width')}) + }) + ], {'data-cramped': cramped}); + MathtoolsUtil.setDisplayLevel(mml, style); const atom = parser.create('node', 'TeXAtom', [mml]); parser.Push(atom); }, + Cramped(parser: TexParser, name: string) { + const style = parser.GetBrackets(name, '').trim(); + const arg = parser.ParseArg(name); + const mml = parser.create('node', 'mstyle', [arg], {'data-cramped': true}); + MathtoolsUtil.setDisplayLevel(mml, style); + parser.Push(mml); + }, + MtLap(parser: TexParser, name: string, pos: string) { const content = ParseUtil.internalMath(parser, parser.GetArgument(name), 0); let mml = parser.create('node', 'mpadded', content, {width: 0}); diff --git a/ts/input/tex/mathtools/MathtoolsUtil.ts b/ts/input/tex/mathtools/MathtoolsUtil.ts index 4cd73fdde..5eb8908a8 100644 --- a/ts/input/tex/mathtools/MathtoolsUtil.ts +++ b/ts/input/tex/mathtools/MathtoolsUtil.ts @@ -27,6 +27,7 @@ import TexError from '../TexError.js'; import {CommandMap} from '../SymbolMap.js'; import {Macro} from '../Symbol.js'; import ParseOptions from '../ParseOptions.js'; +import {lookup} from '../../../util/Options.js'; import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; import {MathtoolsMethods} from './MathtoolsMethods.js'; @@ -37,6 +38,20 @@ import {PAIREDDELIMS} from './MathtoolsConfiguration.js'; */ export const MathtoolsUtil = { + setDisplayLevel(mml: MmlNode, style: string) { + if (!style) return; + const [display, script] = lookup(style, { + '\\displaystyle': [true, 0], + '\\textstyle': [false, 0], + '\\scriptstyle': [false, 1], + '\\scriptscriptstyle': [false, 2] + }, [null, null]); + if (display !== null) { + mml.attributes.set('displaystyle', display); + mml.attributes.set('scriptlevel', script); + } + }, + checkAlignment(parser: TexParser, name: string) { const top = parser.stack.Top() as EqnArrayItem; if (top.kind !== EqnArrayItem.prototype.kind) { From 96bd2cfd7d01eda3086920bedf8ca659e2a9564c Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 11:05:43 -0400 Subject: [PATCH 038/142] Add support for \mathtoolsset --- ts/input/tex/ParseUtil.ts | 3 +-- .../tex/mathtools/MathtoolsConfiguration.ts | 1 + ts/input/tex/mathtools/MathtoolsMappings.ts | 4 +++- ts/input/tex/mathtools/MathtoolsMethods.ts | 18 ++++++++++++++++++ 4 files changed, 23 insertions(+), 3 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 2517f296e..9d7654df7 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -560,8 +560,7 @@ namespace ParseUtil { for (let key of Object.keys(def)) { if (!allowed.hasOwnProperty(key)) { if (error) { - throw new TexError('InvalidOption', - 'Invalid optional argument: %1', key); + throw new TexError('InvalidOption', 'Invalid option: %1', key); } delete def[key]; } diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts index e7449dee5..4cdd91b51 100644 --- a/ts/input/tex/mathtools/MathtoolsConfiguration.ts +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -123,6 +123,7 @@ export const MathtoolsConfiguration = Configuration.create( 'prescript-sub-format': '', // format for \prescript subscript 'prescript-sup-format': '', // format for \prescript superscript 'prescript-arg-format': '', // format for \prescript base + 'allow-mathtoolsset': true, // true to allow \mathtoolsset to change settings pairedDelimiters: expandable({}), // predefined paired delimiters // name: [left, right, body, argcount, pre, post] tagforms: expandable({}), // tag form definitions diff --git a/ts/input/tex/mathtools/MathtoolsMappings.ts b/ts/input/tex/mathtools/MathtoolsMappings.ts index db3f82167..6d8cfbb18 100644 --- a/ts/input/tex/mathtools/MathtoolsMappings.ts +++ b/ts/input/tex/mathtools/MathtoolsMappings.ts @@ -132,7 +132,9 @@ new CommandMap('mathtools-macros', { 'MacroWithTemplate', '\\mathop{{#1}\\vphantom{{#3}}}_{{#2}\\vphantom{{#4}}}\\mathop{{#3}\\vphantom{{#1}}}_{{#4}\\vphantom{{#2}}}', 4, , '_', , '_' - ] + ], + + mathtoolsset: 'SetOptions' }, MathtoolsMethods); diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts index 082743d82..3ac1a56c4 100644 --- a/ts/input/tex/mathtools/MathtoolsMethods.ts +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -498,6 +498,24 @@ export const MathtoolsMethods: Record = { tags.mtCurrent = tags.mtFormats.get(id); }, + SetOptions(parser: TexParser, name: string) { + const options = parser.options.mathtools; + if (!options['allow-mathtoolsset']) { + throw new TexError('ForbiddenMathtoolsSet', '%1 is disabled', name); + } + const allowed = {} as {[id: string]: number}; + Object.keys(options).forEach(id => { + if (id !== 'pariedDelimiters' && id !== 'tagforms' && id !== 'allow-mathtoolsset') { + allowed[id] = 1; + } + }); + const args = parser.GetArgument(name); + const keys = ParseUtil.keyvalOptions(args, allowed, true); + for (const [id, value] of Object.entries(keys)) { + options[id] = value; + } + }, + /** * Use the Base or AMS methods for these */ From b299037546d6b50fce83c60fa9a4d0c9cb937b9b Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 14:51:41 -0400 Subject: [PATCH 039/142] Add jsdoc comments --- ts/input/tex/mathtools/MathtoolsMappings.ts | 15 +- ts/input/tex/mathtools/MathtoolsMethods.ts | 266 ++++++++++++++++++-- ts/input/tex/mathtools/MathtoolsUtil.ts | 53 +++- 3 files changed, 304 insertions(+), 30 deletions(-) diff --git a/ts/input/tex/mathtools/MathtoolsMappings.ts b/ts/input/tex/mathtools/MathtoolsMappings.ts index 6d8cfbb18..b1a276dbb 100644 --- a/ts/input/tex/mathtools/MathtoolsMappings.ts +++ b/ts/input/tex/mathtools/MathtoolsMappings.ts @@ -28,7 +28,7 @@ import {TexConstant} from '../TexConstants.js'; import {MathtoolsMethods} from './MathtoolsMethods.js'; // -// Not implemented: +// Mathtools macros that are not implemented: // // \smashoperator[〈pos〉]{〈operator with limits〉} // \SwapAboveDisplaySkip @@ -41,6 +41,9 @@ import {MathtoolsMethods} from './MathtoolsMethods.js'; // \renewgathered{〈name〉}{〈pre_line〉}{〈post_line〉}{〈after〉} // +/** + * The macros for this package. + */ new CommandMap('mathtools-macros', { shoveleft: ['HandleShove', TexConstant.Align.LEFT], // override AMS version @@ -138,7 +141,9 @@ new CommandMap('mathtools-macros', { }, MathtoolsMethods); - +/** + * The environments for this package. + */ new EnvironmentMap('mathtools-environments', ParseMethods.environment, { dcases: ['Array', null, '\\{', '', 'll', null, '.2em', 'D'], rcases: ['Array', null, '', '\\}', 'll', null, '.2em'], @@ -178,11 +183,17 @@ new EnvironmentMap('mathtools-environments', ParseMethods.environment, { }, MathtoolsMethods); +/** + * The delimiters for this package. + */ new DelimiterMap('mathtools-delimiters', ParseMethods.delimiter, { '\\lparen': '(', '\\rparen': ')' }); +/** + * The special characters for this package. + */ new CommandMap('mathtools-characters', { ':' : ['CenterColon', true] }, MathtoolsMethods); diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts index 3ac1a56c4..8d69401c4 100644 --- a/ts/input/tex/mathtools/MathtoolsMethods.ts +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -45,12 +45,31 @@ import {MathtoolsUtil} from './MathtoolsUtil.js'; */ export const MathtoolsMethods: Record = { + /** + * Handle a mathtools matrix environment, with optional alignment. + * + * @param {TexParser} parser The active tex parser. + * @param {StackItem} begin The BeginItem for the environment. + * @param {string} open The open delimiter for the matrix. + * @param {string} close The close delimiter for the matrix. + * @return {StackItem} The ArrayItem for the matrix. + */ MtMatrix(parser: TexParser, begin: StackItem, open: string, close: string) { const align = parser.GetBrackets(`\\begin{${begin.getName()}}`, 'c'); return MathtoolsMethods.Array(parser, begin, open, close, align); }, - MtSmallMatrix(parser: TexParser, begin: StackItem, open: string, close: string, align: string) { + /** + * Create a smallmatrix with given delimiters, and with optional alignment (and settable default) + * + * @param {TexParser} parser The active tex parser. + * @param {StackItem} begin The BeginItem for the environment. + * @param {string} open The open delimiter for the matrix. + * @param {string} close The close delimiter for the matrix. + * @param {string} align The (optional) alignment. If not given, use a bracket argument for it. + * @return {StackItem} The ArrayItem for the matrix. + */ + MtSmallMatrix(parser: TexParser, begin: StackItem, open: string, close: string, align?: string) { if (!align) { align = parser.GetBrackets(`\\begin{${begin.getName()}}`, parser.options.mathtools['smallmatrix-align']); } @@ -59,6 +78,13 @@ export const MathtoolsMethods: Record = { ); }, + /** + * Create the multlined StackItem. + * + * @param {TexParser} parser The active tex parser. + * @param {StackItem} begin The BeginItem for the environment. + * @return {StackItem} The MultlinedItem. + */ MtMultlined(parser: TexParser, begin: StackItem) { const name = `\\begin{${begin.getName()}}`; let pos = parser.GetBrackets(name, parser.options.mathtools['multlined-pos'] || 'c'); @@ -77,6 +103,13 @@ export const MathtoolsMethods: Record = { return ParseUtil.setArrayAlign(item as ArrayItem, pos || 'c'); }, + /** + * Replacement for the AMS HandleShove that incldues optional spacing values + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the calling macro. + * @param {string} shove Which way to shove the result. + */ HandleShove(parser: TexParser, name: string, shove: string) { let top = parser.stack.Top(); if (top.kind !== 'multline' && top.kind !== 'multlined') { @@ -109,8 +142,18 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Handle the spreadlines environment. + * + * @param {TexParser} parser The active tex parser. + * @param {StackItem} begin The BeginItem for the environment. + */ SpreadLines(parser: TexParser, begin: StackItem) { if (parser.stack.env.closing === begin.getName()) { + // + // When the environment ends, look through the contents and + // adjust the spacing in any tables, then push the results. + // delete parser.stack.env.closing; const top = parser.stack.Pop(); const mml = top.toMml(); @@ -124,6 +167,9 @@ export const MathtoolsMethods: Record = { } parser.Push(mml); } else { + // + // Read the spread dimension and save it, then begin the environment. + // const spread = parser.GetDimen(`\\begin{${begin.getName()}}`); begin.setProperty('spread', spread); parser.Push(begin); @@ -131,7 +177,32 @@ export const MathtoolsMethods: Record = { }, /** - * Handle mathrlap, mathllap, mathclap commands. + * Implements the various cases environments. + * + * @param {TexParser} parser The calling parser. + * @param {StackItem} begin The BeginItem for the environment. + * @param {string} open The open delimiter for the matrix. + * @param {string} close The close delimiter for the matrix. + * @param {string} style The style (D, T, S, SS) for the contents of the array + * @return {ArrayItem} The ArrayItem for the environment + */ + Cases(parser: TexParser, begin: StackItem, open: string, close: string, style: string) { + const array = parser.itemFactory.create('array').setProperty('casesEnv', begin.getName()) as ArrayItem; + array.arraydef = { + rowspacing: '.2em', + columnspacing: '1em', + columnalign: 'left' + }; + if (style === 'D') { + array.arraydef.displaystyle = true; + } + array.setProperties({open, close}); + parser.Push(begin); + return array; + }, + + /** + * Handle \mathrlap, \mathllap, \mathclap, and their cramped versions. * * @param {TexParser} parser The calling parser. * @param {string} name The macro name. @@ -146,10 +217,15 @@ export const MathtoolsMethods: Record = { }) ], {'data-cramped': cramped}); MathtoolsUtil.setDisplayLevel(mml, style); - const atom = parser.create('node', 'TeXAtom', [mml]); - parser.Push(atom); + parser.Push(parser.create('node', 'TeXAtom', [mml])); }, + /** + * Implements \cramped. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ Cramped(parser: TexParser, name: string) { const style = parser.GetBrackets(name, '').trim(); const arg = parser.ParseArg(name); @@ -158,6 +234,13 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \clap (and could do \llap and \rlap, where the contents are text mode). + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {string} pos The position (l, c, r) of the lapped content + */ MtLap(parser: TexParser, name: string, pos: string) { const content = ParseUtil.internalMath(parser, parser.GetArgument(name), 0); let mml = parser.create('node', 'mpadded', content, {width: 0}); @@ -167,6 +250,12 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \mathmakebox. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ MathMakeBox(parser: TexParser, name: string) { const width = parser.GetBrackets(name); const pos = parser.GetBrackets(name, 'c'); @@ -181,10 +270,26 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \mathmbox. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ MathMBox(parser: TexParser, name: string) { parser.Push(parser.create('node', 'mrow', [parser.ParseArg(name)])); }, + /** + * Implements \underbacket and \overbracket. + * (Currently only works in CHTML, since we don't yet handle styles properly in SVG. + * This includes a workaround oin CHTML to the fact that the border size is not + * part of MathJax's bbox computations yet. That will need to be removed when + * we handle borders properly.) + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ UnderOverBracket(parser: TexParser, name: string) { const thickness = length2em(parser.GetBrackets(name, '.1em'), .1); const height = parser.GetBrackets(name, '.2em'); @@ -217,21 +322,12 @@ export const MathtoolsMethods: Record = { parser.Push(node); }, - Cases(parser: TexParser, begin: StackItem, open: string, close: string, style: string) { - const array = parser.itemFactory.create('array').setProperty('casesEnv', begin.getName()) as ArrayItem; - array.arraydef = { - rowspacing: '.2em', - columnspacing: '1em', - columnalign: 'left' - }; - if (style === 'D') { - array.arraydef.displaystyle = true; - } - array.setProperties({open, close}); - parser.Push(begin); - return array; - }, - + /** + * Implements \Aboxed. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ Aboxed(parser: TexParser, name: string) { // // Check that the top item is an alignment, and that we are on an even number of cells @@ -247,15 +343,16 @@ export const MathtoolsMethods: Record = { const arg = parser.GetArgument(name); const rest = parser.string.substr(parser.i); // - // Put argument back, followed by "&&", which we look for below. + // Put the argument back, followed by "&&", and a marker that we look for below. // - parser.string = arg + '&&'; + parser.string = arg + '&&\\endAboxed'; parser.i = 0; // // Get the two parts separated by ampersands, and ignore the rest. // const left = parser.GetUpTo(name, '&'); const right = parser.GetUpTo(name, '&'); + parser.GetUpTo(name, '\\endAboxed'); // // Insert the TeX needed for the boxed content // @@ -266,6 +363,12 @@ export const MathtoolsMethods: Record = { parser.i = 0; }, + /** + * Implements \ArrowBetweenLines. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ ArrowBetweenLines(parser: TexParser, name: string) { const top = MathtoolsUtil.checkAlignment(parser, name); if (top.Size() || top.row.length) { @@ -284,6 +387,12 @@ export const MathtoolsMethods: Record = { top.EndRow(); }, + /** + * Implements \vdotswithin. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ VDotsWithin(parser: TexParser, name: string) { const top = parser.stack.Top() as EqnArrayItem; const isFlush = (top.getProperty('flushspaceabove') === top.table.length); @@ -298,6 +407,12 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \shortvdotswithin. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ ShortVDotsWithin(parser: TexParser, _name: string) { const top = parser.stack.Top() as EqnArrayItem; const star = parser.GetStar(); @@ -308,12 +423,24 @@ export const MathtoolsMethods: Record = { MathtoolsMethods.FlushSpaceBelow(parser, '\\MTFlushSpaceBelow'); }, + /** + * Implements \MTFlushSpaceAbove. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ FlushSpaceAbove(parser: TexParser, name: string) { const top = MathtoolsUtil.checkAlignment(parser, name); - top.setProperty('flushspaceabove', top.table.length); + top.setProperty('flushspaceabove', top.table.length); // marker so \vdotswithin can shorten its height top.addRowSpacing('-' + parser.options.mathtools['shortvdotsadjustabove']); }, + /** + * Implements \MTFlushSpaceBelow. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ FlushSpaceBelow(parser: TexParser, name: string) { const top = MathtoolsUtil.checkAlignment(parser, name); top.Size() && top.EndEntry(); @@ -321,6 +448,18 @@ export const MathtoolsMethods: Record = { top.addRowSpacing('-' + parser.options.mathtools['shortvdotsadjustbelow']); }, + /** + * Implements a paired delimiter (e.g., from \DeclarePairedDelimiter). + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {string} open The open delimiter. + * @param {string} close The close delimiter. + * @param {string?} body The body betweeen the delimiters. + * @param {number?} n The number of arguments to use for the body. + * @param {string?} pre The TeX to go before the open delimiter. + * @param {string?} post The TeX to go after the close delimiter. + */ PairedDelimiters(parser: TexParser, name: string, open: string, close: string, body: string = '#1', n: number = 1, @@ -343,6 +482,12 @@ export const MathtoolsMethods: Record = { ParseUtil.checkMaxMacros(parser); }, + /** + * Implements \DeclarePairedDelimiters. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ DeclarePairedDelimiters(parser: TexParser, name: string) { const cs = NewcommandUtil.GetCsNameArgument(parser, name); const open = parser.GetArgument(name); @@ -350,6 +495,12 @@ export const MathtoolsMethods: Record = { MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close]); }, + /** + * Implements \DeclarePairedDelimitersX. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ DeclarePairedDelimitersX(parser: TexParser, name: string) { const cs = NewcommandUtil.GetCsNameArgument(parser, name); const n = NewcommandUtil.GetArgCount(parser, name); @@ -359,6 +510,12 @@ export const MathtoolsMethods: Record = { MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close, body, n]); }, + /** + * Implements \DeclarePairedDelimitersXPP. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ DeclarePairedDelimitersXPP(parser: TexParser, name: string) { const cs = NewcommandUtil.GetCsNameArgument(parser, name); const n = NewcommandUtil.GetArgCount(parser, name); @@ -370,6 +527,15 @@ export const MathtoolsMethods: Record = { MathtoolsUtil.addPairedDelims(parser.configuration, cs, [open, close, body, n, pre, post]); }, + /** + * Implements \centeredcolon, \ordinarycolon, \MTThinColon. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {boolean} center True if colon should be centered + * @param {boolean} force True menas always center (don't use centercolon option). + * @param {boolean} thin True if this is a thin color (for \coloneqq, etc). + */ CenterColon(parser: TexParser, _name: string, center: boolean, force: boolean = false, thin: boolean = false) { const options = parser.options.mathtools; let mml = parser.create('token', 'mo', {}, ':'); @@ -383,6 +549,14 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \coloneqq and related macros. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {string} tex The tex string to use (if not using unicode versions or if there isn't one). + * @param {string} unicode The unicode character (if there is one). + */ Relation(parser: TexParser, _name: string, tex: string, unicode?: string) { const options = parser.options.mathtools; if (options['use-unicode'] && unicode) { @@ -394,6 +568,12 @@ export const MathtoolsMethods: Record = { } }, + /** + * Implements \ndownarrow and \nuparrow via a terrible hack (visual only, no chance of this working with SRE). + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ NArrow(parser: TexParser, _name: string, c: string, dy: string) { parser.Push( parser.create('node', 'TeXAtom', [ @@ -412,6 +592,13 @@ export const MathtoolsMethods: Record = { ); }, + /** + * Implements \splitfrac and \splitdfrac. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {boolean} display True if \splitdfrac. + */ SplitFrac(parser: TexParser, name: string, display: boolean) { const num = parser.ParseArg(name); const den = parser.ParseArg(name); @@ -421,7 +608,7 @@ export const MathtoolsMethods: Record = { parser.create('node', 'mstyle', [ num, parser.create('token', 'mi'), - parser.create('token', 'mspace', {width: '1em'}) + parser.create('token', 'mspace', {width: '1em'}) // no parameter for this in mathtools. Should we add one? ], {scriptlevel: 0}), parser.create('node', 'mstyle', [ parser.create('token', 'mspace', {width: '1em'}), @@ -433,6 +620,12 @@ export const MathtoolsMethods: Record = { ); }, + /** + * Implements \xmathstrut. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ XMathStrut(parser: TexParser, name: string) { let dd = parser.GetBrackets(name); let dh = parser.GetArgument(name); @@ -449,6 +642,12 @@ export const MathtoolsMethods: Record = { ); }, + /** + * Implements \prescript. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ Prescript(parser: TexParser, name: string) { const sup = MathtoolsUtil.getScript(parser, name, 'sup'); const sub = MathtoolsUtil.getScript(parser, name, 'sub'); @@ -464,6 +663,13 @@ export const MathtoolsMethods: Record = { parser.Push(mml); }, + /** + * Implements \newtagform and \renewtagform. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + * @param {boolean=} renew True if \renewtagform. + */ NewTagForm(parser: TexParser, name: string, renew: boolean = false) { const tags = parser.tags as MathtoolsTags; if (!('mtFormats' in tags)) { @@ -482,6 +688,12 @@ export const MathtoolsMethods: Record = { tags.mtFormats.set(id, [left, right, format]); }, + /** + * Implements \usetagform. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ UseTagForm(parser: TexParser, name: string) { const tags = parser.tags as MathtoolsTags; if (!('mtFormats' in tags)) { @@ -498,6 +710,12 @@ export const MathtoolsMethods: Record = { tags.mtCurrent = tags.mtFormats.get(id); }, + /** + * Implements \mathtoolsset. + * + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ SetOptions(parser: TexParser, name: string) { const options = parser.options.mathtools; if (!options['allow-mathtoolsset']) { @@ -524,6 +742,6 @@ export const MathtoolsMethods: Record = { xArrow: AmsMethods.xArrow, HandleRef: AmsMethods.HandleRef, AmsEqnArray: AmsMethods.AmsEqnArray, - MacroWithTemplate: NewcommandMethods.MacroWithTemplate + MacroWithTemplate: NewcommandMethods.MacroWithTemplate, }; diff --git a/ts/input/tex/mathtools/MathtoolsUtil.ts b/ts/input/tex/mathtools/MathtoolsUtil.ts index 5eb8908a8..4ac957eba 100644 --- a/ts/input/tex/mathtools/MathtoolsUtil.ts +++ b/ts/input/tex/mathtools/MathtoolsUtil.ts @@ -29,6 +29,7 @@ import {Macro} from '../Symbol.js'; import ParseOptions from '../ParseOptions.js'; import {lookup} from '../../../util/Options.js'; import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; +import {MmlMstyle} from '../../../core/MmlTree/MmlNodes/mstyle.js'; import {MathtoolsMethods} from './MathtoolsMethods.js'; import {PAIREDDELIMS} from './MathtoolsConfiguration.js'; @@ -38,7 +39,13 @@ import {PAIREDDELIMS} from './MathtoolsConfiguration.js'; */ export const MathtoolsUtil = { - setDisplayLevel(mml: MmlNode, style: string) { + /** + * Set the displaystyle and scriptlevel attributes of an mstyle element + * + * @param {MmlMstyle} mml The mstyle node to modify. + * @param {string} style The TeX style macro to apply. + */ + setDisplayLevel(mml: MmlMstyle, style: string) { if (!style) return; const [display, script] = lookup(style, { '\\displaystyle': [true, 0], @@ -52,7 +59,14 @@ export const MathtoolsUtil = { } }, - checkAlignment(parser: TexParser, name: string) { + /** + * Check that the top stack item is an alignment table. + * + * @param {TexParser} parser The current TeX parser. + * @param {string} name The name of the macro doing the checking. + * @return {EqnArrayItem} The top item (an EqnArrayItem). + */ + checkAlignment(parser: TexParser, name: string): EqnArrayItem { const top = parser.stack.Top() as EqnArrayItem; if (top.kind !== EqnArrayItem.prototype.kind) { throw new TexError('NotInAlignment', '%1 can only be used in aligment environments', name); @@ -60,11 +74,27 @@ export const MathtoolsUtil = { return top; }, + /** + * Add a paired delimiter to the list of them. + * + * @param {ParseOptions} config The parse options to modify. + * @param {string} cs The control sequence for the paired delimiters. + * @param {string[]} args The definition for the paired delimiters. One of: + * [left, right] + * [left, right, body, argcount] + * [left, right, body, argcount, pre, post] + */ addPairedDelims(config: ParseOptions, cs: string, args: string[]) { const delims = config.handlers.retrieve(PAIREDDELIMS) as CommandMap; delims.add(cs, new Macro(cs, MathtoolsMethods.PairedDelimiters, args)); }, + /** + * Adjust the line spacing for a table. + * + * @param {MmlNode} mtable The mtable node to adjust (if it is a table). + * @param {string} spread The dimension to change by (number-with-units). + */ spreadLines(mtable: MmlNode, spread: string) { if (!mtable.isKind('mtable')) return; let rowspacing = mtable.attributes.get('rowspacing') as string; @@ -80,7 +110,14 @@ export const MathtoolsUtil = { mtable.attributes.set('rowspacing', rowspacing); }, - plusOrMinus(name: string, n: string) { + /** + * Check if a string is a number and return it with an explicit plus if there isn't one. + * + * @param {string} name The name of the macro doing the checking. + * @param {string} n The string to test as a number. + * @return {srtring} The number with an explicit sign. + */ + plusOrMinus(name: string, n: string): string { n = n.trim(); if (!n.match(/^[-+]?(?:\d+(?:\.\d*)?|\.\d+)$/)) { throw new TexError('NotANumber', 'Argument to %1 is not a number', name); @@ -88,7 +125,15 @@ export const MathtoolsUtil = { return (n.match(/^[-+]/) ? n : '+' + n); }, - getScript(parser: TexParser, name: string, pos: string) { + /** + * Parse a \prescript argument, with its associated format, if any. + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the calling macro (\prescript). + * @param {string} pos The position for the argument (sub, sup, arg). + * @return {MmlNode} The parsed MML version of the argument. + */ + getScript(parser: TexParser, name: string, pos: string): MmlNode { let arg = ParseUtil.trimSpaces(parser.GetArgument(name)); if (arg === '') { return parser.create('node', 'none'); From 3bf820c69e3ace5cbd6173ec81860c1c26792c16 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 15:51:56 -0400 Subject: [PATCH 040/142] Fix typos in comments --- ts/input/tex/ParseUtil.ts | 2 +- ts/util/Options.ts | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 9d7654df7..919928582 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -486,7 +486,7 @@ namespace ParseUtil { } /** - * Repoort an error if there are too many macro substitutions. + * Report an error if there are too many macro substitutions. * @param {TexParser} parser The current TeX parser. * @param {boolean} isMacro True if we are substituting a macro, false for environment. */ diff --git a/ts/util/Options.ts b/ts/util/Options.ts index 43aedf872..5b045dc0b 100644 --- a/ts/util/Options.ts +++ b/ts/util/Options.ts @@ -328,7 +328,7 @@ export function separateOptions(options: OptionList, ...objects: OptionList[]): /*****************************************************************/ /** - * Look up a value fromn object literal, being sure it is an + * Look up a value from object literal, being sure it is an * actual property (not inherited), with a default if not found. * * @param {string} name The name of the key to look up. From a61bb47a44059b8392066345523ce35159aae07c Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 11 May 2021 16:58:38 -0400 Subject: [PATCH 041/142] Trim delimiter for \big and friends, and put \math* in a TeXAtom --- ts/input/tex/TexParser.ts | 2 +- ts/input/tex/base/BaseMethods.ts | 5 +---- 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/ts/input/tex/TexParser.ts b/ts/input/tex/TexParser.ts index c6b770450..cfa98f479 100644 --- a/ts/input/tex/TexParser.ts +++ b/ts/input/tex/TexParser.ts @@ -373,7 +373,7 @@ export default class TexParser { c += this.GetCS(); } else if (c === '{' && braceOK) { this.i--; - c = this.GetArgument(name); + c = this.GetArgument(name).trim(); } if (this.contains('delimiter', c)) { return this.convertDelimiter(c); diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 3339a3230..fb5fc6b87 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -283,10 +283,7 @@ BaseMethods.MathFont = function(parser: TexParser, name: string, variant: string font: variant, multiLetterIdentifiers: true }, parser.configuration).mml(); - if (mml.isKind('inferredMrow')) { - mml = parser.create('node', 'mrow', mml.childNodes); - } - parser.Push(mml); + parser.Push(parser.create('node', 'TeXAtom', [mml])); }; /** From 34439e761b5af1088abdfeb3758e242fd6a8f5d5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 12 May 2021 10:28:39 -0400 Subject: [PATCH 042/142] Fix tsc compile errors --- ts/input/tex/mathtools/MathtoolsMethods.ts | 20 ++++++++++---------- ts/input/tex/mathtools/MathtoolsUtil.ts | 5 ++--- 2 files changed, 12 insertions(+), 13 deletions(-) diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts index 8d69401c4..4562485dc 100644 --- a/ts/input/tex/mathtools/MathtoolsMethods.ts +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -25,7 +25,7 @@ import {ArrayItem, EqnArrayItem} from '../base/BaseItems.js'; import {StackItem} from '../StackItem.js'; import ParseUtil from '../ParseUtil.js'; -import {ParseMethod} from '../Types.js'; +import {ParseMethod, ParseResult} from '../Types.js'; import {AmsMethods} from '../ams/AmsMethods.js'; import BaseMethods from '../base/BaseMethods.js'; import TexParser from '../TexParser.js'; @@ -52,9 +52,9 @@ export const MathtoolsMethods: Record = { * @param {StackItem} begin The BeginItem for the environment. * @param {string} open The open delimiter for the matrix. * @param {string} close The close delimiter for the matrix. - * @return {StackItem} The ArrayItem for the matrix. + * @return {ParserResult} The ArrayItem for the matrix. */ - MtMatrix(parser: TexParser, begin: StackItem, open: string, close: string) { + MtMatrix(parser: TexParser, begin: StackItem, open: string, close: string): ParseResult { const align = parser.GetBrackets(`\\begin{${begin.getName()}}`, 'c'); return MathtoolsMethods.Array(parser, begin, open, close, align); }, @@ -67,9 +67,9 @@ export const MathtoolsMethods: Record = { * @param {string} open The open delimiter for the matrix. * @param {string} close The close delimiter for the matrix. * @param {string} align The (optional) alignment. If not given, use a bracket argument for it. - * @return {StackItem} The ArrayItem for the matrix. + * @return {ParseResult} The ArrayItem for the matrix. */ - MtSmallMatrix(parser: TexParser, begin: StackItem, open: string, close: string, align?: string) { + MtSmallMatrix(parser: TexParser, begin: StackItem, open: string, close: string, align?: string): ParseResult { if (!align) { align = parser.GetBrackets(`\\begin{${begin.getName()}}`, parser.options.mathtools['smallmatrix-align']); } @@ -83,9 +83,9 @@ export const MathtoolsMethods: Record = { * * @param {TexParser} parser The active tex parser. * @param {StackItem} begin The BeginItem for the environment. - * @return {StackItem} The MultlinedItem. + * @return {ParseResult} The MultlinedItem. */ - MtMultlined(parser: TexParser, begin: StackItem) { + MtMultlined(parser: TexParser, begin: StackItem): ParseResult { const name = `\\begin{${begin.getName()}}`; let pos = parser.GetBrackets(name, parser.options.mathtools['multlined-pos'] || 'c'); let width = pos ? parser.GetBrackets(name, '') : ''; @@ -186,7 +186,7 @@ export const MathtoolsMethods: Record = { * @param {string} style The style (D, T, S, SS) for the contents of the array * @return {ArrayItem} The ArrayItem for the environment */ - Cases(parser: TexParser, begin: StackItem, open: string, close: string, style: string) { + Cases(parser: TexParser, begin: StackItem, open: string, close: string, style: string): ArrayItem { const array = parser.itemFactory.create('array').setProperty('casesEnv', begin.getName()) as ArrayItem; array.arraydef = { rowspacing: '.2em', @@ -729,8 +729,8 @@ export const MathtoolsMethods: Record = { }); const args = parser.GetArgument(name); const keys = ParseUtil.keyvalOptions(args, allowed, true); - for (const [id, value] of Object.entries(keys)) { - options[id] = value; + for (const id of Object.keys(keys)) { + options[id] = keys[id]; } }, diff --git a/ts/input/tex/mathtools/MathtoolsUtil.ts b/ts/input/tex/mathtools/MathtoolsUtil.ts index 4ac957eba..2b77d60e0 100644 --- a/ts/input/tex/mathtools/MathtoolsUtil.ts +++ b/ts/input/tex/mathtools/MathtoolsUtil.ts @@ -29,7 +29,6 @@ import {Macro} from '../Symbol.js'; import ParseOptions from '../ParseOptions.js'; import {lookup} from '../../../util/Options.js'; import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; -import {MmlMstyle} from '../../../core/MmlTree/MmlNodes/mstyle.js'; import {MathtoolsMethods} from './MathtoolsMethods.js'; import {PAIREDDELIMS} from './MathtoolsConfiguration.js'; @@ -42,10 +41,10 @@ export const MathtoolsUtil = { /** * Set the displaystyle and scriptlevel attributes of an mstyle element * - * @param {MmlMstyle} mml The mstyle node to modify. + * @param {MmlNode} mml The mstyle node to modify. * @param {string} style The TeX style macro to apply. */ - setDisplayLevel(mml: MmlMstyle, style: string) { + setDisplayLevel(mml: MmlNode, style: string) { if (!style) return; const [display, script] = lookup(style, { '\\displaystyle': [true, 0], From 8d176946b4aa626a620c2a97025a78f3854ac106 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 12 May 2021 18:13:17 -0400 Subject: [PATCH 043/142] Force width of -explicitFont text (work around Safari bug) --- ts/output/chtml.ts | 23 +++++++++++++++++++---- ts/output/chtml/Wrappers/TextNode.ts | 3 +-- 2 files changed, 20 insertions(+), 6 deletions(-) diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index 53c42901c..2e6f356a2 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -208,7 +208,7 @@ CommonOutputJax, CHTMLWrapperFactory, CH /** * @override */ - public unknownText(text: string, variant: string) { + public unknownText(text: string, variant: string, width: number = null) { const styles: StyleList = {}; const scale = 100 / this.math.metrics.scale; if (scale !== 100) { @@ -221,6 +221,16 @@ CommonOutputJax, CHTMLWrapperFactory, CH this.cssFontStyles(this.font.getCssFont(variant), styles); } } + // + // Work around Safari bug with the MJXZERO font by forcing the width. + // (If MJXZERO can be made to work with Safari, then remove width parameter + // and call to getBBox().w in TextNode.ts) + // + if (width !== null) { + const metrics = this.math.metrics; + styles.width = Math.round(width * metrics.em * metrics.scale) + 'px'; + } + // return this.html('mjx-utext', {variant: variant, style: styles}, [this.text(text)]); } @@ -231,11 +241,16 @@ CommonOutputJax, CHTMLWrapperFactory, CH * @override */ - public measureTextNode(text: N) { + public measureTextNode(textNode: N) { const adaptor = this.adaptor; - text = adaptor.clone(text); + const text = adaptor.clone(textNode); + // + // Work arround Safari bug with the MJXZERO font. + // + adaptor.setStyle(text, 'font-family', adaptor.getStyle(text, 'font-family').replace(/MJXZERO, /g, '')); + // const style = {position: 'absolute', 'white-space': 'nowrap'}; - const node = this.html('mjx-measure-text', {style}, [ text]); + const node = this.html('mjx-measure-text', {style}, [text]); adaptor.append(adaptor.parent(this.math.start.node), this.container); adaptor.append(this.container, node); let w = adaptor.nodeSize(text, this.math.metrics.em)[0] / this.math.metrics.scale; diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index b1a61931e..ab45d9682 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -70,8 +70,7 @@ CommonTextNodeMixin>(CHTMLWrapper) { const variant = this.parent.variant; const text = (this.node as TextNode).getText(); if (variant === '-explicitFont') { - const font = this.jax.getFontData(this.parent.styles); - adaptor.append(parent, this.jax.unknownText(text, variant, font)); + adaptor.append(parent, this.jax.unknownText(text, variant, this.getBBox().w)); } else { const chars = this.remappedText(text, variant); for (const n of chars) { From 89c4c4cd3c04e1f0be6017cafbcbbbb0906cb613 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 13 May 2021 11:31:06 -0400 Subject: [PATCH 044/142] Fix incorrect merge conflict resolution from #653 --- ts/core/MmlTree/MmlNodes/mo.ts | 26 ++++---------------------- 1 file changed, 4 insertions(+), 22 deletions(-) diff --git a/ts/core/MmlTree/MmlNodes/mo.ts b/ts/core/MmlTree/MmlNodes/mo.ts index 8c7920365..d0823e301 100644 --- a/ts/core/MmlTree/MmlNodes/mo.ts +++ b/ts/core/MmlTree/MmlNodes/mo.ts @@ -25,7 +25,7 @@ import {PropertyList} from '../../Tree/Node.js'; import {AbstractMmlTokenNode, MmlNode, AttributeList, TEXCLASS} from '../MmlNode.js'; import {MmlMrow} from './mrow.js'; import {MmlMover, MmlMunder, MmlMunderover} from './munderover.js'; -import {OperatorList, OPTABLE, RangeDef, RANGES, MMLSPACING} from '../OperatorDictionary.js'; +import {OperatorList, OPTABLE, getRange, MMLSPACING} from '../OperatorDictionary.js'; import {unicodeChars, unicodeString} from '../../../util/string.js'; /*****************************************************************/ @@ -118,6 +118,9 @@ export class MmlMo extends AbstractMmlTokenNode { 0x201F: 0x2036, // reversed open double quote }; + /** + * Regular expression matching characters that are marked as math accents + */ protected static mathaccents = new RegExp([ '^[', '\u00B4\u0301\u02CA', // acute @@ -433,27 +436,6 @@ export class MmlMo extends AbstractMmlTokenNode { return forms; } - /** - * @param {string} mo The character to look up in the range table - * @return {RangeDef} The unicode range in which the character falls, or null - */ - protected getRange(mo: string): RangeDef { - if (!mo.match(/^[\uD800-\uDBFF]?.$/)) { - return null; - } - let n = mo.codePointAt(0); - let ranges = (this.constructor as typeof MmlMo).RANGES; - for (const range of ranges) { - if (range[0] <= n && n <= range[1]) { - return range; - } - if (n < range[0]) { - return null; - } - } - return null; - } - /** * Mark the mo as a pseudoscript if it is one. True means it is, * false means it is a pseudo-script character, but in an msup (so needs a variant form) From 53df1b55ce0173ae44d3267bf83b13824afa9b31 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 13 May 2021 12:22:30 -0400 Subject: [PATCH 045/142] Remove unwanted .js file --- ts/ui/lazy/LazyHandler.js | 248 -------------------------------------- 1 file changed, 248 deletions(-) delete mode 100644 ts/ui/lazy/LazyHandler.js diff --git a/ts/ui/lazy/LazyHandler.js b/ts/ui/lazy/LazyHandler.js deleted file mode 100644 index 953d371e5..000000000 --- a/ts/ui/lazy/LazyHandler.js +++ /dev/null @@ -1,248 +0,0 @@ -"use strict"; -/************************************************************* - * - * Copyright (c) 2019 The MathJax Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -var __extends = (this && this.__extends) || (function () { - var extendStatics = function (d, b) { - extendStatics = Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || - function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; - return extendStatics(d, b); - }; - return function (d, b) { - extendStatics(d, b); - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); - }; -})(); -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -Object.defineProperty(exports, "__esModule", { value: true }); -exports.AssistiveMmlHandler = exports.AssistiveMmlMathDocumentMixin = exports.AssistiveMmlMathItemMixin = exports.LimitedMmlVisitor = void 0; -var MathItem_js_1 = require("../core/MathItem.js"); -var SerializedMmlVisitor_js_1 = require("../core/MmlTree/SerializedMmlVisitor.js"); -var Options_js_1 = require("../util/Options.js"); -/*==========================================================================*/ -var LimitedMmlVisitor = /** @class */ (function (_super) { - __extends(LimitedMmlVisitor, _super); - function LimitedMmlVisitor() { - return _super !== null && _super.apply(this, arguments) || this; - } - /** - * @override - */ - LimitedMmlVisitor.prototype.getAttributes = function (node) { - /** - * Remove id from attribute output - */ - return _super.prototype.getAttributes.call(this, node).replace(/ ?id=".*?"/, ''); - }; - return LimitedMmlVisitor; -}(SerializedMmlVisitor_js_1.SerializedMmlVisitor)); -exports.LimitedMmlVisitor = LimitedMmlVisitor; -/*==========================================================================*/ -/** - * Add STATE value for having assistive MathML (after TYPESETTING) - */ -MathItem_js_1.newState('ASSISTIVEMML', 153); -/** - * The mixin for adding assistive MathML to MathItems - * - * @param {B} BaseMathItem The MathItem class to be extended - * @return {AssistiveMathItem} The augmented MathItem class - * - * @template N The HTMLElement node class - * @template T The Text node class - * @template D The Document class - * @template B The MathItem class to extend - */ -function AssistiveMmlMathItemMixin(BaseMathItem) { - return /** @class */ (function (_super) { - __extends(class_1, _super); - function class_1() { - return _super !== null && _super.apply(this, arguments) || this; - } - /** - * @param {MathDocument} document The MathDocument for the MathItem - * @param {boolean} force True to force assistive MathML evenif enableAssistiveMml is false - */ - class_1.prototype.assistiveMml = function (document, force) { - if (force === void 0) { force = false; } - if (this.state() >= MathItem_js_1.STATE.ASSISTIVEMML) - return; - if (!this.isEscaped && (document.options.enableAssistiveMml || force)) { - var adaptor = document.adaptor; - // - // Get the serialized MathML - // - var mml = document.toMML(this.root).replace(/\n */g, '').replace(//g, ''); - // - // Parse is as HTML and retrieve the element - // - var mmlNodes = adaptor.firstChild(adaptor.body(adaptor.parse(mml, 'text/html'))); - // - // Create a container for the hidden MathML - // - var node = adaptor.node('mjx-assistive-mml', { - unselectable: 'on', display: (this.display ? 'block' : 'inline') - }, [mmlNodes]); - // - // Hide the typeset math from assistive technology and append the MathML that is visually - // hidden from other users - // - adaptor.setAttribute(adaptor.firstChild(this.typesetRoot), 'aria-hidden', 'true'); - adaptor.setStyle(this.typesetRoot, 'position', 'relative'); - adaptor.append(this.typesetRoot, node); - } - this.state(MathItem_js_1.STATE.ASSISTIVEMML); - }; - return class_1; - }(BaseMathItem)); -} -exports.AssistiveMmlMathItemMixin = AssistiveMmlMathItemMixin; -/** - * The mixin for adding assistive MathML to MathDocuments - * - * @param {B} BaseDocument The MathDocument class to be extended - * @return {AssistiveMmlMathDocument} The Assistive MathML MathDocument class - * - * @template N The HTMLElement node class - * @template T The Text node class - * @template D The Document class - * @template B The MathDocument class to extend - */ -function AssistiveMmlMathDocumentMixin(BaseDocument) { - var _a; - return _a = /** @class */ (function (_super) { - __extends(BaseClass, _super); - /** - * Augment the MathItem class used for this MathDocument, and create the serialization visitor. - * - * @override - * @constructor - */ - function BaseClass() { - var args = []; - for (var _i = 0; _i < arguments.length; _i++) { - args[_i] = arguments[_i]; - } - var _this = _super.apply(this, args) || this; - var CLASS = _this.constructor; - var ProcessBits = CLASS.ProcessBits; - if (!ProcessBits.has('assistive-mml')) { - ProcessBits.allocate('assistive-mml'); - } - _this.visitor = new LimitedMmlVisitor(_this.mmlFactory); - _this.options.MathItem = - AssistiveMmlMathItemMixin(_this.options.MathItem); - if ('addStyles' in _this) { - _this.addStyles(CLASS.assistiveStyles); - } - return _this; - } - /** - * @param {MmlNode} node The node to be serializes - * @return {string} The serialization of the node - */ - BaseClass.prototype.toMML = function (node) { - return this.visitor.visitTree(node); - }; - /** - * Add assistive MathML to the MathItems in this MathDocument - */ - BaseClass.prototype.assistiveMml = function () { - if (!this.processed.isSet('assistive-mml')) { - for (var _i = 0, _a = this.math; _i < _a.length; _i++) { - var math = _a[_i]; - math.assistiveMml(this); - } - this.processed.set('assistive-mml'); - } - return this; - }; - /** - * @override - */ - BaseClass.prototype.state = function (state, restore) { - if (restore === void 0) { restore = false; } - _super.prototype.state.call(this, state, restore); - if (state < MathItem_js_1.STATE.ASSISTIVEMML) { - this.processed.clear('assistive-mml'); - } - return this; - }; - return BaseClass; - }(BaseDocument)), - /** - * @override - */ - _a.OPTIONS = __assign(__assign({}, BaseDocument.OPTIONS), { enableAssistiveMml: true, renderActions: Options_js_1.expandable(__assign(__assign({}, BaseDocument.OPTIONS.renderActions), { assistiveMml: [MathItem_js_1.STATE.ASSISTIVEMML] })) }), - /** - * styles needed for the hidden MathML - */ - _a.assistiveStyles = { - 'mjx-assistive-mml': { - position: 'absolute !important', - top: '0px', left: '0px', - clip: 'rect(1px, 1px, 1px, 1px)', - padding: '1px 0px 0px 0px !important', - border: '0px !important', - display: 'block !important', - width: 'auto !important', - overflow: 'hidden !important', - /* - * Don't allow the assistive MathML to become part of the selection - */ - '-webkit-touch-callout': 'none', - '-webkit-user-select': 'none', - '-khtml-user-select': 'none', - '-moz-user-select': 'none', - '-ms-user-select': 'none', - 'user-select': 'none' - }, - 'mjx-assistive-mml[display="block"]': { - width: '100% !important' - } - }, - _a; -} -exports.AssistiveMmlMathDocumentMixin = AssistiveMmlMathDocumentMixin; -/*==========================================================================*/ -/** - * Add assitive MathML support a Handler instance - * - * @param {Handler} handler The Handler instance to enhance - * @return {Handler} The handler that was modified (for purposes of chainging extensions) - * - * @template N The HTMLElement node class - * @template T The Text node class - * @template D The Document class - */ -function AssistiveMmlHandler(handler) { - handler.documentClass = - AssistiveMmlMathDocumentMixin(handler.documentClass); - return handler; -} -exports.AssistiveMmlHandler = AssistiveMmlHandler; From d5ec98ec52f2e2070a0d5ec856b91e918c8f4755 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 13 May 2021 12:50:02 -0400 Subject: [PATCH 046/142] Make sure style is defined before getting its first character --- ts/input/tex/base/BaseMethods.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 054c77b7c..d0635e4f8 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -1386,7 +1386,7 @@ BaseMethods.Array = function(parser: TexParser, begin: StackItem, // @test Cross Product array.setProperty('close', parser.convertDelimiter(close)); } - if (style.charAt(1) === '\'') { + if ((style || '').charAt(1) === '\'') { array.arraydef['data-cramped'] = true; style = style.charAt(0); } From 5455596294753b6861cfbc507b292f9d19c2c967 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 13 May 2021 12:51:22 -0400 Subject: [PATCH 047/142] Add packages to AllPackages, source, and dependencies --- components/src/dependencies.js | 8 ++++++-- components/src/source.js | 2 ++ ts/input/tex/AllPackages.ts | 6 ++++++ 3 files changed, 14 insertions(+), 2 deletions(-) diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..0309cb069 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -27,7 +27,9 @@ export const dependencies = { '[tex]/tagformat': ['input/tex-base'], '[tex]/textmacros': ['input/tex-base'], '[tex]/unicode': ['input/tex-base'], - '[tex]/verb': ['input/tex-base'] + '[tex]/verb': ['input/tex-base'], + '[tex]/numcases': ['[tex]/empheq'], + '[tex]/empheq': ['input/tex-base', '[tex]/ams'] }; export const paths = { @@ -58,7 +60,9 @@ const allPackages = [ '[tex]/tagformat', '[tex]/textmacros', '[tex]/unicode', - '[tex]/verb' + '[tex]/verb', + '[tex]/numcases', + '[tex]/empheq' ]; export const provides = { diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..d262b5476 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -32,6 +32,8 @@ export const source = { '[tex]/textmacros': `${src}/input/tex/extensions/textmacros/textmacros.js`, '[tex]/unicode': `${src}/input/tex/extensions/unicode/unicode.js`, '[tex]/verb': `${src}/input/tex/extensions/verb/verb.js`, + '[tex]/numcases': `${src}/input/tex/extensions/numcases/numcases.js`, + '[tex]/empheq': `${src}/input/tex/extensions/empheq/empheq.js`, 'input/mml': `${src}/input/mml/mml.js`, 'input/mml/entities': `${src}/input/mml/entities/entities.js`, 'input/asciimath': `${src}/input/asciimath/asciimath.js`, diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..dfb548fc4 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -45,6 +45,8 @@ import './tagformat/TagFormatConfiguration.js'; import './textmacros/TextMacrosConfiguration.js'; import './unicode/UnicodeConfiguration.js'; import './verb/VerbConfiguration.js'; +import './numcases/NumcasesConfiguration.js'; +import './empheq/EmpheqConfiguration.js'; declare const MathJax: any; if (typeof MathJax !== 'undefined' && MathJax.loader) { @@ -69,6 +71,8 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/physics', '[tex]/unicode', '[tex]/verb', + '[tex]/numcases', + '[tex]/empheq', '[tex]/configmacros', '[tex]/tagformat', '[tex]/textmacros' @@ -95,6 +99,8 @@ export const AllPackages: string[] = [ 'noundefined', 'unicode', 'verb', + 'numcases', + 'empheq', 'configmacros', 'tagformat', 'textmacros' From 6a6b18d4778c78ada49d1e1c8d828f6808eff2b4 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 14 May 2021 15:31:10 +0100 Subject: [PATCH 048/142] Corrects Bqty. --- ts/input/tex/physics/PhysicsMappings.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index 758d9b946..e50b23cf5 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -38,7 +38,7 @@ new CommandMap('Physics-automatic-bracing-macros', { 'pqty': ['Quantity', '(', ')', true], 'bqty': ['Quantity', '[', ']', true], 'vqty': ['Quantity', '|', '|', true], - 'Bqty': ['Quantity', '{', '}', true], + 'Bqty': ['Quantity', '\\{', '\\}', true], 'absolutevalue': ['Quantity', '|', '|', true], 'abs': ['Quantity', '|', '|', true], 'norm': ['Quantity', '\\|', '\\|', true], From 6a759ec2d56f544faf771b6e70c08a29b6188266 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 14 May 2021 15:32:43 +0100 Subject: [PATCH 049/142] Fixes qsince. --- ts/input/tex/physics/PhysicsMappings.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index e50b23cf5..a5d98e9d6 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -183,7 +183,7 @@ new CommandMap('Physics-quick-quad-macros', { 'qgiven': ['Qqtext', 'given'], 'qusing': ['Qqtext', 'using'], 'qassume': ['Qqtext', 'assume'], - 'qsince,': ['Qqtext', 'since,'], + 'qsince': ['Qqtext', 'since'], 'qlet': ['Qqtext', 'let'], 'qfor': ['Qqtext', 'for'], 'qall': ['Qqtext', 'all'], From cd0ff9704ca7d3196ee1b6eea07ecc1046d13ad1 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 14 May 2021 15:53:55 +0100 Subject: [PATCH 050/142] Adds Residue as base operator. --- ts/input/tex/physics/PhysicsMappings.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index a5d98e9d6..4ae608a4c 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -127,7 +127,8 @@ new CommandMap('Physics-expressions-macros', { 'Trace': ['Expression', false, 'Tr'], 'rank': 'NamedFn', 'erf': ['Expression', false], - 'Res': ['OperatorApplication', '{\\rm Res}', '(', '[', '{'], + 'Residue': ['Macro', '{\\rm Res}'], + 'Res': ['OperatorApplication', '\\Residue', '(', '[', '{'], 'principalvalue': ['OperatorApplication', '{\\cal P}'], 'pv': ['OperatorApplication', '{\\cal P}'], 'PV': ['OperatorApplication', '{\\rm P.V.}'], From 88970a5415962818f78908e8bd0a57694f8d266a Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 14 May 2021 16:31:56 +0100 Subject: [PATCH 051/142] Introduces vnabla and the arrowdel option. --- ts/input/tex/physics/PhysicsConfiguration.ts | 6 ++++++ ts/input/tex/physics/PhysicsMappings.ts | 12 ++++++------ ts/input/tex/physics/PhysicsMethods.ts | 13 +++++++++++++ 3 files changed, 25 insertions(+), 6 deletions(-) diff --git a/ts/input/tex/physics/PhysicsConfiguration.ts b/ts/input/tex/physics/PhysicsConfiguration.ts index f5970f41c..fb4ba553e 100644 --- a/ts/input/tex/physics/PhysicsConfiguration.ts +++ b/ts/input/tex/physics/PhysicsConfiguration.ts @@ -45,6 +45,12 @@ export const PhysicsConfiguration = Configuration.create( }, items: { [AutoOpen.prototype.kind]: AutoOpen + }, + options: { + physics: { + italicdiff: false, + arrowdel: false + } } } ); diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index 4ae608a4c..2fd1c0fd9 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -71,18 +71,18 @@ new CharacterMap('Physics-vector-chars', ParseMethods.mathchar0mi, { }); new CommandMap('Physics-vector-macros', { + 'vnabla': 'Vnabla', 'vectorbold': 'VectorBold', 'vb': 'VectorBold', 'vectorarrow': ['StarMacro', 1, '\\vec{\\vb', '{#1}}'], 'va': ['StarMacro', 1, '\\vec{\\vb', '{#1}}'], 'vectorunit': ['StarMacro', 1, '\\hat{\\vb', '{#1}}'], 'vu': ['StarMacro', 1, '\\hat{\\vb', '{#1}}'], - 'gradient': ['OperatorApplication', '\\gradientnabla', '(', '['], - 'grad': ['OperatorApplication', '\\gradientnabla', '(', '['], - 'divergence': ['VectorOperator', '\\gradientnabla\\vdot', '(', '['], - 'div': ['VectorOperator', '\\gradientnabla\\vdot', '(', '['], - 'curl': ['VectorOperator', - '\\gradientnabla\\crossproduct', '(', '['], + 'gradient': ['OperatorApplication', '\\vnabla', '(', '['], + 'grad': ['OperatorApplication', '\\vnabla', '(', '['], + 'divergence': ['VectorOperator', '\\vnabla\\vdot', '(', '['], + 'div': ['VectorOperator', '\\vnabla\\vdot', '(', '['], + 'curl': ['VectorOperator', '\\vnabla\\crossproduct', '(', '['], 'laplacian': ['OperatorApplication', '\\nabla^2', '(', '['], }, PhysicsMethods); diff --git a/ts/input/tex/physics/PhysicsMethods.ts b/ts/input/tex/physics/PhysicsMethods.ts index 877b0b7fe..3535a7bf1 100644 --- a/ts/input/tex/physics/PhysicsMethods.ts +++ b/ts/input/tex/physics/PhysicsMethods.ts @@ -937,6 +937,19 @@ PhysicsMethods.AutoClose = function(parser: TexParser, fence: string, _texclass: }; +/** + * Generates the vector nabla depending on the arrowdel option. + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ +PhysicsMethods.Vnabla = function(parser: TexParser, _name: string) { + let argument = parser.options.physics.arrowdel ? + '\\vec{\\gradientnabla}' : '{\\gradientnabla}'; + return parser.Push(new TexParser(argument, parser.stack.env, + parser.configuration).mml()); +}; + + /** * Methods taken from Base package. */ From 6cd38630ae17bfe7ae2e136c3225c2385db49481 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 14 May 2021 16:45:03 +0100 Subject: [PATCH 052/142] Adds diffd macro and italicdiff option. --- ts/input/tex/physics/PhysicsMappings.ts | 9 +++++---- ts/input/tex/physics/PhysicsMethods.ts | 12 ++++++++++++ 2 files changed, 17 insertions(+), 4 deletions(-) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index 2fd1c0fd9..7952cb87a 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -202,13 +202,14 @@ new CommandMap('Physics-quick-quad-macros', { * Macros for physics package (section 2.5). */ new CommandMap('Physics-derivative-macros', { + 'diffd': 'DiffD', 'flatfrac': ['Macro', '\\left.#1\\middle/#2\\right.', 2], - 'differential': ['Differential', '{\\rm d}'], - 'dd': ['Differential', '{\\rm d}'], + 'differential': ['Differential', '\\diffd'], + 'dd': ['Differential', '\\diffd'], 'variation': ['Differential', '\\delta'], 'var': ['Differential', '\\delta'], - 'derivative': ['Derivative', 2, '{\\rm d}'], - 'dv': ['Derivative', 2, '{\\rm d}'], + 'derivative': ['Derivative', 2, '\\diffd'], + 'dv': ['Derivative', 2, '\\diffd'], 'partialderivative': ['Derivative', 3, '\\partial'], 'pderivative': ['Derivative', 3, '\\partial'], 'pdv': ['Derivative', 3, '\\partial'], diff --git a/ts/input/tex/physics/PhysicsMethods.ts b/ts/input/tex/physics/PhysicsMethods.ts index 3535a7bf1..f81587759 100644 --- a/ts/input/tex/physics/PhysicsMethods.ts +++ b/ts/input/tex/physics/PhysicsMethods.ts @@ -950,6 +950,18 @@ PhysicsMethods.Vnabla = function(parser: TexParser, _name: string) { }; +/** + * Generates the differential d depending on the italicdiff option. + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ +PhysicsMethods.DiffD = function(parser: TexParser, _name: string) { + let argument = parser.options.physics.italicdiff ? 'd' : '{\\rm d}'; + return parser.Push(new TexParser(argument, parser.stack.env, + parser.configuration).mml()); +}; + + /** * Methods taken from Base package. */ From 1cd704fdc772e00be73e19e0a4ae4c5e609cc224 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Sat, 15 May 2021 07:37:00 -0400 Subject: [PATCH 053/142] Implement mml3 mathml extension and component --- components/src/dependencies.js | 2 + .../src/input/mml/extensions/mml3/build.json | 4 + .../src/input/mml/extensions/mml3/copy.json | 7 + .../src/input/mml/extensions/mml3/mml3.js | 7 + .../mml/extensions/mml3/webpack.config.js | 11 + components/src/source.js | 1 + package.json | 8 +- ts/input/mathml/mml3/mml3-node.ts | 43 + ts/input/mathml/mml3/mml3.sef.json | 1 + ts/input/mathml/mml3/mml3.ts | 779 ++++++++++++++++++ ts/input/mathml/mml3/mml3.xsl | 657 +++++++++++++++ 11 files changed, 1518 insertions(+), 2 deletions(-) create mode 100644 components/src/input/mml/extensions/mml3/build.json create mode 100644 components/src/input/mml/extensions/mml3/copy.json create mode 100644 components/src/input/mml/extensions/mml3/mml3.js create mode 100644 components/src/input/mml/extensions/mml3/webpack.config.js create mode 100644 ts/input/mathml/mml3/mml3-node.ts create mode 100644 ts/input/mathml/mml3/mml3.sef.json create mode 100644 ts/input/mathml/mml3/mml3.ts create mode 100644 ts/input/mathml/mml3/mml3.xsl diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..b5c400210 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -2,6 +2,7 @@ export const dependencies = { 'a11y/semantic-enrich': ['input/mml', '[sre]'], 'a11y/complexity': ['a11y/semantic-enrich'], 'a11y/explorer': ['a11y/semantic-enrich', 'ui/menu'], + '[mml]/mml3': ['input/mml'], '[tex]/all-packages': ['input/tex-base'], '[tex]/action': ['input/tex-base', '[tex]/newcommand'], '[tex]/autoload': ['input/tex-base', '[tex]/require'], @@ -32,6 +33,7 @@ export const dependencies = { export const paths = { tex: '[mathjax]/input/tex/extensions', + mml: '[mathjax]/input/mml/extensions', sre: '[mathjax]/sre/' + (typeof window === 'undefined' ? 'sre-node' : 'sre_browser') }; diff --git a/components/src/input/mml/extensions/mml3/build.json b/components/src/input/mml/extensions/mml3/build.json new file mode 100644 index 000000000..1de76ca6f --- /dev/null +++ b/components/src/input/mml/extensions/mml3/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/mml/extensions/mml3", + "targets": ["input/mathml/mml3"] +} diff --git a/components/src/input/mml/extensions/mml3/copy.json b/components/src/input/mml/extensions/mml3/copy.json new file mode 100644 index 000000000..aa791ea7a --- /dev/null +++ b/components/src/input/mml/extensions/mml3/copy.json @@ -0,0 +1,7 @@ +{ + "to": "../../../../../../es5/input/mml/extensions", + "from": "../../../../../../ts/input/mathml/mml3", + "copy": [ + "mml3.sef.json" + ] +} diff --git a/components/src/input/mml/extensions/mml3/mml3.js b/components/src/input/mml/extensions/mml3/mml3.js new file mode 100644 index 000000000..72ecdf12c --- /dev/null +++ b/components/src/input/mml/extensions/mml3/mml3.js @@ -0,0 +1,7 @@ +import './lib/mml3.js'; + +import {Mml3Handler} from '../../../../../../js/input/mathml/mml3/mml3.js'; + +if (MathJax.startup) { + MathJax.startup.extendHandler(handler => Mml3Handler(handler)); +} diff --git a/components/src/input/mml/extensions/mml3/webpack.config.js b/components/src/input/mml/extensions/mml3/webpack.config.js new file mode 100644 index 000000000..b09f30c9f --- /dev/null +++ b/components/src/input/mml/extensions/mml3/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/mml/extensions/mml3', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/mml/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..0205a1f5e 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -34,6 +34,7 @@ export const source = { '[tex]/verb': `${src}/input/tex/extensions/verb/verb.js`, 'input/mml': `${src}/input/mml/mml.js`, 'input/mml/entities': `${src}/input/mml/entities/entities.js`, + '[mml]/mml3': `${src}/input/mml/extensions/mml3/mml3.js`, 'input/asciimath': `${src}/input/asciimath/asciimath.js`, 'output/chtml': `${src}/output/chtml/chtml.js`, 'output/chtml/fonts/tex': `${src}/output/chtml/fonts/tex/tex.js`, diff --git a/package.json b/package.json index ffe561562..739e86e32 100644 --- a/package.json +++ b/package.json @@ -34,11 +34,15 @@ "clean:lib": "npx rimraf 'components/src/**/lib'", "clean": "npm run --silent clean:js && npm run --silent clean:es5 && npm run --silent clean:lib", "copy:mj2": "npx copyfiles -u 1 'ts/input/asciimath/mathjax2/**/*' js", + "copy:mml3": "npx copyfiles -u 1 'ts/input/mathml/mml3/mml3.sef.json' js", "precompile": "npm run --silent clean:js", "compile": "npx tsc", - "postcompile": "npm run --silent copy:mj2", + "postcompile": "npm run --silent copy:mj2 && npm run --silent copy:mml3", "premake-components": "npm run --silent clean:es5 && npm run --silent clean:lib", - "make-components": "cd components && node bin/makeAll src | grep 'Building\\|Webpacking\\|Copying\\|npx'" + "make-components": "cd components && node bin/makeAll src | grep 'Building\\|Webpacking\\|Copying\\|npx'", + "premake-mml3-xslt": "cd ts/input/mathml/mml3 && grep '^\\s*\\(<\\|or\\|xmlns\\|excl\\|\">\\)' mml3.ts > mml3.xsl", + "make-mml3-xslt": "cd ts/input/mathml/mml3 && npx xslt3 -t -xsl:mml3.xsl -export:mml3.sef.json -nogo", + "postmake-mml3-xslt": "rpx rimraf ts/input/mathml/mml3/mml3.xsl" }, "devDependencies": { "@babel/core": "^7.13.16", diff --git a/ts/input/mathml/mml3/mml3-node.ts b/ts/input/mathml/mml3/mml3-node.ts new file mode 100644 index 000000000..3e3bd71e9 --- /dev/null +++ b/ts/input/mathml/mml3/mml3-node.ts @@ -0,0 +1,43 @@ +/** + * Create the transform function that uses Saxon-js to perform the + * xslt transformation. + * + * @return {(mml: string) => string)} The transformation function + */ +export function createTransform(): (mml: string) => string { + /* tslint:disable-next-line:no-eval */ + const nodeRequire = eval('require'); // get the actual require from node. + /* tslint:disable-next-line:no-eval */ + const dirname = eval('__dirname'); // get the actual __dirname + try { + nodeRequire.resolve('saxon-js'); // check if saxon-js is installed. + } catch (err) { + throw Error('Saxon-js not found. Run the command:\n npm install saxon-js\nand try again.'); + } + const Saxon = nodeRequire('saxon-js'); // dynamically load Saxon-JS. + const path = nodeRequire('path'); // use the real version from node. + const fs = nodeRequire('fs'); // use the real version from node. + const xsltFile = path.resolve(dirname, 'mml3.sef.json'); // load the preprocessed stylesheet. + const xslt = JSON.parse(fs.readFileSync(xsltFile)); // and parse it. + return (mml: string) => { + // + // Make sure the namespace is present + // + if (!mml.match(/ xmlns[=:]/)) { + mml = mml.replace(/<(?:(\w+)(:))?math/, '<$1$2math xmlns$2$1="http://www.w3.org/1998/Math/MathML"'); + } + let result; + // + // Try to run the transform, and if it fails, return the original MathML + try { + result = Saxon.transform({ + stylesheetInternal: xslt, + sourceText: mml, + destination: 'serialized' + }).principalResult; + } catch (err) { + result = mml; + } + return result; + }; +} diff --git a/ts/input/mathml/mml3/mml3.sef.json b/ts/input/mathml/mml3/mml3.sef.json new file mode 100644 index 000000000..b6677f476 --- /dev/null +++ b/ts/input/mathml/mml3/mml3.sef.json @@ -0,0 +1 @@ +{"N":"package","version":"10","packageVersion":"1","saxonVersion":"Saxon-JS 2.2","target":"JS","targetVersion":"2","name":"TOP-LEVEL","relocatable":"true","buildDateTime":"2021-05-15T07:04:31.151-04:00","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","C":[{"N":"co","id":"0","binds":"0 3 2 1","C":[{"N":"mode","onNo":"TC","flags":"","patternSlots":"0","prec":"","C":[{"N":"templateRule","rank":"0","prec":"0","seq":"52","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"514","module":"mml3.xsl","match":"m:mlongdiv","prio":"11","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"let","var":"Q{}ms","slot":"0","sType":"* ","line":"515","role":"action","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"elem","name":"m:mstack","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstack ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"516","C":[{"N":"sequence","sType":"*N ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"517","sType":"?NA nQ{}decimalpoint","C":[{"N":"lastOf","sType":"?NA nQ{}decimalpoint","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"517","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"fn","name":"reverse","C":[{"N":"axis","name":"ancestor-or-self","nodeTest":"*NE"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}decimalpoint"}]}]}]}]},{"N":"choose","sType":"*N ","type":"item()*","line":"518","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"519","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"left)(right"}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"520","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"521","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"522","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":")"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"523","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"523","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"524","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"("}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"525","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"525","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"528","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"left/\\right"}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"529","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"530","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"17","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"531","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"/"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"532","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"532","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"533","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"\\"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"534","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"534","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"537","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":":right=right"}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"538","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"539","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"539","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"540","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":":"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"541","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"541","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"542","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"="}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"543","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"543","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]},{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"550","C":[{"N":"or","C":[{"N":"or","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"stackedrightright"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"mediumstackedrightright"}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"shortstackedrightright"}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"stackedleftleft"}]}]},{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"align","sType":"1NA ","line":"551","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"top"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"552","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"552","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"554","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"stackedleftlinetop"}]},{"N":"sequence","sType":"*NE ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"555","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"555","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]},{"N":"elem","name":"m:msline","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msline ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"556","C":[{"N":"att","name":"length","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"1AO","C":[{"N":"arith10","op":"-","calc":"d-d","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"556","C":[{"N":"fn","name":"string-length","C":[{"N":"fn","name":"string","C":[{"N":"subscript","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]},{"N":"int","val":"1"}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"557","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"558","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"559","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom right"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"560","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"560","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"563","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"563","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"566","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"righttop"}]},{"N":"sequence","sType":"*NE ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"567","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"567","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]},{"N":"elem","name":"m:msline","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msline ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"568","C":[{"N":"att","name":"length","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"1ADI","C":[{"N":"fn","name":"string-length","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"568","C":[{"N":"fn","name":"string","C":[{"N":"subscript","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"569","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"570","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"570","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"571","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top left bottom"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"572","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"572","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]},{"N":"true"},{"N":"sequence","sType":"*NE ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"576","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"576","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]},{"N":"elem","name":"m:msline","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msline ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"577","C":[{"N":"att","name":"length","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"1ADI","C":[{"N":"fn","name":"string-length","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"577","C":[{"N":"fn","name":"string","C":[{"N":"subscript","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]},{"N":"elem","name":"m:msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"578","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"579","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"52","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"580","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":")"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"581","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"581","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]}]}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"585","sType":"*NE","C":[{"N":"filter","flags":"p","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"585","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"gc10","op":">","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"int","val":"3"}]}]}]}]}]}]},{"N":"choose","sType":"* ","type":"item()*","line":"588","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"589","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"stackedrightright"}]},{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"590","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"right"}]},{"N":"applyT","sType":"* ","line":"591","mode":"#unnamed","bSlot":"0","C":[{"N":"varRef","name":"Q{}ms","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"591"}]}]}]},{"N":"elem","name":"m:mtable","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"593","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"align","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top"}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"594","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"595","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"596","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"596","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"599","C":[{"N":"elem","name":"mtd","sType":"1NE nQ{}mtd ","nsuri":"","namespaces":"","line":"600","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"66","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"604","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"mediumstackedrightright"}]},{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"605","mode":"#unnamed","bSlot":"0","C":[{"N":"varRef","name":"Q{}ms","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"605"}]},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"606","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"left"}]},{"N":"elem","name":"m:mtable","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"607","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"align","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top"}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"608","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"609","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"610","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"610","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"613","C":[{"N":"elem","name":"mtd","sType":"1NE nQ{}mtd ","nsuri":"","namespaces":"","line":"614","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"76","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"619","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"shortstackedrightright"}]},{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"620","mode":"#unnamed","bSlot":"0","C":[{"N":"varRef","name":"Q{}ms","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"620"}]},{"N":"elem","name":"m:mtable","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"621","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"align","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top"}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"622","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"623","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"left bottom"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"624","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"624","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"627","C":[{"N":"elem","name":"mtd","sType":"1NE nQ{}mtd ","nsuri":"","namespaces":"","line":"628","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"85","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"632","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}longdivstyle"},{"N":"str","val":"stackedleftleft"}]},{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mtable","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"633","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"align","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top"}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"634","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"635","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"636","sType":"?NE","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"636","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"639","C":[{"N":"elem","name":"mtd","sType":"1NE nQ{}mtd ","nsuri":"","namespaces":"","line":"640","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"?NE","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"93","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]}]},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"643","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"left"}]},{"N":"applyT","sType":"* ","line":"644","mode":"#unnamed","bSlot":"0","C":[{"N":"varRef","name":"Q{}ms","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"644"}]}]}]}]},{"N":"true"},{"N":"applyT","sType":"* ","line":"648","mode":"#unnamed","bSlot":"0","C":[{"N":"varRef","name":"Q{}ms","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"648"}]}]}]}]},{"N":"templateRule","rank":"1","prec":"0","seq":"38","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"171","module":"mml3.xsl","match":"m:mstack","prio":"11","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mstack","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mstack","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstack","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"let","var":"Q{}m","slot":"0","sType":"* ","line":"172","role":"action","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"elem","name":"m:mtable","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"173","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"columnspacing","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"rowspacing","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"174","sType":"*NA nQ{}align","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}align","sType":"*NA nQ{}align","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"174"}]},{"N":"let","var":"Q{}t","slot":"0","sType":"*N ","line":"175","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"applyT","sType":"* ","line":"176","mode":"Q{}mstack1","bSlot":"1","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"176"},{"N":"withParam","name":"Q{}p","slot":"0","sType":"1ADI","C":[{"N":"int","val":"0","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"177"}]}]}]},{"N":"let","var":"Q{}maxl","slot":"1","sType":"*N ","line":"180","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"forEach","sType":"* ","line":"181","C":[{"N":"sort","sType":"*NA nQ{}l","C":[{"N":"docOrder","sType":"*NA nQ{}l","role":"select","line":"181","C":[{"N":"docOrder","sType":"*NA nQ{}l","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}t","slot":"0"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]},{"N":"sortKey","sType":"*A ","C":[{"N":"data","sType":"*A ","role":"select","C":[{"N":"dot","sType":"1NA nQ{}l ","role":"select"}]},{"N":"str","sType":"1AS ","val":"descending","role":"order"},{"N":"str","sType":"1AS ","val":"en","role":"lang"},{"N":"str","sType":"1AS ","val":"#default","role":"caseOrder"},{"N":"str","sType":"1AS ","val":"true","role":"stable"},{"N":"str","sType":"1AS ","val":"number","role":"dataType"}]}]},{"N":"choose","sType":"? ","line":"183","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"183","C":[{"N":"fn","name":"position"},{"N":"int","val":"1"}]},{"N":"valueOf","flags":"l","sType":"1NT ","line":"184","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"dot","sType":"1NA nQ{}l","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"184"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"true"},{"N":"empty","sType":"0 "}]}]}]},{"N":"forEach","sType":"*N ","line":"188","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"188","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}t","slot":"0"}]},{"N":"filter","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"or","C":[{"N":"fn","name":"not","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}class"},{"N":"str","val":"mscarries"}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"slash","op":"/","C":[{"N":"first","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}class"}]},{"N":"str","val":"mscarries"}]}]}]}]}]}]},{"N":"let","var":"Q{}c","slot":"2","sType":"*N ","line":"189","C":[{"N":"fn","name":"reverse","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"189","C":[{"N":"filter","C":[{"N":"first","C":[{"N":"axis","name":"preceding-sibling","nodeTest":"*NE"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}class"},{"N":"str","val":"mscarries"}]}]}]},{"N":"sequence","sType":"?N ","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"\n"}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"191","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"192","sType":"*NA nQ{}class","C":[{"N":"filter","sType":"*NA nQ{}class","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"192","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}class"},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"dot"},{"N":"str","val":"msline"}]}]}]},{"N":"let","var":"Q{}offset","slot":"3","sType":"* ","line":"193","C":[{"N":"arith10","op":"-","calc":"d-d","sType":"?AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"193","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}maxl","slot":"1"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]},{"N":"choose","sType":"* ","type":"item()*","line":"194","C":[{"N":"and","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"195","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}class"},{"N":"str","val":"msline"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"},{"N":"str","val":"*"}]}]},{"N":"let","var":"Q{}msl","slot":"4","sType":"* ","line":"196","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"196","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]},{"N":"forEach","sType":"*","line":"197","C":[{"N":"filter","flags":"p","sType":"*N","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"197","C":[{"N":"slash","op":"/","C":[{"N":"root"},{"N":"axis","name":"descendant","nodeTest":"*N u[NT,NP,NC,NE]"}]},{"N":"gc10","op":"<=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"varRef","name":"Q{}maxl","slot":"1"}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"198","sType":"*","C":[{"N":"varRef","name":"Q{}msl","slot":"4","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"198"}]}]}]},{"N":"varRef","name":"Q{}c","slot":"2","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"201"},{"N":"let","var":"Q{}ldiff","slot":"4","sType":"*NE ","line":"202","C":[{"N":"arith10","op":"-","calc":"d-d","sType":"?AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"202","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}c","slot":"2"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]},{"N":"let","var":"Q{}loffset","slot":"5","sType":"*NE ","line":"203","C":[{"N":"arith10","op":"-","calc":"d-d","sType":"?AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"203","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}maxl","slot":"1"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}c","slot":"2"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]}]}]},{"N":"sequence","sType":"*NE ","C":[{"N":"forEach","sType":"*NE ","line":"204","C":[{"N":"filter","flags":"p","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"204","C":[{"N":"slash","op":"/","C":[{"N":"root"},{"N":"axis","name":"descendant","nodeTest":"*NE"}]},{"N":"gc10","op":"<=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"varRef","name":"Q{}offset","slot":"3"}]}]},{"N":"let","var":"Q{}pn","slot":"6","sType":"*NE ","line":"205","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"205"},{"N":"let","var":"Q{}cy","slot":"7","sType":"*NE ","line":"206","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"206","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}c","slot":"2"}]},{"N":"filter","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"arith10","op":"-","calc":"d-d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}pn","slot":"6"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}loffset","slot":"5"}]}]}]}]}]}]}]}]},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"207","C":[{"N":"choose","sType":"? ","line":"208","C":[{"N":"docOrder","sType":"*NE","line":"208","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]},{"N":"elem","name":"m:mover","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mover ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"209","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mphantom","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mphantom ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"elem","name":"m:mn","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mn ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0"}]}]}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-0.5width"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"210","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"210","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"true"},{"N":"empty","sType":"0 "}]}]}]}]}]},{"N":"forEach","sType":"*NE ","line":"214","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"214"},{"N":"let","var":"Q{}pn","slot":"6","sType":"*NE ","line":"215","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"215"},{"N":"let","var":"Q{}cy","slot":"7","sType":"*NE ","line":"216","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"216","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}c","slot":"2"}]},{"N":"filter","flags":"p","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"arith10","op":"+","calc":"d+d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}pn","slot":"6"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}ldiff","slot":"4"}]}]}]}]}]}]}]}]},{"N":"copy","sType":"1NE ","flags":"cin","line":"217","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"218","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"218"}]},{"N":"let","var":"Q{}b","slot":"8","sType":"* ","line":"219","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"*NE ","type":"item()*","line":"220","C":[{"N":"fn","name":"not","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"221","C":[{"N":"or","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}crossout"}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}crossout"}]}]},{"N":"str","val":"none"}]}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"45"}]},{"N":"true"},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"223","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"*NA nQ{}crossout","C":[{"N":"docOrder","sType":"*NA nQ{}crossout","line":"223","C":[{"N":"docOrder","sType":"*NA nQ{}crossout","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}crossout"}]}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"48"}]}]}]}]}]},{"N":"choose","sType":"* ","type":"item()*","line":"227","C":[{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"228","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}none"}]}]},{"N":"fn","name":"not","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"51"}]},{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"229","C":[{"N":"fn","name":"not","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"n"}]}]},{"N":"elem","name":"m:mover","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mover ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"230","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"231","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"231"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"231","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-0.5width"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"232","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"232","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"236","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"nw"}]},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"237","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"59"}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:none","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}none ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-1width"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"63","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"239","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"s"}]},{"N":"elem","name":"m:munder","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}munder ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"240","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"66"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-0.5width"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"68","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"242","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"sw"}]},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"243","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"71"}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-1width"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"74","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]},{"N":"elem","name":"m:none","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}none ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"245","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"ne"}]},{"N":"elem","name":"m:msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"246","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"78"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"80","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"248","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"se"}]},{"N":"elem","name":"m:msub","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msub ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"249","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"83"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"85","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"251","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"w"}]},{"N":"sequence","sType":"* ","C":[{"N":"elem","name":"m:msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"252","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-1width"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"90","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"253","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"253"}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"255","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]}]},{"N":"str","val":"e"}]},{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"256","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"256"}]},{"N":"elem","name":"m:msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"257","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"97","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}cy","slot":"7"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]}]},{"N":"true"},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"260","sType":"*","C":[{"N":"varRef","name":"Q{}b","slot":"8","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"260"}]}]}]}]}]}]}]}]}]}]}]},{"N":"true"},{"N":"sequence","sType":"*NE ","C":[{"N":"forEach","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","line":"267","C":[{"N":"filter","flags":"p","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"267","C":[{"N":"slash","op":"/","C":[{"N":"root"},{"N":"axis","name":"descendant","nodeTest":"*NE"}]},{"N":"gc10","op":"<=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"varRef","name":"Q{}offset","slot":"3"}]}]},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"268","sType":"*NE","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"268"}]}]}]}]}]}]}]}]}]}]}]}]}]}]},{"N":"applyT","sType":"* ","line":"275","mode":"Q{}ml","bSlot":"2","C":[{"N":"varRef","name":"Q{}m","slot":"0","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"275"}]}]}]},{"N":"templateRule","rank":"2","prec":"0","seq":"1","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"13","module":"mml3.xsl","match":"m:*[@dir='rtl']","prio":"10","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}*","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}*"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}dir"},{"N":"str","val":"rtl"}]}]},{"N":"applyT","sType":"* ","line":"14","mode":"Q{}rtl","role":"action","bSlot":"3","C":[{"N":"dot","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"14"}]}]},{"N":"templateRule","rank":"3","prec":"0","seq":"0","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"7","module":"mml3.xsl","match":"*","prio":"-0.5","matches":"NE","C":[{"N":"p.nodeTest","role":"match","test":"NE","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"copy","sType":"1NE ","flags":"cin","role":"action","line":"8","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"9","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9"}]},{"N":"applyT","sType":"* ","line":"10","mode":"#unnamed","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"10"}]}]}]}]}]}]},{"N":"co","id":"1","binds":"1 0","C":[{"N":"mode","onNo":"TC","flags":"","patternSlots":"0","name":"Q{}rtl","prec":"","C":[{"N":"templateRule","rank":"0","prec":"0","seq":"27","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"144","module":"mml3.xsl","match":"m:mmultiscripts[not(m:mprescripts)]","prio":"3","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts"},{"N":"fn","name":"not","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts"}]}]},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"145","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"146","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"146","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"147","C":[{"N":"empty","sType":"0 "}]},{"N":"forEach","sType":"* ","line":"148","C":[{"N":"sort","sType":"*NE","C":[{"N":"filter","flags":"p","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"148","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"arith10","op":"mod","calc":"d%d","C":[{"N":"fn","name":"position"},{"N":"int","val":"2"}]},{"N":"int","val":"0"}]}]},{"N":"sortKey","sType":"?ADI ","C":[{"N":"first","role":"select","sType":"?ADI ","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"149"}]},{"N":"str","sType":"1AS ","val":"descending","role":"order"},{"N":"str","sType":"1AS ","val":"en","role":"lang"},{"N":"str","sType":"1AS ","val":"#default","role":"caseOrder"},{"N":"str","sType":"1AS ","val":"true","role":"stable"},{"N":"str","sType":"1AS ","val":"number","role":"dataType"}]}]},{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"150","mode":"Q{}rtl","bSlot":"0","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"150"}]},{"N":"applyT","sType":"* ","line":"151","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"151","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]}]}]}]}]}]}]},{"N":"templateRule","rank":"1","prec":"0","seq":"26","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"128","module":"mml3.xsl","match":"m:mmultiscripts","prio":"2","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"129","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"130","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"130","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"forEach","sType":"* ","line":"131","C":[{"N":"sort","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"131","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts"},{"N":"filter","flags":"p","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"arith10","op":"mod","calc":"d%d","C":[{"N":"fn","name":"position"},{"N":"int","val":"2"}]},{"N":"int","val":"1"}]}]}]}]}]},{"N":"sortKey","sType":"?ADI ","C":[{"N":"first","role":"select","sType":"?ADI ","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"132"}]},{"N":"str","sType":"1AS ","val":"descending","role":"order"},{"N":"str","sType":"1AS ","val":"en","role":"lang"},{"N":"str","sType":"1AS ","val":"#default","role":"caseOrder"},{"N":"str","sType":"1AS ","val":"true","role":"stable"},{"N":"str","sType":"1AS ","val":"number","role":"dataType"}]}]},{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"133","mode":"Q{}rtl","bSlot":"0","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"133"}]},{"N":"applyT","sType":"* ","line":"134","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"134","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]}]}]}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"136","C":[{"N":"empty","sType":"0 "}]},{"N":"forEach","sType":"* ","line":"137","C":[{"N":"sort","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"137","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts"},{"N":"fn","name":"reverse","C":[{"N":"filter","flags":"p","C":[{"N":"filter","flags":"p","C":[{"N":"axis","name":"preceding-sibling","nodeTest":"*NE"},{"N":"gc10","op":"!=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"fn","name":"last"}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"arith10","op":"mod","calc":"d%d","C":[{"N":"fn","name":"position"},{"N":"int","val":"2"}]},{"N":"int","val":"0"}]}]}]}]}]}]},{"N":"sortKey","sType":"?ADI ","C":[{"N":"first","role":"select","sType":"?ADI ","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"138"}]},{"N":"str","sType":"1AS ","val":"descending","role":"order"},{"N":"str","sType":"1AS ","val":"en","role":"lang"},{"N":"str","sType":"1AS ","val":"#default","role":"caseOrder"},{"N":"str","sType":"1AS ","val":"true","role":"stable"},{"N":"str","sType":"1AS ","val":"number","role":"dataType"}]}]},{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"139","mode":"Q{}rtl","bSlot":"0","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"139"}]},{"N":"applyT","sType":"* ","line":"140","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"140","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]}]}]}]}]}]}]},{"N":"templateRule","rank":"2","prec":"0","seq":"25","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"120","module":"mml3.xsl","match":"m:msubsup","prio":"2","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msubsup","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msubsup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msubsup","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"121","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"122","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"122","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"123","C":[{"N":"empty","sType":"0 "}]},{"N":"applyT","sType":"* ","line":"124","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"124","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]},{"N":"applyT","sType":"* ","line":"125","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"125","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"3"}]}]}]}]}]},{"N":"templateRule","rank":"3","prec":"0","seq":"24","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"112","module":"mml3.xsl","match":"m:msub","prio":"2","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msub","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msub","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msub","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"113","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"114","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"114","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"115","C":[{"N":"empty","sType":"0 "}]},{"N":"applyT","sType":"* ","line":"116","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"116","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]},{"N":"elem","name":"m:none","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}none ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"117","C":[{"N":"empty","sType":"0 "}]}]}]}]},{"N":"templateRule","rank":"4","prec":"0","seq":"23","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"104","module":"mml3.xsl","match":"m:msup","prio":"2","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msup","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mmultiscripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mmultiscripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"105","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"106","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"106","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]},{"N":"elem","name":"m:mprescripts","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mprescripts ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"107","C":[{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:none","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}none ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"108","C":[{"N":"empty","sType":"0 "}]},{"N":"applyT","sType":"* ","line":"109","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"109","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]},{"N":"templateRule","rank":"5","prec":"0","seq":"22","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"97","module":"mml3.xsl","match":"m:mtable|m:munder|m:mover|m:munderover","prio":"2","matches":"NE u[NE u[NE u[NE nQ{http://www.w3.org/1998/Math/MathML}mtable,NE nQ{http://www.w3.org/1998/Math/MathML}munder],NE nQ{http://www.w3.org/1998/Math/MathML}mover],NE nQ{http://www.w3.org/1998/Math/MathML}munderover]","C":[{"N":"p.venn","role":"match","op":"union","sType":"1NE u[NE u[NE u[NE nQ{http://www.w3.org/1998/Math/MathML}mtable,NE nQ{http://www.w3.org/1998/Math/MathML}munder],NE nQ{http://www.w3.org/1998/Math/MathML}mover],NE nQ{http://www.w3.org/1998/Math/MathML}munderover]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.venn","op":"union","C":[{"N":"p.venn","op":"union","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mtable"},{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}munder"}]},{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mover"}]},{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}munderover"}]},{"N":"copy","sType":"1NE u[1NE u[1NE u[1NE nQ{http://www.w3.org/1998/Math/MathML}mtable ,1NE nQ{http://www.w3.org/1998/Math/MathML}munder ] ,1NE nQ{http://www.w3.org/1998/Math/MathML}mover ] ,1NE nQ{http://www.w3.org/1998/Math/MathML}munderover ] ","flags":"cin","role":"action","line":"98","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"99","mode":"Q{}rtl","bSlot":"0","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"99"}]},{"N":"applyT","sType":"* ","line":"100","mode":"Q{}rtl","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"100"}]}]}]}]},{"N":"templateRule","rank":"6","prec":"0","seq":"53","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"652","module":"mml3.xsl","match":"m:menclose[@notation='madruwb']","prio":"0.5","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}menclose","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}menclose"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}notation"},{"N":"str","val":"madruwb"}]}]},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"653","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom right"}]},{"N":"applyT","sType":"* ","line":"654","mode":"Q{}rtl","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"654"}]}]}]}]},{"N":"templateRule","rank":"7","prec":"0","seq":"36","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"163","module":"mml3.xsl","match":"@notation[.='radical']","prio":"0.5","matches":"NA nQ{}notation","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}notation","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}notation"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"radical"}]}]},{"N":"att","name":"notation","sType":"1NA ","role":"action","line":"164","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"top right"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"8","prec":"0","seq":"35","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"162","module":"mml3.xsl","match":"text()[.='∋']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"∋"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"∈"}]}]},{"N":"templateRule","rank":"9","prec":"0","seq":"34","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"161","module":"mml3.xsl","match":"text()[.='∈']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"∈"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"∋"}]}]},{"N":"templateRule","rank":"10","prec":"0","seq":"33","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"160","module":"mml3.xsl","match":"text()[.='>']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":">"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"<"}]}]},{"N":"templateRule","rank":"11","prec":"0","seq":"32","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"159","module":"mml3.xsl","match":"text()[.='<']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"<"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":">"}]}]},{"N":"templateRule","rank":"12","prec":"0","seq":"31","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"158","module":"mml3.xsl","match":"text()[.='}']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"}"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"{"}]}]},{"N":"templateRule","rank":"13","prec":"0","seq":"30","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"157","module":"mml3.xsl","match":"text()[.='{']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"{"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"}"}]}]},{"N":"templateRule","rank":"14","prec":"0","seq":"29","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"156","module":"mml3.xsl","match":"text()[.=')']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":")"}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":"("}]}]},{"N":"templateRule","rank":"15","prec":"0","seq":"28","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"155","module":"mml3.xsl","match":"text()[.='(']","prio":"0.5","matches":"NT","C":[{"N":"p.withPredicate","role":"match","sType":"1NT","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NT"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"("}]}]},{"N":"valueOf","sType":"1NT ","role":"action","C":[{"N":"str","sType":"1AS ","val":")"}]}]},{"N":"templateRule","rank":"16","prec":"0","seq":"18","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"72","module":"mml3.xsl","match":"m:mfrac[@bevelled='true']","prio":"0.5","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mfrac","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mfrac","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mfrac"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}bevelled"},{"N":"str","val":"true"}]}]},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"73","C":[{"N":"sequence","sType":"*NE ","C":[{"N":"elem","name":"m:msub","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msub ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"74","C":[{"N":"sequence","sType":"* ","C":[{"N":"elem","name":"m:mi","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mi ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"applyT","sType":"* ","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"5","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]},{"N":"elem","name":"m:mo","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mo ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"75","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"\\"}]}]},{"N":"elem","name":"m:msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"76","C":[{"N":"sequence","sType":"* ","C":[{"N":"elem","name":"m:mi","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mi ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"empty","sType":"0 "}]},{"N":"applyT","sType":"* ","mode":"Q{}rtl","bSlot":"0","C":[{"N":"first","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]},{"N":"templateRule","rank":"17","prec":"0","seq":"17","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"69","module":"mml3.xsl","match":"@close[.='}']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"}"}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"70","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"{"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"18","prec":"0","seq":"16","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"66","module":"mml3.xsl","match":"@close[.='{']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"{"}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"67","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"}"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"19","prec":"0","seq":"15","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"63","module":"mml3.xsl","match":"@close[.=']']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"]"}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"64","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"["}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"20","prec":"0","seq":"14","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"60","module":"mml3.xsl","match":"@close[.='[']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"["}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"61","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"]"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"21","prec":"0","seq":"13","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"57","module":"mml3.xsl","match":"@close[.=')']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":")"}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"58","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"("}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"22","prec":"0","seq":"12","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"54","module":"mml3.xsl","match":"@close[.='(']","prio":"0.5","matches":"NA nQ{}close","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}close"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"("}]}]},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"55","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":")"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"23","prec":"0","seq":"10","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"48","module":"mml3.xsl","match":"@open[.='}']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"}"}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"49","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"{"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"24","prec":"0","seq":"9","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"45","module":"mml3.xsl","match":"@open[.='{']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"{"}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"46","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"}"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"25","prec":"0","seq":"8","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"42","module":"mml3.xsl","match":"@open[.=']']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"]"}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"43","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"["}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"26","prec":"0","seq":"7","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"39","module":"mml3.xsl","match":"@open[.='[']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"["}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"40","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"]"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"27","prec":"0","seq":"6","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"36","module":"mml3.xsl","match":"@open[.=')']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":")"}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"37","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"("}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"28","prec":"0","seq":"5","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"33","module":"mml3.xsl","match":"@open[.='(']","prio":"0.5","matches":"NA nQ{}open","C":[{"N":"p.withPredicate","role":"match","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NA nQ{}open"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"atomSing","diag":"1|0||gc","card":"?","C":[{"N":"dot"}]},{"N":"str","val":"("}]}]},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"34","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":")"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"29","prec":"0","seq":"37","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"166","module":"mml3.xsl","match":"m:mlongdiv|m:mstack","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv"},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"167","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"dir","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"ltr"}]},{"N":"applyT","sType":"* ","line":"168","mode":"#unnamed","bSlot":"1","C":[{"N":"dot","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mlongdiv","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"168"}]}]}]}]},{"N":"templateRule","rank":"30","prec":"0","seq":"37","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"166","module":"mml3.xsl","match":"m:mlongdiv|m:mstack","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mstack","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mstack","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstack"},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"167","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"dir","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"ltr"}]},{"N":"applyT","sType":"* ","line":"168","mode":"#unnamed","bSlot":"1","C":[{"N":"dot","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstack","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"168"}]}]}]}]},{"N":"templateRule","rank":"31","prec":"0","seq":"21","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"92","module":"mml3.xsl","match":"m:msqrt","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msqrt","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msqrt","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msqrt","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"93","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top right"}]},{"N":"applyT","sType":"* ","line":"94","mode":"Q{}rtl","bSlot":"0","C":[{"N":"docOrder","sType":"*N u[NA,NE]","role":"select","line":"94","C":[{"N":"union","op":"|","sType":"*N u[NA,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"attribute","nodeTest":"*NA"},{"N":"first","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]},{"N":"templateRule","rank":"32","prec":"0","seq":"20","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"84","module":"mml3.xsl","match":"m:mroot","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mroot","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mroot","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mroot","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:msup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msup ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"85","C":[{"N":"sequence","sType":"* ","C":[{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"86","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"top right"}]},{"N":"applyT","sType":"* ","line":"87","mode":"Q{}rtl","bSlot":"0","C":[{"N":"docOrder","sType":"*N u[NA,NE]","role":"select","line":"87","C":[{"N":"union","op":"|","sType":"*N u[NA,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"attribute","nodeTest":"*NA"},{"N":"first","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]},{"N":"applyT","sType":"* ","line":"89","mode":"Q{}rtl","bSlot":"0","C":[{"N":"subscript","flags":"p","sType":"?NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"89","C":[{"N":"axis","name":"child","nodeTest":"*NE"},{"N":"int","val":"2"}]}]}]}]}]},{"N":"templateRule","rank":"33","prec":"0","seq":"19","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"79","module":"mml3.xsl","match":"m:mfrac","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mfrac","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mfrac","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mfrac","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"copy","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mfrac ","flags":"cin","role":"action","line":"80","C":[{"N":"applyT","sType":"* ","line":"81","mode":"Q{}rtl","bSlot":"0","C":[{"N":"docOrder","sType":"*N u[NA,NE]","role":"select","line":"81","C":[{"N":"union","op":"|","sType":"*N u[NA,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"attribute","nodeTest":"*NA"},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]},{"N":"templateRule","rank":"34","prec":"0","seq":"11","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"51","module":"mml3.xsl","match":"@close","prio":"0","matches":"NA nQ{}close","C":[{"N":"p.nodeTest","role":"match","test":"NA nQ{}close","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"att","name":"open","sType":"1NA ","role":"action","line":"52","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"dot","sType":"1NA nQ{}close","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"3"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"35","prec":"0","seq":"4","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"30","module":"mml3.xsl","match":"@open","prio":"0","matches":"NA nQ{}open","C":[{"N":"p.nodeTest","role":"match","test":"NA nQ{}open","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"att","name":"close","sType":"1NA ","role":"action","line":"31","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"dot","sType":"1NA nQ{}open","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"3"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]},{"N":"templateRule","rank":"36","prec":"0","seq":"3","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"20","module":"mml3.xsl","match":"*","prio":"-0.5","matches":"NE","C":[{"N":"p.nodeTest","role":"match","test":"NE","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"copy","sType":"1NE ","flags":"cin","role":"action","line":"21","C":[{"N":"sequence","sType":"* ","C":[{"N":"applyT","sType":"* ","line":"22","mode":"Q{}rtl","bSlot":"0","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"22"}]},{"N":"forEach","sType":"* ","line":"23","C":[{"N":"sort","sType":"*N u[NT,NP,NC,NE]","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"23"},{"N":"sortKey","sType":"?ADI ","C":[{"N":"first","role":"select","sType":"?ADI ","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"24"}]},{"N":"str","sType":"1AS ","val":"descending","role":"order"},{"N":"str","sType":"1AS ","val":"en","role":"lang"},{"N":"str","sType":"1AS ","val":"#default","role":"caseOrder"},{"N":"str","sType":"1AS ","val":"true","role":"stable"},{"N":"str","sType":"1AS ","val":"number","role":"dataType"}]}]},{"N":"sequence","sType":"* ","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":" "}]},{"N":"applyT","sType":"* ","line":"26","mode":"Q{}rtl","bSlot":"0","C":[{"N":"dot","sType":"1N u[N u[N u[NT,NP],NC],NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"26"}]}]}]}]}]}]},{"N":"templateRule","rank":"37","prec":"0","seq":"2","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"16","module":"mml3.xsl","match":"@*","prio":"-0.5","matches":"NA","C":[{"N":"p.nodeTest","role":"match","test":"NA","sType":"1NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"*NA ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"17","sType":"1NA","C":[{"N":"dot","sType":"1NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"17"}]},{"N":"att","name":"dir","sType":"1NA ","line":"18","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"ltr"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]}]}]}]}]},{"N":"co","id":"2","binds":"2","C":[{"N":"mode","onNo":"TC","flags":"","patternSlots":"0","name":"Q{}ml","prec":"","C":[{"N":"templateRule","rank":"0","prec":"0","seq":"42","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"310","module":"mml3.xsl","match":"m:mtr[not(preceding-sibling::*)][@class='msline']","prio":"3","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.withPredicate","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr"},{"N":"fn","name":"not","C":[{"N":"fn","name":"reverse","C":[{"N":"axis","name":"preceding-sibling","nodeTest":"*NE"}]}]}]},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}class"},{"N":"str","val":"msline"}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"311","C":[{"N":"sequence","sType":"*N ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"312","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"312"}]},{"N":"forEach","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","line":"313","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"313"},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"314","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"315","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"315"}]},{"N":"choose","sType":"? ","line":"316","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mpadded","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mpadded","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"316"},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"317","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"318","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"depth","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".1em"}]},{"N":"att","name":"height","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"1em"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".5em"}]},{"N":"elem","name":"m:mspace","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mspace ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"319","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".2em"}]}]}]}]}]}]},{"N":"true"},{"N":"empty","sType":"0 "}]}]}]}]}]}]}]},{"N":"templateRule","rank":"1","prec":"0","seq":"43","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"327","module":"mml3.xsl","match":"m:mtr[@class='msline']","prio":"2","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr"},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}class"},{"N":"str","val":"msline"}]}]},{"N":"empty","sType":"0 ","role":"action"}]},{"N":"templateRule","rank":"2","prec":"0","seq":"41","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"286","module":"mml3.xsl","match":"m:mtr[following-sibling::*[1][@class='msline']]","prio":"0.5","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr","C":[{"N":"p.withPredicate","role":"match","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"p.nodeTest","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mtr"},{"N":"filter","C":[{"N":"first","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]},{"N":"gc","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"attVal","name":"Q{}class"},{"N":"str","val":"msline"}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"287","C":[{"N":"sequence","sType":"*N ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"288","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"288"}]},{"N":"let","var":"Q{}m","slot":"0","sType":"*NE ","line":"289","C":[{"N":"docOrder","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","role":"select","line":"289","C":[{"N":"slash","op":"/","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"first","C":[{"N":"axis","name":"following-sibling","nodeTest":"*NE"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd"}]}]},{"N":"forEach","sType":"*NE ","line":"290","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"290"},{"N":"let","var":"Q{}p","slot":"1","sType":"*NE ","line":"291","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"291"},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"292","C":[{"N":"sequence","sType":"*N ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"293","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"293"}]},{"N":"choose","sType":"*NE ","type":"item()*","line":"294","C":[{"N":"docOrder","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mpadded","line":"295","C":[{"N":"docOrder","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mpadded","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"filter","flags":"i","C":[{"N":"varRef","name":"Q{}m","slot":"0"},{"N":"varRef","name":"Q{}p","slot":"1"}]}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mpadded"}]}]}]},{"N":"elem","name":"m:menclose","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}menclose ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"296","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"notation","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"bottom"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"297","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"depth","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".1em"}]},{"N":"att","name":"height","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"1em"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".5em"}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"298","sType":"*NE","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"298"}]}]}]}]}]},{"N":"true"},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"303","sType":"*NE","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"303"}]}]}]}]}]}]}]}]}]}]},{"N":"templateRule","rank":"3","prec":"0","seq":"39","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"277","module":"mml3.xsl","match":"m:none","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}none","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}none","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}none","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"278","C":[{"N":"empty","sType":"0 "}]}]},{"N":"templateRule","rank":"4","prec":"0","seq":"40","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"280","module":"mml3.xsl","match":"*","prio":"-0.5","matches":"NE","C":[{"N":"p.nodeTest","role":"match","test":"NE","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"copy","sType":"1NE ","flags":"cin","role":"action","line":"281","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"282","sType":"*NA","C":[{"N":"axis","name":"attribute","nodeTest":"*NA","sType":"*NA","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"282"}]},{"N":"applyT","sType":"* ","line":"283","mode":"Q{}ml","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"283"}]}]}]}]}]}]},{"N":"co","id":"3","binds":"4 3 0","C":[{"N":"mode","onNo":"TC","flags":"","patternSlots":"0","name":"Q{}mstack1","prec":"","C":[{"N":"templateRule","rank":"0","prec":"0","seq":"49","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"471","module":"mml3.xsl","match":"m:mscarries","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mscarries","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mscarries","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mscarries","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"472","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"let","var":"Q{}align1","slot":"1","sType":"*NE ","line":"473","C":[{"N":"docOrder","sType":"*NA nQ{}stackalign","role":"select","line":"473","C":[{"N":"slash","op":"/","sType":"*NA nQ{}stackalign","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mstack"}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}stackalign"}]}]},{"N":"let","var":"Q{}l1","slot":"2","sType":"*NE ","line":"474","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"475","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"476","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align1","slot":"1"}]}]},{"N":"str","val":"left"}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0"}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"fn","sType":"1ADI","name":"count","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"8","C":[{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"480","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"class","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"mscarries"}]},{"N":"att","name":"l","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"?AO","C":[{"N":"arith10","op":"+","calc":"d+d","sType":"?AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"480","C":[{"N":"arith10","op":"+","calc":"d+d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}l1","slot":"2"}]}]}]},{"N":"fn","name":"sum","C":[{"N":"attVal","name":"Q{}position"}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"applyT","sType":"* ","line":"481","mode":"Q{}msc","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"481"}]}]}]}]}]}]}]},{"N":"templateRule","rank":"1","prec":"0","seq":"48","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"418","module":"mml3.xsl","match":"m:msline","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msline","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msline","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msline","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"419","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"let","var":"Q{}align1","slot":"1","sType":"*NE ","line":"420","C":[{"N":"docOrder","sType":"*NA nQ{}stackalign","role":"select","line":"420","C":[{"N":"slash","op":"/","sType":"*NA nQ{}stackalign","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mstack"}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}stackalign"}]}]},{"N":"let","var":"Q{}align","slot":"2","sType":"*NE ","line":"421","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"422","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"423","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align1","slot":"1"}]}]},{"N":"str","val":""}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"decimalpoint"}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}align1","slot":"1","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"8"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"427","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"class","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"msline"}]},{"N":"att","name":"l","sType":"1NA ","line":"428","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"429","C":[{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"430","C":[{"N":"fn","name":"not","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length"}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length"},{"N":"int","val":"0"}]}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"*"}]},{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"431","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align","slot":"2"}]}]},{"N":"str","val":"right"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align","slot":"2"}]}]},{"N":"str","val":"decimalpoint"}]}]},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"arith10","sType":"?AO","op":"+","calc":"d+d","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"14","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length"}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}p","slot":"0","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"16"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"let","var":"Q{}w","slot":"3","sType":"*NE ","line":"435","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"436","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"437","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}mslinethickness"},{"N":"str","val":"thin"}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0.1em"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"438","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}mslinethickness"},{"N":"str","val":"medium"}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0.15em"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"439","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}mslinethickness"},{"N":"str","val":"thick"}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0.2em"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}mslinethickness","sType":"*NA nQ{}mslinethickness","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"440"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"axis","sType":"*NA nQ{}mslinethickness","name":"attribute","nodeTest":"*NA nQ{}mslinethickness","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"23"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"true"},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"0.15em"}]}]}]},{"N":"choose","sType":"*NE ","type":"item()*","line":"444","C":[{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"445","C":[{"N":"fn","name":"not","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length"}]}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length"},{"N":"int","val":"0"}]}]},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"446","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"class","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"mslinemax"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"447","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-0.2em"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"height","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"elem","name":"m:mfrac","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mfrac ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"448","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"linethickness","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"*","C":[{"N":"varRef","name":"Q{}w","slot":"3","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"448"}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"elem","name":"m:mspace","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mspace ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"449","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".5em"}]}]},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"450","C":[{"N":"empty","sType":"0 "}]}]}]}]}]}]}]},{"N":"true"},{"N":"let","var":"Q{}l","slot":"4","sType":"*NE ","line":"456","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}length","sType":"*NA nQ{}length","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"456"},{"N":"forEach","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","line":"457","C":[{"N":"filter","flags":"p","sType":"*N","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"457","C":[{"N":"slash","op":"/","C":[{"N":"root"},{"N":"axis","name":"descendant","nodeTest":"*N u[NT,NP,NC,NE]"}]},{"N":"gc10","op":"<=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"varRef","name":"Q{}l","slot":"4"}]}]},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"458","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"class","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"msline"}]},{"N":"elem","name":"m:mpadded","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mpadded ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"459","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"lspace","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"-0.2em"}]},{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"att","name":"height","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"0em"}]},{"N":"elem","name":"m:mfrac","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mfrac ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"460","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"linethickness","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"*","C":[{"N":"varRef","name":"Q{}w","slot":"3","sType":"*","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"460"}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"elem","name":"m:mspace","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mspace ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"461","C":[{"N":"att","name":"width","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":".5em"}]}]},{"N":"elem","name":"m:mrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mrow ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"462","C":[{"N":"empty","sType":"0 "}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]},{"N":"templateRule","rank":"2","prec":"0","seq":"47","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"408","module":"mml3.xsl","match":"m:msgroup","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msgroup","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msgroup","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msgroup","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"409","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"let","var":"Q{}s","slot":"1","sType":"* ","line":"410","C":[{"N":"fn","name":"number","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"410","C":[{"N":"fn","name":"sum","C":[{"N":"attVal","name":"Q{}shift"}]}]},{"N":"let","var":"Q{}thisp","slot":"2","sType":"* ","line":"411","C":[{"N":"fn","name":"number","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"411","C":[{"N":"fn","name":"sum","C":[{"N":"attVal","name":"Q{}position"}]}]},{"N":"forEach","sType":"* ","line":"412","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"412"},{"N":"applyT","sType":"* ","line":"413","mode":"Q{}mstack1","bSlot":"1","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"413"},{"N":"withParam","name":"Q{}p","slot":"0","sType":"1AO","C":[{"N":"arith10","op":"+","calc":"d+d","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"414","C":[{"N":"arith10","op":"+","calc":"d+d","C":[{"N":"fn","name":"number","C":[{"N":"atomSing","diag":"0|0||number","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}thisp","slot":"2"}]}]}]},{"N":"arith10","op":"*","calc":"d*d","C":[{"N":"arith10","op":"-","calc":"d-d","C":[{"N":"fn","name":"position"},{"N":"int","val":"1"}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}s","slot":"1"}]}]}]}]}]}]}]}]}]}]}]},{"N":"templateRule","rank":"3","prec":"0","seq":"46","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"373","module":"mml3.xsl","match":"m:mn","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mn","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mn","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mn","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"374","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"let","var":"Q{}align1","slot":"1","sType":"*NE ","line":"375","C":[{"N":"docOrder","sType":"*NA nQ{}stackalign","role":"select","line":"375","C":[{"N":"slash","op":"/","sType":"*NA nQ{}stackalign","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mstack"}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}stackalign"}]}]},{"N":"let","var":"Q{}dp1","slot":"2","sType":"*NE ","line":"376","C":[{"N":"docOrder","sType":"*NA nQ{}decimalpoint","role":"select","line":"376","C":[{"N":"slash","op":"/","sType":"*NA nQ{}decimalpoint","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"filter","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}decimalpoint"}]}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}decimalpoint"}]}]},{"N":"let","var":"Q{}align","slot":"3","sType":"*NE ","line":"377","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"378","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"379","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align1","slot":"1"}]}]},{"N":"str","val":""}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"decimalpoint"}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}align1","slot":"1","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"let","var":"Q{}dp","slot":"4","sType":"*NE ","line":"383","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"384","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"385","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}dp1","slot":"2"}]}]},{"N":"str","val":""}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"."}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}dp1","slot":"2","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"14"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"389","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"l","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"$p"}]},{"N":"let","var":"Q{}mn","slot":"5","sType":"* ","line":"390","C":[{"N":"fn","name":"normalize-space","sType":"1AS","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"390","C":[{"N":"fn","name":"string","C":[{"N":"dot"}]}]},{"N":"let","var":"Q{}len","slot":"6","sType":"* ","line":"391","C":[{"N":"fn","name":"string-length","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"391","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}mn","slot":"5"}]}]}]},{"N":"sequence","sType":"* ","C":[{"N":"choose","sType":"? ","type":"item()*","line":"392","C":[{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"393","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"right"}]},{"N":"and","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"decimalpoint"}]},{"N":"fn","name":"not","C":[{"N":"fn","name":"contains","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}mn","slot":"5"}]}]},{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}dp","slot":"4"}]}]},{"N":"str","val":"http://www.w3.org/2005/xpath-functions/collation/codepoint"}]}]}]}]},{"N":"att","name":"l","sType":"1NA ","line":"394","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"arith10","sType":"?AO","op":"+","calc":"d+d","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"21","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}len","slot":"6"}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"396","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"center"}]},{"N":"att","name":"l","sType":"1NA ","line":"397","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"fn","sType":"?A m[AO,AD,AF]","name":"round","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"24","C":[{"N":"arith10","op":"div","calc":"d/d","C":[{"N":"arith10","op":"+","calc":"d+d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}len","slot":"6"}]}]}]},{"N":"int","val":"2"}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"399","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"decimalpoint"}]},{"N":"att","name":"l","sType":"1NA ","line":"400","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"arith10","sType":"?AO","op":"+","calc":"d+d","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"27","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]},{"N":"fn","name":"string-length","C":[{"N":"fn","name":"substring-before","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}mn","slot":"5"}]}]},{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}dp","slot":"4"}]}]},{"N":"str","val":"http://www.w3.org/2005/xpath-functions/collation/codepoint"}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"true"},{"N":"empty","sType":"0 "}]},{"N":"forEach","sType":"*NE ","line":"402","C":[{"N":"filter","flags":"p","sType":"*N","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"402","C":[{"N":"slash","op":"/","C":[{"N":"root"},{"N":"axis","name":"descendant","nodeTest":"*N u[NT,NP,NC,NE]"}]},{"N":"gc10","op":"<=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"fn","name":"position"},{"N":"varRef","name":"Q{}len","slot":"6"}]}]},{"N":"let","var":"Q{}pos","slot":"7","sType":"*NE ","line":"403","C":[{"N":"fn","name":"position","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"403"},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"404","C":[{"N":"elem","name":"m:mn","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mn ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","C":[{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"fn","name":"substring","sType":"1AS","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"32","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}mn","slot":"5"}]}]},{"N":"fn","name":"number","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}pos","slot":"7"}]}]},{"N":"fn","name":"number","C":[{"N":"int","val":"1"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]},{"N":"templateRule","rank":"4","prec":"0","seq":"45","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"338","module":"mml3.xsl","match":"m:msrow","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}msrow","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}msrow","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}msrow","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"339","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"param","name":"Q{}maxl","slot":"1","sType":"* ","as":"* ","flags":"","line":"340","C":[{"N":"int","val":"0","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"340"},{"N":"supplied","role":"conversion","slot":"1","sType":"* "}]},{"N":"let","var":"Q{}align1","slot":"2","sType":"*N ","line":"341","C":[{"N":"docOrder","sType":"*NA nQ{}stackalign","role":"select","line":"341","C":[{"N":"slash","op":"/","sType":"*NA nQ{}stackalign","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mstack"}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}stackalign"}]}]},{"N":"let","var":"Q{}align","slot":"3","sType":"*N ","line":"342","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"?NT ","type":"item()*","line":"343","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"344","C":[{"N":"fn","name":"string","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}align1","slot":"2"}]}]},{"N":"str","val":""}]},{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"decimalpoint"}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}align1","slot":"2","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"let","var":"Q{}row","slot":"4","sType":"*N ","line":"348","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"applyT","sType":"* ","line":"349","mode":"Q{}mstack1","bSlot":"1","C":[{"N":"axis","name":"child","nodeTest":"*NE","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"349"},{"N":"withParam","name":"Q{}p","slot":"0","sType":"1ADI","C":[{"N":"int","val":"0","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"350"}]}]}]},{"N":"sequence","sType":"*N ","C":[{"N":"valueOf","sType":"1NT ","C":[{"N":"str","sType":"1AS ","val":"\n"}]},{"N":"let","var":"Q{}l1","slot":"5","sType":"*NE ","line":"354","C":[{"N":"doc","sType":"1ND ","base":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","role":"select","C":[{"N":"choose","sType":"*NT ","type":"item()*","line":"355","C":[{"N":"and","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"356","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"decimalpoint"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mn"}]},{"N":"forEach","sType":"*NT ","line":"357","C":[{"N":"docOrder","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtr","role":"select","line":"357","C":[{"N":"docOrder","sType":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtr","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}row","slot":"4"}]},{"N":"first","C":[{"N":"filter","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtr"},{"N":"slash","op":"/","C":[{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd"},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mn"}]}]}]}]}]}]},{"N":"valueOf","flags":"l","sType":"1NT ","line":"358","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"arith10","sType":"1AO","op":"+","calc":"d+d","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"358","C":[{"N":"fn","name":"number","C":[{"N":"fn","name":"sum","C":[{"N":"attVal","name":"Q{}l"}]}]},{"N":"fn","name":"count","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"fn","name":"reverse","C":[{"N":"axis","name":"preceding-sibling","nodeTest":"*NE"}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}l"}]}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]},{"N":"or","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"361","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"right"}]},{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","C":[{"N":"varRef","name":"Q{}align","slot":"3"},{"N":"str","val":"decimalpoint"}]}]},{"N":"valueOf","flags":"l","sType":"1NT ","line":"362","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"fn","sType":"1ADI","name":"count","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"362","C":[{"N":"docOrder","C":[{"N":"slash","op":"/","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}row","slot":"4"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtr"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtd"}]}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"true"},{"N":"valueOf","flags":"l","sType":"1NT ","line":"365","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"int","sType":"1ADI","val":"0","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"365"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"369","C":[{"N":"sequence","sType":"*N ","C":[{"N":"att","name":"class","nsuri":"","sType":"1NA ","C":[{"N":"str","sType":"1AS ","val":"msrow"}]},{"N":"att","name":"l","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"1AO","C":[{"N":"arith10","op":"+","calc":"d+d","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"369","C":[{"N":"arith10","op":"+","calc":"d+d","C":[{"N":"fn","name":"number","C":[{"N":"atomSing","diag":"0|0||number","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}l1","slot":"5"}]}]}]},{"N":"fn","name":"number","C":[{"N":"fn","name":"sum","C":[{"N":"attVal","name":"Q{}position"}]}]}]},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"370","sType":"*NE","C":[{"N":"docOrder","sType":"*NE","role":"select","line":"370","C":[{"N":"docOrder","sType":"*NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"slash","op":"/","C":[{"N":"treat","as":"N","diag":"1|0|XPTY0019|slash","C":[{"N":"varRef","name":"Q{}row","slot":"4"}]},{"N":"axis","name":"child","nodeTest":"*NE nQ{http://www.w3.org/1998/Math/MathML}mtr"}]},{"N":"axis","name":"child","nodeTest":"*NE"}]}]}]}]}]}]}]}]}]}]}]}]}]},{"N":"templateRule","rank":"5","prec":"0","seq":"44","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"328","module":"mml3.xsl","match":"*","prio":"-0.5","matches":"NE","C":[{"N":"p.nodeTest","role":"match","test":"NE","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"sequence","role":"action","sType":"* ","C":[{"N":"param","name":"Q{}p","slot":"0","sType":"* ","as":"* ","flags":"","line":"329","C":[{"N":"str","sType":"1AS ","val":"","role":"select"},{"N":"supplied","role":"conversion","slot":"0","sType":"* "}]},{"N":"param","name":"Q{}maxl","slot":"1","sType":"* ","as":"* ","flags":"","line":"330","C":[{"N":"int","val":"0","sType":"1ADI","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"330"},{"N":"supplied","role":"conversion","slot":"1","sType":"* "}]},{"N":"elem","name":"m:mtr","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtr ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"331","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"l","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"1AO","C":[{"N":"arith10","op":"+","calc":"d+d","sType":"1AO","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"331","C":[{"N":"int","val":"1"},{"N":"atomSing","diag":"1|1||arith","card":"?","C":[{"N":"first","C":[{"N":"varRef","name":"Q{}p","slot":"0"}]}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]},{"N":"choose","sType":"? ","line":"332","C":[{"N":"gc10","op":"=","comp":"GAC|http://www.w3.org/2005/xpath-functions/collation/codepoint","card":"1:1","sType":"1AB","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"332","C":[{"N":"slash","op":"/","C":[{"N":"fn","name":"reverse","C":[{"N":"first","C":[{"N":"axis","name":"ancestor","nodeTest":"*NE nQ{}mstack"}]}]},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}stackalign"}]},{"N":"str","val":"left"}]},{"N":"att","name":"l","sType":"1NA ","line":"333","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"valueOf","sType":"1NT ","flags":"l","C":[{"N":"fn","name":"string-join","role":"select","C":[{"N":"first","C":[{"N":"forEach","sType":"*AS ","C":[{"N":"data","sType":"*A ","C":[{"N":"mergeAdj","C":[{"N":"varRef","sType":"*","name":"Q{}p","slot":"0","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"7"}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":" "}]}]}]}]},{"N":"fn","name":"string","sType":"1AS ","C":[{"N":"dot"}]}]}]},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"true"},{"N":"empty","sType":"0 "}]},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"335","C":[{"N":"applyT","sType":"* ","mode":"#unnamed","bSlot":"2","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"9"}]}]}]}]}]}]}]}]},{"N":"co","id":"4","binds":"0","C":[{"N":"mode","onNo":"TC","flags":"","patternSlots":"0","name":"Q{}msc","prec":"","C":[{"N":"templateRule","rank":"0","prec":"0","seq":"51","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"499","module":"mml3.xsl","match":"m:mscarry","prio":"0","matches":"NE nQ{http://www.w3.org/1998/Math/MathML}mscarry","C":[{"N":"p.nodeTest","role":"match","test":"NE nQ{http://www.w3.org/1998/Math/MathML}mscarry","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mscarry","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"500","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"501","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","C":[{"N":"docOrder","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","role":"select","line":"501","C":[{"N":"union","op":"|","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}crossout"}]}]}]},{"N":"choose","sType":"* ","type":"item()*","line":"502","C":[{"N":"docOrder","sType":"*NA nQ{}scriptsizemultiplier","line":"503","C":[{"N":"slash","op":"/","sType":"*NA nQ{}scriptsizemultiplier","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}scriptsizemultiplier"}]}]},{"N":"elem","name":"m:mstyle","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstyle ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"504","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"mathsize","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"concat","sType":"1AS ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"?A m[AO,AD,AF]","C":[{"N":"fn","name":"round","sType":"?A m[AO,AD,AF]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"504","C":[{"N":"arith10","op":"div","calc":"d/d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"slash","op":"/","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}scriptsizemultiplier"}]}]}]},{"N":"dec","val":"0.007"}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]},{"N":"str","sType":"1AS ","val":"%"},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"applyT","sType":"* ","line":"505","mode":"#unnamed","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"505"}]}]}]},{"N":"true"},{"N":"applyT","sType":"* ","line":"509","mode":"#unnamed","bSlot":"0","C":[{"N":"axis","name":"child","nodeTest":"*N u[NT,NP,NC,NE]","sType":"*N u[NT,NP,NC,NE]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"509"}]}]}]}]}]},{"N":"templateRule","rank":"1","prec":"0","seq":"50","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common","minImp":"0","flags":"s","baseUri":"file:///Users/dpvc/Desktop/Tumlook/Data/Code/JavaScript/MathJax/Code/Git/mathjax/MathJax-src/ts/input/mathml/mml3/mml3.xsl","slots":"200","line":"484","module":"mml3.xsl","match":"*","prio":"-0.5","matches":"NE","C":[{"N":"p.nodeTest","role":"match","test":"NE","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common "},{"N":"elem","name":"m:mtd","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mtd ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","role":"action","line":"485","C":[{"N":"sequence","sType":"* ","C":[{"N":"copyOf","flags":"c","ns":"xml=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ex=http://ns.saxonica.com/xslt/export","line":"486","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","C":[{"N":"docOrder","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","role":"select","line":"486","C":[{"N":"union","op":"|","sType":"*NA u[NA nQ{}location,NA nQ{}crossout]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"slash","op":"/","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}location"}]},{"N":"slash","op":"/","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}crossout"}]}]}]}]},{"N":"choose","sType":"* ","type":"item()*","line":"487","C":[{"N":"docOrder","sType":"*NA nQ{}scriptsizemultiplier","line":"488","C":[{"N":"slash","op":"/","sType":"*NA nQ{}scriptsizemultiplier","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}scriptsizemultiplier"}]}]},{"N":"elem","name":"m:mstyle","sType":"1NE nQ{http://www.w3.org/1998/Math/MathML}mstyle ","nsuri":"http://www.w3.org/1998/Math/MathML","namespaces":"","line":"489","C":[{"N":"sequence","sType":"* ","C":[{"N":"att","name":"mathsize","nsuri":"","sType":"1NA ","C":[{"N":"fn","name":"concat","sType":"1AS ","C":[{"N":"fn","name":"string-join","sType":"1AS ","C":[{"N":"first","C":[{"N":"convert","type":"AS*","from":"AZ","to":"AS","C":[{"N":"data","C":[{"N":"mergeAdj","sType":"?A m[AO,AD,AF]","C":[{"N":"fn","name":"round","sType":"?A m[AO,AD,AF]","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","line":"489","C":[{"N":"arith10","op":"div","calc":"d/d","C":[{"N":"atomSing","diag":"1|0||arith","card":"?","C":[{"N":"first","C":[{"N":"slash","op":"/","C":[{"N":"axis","name":"parent","nodeTest":"?N"},{"N":"axis","name":"attribute","nodeTest":"*NA nQ{}scriptsizemultiplier"}]}]}]},{"N":"dec","val":"0.007"}]}]}]}]}]}]},{"N":"str","sType":"1AS ","val":" "}]},{"N":"str","sType":"1AS ","val":"%"},{"N":"str","sType":"1AS ","val":""}]}]},{"N":"applyT","sType":"* ","line":"490","mode":"#unnamed","bSlot":"0","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"490"}]}]}]},{"N":"true"},{"N":"applyT","sType":"* ","line":"494","mode":"#unnamed","bSlot":"0","C":[{"N":"dot","sType":"1NE","ns":"= xml=~ fn=~ xsl=~ m=http://www.w3.org/1998/Math/MathML c=http://exslt.org/common ","role":"select","line":"494"}]}]}]}]}]}]}]},{"N":"overridden"},{"N":"output","C":[{"N":"property","name":"Q{http://saxon.sf.net/}stylesheet-version","value":"10"},{"N":"property","name":"indent","value":"yes"},{"N":"property","name":"omit-xml-declaration","value":"yes"}]},{"N":"decimalFormat"}],"Σ":"810a2741"} \ No newline at end of file diff --git a/ts/input/mathml/mml3/mml3.ts b/ts/input/mathml/mml3/mml3.ts new file mode 100644 index 000000000..c0ed2009b --- /dev/null +++ b/ts/input/mathml/mml3/mml3.ts @@ -0,0 +1,779 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Implements the elementary MathML3 support (experimental) + * using David Carlisle's XLST transform. + * + * @author dpvc@mathjax.org (Davide Cervone) + */ + +import {MathItem} from '../../../core/MathItem.js'; +import {MathDocument} from '../../../core/MathDocument.js'; +import {Handler} from '../../../core/Handler.js'; +import {OptionList} from '../../../util/Options.js'; +import {createTransform} from './mml3-node.js'; + + +/** + * The data for a MathML prefilter. + */ +export type FILTERDATA = {math: MathItem, document: MathDocument, data: string}; + +/** + * Class that handles XSLT transform for MathML3 elementary math tags. + */ +export class Mml3 { + + /** + * The XSLT transform as a string; + */ + public static XSLT: string; // added below (it is huge) + + /** + * The function to convert serialized MathML using the XSLT. + * (Different for browser and node environments.) + */ + protected transform: (xml: string) => string; + + /** + * @param {MathDocument} document The MathDocument for the transformation + * @constructor + */ + constructor(document: MathDocument) { + if (typeof XSLTProcessor === 'undefined') { + // + // For Node, get the trasnform from the external module + // + this.transform = createTransform(); + } else { + // + // For in-browser use, use the browser's XSLTProcessor + // + const processor = new XSLTProcessor(); + const parsed = document.adaptor.parse(Mml3.XSLT, 'text/xml') as any as Node; + processor.importStylesheet(parsed); + this.transform = (mml: string) => { + const adaptor = document.adaptor; + const parsed = adaptor.parse(mml) as any as Node; + const xml = processor.transformToDocument(parsed) as any as D; + return adaptor.serializeXML(adaptor.body(xml)); + }; + } + } + + /** + * The prefilter for the MathML input jax + * + * @param {FILTERDATA} args The data from the pre-filter chain. + */ + public preFilter(args: FILTERDATA) { + args.data = this.transform(args.data); + } + +} + +/** + * Add Mml3 support into the handler. + */ +export function Mml3Handler(handler: Handler): Handler { + handler.documentClass = class extends handler.documentClass { + /** + * Add a prefilter to the MathML input jax, if there is one. + * + * @override + * @constructor + */ + constructor(...args: any[]) { + super(...args); + const options = args[2] as OptionList; + if (options.InputJax) { + for (const jax of options.InputJax) { + if (jax.name === 'MathML') { + const mml3 = new Mml3(this); + jax.preFilters.add(mml3.preFilter.bind(mml3)); + break; + } + } + } + } + }; + return handler; +} + +// +// The actual XSLT transform +// +Mml3.XSLT = ` + + + + + + + + + + + + + + + ltr + + + + + + + + + + + + + + + + ) + + + ( + + + ] + + + [ + + + } + + + { + + + + + + ) + + + ( + + + ] + + + [ + + + } + + + { + + + + + \ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +) +( +} +{ +> +< +∋ +∈ + + top right + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + . + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + + * + + + + + + + 0.1em + 0.15em + 0.2em + + 0.15em + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ) + + ( + + + + + + + / + + \ + + + + + + + : + + = + + + + + top + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +`; diff --git a/ts/input/mathml/mml3/mml3.xsl b/ts/input/mathml/mml3/mml3.xsl new file mode 100644 index 000000000..b687ce758 --- /dev/null +++ b/ts/input/mathml/mml3/mml3.xsl @@ -0,0 +1,657 @@ + + + + + + + + + + + + + + + ltr + + + + + + + + + + + + + + + + ) + + + ( + + + ] + + + [ + + + } + + + { + + + + + + ) + + + ( + + + ] + + + [ + + + } + + + { + + + + + \ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +) +( +} +{ +> +< +∋ +∈ + + top right + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + . + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + decimalpoint + + + + + + + * + + + + + + + 0.1em + 0.15em + 0.2em + + 0.15em + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ) + + ( + + + + + + + / + + \ + + + + + + + : + + = + + + + + top + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + From d790c74617f2db0015c79aa7493ea246a4432ff4 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Sat, 15 May 2021 09:48:35 -0400 Subject: [PATCH 054/142] Remove munderover elements that have been cleaned. (mathjax/MathJax#2691) --- ts/input/tex/FilterUtil.ts | 13 +++++++++++-- ts/input/tex/ParseOptions.ts | 18 ++++++++++++++++++ 2 files changed, 29 insertions(+), 2 deletions(-) diff --git a/ts/input/tex/FilterUtil.ts b/ts/input/tex/FilterUtil.ts index fb2c49740..cf3118f9f 100644 --- a/ts/input/tex/FilterUtil.ts +++ b/ts/input/tex/FilterUtil.ts @@ -86,6 +86,7 @@ namespace FilterUtil { * @param {ParseOptions} data The parse options. */ export let combineRelations = function(arg: {data: ParseOptions}) { + const remove: MmlNode[] = []; for (let mo of arg.data.getList('mo')) { if (mo.getProperty('relationsCombined') || !mo.parent || (mo.parent && !NodeUtil.isType(mo.parent, 'mrow')) || @@ -111,6 +112,7 @@ namespace FilterUtil { _copyExplicit(['stretchy', 'rspace'], mo, m2); NodeUtil.setProperties(mo, m2.getAllProperties()); children.splice(next, 1); + remove.push(m2); m2.parent = null; m2.setProperty('relationsCombined', true); } else { @@ -127,7 +129,8 @@ namespace FilterUtil { } } mo.attributes.setInherited('form', (mo as MmlMo).getForms()[0]); - } + } + arg.data.removeFromList('mo', remove); }; @@ -191,6 +194,7 @@ namespace FilterUtil { * @param {string} up String representing the upper part. */ let _cleanSubSup = function(options: ParseOptions, low: string, up: string) { + const remove: MmlNode[] = []; for (let mml of options.getList('m' + low + up) as any[]) { const children = mml.childNodes; if (children[mml[low]] && children[mml[up]]) { @@ -206,7 +210,9 @@ namespace FilterUtil { } else { options.root = newNode; } + remove.push(mml); } + options.removeFromList('m' + low + up, remove); }; @@ -235,8 +241,9 @@ namespace FilterUtil { * @param {ParseOptions} data The parse options. */ let _moveLimits = function (options: ParseOptions, underover: string, subsup: string) { + const remove: MmlNode[] = []; for (const mml of options.getList(underover)) { - if (mml.attributes.get('displaystyle')) { + if (mml.attributes.get('displaystyle') || mml.getProperty('removed')) { continue; } const base = mml.childNodes[(mml as any).base] as MmlNode; @@ -249,8 +256,10 @@ namespace FilterUtil { } else { options.root = node; } + remove.push(mml); } } + options.removeFromList(underover, remove); }; /** diff --git a/ts/input/tex/ParseOptions.ts b/ts/input/tex/ParseOptions.ts index 30bc3b40a..378adf6cd 100644 --- a/ts/input/tex/ParseOptions.ts +++ b/ts/input/tex/ParseOptions.ts @@ -199,6 +199,24 @@ export default class ParseOptions { } + /** + * Remove a list of nodes from a saved list (e.g., when a filter removes the + * node from the DOM, like for munderover => munder). + * + * @param {string} property The property from which to remove nodes. + * @param {MmlNode[]} nodes The nodes to remove. + */ + public removeFromList(property: string, nodes: MmlNode[]) { + const list = this.nodeLists[property] || []; + for (const node of nodes) { + const i = list.indexOf(node); + if (i >= 0) { + list.splice(i, 1); + } + } + } + + /** * Tests if the node is in the tree spanned by the current root node. * @param {MmlNode} node The node to test. From 79142e8bbd55c77c80d12221619ceade369530d8 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Sat, 15 May 2021 17:05:22 -0400 Subject: [PATCH 055/142] Remove .xsl file that can be generated by mpn script --- ts/input/mathml/mml3/mml3.xsl | 657 ---------------------------------- 1 file changed, 657 deletions(-) delete mode 100644 ts/input/mathml/mml3/mml3.xsl diff --git a/ts/input/mathml/mml3/mml3.xsl b/ts/input/mathml/mml3/mml3.xsl deleted file mode 100644 index b687ce758..000000000 --- a/ts/input/mathml/mml3/mml3.xsl +++ /dev/null @@ -1,657 +0,0 @@ - - - - - - - - - - - - - - - ltr - - - - - - - - - - - - - - - - ) - - - ( - - - ] - - - [ - - - } - - - { - - - - - - ) - - - ( - - - ] - - - [ - - - } - - - { - - - - - \ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -) -( -} -{ -> -< -∋ -∈ - - top right - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - decimalpoint - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - decimalpoint - - - - - - . - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - decimalpoint - - - - - - - * - - - - - - - 0.1em - 0.15em - 0.2em - - 0.15em - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 0 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ) - - ( - - - - - - - / - - \ - - - - - - - : - - = - - - - - top - - - - - - - - - - - - - - - - - - - - - - - - - - - - - ) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - From 25ac55b6426a3c3e37c2d720466e16227cd8102a Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 17 May 2021 12:54:27 -0400 Subject: [PATCH 056/142] Fix typos in comments --- ts/a11y/assistive-mml.ts | 4 ++-- ts/a11y/complexity.ts | 2 +- ts/a11y/explorer.ts | 2 +- ts/a11y/semantic-enrich.ts | 4 ++-- 4 files changed, 6 insertions(+), 6 deletions(-) diff --git a/ts/a11y/assistive-mml.ts b/ts/a11y/assistive-mml.ts index 7f08f199f..0ad95cfd6 100644 --- a/ts/a11y/assistive-mml.ts +++ b/ts/a11y/assistive-mml.ts @@ -58,7 +58,7 @@ export type Constructor = new(...args: any[]) => T; newState('ASSISTIVEMML', 153); /** - * The funtions added to MathItem for assistive MathML + * The functions added to MathItem for assistive MathML * * @template N The HTMLElement node class * @template T The Text node class @@ -129,7 +129,7 @@ export function AssistiveMmlMathItemMixin>(BaseMathItem: B, computeComplexity: (node: MmlNode) => void): /*==========================================================================*/ /** - * The funtions added to MathDocument for complexity + * The functions added to MathDocument for complexity * * @template N The HTMLElement node class * @template T The Text node class diff --git a/ts/a11y/explorer.ts b/ts/a11y/explorer.ts index e22847d7c..ddb48eb5b 100644 --- a/ts/a11y/explorer.ts +++ b/ts/a11y/explorer.ts @@ -203,7 +203,7 @@ export function ExplorerMathItemMixin>( } /** - * The funtions added to MathDocument for the Explorer + * The functions added to MathDocument for the Explorer */ export interface ExplorerMathDocument extends HTMLDOCUMENT { diff --git a/ts/a11y/semantic-enrich.ts b/ts/a11y/semantic-enrich.ts index 48d011d69..dd9797bdb 100644 --- a/ts/a11y/semantic-enrich.ts +++ b/ts/a11y/semantic-enrich.ts @@ -58,7 +58,7 @@ newState('ATTACHSPEECH', 155); /** - * The funtions added to MathItem for enrichment + * The functions added to MathItem for enrichment * * @template N The HTMLElement node class * @template T The Text node class @@ -197,7 +197,7 @@ export function EnrichedMathItemMixin Date: Mon, 17 May 2021 16:51:49 -0400 Subject: [PATCH 057/142] Add colortbl package and component --- components/src/dependencies.js | 2 + .../input/tex/extensions/colortbl/build.json | 4 + .../input/tex/extensions/colortbl/colortbl.js | 1 + .../tex/extensions/colortbl/webpack.config.js | 11 ++ ts/input/tex/AllPackages.ts | 3 + ts/input/tex/base/BaseItems.ts | 75 +++++----- .../tex/colortbl/ColortblConfiguration.ts | 134 ++++++++++++++++++ 7 files changed, 197 insertions(+), 33 deletions(-) create mode 100644 components/src/input/tex/extensions/colortbl/build.json create mode 100644 components/src/input/tex/extensions/colortbl/colortbl.js create mode 100644 components/src/input/tex/extensions/colortbl/webpack.config.js create mode 100644 ts/input/tex/colortbl/ColortblConfiguration.ts diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..b193adf11 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -14,6 +14,7 @@ export const dependencies = { '[tex]/cancel': ['input/tex-base', '[tex]/enclose'], '[tex]/color': ['input/tex-base'], '[tex]/colorv2': ['input/tex-base'], + '[tex]/colortbl': ['input/tex-base', '[tex]/color'], '[tex]/configmacros': ['input/tex-base', '[tex]/newcommand'], '[tex]/enclose': ['input/tex-base'], '[tex]/extpfeil': ['input/tex-base', '[tex]/newcommand', '[tex]/ams'], @@ -45,6 +46,7 @@ const allPackages = [ '[tex]/bussproofs', '[tex]/cancel', '[tex]/color', + '[tex]/colortbl', '[tex]/configmacros', '[tex]/enclose', '[tex]/extpfeil', diff --git a/components/src/input/tex/extensions/colortbl/build.json b/components/src/input/tex/extensions/colortbl/build.json new file mode 100644 index 000000000..5b2e25c68 --- /dev/null +++ b/components/src/input/tex/extensions/colortbl/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/colortbl", + "targets": ["input/tex/colortbl"] +} diff --git a/components/src/input/tex/extensions/colortbl/colortbl.js b/components/src/input/tex/extensions/colortbl/colortbl.js new file mode 100644 index 000000000..fbdf6e67f --- /dev/null +++ b/components/src/input/tex/extensions/colortbl/colortbl.js @@ -0,0 +1 @@ +import './lib/colortbl.js'; diff --git a/components/src/input/tex/extensions/colortbl/webpack.config.js b/components/src/input/tex/extensions/colortbl/webpack.config.js new file mode 100644 index 000000000..74b52a8d3 --- /dev/null +++ b/components/src/input/tex/extensions/colortbl/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/colortbl', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..291292b69 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -32,6 +32,7 @@ import './bussproofs/BussproofsConfiguration.js'; import './cancel/CancelConfiguration.js'; import './color/ColorConfiguration.js'; import './colorv2/ColorV2Configuration.js'; +import './colortbl/ColortblConfiguration.js'; import './configmacros/ConfigMacrosConfiguration.js'; import './enclose/EncloseConfiguration.js'; import './extpfeil/ExtpfeilConfiguration.js'; @@ -59,6 +60,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/cancel', '[tex]/color', '[tex]/colorv2', + '[tex]/colortbl', '[tex]/enclose', '[tex]/extpfeil', '[tex]/html', @@ -86,6 +88,7 @@ export const AllPackages: string[] = [ 'bussproofs', 'cancel', 'color', + 'colortbl', 'enclose', 'extpfeil', 'html', diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index f4f8ba42c..66d08f08e 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -894,39 +894,7 @@ export class ArrayItem extends BaseItem { } this.EndTable(); this.clearEnv(); - const scriptlevel = this.arraydef['scriptlevel']; - delete this.arraydef['scriptlevel']; - let mml = this.create('node', 'mtable', this.table, this.arraydef); - if (scriptlevel) { - mml.setProperty('scriptlevel', scriptlevel); - } - if (this.frame.length === 4) { - // @test Enclosed frame solid, Enclosed frame dashed - NodeUtil.setAttribute(mml, 'frame', this.dashed ? 'dashed' : 'solid'); - } else if (this.frame.length) { - // @test Enclosed left right - if (this.arraydef['rowlines']) { - // @test Enclosed dashed row, Enclosed solid row, - this.arraydef['rowlines'] = - (this.arraydef['rowlines'] as string).replace(/none( none)+$/, 'none'); - } - // @test Enclosed left right - mml = this.create('node', 'menclose', [mml], - {notation: this.frame.join(' '), isFrame: true}); - if ((this.arraydef['columnlines'] || 'none') !== 'none' || - (this.arraydef['rowlines'] || 'none') !== 'none') { - // @test Enclosed dashed row, Enclosed solid row - // @test Enclosed dashed column, Enclosed solid column - NodeUtil.setAttribute(mml, 'padding', 0); - } - } - if (this.getProperty('open') || this.getProperty('close')) { - // @test Cross Product Formula - mml = ParseUtil.fenced(this.factory.configuration, - this.getProperty('open') as string, mml, - this.getProperty('close') as string); - } - let newItem = this.factory.create('mml', mml); + let newItem = this.factory.create('mml', this.createMml()); if (this.getProperty('requireClose')) { // @test: Label if (item.isKind('close')) { @@ -941,6 +909,47 @@ export class ArrayItem extends BaseItem { return super.checkItem(item); } + /** + * Create the MathML representation of the table. + * + * @return {MmlNode} + */ + public createMml(): MmlNode { + const scriptlevel = this.arraydef['scriptlevel']; + delete this.arraydef['scriptlevel']; + let mml = this.create('node', 'mtable', this.table, this.arraydef); + if (scriptlevel) { + mml.setProperty('scriptlevel', scriptlevel); + } + if (this.frame.length === 4) { + // @test Enclosed frame solid, Enclosed frame dashed + NodeUtil.setAttribute(mml, 'frame', this.dashed ? 'dashed' : 'solid'); + } else if (this.frame.length) { + // @test Enclosed left right + if (this.arraydef['rowlines']) { + // @test Enclosed dashed row, Enclosed solid row, + this.arraydef['rowlines'] = + (this.arraydef['rowlines'] as string).replace(/none( none)+$/, 'none'); + } + // @test Enclosed left right + NodeUtil.setAttribute(mml, 'frame', ''); + mml = this.create('node', 'menclose', [mml], + {notation: this.frame.join(' '), isFrame: true}); + if ((this.arraydef['columnlines'] || 'none') !== 'none' || + (this.arraydef['rowlines'] || 'none') !== 'none') { + // @test Enclosed dashed row, Enclosed solid row + // @test Enclosed dashed column, Enclosed solid column + NodeUtil.setAttribute(mml, 'data-padding', 0); + } + } + if (this.getProperty('open') || this.getProperty('close')) { + // @test Cross Product Formula + mml = ParseUtil.fenced(this.factory.configuration, + this.getProperty('open') as string, mml, + this.getProperty('close') as string); + } + return mml; + } /** * Finishes a single cell of the array. diff --git a/ts/input/tex/colortbl/ColortblConfiguration.ts b/ts/input/tex/colortbl/ColortblConfiguration.ts new file mode 100644 index 000000000..a58561fcb --- /dev/null +++ b/ts/input/tex/colortbl/ColortblConfiguration.ts @@ -0,0 +1,134 @@ +import {ArrayItem} from '../base/BaseItems.js'; +import {Configuration, ParserConfiguration, ConfigurationHandler} from '../Configuration.js'; +import {CommandMap} from '../SymbolMap.js'; +import TexParser from '../TexParser.js'; +import TexError from '../TexError.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; + +import {TeX} from '../../tex.js'; + +export type ColorData = { + cell: string; + row: string; + col: string[]; +}; + +// +// Sublcass the ArrayItem to handle colored entries +// +export class ColorArrayItem extends ArrayItem { + /** + * Store current color for cell, row, and columns + */ + public color: ColorData = { + cell: '', + row: '', + col: [] + }; + + /** + * True if any cell is colored (we will make sure the edge cells are full sized). + */ + public hasColor: boolean = false; + + /** + * @override + */ + public EndEntry() { + super.EndEntry(); + const cell = this.row[this.row.length - 1]; + const color = this.color.cell || this.color.row || this.color.col[this.row.length - 1]; + if (color) { + cell.attributes.set('mathbackground', color); + this.color.cell = ''; + this.hasColor = true; + } + } + + /** + * @override + */ + public EndRow() { + super.EndRow(); + this.color.row = ''; + } + + /** + * @override + */ + public createMml() { + const mml = super.createMml(); + let table = (mml.isKind('mrow') ? mml.childNodes[1] : mml) as MmlNode; + if (table.isKind('menclose')) { + table = table.childNodes[0].childNodes[0] as MmlNode; + } + if (this.hasColor && table.attributes.get('frame') === 'none') { + table.attributes.set('frame', ''); + } + return mml; + } + +} + +// +// Define macros for table coloring +// +new CommandMap('colortbl', { + cellcolor: ['TableColor', 'cell'], + rowcolor: ['TableColor', 'row'], + columncolor: ['TableColor', 'col'] +}, { + /** + * Add color to a column, row, or cell + * + * @param {TexParser} parser The active TeX parser + * @param {string} name The name of the macro that is being processed + * @param {keyof ColorData} type The type (col, row, cell) of color being added + */ + TableColor(parser: TexParser, name: string, type: keyof ColorData) { + const top = parser.stack.Top() as ColorArrayItem; + const model = parser.GetBrackets(name, ''); + const lookup = parser.configuration.packageData.get('color').model; + const color = lookup.getColor(model, parser.GetArgument(name)); + if (top instanceof ColorArrayItem) { + if (type === 'col') { + if (top.table.length) { + throw new TexError('ColumnColorNotTop', '%1 must be in the top row', name); + } + top.color.col[top.row.length] = color; + } else { + top.color[type] = color; + if (type === 'row' && (top.Size() || top.row.length)) { + throw new TexError('RowColorNotFirst', '%1 must be at the beginning of a row', name); + } + } + } else { + throw new TexError('UnsupportedTableColor', 'Unsupported use of %1', parser.currentCS); + } + } +}); + +/** + * The configuration function for colortbl. + * + * @param {ParserConfiguration} config The configuration being used + * @param {Tex} jax The TeX jax using this configuration + */ +const config = function (config: ParserConfiguration, jax: TeX) { + // + // Make sure color is configured. (It doesn't have to be included in tex.packages.) + // + if (!jax.parseOptions.packageData.has('color')) { + ConfigurationHandler.get('color').config(config, jax); + } +}; + +// +// Create the color-table configuration +// +export const ColortblConfiguration = Configuration.create('colortbl', { + handler: {macro: ['colortbl']}, + items: {'array': ColorArrayItem}, // overrides original array class + priority: 10, // make sure we are processed after the base package (to override its array) + config: [config, 10] // make sure we configure after the color package, if it is used. +}); From 10967b153959242191aa2a96b84928f18e5313d7 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 17 May 2021 16:52:14 -0400 Subject: [PATCH 058/142] Update tables to handle and empty frame attribute better. --- ts/output/chtml/Wrappers/mtable.ts | 2 +- ts/output/common/Wrappers/mtable.ts | 2 +- ts/output/svg/Wrappers/mtable.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/ts/output/chtml/Wrappers/mtable.ts b/ts/output/chtml/Wrappers/mtable.ts index 6316e5f63..ae896f884 100644 --- a/ts/output/chtml/Wrappers/mtable.ts +++ b/ts/output/chtml/Wrappers/mtable.ts @@ -416,7 +416,7 @@ CommonMtableMixin, CHTMLmtr, CHTMLConstru * Add a frame to the mtable, if needed */ protected handleFrame() { - if (this.frame) { + if (this.frame && this.fLine) { this.adaptor.setStyle(this.itable, 'border', '.07em ' + this.node.attributes.get('frame')); } } diff --git a/ts/output/common/Wrappers/mtable.ts b/ts/output/common/Wrappers/mtable.ts index 174c0a387..80a60f8dc 100644 --- a/ts/output/common/Wrappers/mtable.ts +++ b/ts/output/common/Wrappers/mtable.ts @@ -464,7 +464,7 @@ export function CommonMtableMixin< // const attributes = this.node.attributes; this.frame = attributes.get('frame') !== 'none'; - this.fLine = (this.frame ? .07 : 0); + this.fLine = (this.frame && attributes.get('frame') ? .07 : 0); this.fSpace = (this.frame ? this.convertLengths(this.getAttributeArray('framespacing')) : [0, 0]); this.cSpace = this.convertLengths(this.getColumnAttributes('columnspacing')); this.rSpace = this.convertLengths(this.getRowAttributes('rowspacing')); diff --git a/ts/output/svg/Wrappers/mtable.ts b/ts/output/svg/Wrappers/mtable.ts index 0aedb794c..ed07efa2e 100644 --- a/ts/output/svg/Wrappers/mtable.ts +++ b/ts/output/svg/Wrappers/mtable.ts @@ -204,7 +204,7 @@ CommonMtableMixin, SVGmtr, SVGConstructor Date: Tue, 18 May 2021 09:29:13 -0400 Subject: [PATCH 059/142] Remove unneeded test that was part of a previous approach to the issue. --- ts/input/tex/FilterUtil.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/FilterUtil.ts b/ts/input/tex/FilterUtil.ts index cf3118f9f..470eb3d83 100644 --- a/ts/input/tex/FilterUtil.ts +++ b/ts/input/tex/FilterUtil.ts @@ -243,7 +243,7 @@ namespace FilterUtil { let _moveLimits = function (options: ParseOptions, underover: string, subsup: string) { const remove: MmlNode[] = []; for (const mml of options.getList(underover)) { - if (mml.attributes.get('displaystyle') || mml.getProperty('removed')) { + if (mml.attributes.get('displaystyle')) { continue; } const base = mml.childNodes[(mml as any).base] as MmlNode; From 7a9635134af86f6f9916d8a5a79b0ce0f6759d0a Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 18 May 2021 12:06:09 -0400 Subject: [PATCH 060/142] Add more comments, ignore optional overlap bracket parameters, and reduce indenting. --- .../tex/colortbl/ColortblConfiguration.ts | 52 ++++++++++++------- 1 file changed, 34 insertions(+), 18 deletions(-) diff --git a/ts/input/tex/colortbl/ColortblConfiguration.ts b/ts/input/tex/colortbl/ColortblConfiguration.ts index a58561fcb..8a79c0a18 100644 --- a/ts/input/tex/colortbl/ColortblConfiguration.ts +++ b/ts/input/tex/colortbl/ColortblConfiguration.ts @@ -18,7 +18,7 @@ export type ColorData = { // export class ColorArrayItem extends ArrayItem { /** - * Store current color for cell, row, and columns + * Store current color for cell, row, and columns. */ public color: ColorData = { cell: '', @@ -57,6 +57,11 @@ export class ColorArrayItem extends ArrayItem { * @override */ public createMml() { + // + // If there is any color in the array, give it an empty frame, + // if there isn't one already. This will make sure the color + // in edge cells extends past their contents. + // const mml = super.createMml(); let table = (mml.isKind('mrow') ? mml.childNodes[1] : mml) as MmlNode; if (table.isKind('menclose')) { @@ -71,7 +76,7 @@ export class ColorArrayItem extends ArrayItem { } // -// Define macros for table coloring +// Define macros for table coloring. // new CommandMap('colortbl', { cellcolor: ['TableColor', 'cell'], @@ -79,7 +84,7 @@ new CommandMap('colortbl', { columncolor: ['TableColor', 'col'] }, { /** - * Add color to a column, row, or cell + * Add color to a column, row, or cell. * * @param {TexParser} parser The active TeX parser * @param {string} name The name of the macro that is being processed @@ -90,20 +95,31 @@ new CommandMap('colortbl', { const model = parser.GetBrackets(name, ''); const lookup = parser.configuration.packageData.get('color').model; const color = lookup.getColor(model, parser.GetArgument(name)); - if (top instanceof ColorArrayItem) { - if (type === 'col') { - if (top.table.length) { - throw new TexError('ColumnColorNotTop', '%1 must be in the top row', name); - } - top.color.col[top.row.length] = color; - } else { - top.color[type] = color; - if (type === 'row' && (top.Size() || top.row.length)) { - throw new TexError('RowColorNotFirst', '%1 must be at the beginning of a row', name); - } + // + // Ignore the left and right overlap options. + // + if (parser.GetBrackets(name, '')) { + parser.GetBrackets(name, ''); + } + // + // Check that we are in a colorable array. + // + if (!(top instanceof ColorArrayItem)) { + throw new TexError('UnsupportedTableColor', 'Unsupported use of %1', parser.currentCS); + } + // + // Check the position of the macro and save the color. + // + if (type === 'col') { + if (top.table.length) { + throw new TexError('ColumnColorNotTop', '%1 must be in the top row', name); } + top.color.col[top.row.length] = color; } else { - throw new TexError('UnsupportedTableColor', 'Unsupported use of %1', parser.currentCS); + top.color[type] = color; + if (type === 'row' && (top.Size() || top.row.length)) { + throw new TexError('RowColorNotFirst', '%1 must be at the beginning of a row', name); + } } } }); @@ -111,8 +127,8 @@ new CommandMap('colortbl', { /** * The configuration function for colortbl. * - * @param {ParserConfiguration} config The configuration being used - * @param {Tex} jax The TeX jax using this configuration + * @param {ParserConfiguration} config The configuration being used. + * @param {Tex} jax The TeX jax using this configuration. */ const config = function (config: ParserConfiguration, jax: TeX) { // @@ -124,7 +140,7 @@ const config = function (config: ParserConfiguration, jax: TeX) { }; // -// Create the color-table configuration +// Create the color-table configuration. // export const ColortblConfiguration = Configuration.create('colortbl', { handler: {macro: ['colortbl']}, From 149c9b661c8855c81b5ced5a257f18fa44735b7d Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 18 May 2021 12:08:41 -0400 Subject: [PATCH 061/142] The isFrame property is never used --- ts/input/tex/base/BaseItems.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index 66d08f08e..11ef74097 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -933,8 +933,7 @@ export class ArrayItem extends BaseItem { } // @test Enclosed left right NodeUtil.setAttribute(mml, 'frame', ''); - mml = this.create('node', 'menclose', [mml], - {notation: this.frame.join(' '), isFrame: true}); + mml = this.create('node', 'menclose', [mml], {notation: this.frame.join(' ')}); if ((this.arraydef['columnlines'] || 'none') !== 'none' || (this.arraydef['rowlines'] || 'none') !== 'none') { // @test Enclosed dashed row, Enclosed solid row From 325f48c22af315a895733bc4d105ca2e6880dc19 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 18 May 2021 15:47:43 -0400 Subject: [PATCH 062/142] Optional overlaps are just for \columncolor --- ts/input/tex/colortbl/ColortblConfiguration.ts | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/ts/input/tex/colortbl/ColortblConfiguration.ts b/ts/input/tex/colortbl/ColortblConfiguration.ts index 8a79c0a18..60251fbd2 100644 --- a/ts/input/tex/colortbl/ColortblConfiguration.ts +++ b/ts/input/tex/colortbl/ColortblConfiguration.ts @@ -91,19 +91,13 @@ new CommandMap('colortbl', { * @param {keyof ColorData} type The type (col, row, cell) of color being added */ TableColor(parser: TexParser, name: string, type: keyof ColorData) { - const top = parser.stack.Top() as ColorArrayItem; + const lookup = parser.configuration.packageData.get('color').model; // use the color extension's color model const model = parser.GetBrackets(name, ''); - const lookup = parser.configuration.packageData.get('color').model; const color = lookup.getColor(model, parser.GetArgument(name)); // - // Ignore the left and right overlap options. - // - if (parser.GetBrackets(name, '')) { - parser.GetBrackets(name, ''); - } - // // Check that we are in a colorable array. // + const top = parser.stack.Top() as ColorArrayItem; if (!(top instanceof ColorArrayItem)) { throw new TexError('UnsupportedTableColor', 'Unsupported use of %1', parser.currentCS); } @@ -115,6 +109,12 @@ new CommandMap('colortbl', { throw new TexError('ColumnColorNotTop', '%1 must be in the top row', name); } top.color.col[top.row.length] = color; + // + // Ignore the left and right overlap options. + // + if (parser.GetBrackets(name, '')) { + parser.GetBrackets(name, ''); + } } else { top.color[type] = color; if (type === 'row' && (top.Size() || top.row.length)) { From 09f7b450e6b97ed31f29325f19313dce3b701bf6 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 10:57:59 -0400 Subject: [PATCH 063/142] Allow control over indentalign --- ts/input/tex.ts | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/ts/input/tex.ts b/ts/input/tex.ts index 2867eb1d7..e0b7c1ec9 100644 --- a/ts/input/tex.ts +++ b/ts/input/tex.ts @@ -181,11 +181,13 @@ export class TeX extends AbstractInputJax { this.latex = math.math; let node: MmlNode; this.parseOptions.tags.startEquation(math); + let global; try { let parser = new TexParser(this.latex, {display: display, isInner: false}, this.parseOptions); node = parser.mml(); + global = parser.stack.global; } catch (err) { if (!(err instanceof TexError)) { throw err; @@ -194,6 +196,9 @@ export class TeX extends AbstractInputJax { node = this.options.formatError(this, err); } node = this.parseOptions.nodeFactory.create('node', 'math', [node]); + if (global && global.indentalign) { + NodeUtil.setAttribute(node, 'indentalign', global.indentalign); + } if (display) { NodeUtil.setAttribute(node, 'display', 'block'); } From 1d182d01c4795f9e2f67ee257f7f3a527d34c2df Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 11:00:13 -0400 Subject: [PATCH 064/142] Move multline options to ams and use full width with an indent, add support for labels inside width of table (needed for multline and flalign), fix problem with SVG percentage widths, fix problem with CHTML 0-width labels. --- ts/input/tex/Tags.ts | 2 -- ts/input/tex/ams/AmsConfiguration.ts | 6 +++++- ts/input/tex/ams/AmsMethods.ts | 6 +++++- ts/output/chtml/Wrappers/mpadded.ts | 2 +- ts/output/chtml/Wrappers/mtable.ts | 10 ++++++---- ts/output/common/Wrappers/mtable.ts | 7 ++++--- 6 files changed, 21 insertions(+), 12 deletions(-) diff --git a/ts/input/tex/Tags.ts b/ts/input/tex/Tags.ts index 702b90b9d..16f088a14 100644 --- a/ts/input/tex/Tags.ts +++ b/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 diff --git a/ts/input/tex/ams/AmsConfiguration.ts b/ts/input/tex/ams/AmsConfiguration.ts index cbb2a74d4..e172f1cbc 100644 --- a/ts/input/tex/ams/AmsConfiguration.ts +++ b/ts/input/tex/ams/AmsConfiguration.ts @@ -59,7 +59,11 @@ export const AmsConfiguration = Configuration.create( }, items: {[MultlineItem.prototype.kind]: MultlineItem}, tags: {'ams': AmsTags}, - init: init + init: init, + options: { + multlineWidth: '100%', // The width to use for multline environments. + multlineIndent: '1em', // The margin to use on both sides of multline environments. + } } ); diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index 4c275307c..7cf28b443 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -121,8 +121,12 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b columnwidth: '100%', width: parser.options['multlineWidth'], side: parser.options['tagSide'], - minlabelspacing: parser.options['tagIndent'] + minlabelspacing: parser.options['tagIndent'], + framespacing: parser.options['multlineIndent'] + ' 0', + frame: '', // Use frame spacing with no actual frame + 'data-width-includes-label': true // take label space out of 100% width }; + parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); return item; }; diff --git a/ts/output/chtml/Wrappers/mpadded.ts b/ts/output/chtml/Wrappers/mpadded.ts index b949cb1f5..0d1b8b6b8 100644 --- a/ts/output/chtml/Wrappers/mpadded.ts +++ b/ts/output/chtml/Wrappers/mpadded.ts @@ -82,7 +82,7 @@ CommonMpaddedMixin>(CHTMLWrapper) { // if (x + dx || y) { style.position = 'relative'; - const rbox = this.html('mjx-rbox', {style: {left: this.em(x + dx), top: this.em(-y)}}); + const rbox = this.html('mjx-rbox', {style: {left: this.em(x + dx), top: this.em(-y), width: style.width}}); if (x + dx && this.childNodes[0].getBBox().pwidth) { this.adaptor.setAttribute(rbox, 'width', 'full'); this.adaptor.setStyle(rbox, 'left', this.em(x)); diff --git a/ts/output/chtml/Wrappers/mtable.ts b/ts/output/chtml/Wrappers/mtable.ts index 6316e5f63..1a69d41e4 100644 --- a/ts/output/chtml/Wrappers/mtable.ts +++ b/ts/output/chtml/Wrappers/mtable.ts @@ -70,7 +70,8 @@ CommonMtableMixin, CHTMLmtr, CHTMLConstru }, 'mjx-table': { 'display': 'inline-block', - 'vertical-align': '-.5ex' + 'vertical-align': '-.5ex', + 'box-sizing': 'border-box' }, 'mjx-table > mjx-itable': { 'vertical-align': 'middle', @@ -441,10 +442,11 @@ CommonMtableMixin, CHTMLmtr, CHTMLConstru adaptor.setStyle(table, 'minWidth', this.em(w)); if (L || R) { adaptor.setStyle(this.chtml, 'margin', ''); + const style = (this.node.attributes.get('data-width-includes-label') ? 'padding' : 'margin'); if (L === R) { - adaptor.setStyle(table, 'margin', '0 ' + this.em(R)); + adaptor.setStyle(table, style, '0 ' + this.em(R)); } else { - adaptor.setStyle(table, 'margin', '0 ' + this.em(R) + ' 0 ' + this.em(L)); + adaptor.setStyle(table, style, '0 ' + this.em(R) + ' 0 ' + this.em(L)); } } adaptor.setAttribute(this.itable, 'width', 'full'); @@ -518,7 +520,7 @@ CommonMtableMixin, CHTMLmtr, CHTMLConstru protected addLabelPadding(side: string): [string, number] { const [ , align, shift] = this.getPadAlignShift(side); const styles: OptionList = {}; - if (side === 'right') { + if (side === 'right' && !this.node.attributes.get('data-width-includes-label')) { const W = this.node.attributes.get('width') as string; const {w, L, R} = this.getBBox(); styles.style = { diff --git a/ts/output/common/Wrappers/mtable.ts b/ts/output/common/Wrappers/mtable.ts index 174c0a387..707e2e48b 100644 --- a/ts/output/common/Wrappers/mtable.ts +++ b/ts/output/common/Wrappers/mtable.ts @@ -738,7 +738,8 @@ export function CommonMtableMixin< this.container.bbox.pwidth = ''; } const {w, L, R} = this.bbox; - const W = Math.max(w, this.length2em(width, Math.max(cwidth, L + w + R))); + const labelInWidth = this.node.attributes.get('data-width-includes-label') as boolean; + const W = Math.max(w, this.length2em(width, Math.max(cwidth, L + w + R))) - (labelInWidth ? L + R : 0); const cols = (this.node.attributes.get('equalcolumns') as boolean ? Array(this.numCols).fill(this.percent(1 / Math.max(1, this.numCols))) : this.getColumnAttributes('columnwidth', 0)); @@ -933,7 +934,7 @@ export function CommonMtableMixin< } /** - * For tables with percentage widths, let 'fit' columns (or 'auto' + * For tables with percentage widths, the 'fit' columns (or 'auto' * columns if there are not 'fit' ones) will stretch automatically, * but for 'auto' columns (when there are 'fit' ones), set the size * to the natural size of the column. @@ -979,7 +980,7 @@ export function CommonMtableMixin< let dw = cwidth; indices.forEach(i => { const x = swidths[i]; - dw -= (x === 'fit' || x === 'auto' ? W[i] : this.length2em(x, width)); + dw -= (x === 'fit' || x === 'auto' ? W[i] : this.length2em(x, cwidth)); }); // // Get the amount of extra space per column, or 0 (fw) From dca9394334b3b2b91f13816ba74c8e66584f85d9 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 12:20:26 -0400 Subject: [PATCH 065/142] Use max-width for CHTML mpadded fix to avoid extra width if width is increated --- ts/output/chtml/Wrappers/mpadded.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ts/output/chtml/Wrappers/mpadded.ts b/ts/output/chtml/Wrappers/mpadded.ts index 0d1b8b6b8..08c0aad6b 100644 --- a/ts/output/chtml/Wrappers/mpadded.ts +++ b/ts/output/chtml/Wrappers/mpadded.ts @@ -82,7 +82,9 @@ CommonMpaddedMixin>(CHTMLWrapper) { // if (x + dx || y) { style.position = 'relative'; - const rbox = this.html('mjx-rbox', {style: {left: this.em(x + dx), top: this.em(-y), width: style.width}}); + const rbox = this.html('mjx-rbox', { + style: {left: this.em(x + dx), top: this.em(-y), 'max-width': style.width} + }); if (x + dx && this.childNodes[0].getBBox().pwidth) { this.adaptor.setAttribute(rbox, 'width', 'full'); this.adaptor.setStyle(rbox, 'left', this.em(x)); From 4b6a2db1f99c6752a4f04b25c38ebd298fde697c Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 12:20:45 -0400 Subject: [PATCH 066/142] Add flalign, xalign, and xxalign environments --- ts/input/tex/ams/AmsConfiguration.ts | 7 +- ts/input/tex/ams/AmsItems.ts | 103 ++++++++++++++++++++++++++- ts/input/tex/ams/AmsMappings.ts | 8 +++ ts/input/tex/ams/AmsMethods.ts | 78 ++++++++++++++++++++ 4 files changed, 193 insertions(+), 3 deletions(-) diff --git a/ts/input/tex/ams/AmsConfiguration.ts b/ts/input/tex/ams/AmsConfiguration.ts index e172f1cbc..2f7039d6b 100644 --- a/ts/input/tex/ams/AmsConfiguration.ts +++ b/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,7 +57,10 @@ 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, options: { diff --git a/ts/input/tex/ams/AmsItems.ts b/ts/input/tex/ams/AmsItems.ts index cbdd3cc52..d976bd4f2 100644 --- a/ts/input/tex/ams/AmsItems.ts +++ b/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,103 @@ export class MultlineItem extends ArrayItem { this.factory.configuration.tags.end(); } } + +/** + * StackItem for handling flalign, xalignat, and xxalignat environments. + */ +export class FlalignItem extends EqnArrayItem { + + /** + * Maximum row number in the array. + * @type {number} + */ + public maxrow: number = 0; + + /** + * @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 EndRow() { + let cell: MmlNode; + let row = this.row; + this.row = []; + // + // Insert padding cells between pairs of entries, as needed for "fit" columns, + // and include initial and end cells if that is needed + // + 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-0width 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) { + let def = this.arraydef; + // + // If there is only one equation (one pair): + // Don't make it 100%, and don't change the indentalign + // + if (this.maxrow <= 2) { + delete def.width; + delete this.global.indentalign; + } + // + // Remove any unwanted column alignments and widths + // + def.columnalign = (def.columnalign as string) + .split(/ /) + .slice(0, this.maxrow) + .join(' '); + def.columnwidth = (def.columnwidth as string) + .split(/ /) + .slice(0, this.maxrow) + .join(' '); + } + } + +} diff --git a/ts/input/tex/ams/AmsMappings.ts b/ts/input/tex/ams/AmsMappings.ts index fc7678659..f7501fa16 100644 --- a/ts/input/tex/ams/AmsMappings.ts +++ b/ts/input/tex/ams/AmsMappings.ts @@ -127,6 +127,14 @@ new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, { COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0]), '.5em', 'D'], gathered: ['AmsEqnArray', null, null, null, 'c', null, '.5em', 'D'], + xalignat: ['XalignAt', null, true, true], + 'xalignat*': ['XalignAt', null, false, true], + xxalignat: ['XalignAt', null, false, false], + flalign: ['FlalignArray', null, true, false, true, 'rlcrlcrlcrlcrlcrlc', + ['', ' ', ' ', ' ', ' ', ' ', ''].join('auto auto fit')], + 'flalign*': ['FlalignArray', null, false, false, true, 'rlcrlcrlcrlcrlcrlc', + ['', ' ', ' ', ' ', ' ', ' ', ''].join('auto auto fit')], + subarray: ['Array', null, null, null, null, COLS([0]), '0.1em', 'S', 1], smallmatrix: ['Array', null, null, null, 'c', COLS([1 / 3]), '.2em', 'S', 1], diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index 7cf28b443..ade43ded5 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/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'; @@ -131,6 +132,83 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b }; +/** + * 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 arg = parser.GetArgument('\\begin{' + begin.getName() + '}'); + if (arg.match(/[^0-9]/)) { + throw new TexError('PositiveIntegerArg', + 'Argument to %1 must me a positive integer', + '\\begin{' + begin.getName() + '}'); + } + let n = parseInt(arg, 10); + let align = []; + let width = []; + if (padded) { + align.push(''); + width.push(''); + } + while (n > 0) { + align.push('rl'); + width.push('auto auto'); + n--; + } + if (padded) { + align.push(''); + width.push(''); + } + return AmsMethods.FlalignArray( + parser, begin, numbered, padded, false, align.join('c'), width.join(' fit '), true); +}; + + +/** + * 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); + parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); + return item; +}; + + export const NEW_OPS = 'ams-declare-ops'; /** From 8bca1e47ae09001ea38dd2b0ec85057c2d8b1bd1 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 12:54:13 -0400 Subject: [PATCH 067/142] Move COLS() to ParseUtil, use the em() from util/lengths, and move equation* to ams from base --- ts/input/tex/ParseUtil.ts | 18 +++++++++++++----- ts/input/tex/ams/AmsMappings.ts | 26 +++++++++----------------- ts/input/tex/ams/AmsMethods.ts | 2 ++ ts/input/tex/base/BaseMappings.ts | 4 ++-- 4 files changed, 26 insertions(+), 24 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 9ec8ecc15..1f861e3fe 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/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(' '); } diff --git a/ts/input/tex/ams/AmsMappings.ts b/ts/input/tex/ams/AmsMappings.ts index f7501fa16..fea8e260c 100644 --- a/ts/input/tex/ams/AmsMappings.ts +++ b/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,15 +98,16 @@ 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'], + ParseUtil.cols(0, MATHSPACE.thickmathspace), '.5em'], align: ['EqnArray', null, true, true, 'rlrlrlrlrlrl', - COLS([0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0])], + ParseUtil.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, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0)], 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'], @@ -124,7 +116,7 @@ new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, { 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'], + ParseUtil.cols(0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0), '.5em', 'D'], gathered: ['AmsEqnArray', null, null, null, 'c', null, '.5em', 'D'], xalignat: ['XalignAt', null, true, true], @@ -135,8 +127,8 @@ new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, { 'flalign*': ['FlalignArray', null, false, false, true, 'rlcrlcrlcrlcrlcrlc', ['', ' ', ' ', ' ', ' ', ' ', ''].join('auto auto fit')], - subarray: ['Array', null, null, null, null, COLS([0]), '0.1em', 'S', 1], - smallmatrix: ['Array', null, null, null, 'c', COLS([1 / 3]), + 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'], diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index ade43ded5..ad8b0e39c 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -487,3 +487,5 @@ AmsMethods.Spacer = BaseMethods.Spacer; AmsMethods.NamedOp = BaseMethods.NamedOp; AmsMethods.EqnArray = BaseMethods.EqnArray; + +AmsMethods.Equation = BaseMethods.Equation; diff --git a/ts/input/tex/base/BaseMappings.ts b/ts/input/tex/base/BaseMappings.ts index 405cbdcdd..1460f12d1 100644 --- a/ts/input/tex/base/BaseMappings.ts +++ b/ts/input/tex/base/BaseMappings.ts @@ -26,6 +26,7 @@ import * as sm from '../SymbolMap.js'; import {TexConstant} from '../TexConstants.js'; import BaseMethods from './BaseMethods.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'; @@ -697,9 +698,8 @@ new sm.CommandMap('macros', { new sm.EnvironmentMap('environment', ParseMethods.environment, { array: ['AlignedArray'], equation: ['Equation', null, true], - 'equation*': ['Equation', null, false], eqnarray: ['EqnArray', null, true, true, 'rcl', - '0 ' + em(MATHSPACE.thickmathspace), '.5em'] + ParseUtil.cols(0, MATHSPACE.thickmathspace), '.5em'] }, BaseMethods); From 8a6ffe9ae86f1fd6ebc316f6e3928ecf3f32498b Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 14:38:37 -0400 Subject: [PATCH 068/142] Make EqnArrayItem pad the column align/spacing/width strings by repeating the intial values as needed, and trim them to the right size. Make xalignat error if there are too many columns, and pad out to the proper number if not enough. --- ts/input/tex/ams/AmsItems.ts | 50 +++++++++++++++++---------------- ts/input/tex/ams/AmsMappings.ts | 15 ++++------ ts/input/tex/ams/AmsMethods.ts | 29 ++++++------------- ts/input/tex/base/BaseItems.ts | 32 ++++++++++++++++++++- 4 files changed, 70 insertions(+), 56 deletions(-) diff --git a/ts/input/tex/ams/AmsItems.ts b/ts/input/tex/ams/AmsItems.ts index d976bd4f2..22324c3d5 100644 --- a/ts/input/tex/ams/AmsItems.ts +++ b/ts/input/tex/ams/AmsItems.ts @@ -124,12 +124,6 @@ export class MultlineItem extends ArrayItem { */ export class FlalignItem extends EqnArrayItem { - /** - * Maximum row number in the array. - * @type {number} - */ - public maxrow: number = 0; - /** * @override */ @@ -147,6 +141,18 @@ export class FlalignItem extends EqnArrayItem { 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 @@ -154,11 +160,18 @@ export class FlalignItem extends EqnArrayItem { public EndRow() { let cell: MmlNode; let row = this.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 + // and include initial and end cells if that is needed. // + this.row = []; if (this.padded) { this.row.push(this.create('node', 'mtd')); } @@ -174,8 +187,8 @@ export class FlalignItem extends EqnArrayItem { if (this.row.length > this.maxrow) this.maxrow = this.row.length; super.EndRow(); // - // For full-0width 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 + // 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')) { @@ -194,27 +207,16 @@ export class FlalignItem extends EqnArrayItem { public EndTable() { super.EndTable(); if (this.center) { - let def = this.arraydef; // // If there is only one equation (one pair): - // Don't make it 100%, and don't change the indentalign + // 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; } - // - // Remove any unwanted column alignments and widths - // - def.columnalign = (def.columnalign as string) - .split(/ /) - .slice(0, this.maxrow) - .join(' '); - def.columnwidth = (def.columnwidth as string) - .split(/ /) - .slice(0, this.maxrow) - .join(' '); - } + } } } diff --git a/ts/input/tex/ams/AmsMappings.ts b/ts/input/tex/ams/AmsMappings.ts index fea8e260c..4dc57980e 100644 --- a/ts/input/tex/ams/AmsMappings.ts +++ b/ts/input/tex/ams/AmsMappings.ts @@ -101,10 +101,8 @@ new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, { 'equation*': ['Equation', null, false], 'eqnarray*': ['EqnArray', null, false, true, 'rcl', ParseUtil.cols(0, MATHSPACE.thickmathspace), '.5em'], - align: ['EqnArray', null, true, true, 'rlrlrlrlrlrl', - ParseUtil.cols(0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0)], - 'align*': ['EqnArray', null, false, true, 'rlrlrlrlrlrl', - ParseUtil.cols(0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 0)], + 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', ParseUtil.cols(0)], @@ -115,17 +113,14 @@ new sm.EnvironmentMap('AMSmath-environment', ParseMethods.environment, { 'alignat*': ['AlignAt', null, false, true], alignedat: ['AlignAt', null, false, false], - aligned: ['AmsEqnArray', null, null, null, 'rlrlrlrlrlrl', - ParseUtil.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'], xalignat: ['XalignAt', null, true, true], 'xalignat*': ['XalignAt', null, false, true], xxalignat: ['XalignAt', null, false, false], - flalign: ['FlalignArray', null, true, false, true, 'rlcrlcrlcrlcrlcrlc', - ['', ' ', ' ', ' ', ' ', ' ', ''].join('auto auto fit')], - 'flalign*': ['FlalignArray', null, false, false, true, 'rlcrlcrlcrlcrlcrlc', - ['', ' ', ' ', ' ', ' ', ' ', ''].join('auto auto fit')], + 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), diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index ad8b0e39c..8454c5b3a 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -119,7 +119,7 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b item.arraydef = { displaystyle: true, rowspacing: '.5em', - columnwidth: '100%', + columnspacing: '100%', width: parser.options['multlineWidth'], side: parser.options['tagSide'], minlabelspacing: parser.options['tagIndent'], @@ -141,30 +141,17 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b */ AmsMethods.XalignAt = function(parser: TexParser, begin: StackItem, numbered: boolean, padded: boolean) { - let arg = parser.GetArgument('\\begin{' + begin.getName() + '}'); - if (arg.match(/[^0-9]/)) { + 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() + '}'); } - let n = parseInt(arg, 10); - let align = []; - let width = []; - if (padded) { - align.push(''); - width.push(''); - } - while (n > 0) { - align.push('rl'); - width.push('auto auto'); - n--; - } - if (padded) { - align.push(''); - width.push(''); - } - return AmsMethods.FlalignArray( - parser, begin, numbered, padded, false, align.join('c'), width.join(' fit '), true); + 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; }; diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index f4f8ba42c..abb4257bf 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -36,7 +36,6 @@ import StackItemFactory from '../StackItemFactory.js'; import {CheckType, BaseItem, StackItem, EnvList} from '../StackItem.js'; - /** * Initial item on the stack. It's pushed when parsing begins. */ @@ -1027,6 +1026,11 @@ export class ArrayItem extends BaseItem { */ export class EqnArrayItem extends ArrayItem { + /** + * The length of the longest row. + */ + public maxrow: number = 0; + /** * @override */ @@ -1061,6 +1065,9 @@ export class EqnArrayItem extends ArrayItem { * @override */ public EndRow() { + if (this.row.length > this.maxrow) { + this.maxrow = this.row.length; + } // @test Cubic Binomial let mtr = 'mtr'; let tag = this.factory.configuration.tags.getTag(); @@ -1081,6 +1088,29 @@ export class EqnArrayItem extends ArrayItem { // @test Cubic Binomial super.EndTable(); this.factory.configuration.tags.end(); + // + // Repeat the column align and width specifications + // to match the number of columns + // + this.extendArray('columnalign', this.maxrow); + this.extendArray('columnwidth', this.maxrow); + this.extendArray('columnspacing', this.maxrow - 1); + } + + /** + * Extend a column specification to include a repeating set of values + * so that it has enough to match the maximum row length. + */ + protected extendArray(name: string, max: number) { + if (!this.arraydef[name]) return; + const repeat = (this.arraydef[name] as string).split(/ /); + const columns = [...repeat]; + if (columns.length > 1) { + while (columns.length < max) { + columns.push(...repeat); + } + this.arraydef[name] = columns.slice(0, max).join(' '); + } } } From 185f8a82d7fa26e3922cc76adfeeb9252c48aced Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 21 May 2021 20:03:52 -0400 Subject: [PATCH 069/142] Add \overunderset, \stackbin --- ts/input/tex/base/BaseMappings.ts | 2 ++ ts/input/tex/base/BaseMethods.ts | 15 +++++++++++++++ 2 files changed, 17 insertions(+) diff --git a/ts/input/tex/base/BaseMappings.ts b/ts/input/tex/base/BaseMappings.ts index 1460f12d1..6759af338 100644 --- a/ts/input/tex/base/BaseMappings.ts +++ b/ts/input/tex/base/BaseMappings.ts @@ -524,7 +524,9 @@ new sm.CommandMap('macros', { overset: 'Overset', underset: 'Underset', + overunderset: 'Overunderset', stackrel: ['Macro', '\\mathrel{\\mathop{#2}\\limits^{#1}}', 2], + stackbin: ['Macro', '\\mathbin{\\mathop{#2}\\limits^{#1}}', 2], over: 'Over', overwithdelims: 'Over', diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 3339a3230..25ef5ce2b 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -675,6 +675,21 @@ BaseMethods.Underset = function(parser: TexParser, name: string) { }; +/** + * Handles overunderset. + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ +BaseMethods.Overunderset = function(parser: TexParser, name: string) { + const top = parser.ParseArg(name), bot = parser.ParseArg(name), base = parser.ParseArg(name); + if (NodeUtil.isType(base, 'mo') || NodeUtil.getProperty(base, 'movablelimits')) { + NodeUtil.setProperties(base, {'movablelimits': false}); + } + const node = parser.create('node', 'munderover', [base, bot, top]); + parser.Push(node); +}; + + /** * Creates TeXAtom, when class of element is changed explicitly. * @param {TexParser} parser The calling parser. From 15e4d13627d42bc3f46480f292f22d1a6223c655 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Sat, 22 May 2021 13:19:05 -0400 Subject: [PATCH 070/142] Add \noscript command --- ts/input/tex/base/BaseConfiguration.ts | 54 +++++++++++++++++++++----- ts/input/tex/base/BaseItems.ts | 39 +++++++++++++++++++ ts/input/tex/base/BaseMappings.ts | 1 + ts/input/tex/base/BaseMethods.ts | 10 +++++ 4 files changed, 94 insertions(+), 10 deletions(-) diff --git a/ts/input/tex/base/BaseConfiguration.ts b/ts/input/tex/base/BaseConfiguration.ts index 4a90aa58a..6dbc404c3 100644 --- a/ts/input/tex/base/BaseConfiguration.ts +++ b/ts/input/tex/base/BaseConfiguration.ts @@ -32,6 +32,8 @@ import * as bitem from './BaseItems.js'; import {AbstractTags} from '../Tags.js'; import './BaseMappings.js'; import {getRange} from '../../../core/MmlTree/OperatorDictionary.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; +import ParseOptions from '../ParseOptions.js'; /** * Remapping some ASCII characters to their Unicode operator equivalent. @@ -89,6 +91,36 @@ function envUndefined(_parser: TexParser, env: string) { throw new TexError('UnknownEnv', 'Unknown environment \'%1\'', env); } +/** + * Filter for removing spacing following \nonscript + * @param{ParseOptions} data The active tex parser. + */ +function filterNonscript({data}: {data: ParseOptions}) { + for (const mml of data.getList('nonscript')) { + // + // If we are in script or script-script style + // remove the space (either mspace or mrow containing it) + // and remove it (and its contents) from the other lists. + // Otherwise, if it is an mrow (which we added), + // replace the mrow with its contents + // and remove it from its list + // + if (mml.attributes.get('scriptlevel') > 0) { + const parent = mml.parent; + parent.childNodes.splice(parent.childIndex(mml), 1); + data.removeFromList(mml.kind, [mml]); + if (mml.isKind('mrow')) { + const mstyle = mml.childNodes[0] as MmlNode; + data.removeFromList('mstyle', [mstyle]); + data.removeFromList('mspace', mstyle.childNodes[0].childNodes as MmlNode[]); + } + } else if (mml.isKind('mrow')) { + mml.parent.replaceChild(mml.childNodes[0], mml); + data.removeFromList('mrow', [mml]); + } + } +} + /** * @constructor @@ -135,19 +167,21 @@ export const BaseConfiguration: Configuration = Configuration.create( [bitem.MmlItem.prototype.kind]: bitem.MmlItem, [bitem.FnItem.prototype.kind]: bitem.FnItem, [bitem.NotItem.prototype.kind]: bitem.NotItem, + [bitem.NonscriptItem.prototype.kind]: bitem.NonscriptItem, [bitem.DotsItem.prototype.kind]: bitem.DotsItem, [bitem.ArrayItem.prototype.kind]: bitem.ArrayItem, [bitem.EqnArrayItem.prototype.kind]: bitem.EqnArrayItem, [bitem.EquationItem.prototype.kind]: bitem.EquationItem - }, - options: { - maxMacros: 1000, - baseURL: (typeof(document) === 'undefined' || - document.getElementsByTagName('base').length === 0) ? - '' : String(document.location).replace(/#.*$/, '') - }, - tags: { - base: BaseTags - } + }, + options: { + maxMacros: 1000, + baseURL: (typeof(document) === 'undefined' || + document.getElementsByTagName('base').length === 0) ? + '' : String(document.location).replace(/#.*$/, '') + }, + tags: { + base: BaseTags + }, + postprocessors: [[filterNonscript, -4]] } ); diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index f4f8ba42c..8b0b720b1 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -774,6 +774,45 @@ export class NotItem extends BaseItem { } } +export class NonscriptItem extends BaseItem { + + /** + * @override + */ + public get kind() { + return 'nonscript'; + } + + /** + * @override + */ + public checkItem(item: StackItem): CheckType { + if (item.isKind('mml') && item.Size() === 1) { + let mml = item.First; + // + // Space macros like \, wrap with an mstyle to set scriptlevel=0 (so size is independent of level) + // + if (mml.isKind('mstyle') && mml.notParent) { + mml = NodeUtil.getChildren(NodeUtil.getChildren(mml)[0])[0]; + } + if (mml.isKind('mspace')) { + // + // If the space is in an mstyle, wrap it in an mrow so we can test is scriptlevel. + // The mrow will be removed in the post-filter. + // + if (mml !== item.First) { + mml = this.create('node', 'mrow', [item.Pop()]); + item.Push(mml); + } + // + // Save the item for alter post-processing + // + this.factory.configuration.addNode('nonscript', item.First); + } + } + return [[item], true]; + } +} /** * Item indicating a dots command has been encountered. diff --git a/ts/input/tex/base/BaseMappings.ts b/ts/input/tex/base/BaseMappings.ts index 405cbdcdd..612aa2f39 100644 --- a/ts/input/tex/base/BaseMappings.ts +++ b/ts/input/tex/base/BaseMappings.ts @@ -572,6 +572,7 @@ new sm.CommandMap('macros', { rule: 'rule', Rule: ['Rule'], Space: ['Rule', 'blank'], + nonscript: 'Nonscript', big: ['MakeBig', TEXCLASS.ORD, 0.85], Big: ['MakeBig', TEXCLASS.ORD, 1.15], diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 3339a3230..17f448e9f 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -903,6 +903,16 @@ BaseMethods.Hskip = function(parser: TexParser, name: string) { }; +/** + * Handle removal of spaces in script modes + * @param {TexParser} parser The calling parser. + * @param {string} name The macro name. + */ +BaseMethods.Nonscript = function(parser: TexParser, _name: string) { + parser.Push(parser.itemFactory.create('nonscript')); +}; + + /** * Handle Rule and Space command * @param {TexParser} parser The calling parser. From 36bcc89a272410a2c5b783ffd997f5737b323cdc Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 24 May 2021 11:46:22 -0400 Subject: [PATCH 071/142] Update comment, as requested. --- ts/input/tex/Configuration.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/input/tex/Configuration.ts b/ts/input/tex/Configuration.ts index 03eb6e8b6..f68f57c51 100644 --- a/ts/input/tex/Configuration.ts +++ b/ts/input/tex/Configuration.ts @@ -300,7 +300,7 @@ export class ParserConfiguration { * @constructor * @param {(string|[string,number])[]} packages A list of packages with * optional priorities. - * @parm {string[]} parsers The names of the parsers whose packages are supported + * @parm {string[]} parsers The names of the parsers this package targets */ constructor(packages: (string | [string, number])[], parsers: string[] = ['tex']) { this.parsers = parsers; From 4b7cbdc65f358114863044b2ff1fd25de26c9658 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 24 May 2021 11:53:01 -0400 Subject: [PATCH 072/142] Use ?. operation rather than && test, as per review --- ts/output/common/Wrapper.ts | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/ts/output/common/Wrapper.ts b/ts/output/common/Wrapper.ts index dd606acde..219c28844 100644 --- a/ts/output/common/Wrapper.ts +++ b/ts/output/common/Wrapper.ts @@ -375,12 +375,14 @@ export class CommonWrapper< */ protected copySkewIC(bbox: BBox) { const first = this.childNodes[0]; - if (first) { - first.bbox.sk && (bbox.sk = first.bbox.sk); - first.bbox.dx && (bbox.dx = first.bbox.dx); + if (first?.bbox.sk) { + bbox.sk = first.bbox.sk; + } + if (first?.bbox.dx) { + bbox.dx = first.bbox.dx; } const last = this.childNodes[this.childNodes.length - 1]; - if (last && last.bbox.ic) { + if (last?.bbox.ic) { bbox.ic = last.bbox.ic; bbox.w += bbox.ic; } From f618d09c0a663f0b871596c2d979e883b475d85c Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 24 May 2021 13:58:05 -0400 Subject: [PATCH 073/142] Fix issues raised by the review --- ts/input/tex.ts | 8 ++++---- ts/input/tex/ams/AmsItems.ts | 4 +++- ts/input/tex/base/BaseMethods.ts | 12 ++++++++---- 3 files changed, 15 insertions(+), 9 deletions(-) diff --git a/ts/input/tex.ts b/ts/input/tex.ts index e0b7c1ec9..bfb4d7837 100644 --- a/ts/input/tex.ts +++ b/ts/input/tex.ts @@ -181,13 +181,13 @@ export class TeX extends AbstractInputJax { this.latex = math.math; let node: MmlNode; this.parseOptions.tags.startEquation(math); - let global; + let globalEnv; try { let parser = new TexParser(this.latex, {display: display, isInner: false}, this.parseOptions); node = parser.mml(); - global = parser.stack.global; + globalEnv = parser.stack.global; } catch (err) { if (!(err instanceof TexError)) { throw err; @@ -196,8 +196,8 @@ export class TeX extends AbstractInputJax { node = this.options.formatError(this, err); } node = this.parseOptions.nodeFactory.create('node', 'math', [node]); - if (global && global.indentalign) { - NodeUtil.setAttribute(node, 'indentalign', global.indentalign); + if (globalEnv?.indentalign) { + NodeUtil.setAttribute(node, 'indentalign', globalEnv.indentalign); } if (display) { NodeUtil.setAttribute(node, 'display', 'block'); diff --git a/ts/input/tex/ams/AmsItems.ts b/ts/input/tex/ams/AmsItems.ts index 22324c3d5..595a33b4a 100644 --- a/ts/input/tex/ams/AmsItems.ts +++ b/ts/input/tex/ams/AmsItems.ts @@ -184,7 +184,9 @@ export class FlalignItem extends EqnArrayItem { } } // - if (this.row.length > this.maxrow) this.maxrow = this.row.length; + 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, diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 25ef5ce2b..575afe830 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -649,7 +649,8 @@ BaseMethods.UnderOver = function(parser: TexParser, name: string, c: string, sta */ BaseMethods.Overset = function(parser: TexParser, name: string) { // @test Overset - const top = parser.ParseArg(name), base = parser.ParseArg(name); + const top = parser.ParseArg(name); + const base = parser.ParseArg(name); if (NodeUtil.getAttribute(base, 'movablelimits') || NodeUtil.getProperty(base, 'movablelimits')) { NodeUtil.setProperties(base, {'movablelimits': false}); } @@ -659,13 +660,14 @@ BaseMethods.Overset = function(parser: TexParser, name: string) { /** - * Handles overset. + * Handles underset. * @param {TexParser} parser The calling parser. * @param {string} name The macro name. */ BaseMethods.Underset = function(parser: TexParser, name: string) { // @test Underset - const bot = parser.ParseArg(name), base = parser.ParseArg(name); + const bot = parser.ParseArg(name); + const base = parser.ParseArg(name); if (NodeUtil.isType(base, 'mo') || NodeUtil.getProperty(base, 'movablelimits')) { // @test Overline Sum NodeUtil.setProperties(base, {'movablelimits': false}); @@ -681,7 +683,9 @@ BaseMethods.Underset = function(parser: TexParser, name: string) { * @param {string} name The macro name. */ BaseMethods.Overunderset = function(parser: TexParser, name: string) { - const top = parser.ParseArg(name), bot = parser.ParseArg(name), base = parser.ParseArg(name); + const top = parser.ParseArg(name); + const bot = parser.ParseArg(name); + const base = parser.ParseArg(name); if (NodeUtil.isType(base, 'mo') || NodeUtil.getProperty(base, 'movablelimits')) { NodeUtil.setProperties(base, {'movablelimits': false}); } From d39279e2679c665de50345642d0019ca3b60dd4f Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 24 May 2021 18:58:59 -0400 Subject: [PATCH 074/142] Make changes requested by PR review --- ts/ui/lazy/LazyHandler.ts | 85 ++++++++++++++++++++++----------------- 1 file changed, 48 insertions(+), 37 deletions(-) diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts index f12f53ce5..9596d1dcc 100644 --- a/ts/ui/lazy/LazyHandler.ts +++ b/ts/ui/lazy/LazyHandler.ts @@ -126,11 +126,6 @@ export interface LazyMathItem extends MathItem { */ lazyMarker: N; - /** - * The state to use when rerednering the math item (COMPILED vs TYPESET) - */ - lazyState: number; - /** * True if this item is a TeX MathItem */ @@ -139,7 +134,7 @@ export interface LazyMathItem extends MathItem { } /** - * The mixin for adding laxy typesetting to MathItems + * The mixin for adding lazy typesetting to MathItems * * @param {B} BaseMathItem The MathItem class to be extended * @return {AssistiveMathItem} The augmented MathItem class @@ -155,10 +150,27 @@ export function LazyMathItemMixin) { - if (this.lazyCompile) { - if (this.state() < STATE.COMPILED) { - this.lazyTex = (this.inputJax.name === 'TeX'); - this.root = document.mmlFactory.create('math'); - this.state(STATE.COMPILED); - } - } else { + if (!this.lazyCompile) { super.compile(document); - this.lazyState = STATE.TYPESET; + return; + } + if (this.state() < STATE.COMPILED) { + this.lazyTex = (this.inputJax.name === 'TeX'); + this.root = document.mmlFactory.create('math'); + this.state(STATE.COMPILED); } } @@ -190,18 +201,18 @@ export function LazyMathItemMixin) { - if (this.lazyTypeset) { - if (this.state() < STATE.TYPESET) { - const adaptor = document.adaptor; - if (!this.lazyMarker) { - const id = document.lazyList.add(this); - this.lazyMarker = adaptor.node('mjx-lazy', {[LAZYID]: id}); - this.typesetRoot = adaptor.node('mjx-container', {}, [this.lazyMarker]); - } - this.state(STATE.TYPESET); - } - } else { + if (!this.lazyTypeset) { super.typeset(document); + return; + } + if (this.state() < STATE.TYPESET) { + const adaptor = document.adaptor; + if (!this.lazyMarker) { + const id = document.lazyList.add(this); + this.lazyMarker = adaptor.node('mjx-lazy', {[LAZYID]: id}); + this.typesetRoot = adaptor.node('mjx-container', {}, [this.lazyMarker]); + } + this.state(STATE.TYPESET); } } @@ -327,7 +338,7 @@ B extends MathDocumentConstructor>>( /** * The function used by the IntersectionObserver to monitor the markers coming into view. - * When one (or more) does, add it to or remove it from the set to be processed, and + * When one (or more) does, add its math item to or remove it from the set to be processed, and * if added to the set, queue an idle task, if one isn't already pending. * * @param {IntersectionObserverEntry[]} entries The markers that have come into or out of view. @@ -336,15 +347,15 @@ B extends MathDocumentConstructor>>( for (const entry of entries) { const id = this.adaptor.getAttribute(entry.target as any as N, LAZYID); const math = this.lazyList.get(id); - if (!math) return; - if (entry.isIntersecting) { - this.lazySet.add(id); - if (!this.lazyIdle) { - this.lazyIdle = true; - this.lazyProcessSet(); - } - } else { + if (!math) continue; + if (!entry.isIntersecting) { this.lazySet.delete(id); + continue; + } + this.lazySet.add(id); + if (!this.lazyIdle) { + this.lazyIdle = true; + this.lazyProcessSet(); } } } @@ -460,7 +471,7 @@ B extends MathDocumentConstructor>>( /*==========================================================================*/ /** - * Add lazy typesetting support a Handler instance + * Add lazy typesetting support to a Handler instance * * @param {Handler} handler The Handler instance to enhance * @return {Handler} The handler that was modified (for purposes of chaining extensions) @@ -471,7 +482,7 @@ B extends MathDocumentConstructor>>( */ export function LazyHandler(handler: HTMLHandler): HTMLHandler { // - // Only update the document class if we can handle IntersectionObservers and idle callbacks + // Only update the document class if we can handle IntersectionObservers // if (typeof IntersectionObserver !== 'undefined') { handler.documentClass = From dcf5004d2c7a8403cba75670fe394bc79a24ad80 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 25 May 2021 08:18:43 -0400 Subject: [PATCH 075/142] Handle semantic-enrichment and convert() properly. --- ts/ui/lazy/LazyHandler.ts | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts index 9596d1dcc..c6f1eea79 100644 --- a/ts/ui/lazy/LazyHandler.ts +++ b/ts/ui/lazy/LazyHandler.ts @@ -173,6 +173,21 @@ export function LazyMathItemMixin Date: Tue, 25 May 2021 15:58:42 +0100 Subject: [PATCH 076/142] Adds specialised parsing method as requested in review comment. --- ts/input/tex/upgreek/UpgreekConfiguration.ts | 101 +++++++++++-------- 1 file changed, 57 insertions(+), 44 deletions(-) diff --git a/ts/input/tex/upgreek/UpgreekConfiguration.ts b/ts/input/tex/upgreek/UpgreekConfiguration.ts index 8bd96b307..d0c9040ee 100644 --- a/ts/input/tex/upgreek/UpgreekConfiguration.ts +++ b/ts/input/tex/upgreek/UpgreekConfiguration.ts @@ -23,57 +23,70 @@ */ import {Configuration} from '../Configuration.js'; -import ParseMethods from '../ParseMethods.js'; -import {TexConstant} from '../TexConstants.js'; +import {Symbol} from '../Symbol.js'; import {CharacterMap} from '../SymbolMap.js'; +import {TexConstant} from '../TexConstants.js'; +import TexParser from '../TexParser.js'; + +/** + * Handle greek mathchar as mi in normal variant. + * @param {TexParser} parser The current tex parser. + * @param {Symbol} mchar The parsed symbol. + */ +function mathchar0miNormal(parser: TexParser, mchar: Symbol) { + const def = mchar.attributes || {}; + def.mathvariant = TexConstant.Variant.NORMAL; + const node = parser.create('token', 'mi', def, mchar.char); + parser.Push(node); +} /** * Upright Greek characters. */ -new CharacterMap('upgreek', ParseMethods.mathchar0mi, { - upalpha: ['\u03B1', {mathvariant: TexConstant.Variant.NORMAL}], - upbeta: ['\u03B2', {mathvariant: TexConstant.Variant.NORMAL}], - upgamma: ['\u03B3', {mathvariant: TexConstant.Variant.NORMAL}], - updelta: ['\u03B4', {mathvariant: TexConstant.Variant.NORMAL}], - upepsilon: ['\u03F5', {mathvariant: TexConstant.Variant.NORMAL}], - upzeta: ['\u03B6', {mathvariant: TexConstant.Variant.NORMAL}], - upeta: ['\u03B7', {mathvariant: TexConstant.Variant.NORMAL}], - uptheta: ['\u03B8', {mathvariant: TexConstant.Variant.NORMAL}], - upiota: ['\u03B9', {mathvariant: TexConstant.Variant.NORMAL}], - upkappa: ['\u03BA', {mathvariant: TexConstant.Variant.NORMAL}], - uplambda: ['\u03BB', {mathvariant: TexConstant.Variant.NORMAL}], - upmu: ['\u03BC', {mathvariant: TexConstant.Variant.NORMAL}], - upnu: ['\u03BD', {mathvariant: TexConstant.Variant.NORMAL}], - upxi: ['\u03BE', {mathvariant: TexConstant.Variant.NORMAL}], - upomicron: ['\u03BF', {mathvariant: TexConstant.Variant.NORMAL}], - uppi: ['\u03C0', {mathvariant: TexConstant.Variant.NORMAL}], - uprho: ['\u03C1', {mathvariant: TexConstant.Variant.NORMAL}], - upsigma: ['\u03C3', {mathvariant: TexConstant.Variant.NORMAL}], - uptau: ['\u03C4', {mathvariant: TexConstant.Variant.NORMAL}], - upupsilon: ['\u03C5', {mathvariant: TexConstant.Variant.NORMAL}], - upphi: ['\u03D5', {mathvariant: TexConstant.Variant.NORMAL}], - upchi: ['\u03C7', {mathvariant: TexConstant.Variant.NORMAL}], - uppsi: ['\u03C8', {mathvariant: TexConstant.Variant.NORMAL}], - upomega: ['\u03C9', {mathvariant: TexConstant.Variant.NORMAL}], - upvarepsilon: ['\u03B5', {mathvariant: TexConstant.Variant.NORMAL}], - upvartheta: ['\u03D1', {mathvariant: TexConstant.Variant.NORMAL}], - upvarpi: ['\u03D6', {mathvariant: TexConstant.Variant.NORMAL}], - upvarrho: ['\u03F1', {mathvariant: TexConstant.Variant.NORMAL}], - upvarsigma: ['\u03C2', {mathvariant: TexConstant.Variant.NORMAL}], - upvarphi: ['\u03C6', {mathvariant: TexConstant.Variant.NORMAL}], +new CharacterMap('upgreek', mathchar0miNormal, { + upalpha: '\u03B1', + upbeta: '\u03B2', + upgamma: '\u03B3', + updelta: '\u03B4', + upepsilon: '\u03F5', + upzeta: '\u03B6', + upeta: '\u03B7', + uptheta: '\u03B8', + upiota: '\u03B9', + upkappa: '\u03BA', + uplambda: '\u03BB', + upmu: '\u03BC', + upnu: '\u03BD', + upxi: '\u03BE', + upomicron: '\u03BF', + uppi: '\u03C0', + uprho: '\u03C1', + upsigma: '\u03C3', + uptau: '\u03C4', + upupsilon: '\u03C5', + upphi: '\u03D5', + upchi: '\u03C7', + uppsi: '\u03C8', + upomega: '\u03C9', + upvarepsilon: '\u03B5', + upvartheta: '\u03D1', + upvarpi: '\u03D6', + upvarrho: '\u03F1', + upvarsigma: '\u03C2', + upvarphi: '\u03C6', - Upgamma: ['\u0393', {mathvariant: TexConstant.Variant.NORMAL}], - Updelta: ['\u0394', {mathvariant: TexConstant.Variant.NORMAL}], - Uptheta: ['\u0398', {mathvariant: TexConstant.Variant.NORMAL}], - Uplambda: ['\u039B', {mathvariant: TexConstant.Variant.NORMAL}], - Upxi: ['\u039E', {mathvariant: TexConstant.Variant.NORMAL}], - Uppi: ['\u03A0', {mathvariant: TexConstant.Variant.NORMAL}], - Upsigma: ['\u03A3', {mathvariant: TexConstant.Variant.NORMAL}], - Upupsilon: ['\u03A5', {mathvariant: TexConstant.Variant.NORMAL}], - Upphi: ['\u03A6', {mathvariant: TexConstant.Variant.NORMAL}], - Uppsi: ['\u03A8', {mathvariant: TexConstant.Variant.NORMAL}], - Upomega: ['\u03A9', {mathvariant: TexConstant.Variant.NORMAL}] + Upgamma: '\u0393', + Updelta: '\u0394', + Uptheta: '\u0398', + Uplambda: '\u039B', + Upxi: '\u039E', + Uppi: '\u03A0', + Upsigma: '\u03A3', + Upupsilon: '\u03A5', + Upphi: '\u03A6', + Uppsi: '\u03A8', + Upomega: '\u03A9' }); From ca04a5a0ee310f02b3f8160e32bbc2d1e5b474bf Mon Sep 17 00:00:00 2001 From: zorkow Date: Tue, 25 May 2021 18:42:49 +0100 Subject: [PATCH 077/142] Generates all gensymb elements as mi units. --- ts/input/tex/gensymb/GensymbConfiguration.ts | 33 +++++++++++++------- 1 file changed, 21 insertions(+), 12 deletions(-) diff --git a/ts/input/tex/gensymb/GensymbConfiguration.ts b/ts/input/tex/gensymb/GensymbConfiguration.ts index 03102a652..eb80074c0 100644 --- a/ts/input/tex/gensymb/GensymbConfiguration.ts +++ b/ts/input/tex/gensymb/GensymbConfiguration.ts @@ -23,33 +23,42 @@ */ import {Configuration} from '../Configuration.js'; -import ParseMethods from '../ParseMethods.js'; +import {Symbol} from '../Symbol.js'; import {TexConstant} from '../TexConstants.js'; import {CharacterMap} from '../SymbolMap.js'; +import TexParser from '../TexParser.js'; /** - * Ohm symbol as in gensymb. Usually upright, but can be affected by fonts. + * Handle characters that are known units. + * @param {TexParser} parser The current tex parser. + * @param {Symbol} mchar The parsed symbol. */ -new CharacterMap('gensymb-ohm', ParseMethods.mathchar7, { - ohm: '\u03A9' -}); +function mathcharUnit(parser: TexParser, mchar: Symbol) { + console.log(mchar.attributes); + const def = mchar.attributes || {}; + def.mathvariant = TexConstant.Variant.NORMAL; + def.class = 'MathML-Unit'; + const node = parser.create('token', 'mi', def, mchar.char); + parser.Push(node); +} /** - * Remaining symbols from the gensymb package are all in \rm font only. + * gensymb units. */ -new CharacterMap('gensymb-rest', ParseMethods.mathchar0mo, { - degree: ['\u00B0', {mathvariant: TexConstant.Variant.NORMAL}], - celsius: ['\u2103', {mathvariant: TexConstant.Variant.NORMAL}], - perthousand: ['\u2030', {mathvariant: TexConstant.Variant.NORMAL}], - micro: ['\u00B5', {mathvariant: TexConstant.Variant.NORMAL}] +new CharacterMap('gensymb-symbols', mathcharUnit, { + ohm: '\u2126', + degree: '\u00B0', + celsius: '\u2103', + perthousand: '\u2030', + micro: '\u00B5' }); export const GensymbConfiguration = Configuration.create( 'gensymb', { - handler: {macro: ['gensymb-ohm', 'gensymb-rest']}, + handler: {macro: ['gensymb-symbols']}, } ); From 2cf0d68b58581060cdfe93c5acc63321f4e08c34 Mon Sep 17 00:00:00 2001 From: zorkow Date: Tue, 25 May 2021 20:33:01 +0100 Subject: [PATCH 078/142] Removes logging. --- ts/input/tex/gensymb/GensymbConfiguration.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/ts/input/tex/gensymb/GensymbConfiguration.ts b/ts/input/tex/gensymb/GensymbConfiguration.ts index eb80074c0..7a610653a 100644 --- a/ts/input/tex/gensymb/GensymbConfiguration.ts +++ b/ts/input/tex/gensymb/GensymbConfiguration.ts @@ -35,7 +35,6 @@ import TexParser from '../TexParser.js'; * @param {Symbol} mchar The parsed symbol. */ function mathcharUnit(parser: TexParser, mchar: Symbol) { - console.log(mchar.attributes); const def = mchar.attributes || {}; def.mathvariant = TexConstant.Variant.NORMAL; def.class = 'MathML-Unit'; From 363c672ac4c25bb938bf214d1fe56794cccc7a4a Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 25 May 2021 15:41:08 -0400 Subject: [PATCH 079/142] Remove heuristic for U+2061 forcing previous item to be texClass=OP --- ts/core/MmlTree/MmlNodes/mo.ts | 12 ------------ 1 file changed, 12 deletions(-) diff --git a/ts/core/MmlTree/MmlNodes/mo.ts b/ts/core/MmlTree/MmlNodes/mo.ts index d0823e301..2e990b57e 100644 --- a/ts/core/MmlTree/MmlNodes/mo.ts +++ b/ts/core/MmlTree/MmlNodes/mo.ts @@ -289,18 +289,6 @@ export class MmlMo extends AbstractMmlTokenNode { this.texClass = TEXCLASS.CLOSE; } } - if (this.getText() === '\u2061') { - // - // Force previous node to be TEXCLASS.OP and skip this node - // - if (prev && prev.getProperty('texClass') === undefined && - prev.attributes.get('mathvariant') !== 'italic') { - prev.texClass = TEXCLASS.OP; - prev.setProperty('fnOP', true); - } - this.texClass = this.prevClass = TEXCLASS.NONE; - return prev; - } return this.adjustTeXclass(prev); } /** From e66a4c5ee080adf73a99140cf05a48170a915efe Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 25 May 2021 17:00:12 -0400 Subject: [PATCH 080/142] Add centernot package (defines \centernot and non-standard \centerOver) --- components/src/dependencies.js | 2 + .../input/tex/extensions/centernot/build.json | 4 + .../tex/extensions/centernot/centernot.js | 1 + .../extensions/centernot/webpack.config.js | 11 +++ components/src/source.js | 1 + ts/input/tex/AllPackages.ts | 3 + .../tex/centernot/CenternotConfiguration.ts | 81 +++++++++++++++++++ 7 files changed, 103 insertions(+) create mode 100644 components/src/input/tex/extensions/centernot/build.json create mode 100644 components/src/input/tex/extensions/centernot/centernot.js create mode 100644 components/src/input/tex/extensions/centernot/webpack.config.js create mode 100644 ts/input/tex/centernot/CenternotConfiguration.ts diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..30c7f61c8 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -12,6 +12,7 @@ export const dependencies = { '[tex]/braket': ['input/tex-base'], '[tex]/bussproofs': ['input/tex-base'], '[tex]/cancel': ['input/tex-base', '[tex]/enclose'], + '[tex]/centernot': ['input/tex-base'], '[tex]/color': ['input/tex-base'], '[tex]/colorv2': ['input/tex-base'], '[tex]/configmacros': ['input/tex-base', '[tex]/newcommand'], @@ -44,6 +45,7 @@ const allPackages = [ '[tex]/braket', '[tex]/bussproofs', '[tex]/cancel', + '[tex]/centernot', '[tex]/color', '[tex]/configmacros', '[tex]/enclose', diff --git a/components/src/input/tex/extensions/centernot/build.json b/components/src/input/tex/extensions/centernot/build.json new file mode 100644 index 000000000..e754ff18a --- /dev/null +++ b/components/src/input/tex/extensions/centernot/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/centernot", + "targets": ["input/tex/centernot"] +} diff --git a/components/src/input/tex/extensions/centernot/centernot.js b/components/src/input/tex/extensions/centernot/centernot.js new file mode 100644 index 000000000..792de6909 --- /dev/null +++ b/components/src/input/tex/extensions/centernot/centernot.js @@ -0,0 +1 @@ +import './lib/centernot.js'; diff --git a/components/src/input/tex/extensions/centernot/webpack.config.js b/components/src/input/tex/extensions/centernot/webpack.config.js new file mode 100644 index 000000000..28d313fdf --- /dev/null +++ b/components/src/input/tex/extensions/centernot/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/centernot', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..3b9cec1c7 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -16,6 +16,7 @@ export const source = { '[tex]/braket': `${src}/input/tex/extensions/braket/braket.js`, '[tex]/bussproofs': `${src}/input/tex/extensions/bussproofs/bussproofs.js`, '[tex]/cancel': `${src}/input/tex/extensions/cancel/cancel.js`, + '[tex]/centernot': `${src}/input/tex/extensions/centernot/centernot.js`, '[tex]/color': `${src}/input/tex/extensions/color/color.js`, '[tex]/colorv2': `${src}/input/tex/extensions/colorv2/colorv2.js`, '[tex]/configmacros': `${src}/input/tex/extensions/configmacros/configmacros.js`, diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..9d4cae4c8 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -30,6 +30,7 @@ import './boldsymbol/BoldsymbolConfiguration.js'; import './braket/BraketConfiguration.js'; import './bussproofs/BussproofsConfiguration.js'; import './cancel/CancelConfiguration.js'; +import './centernot/CenternotConfiguration.js'; import './color/ColorConfiguration.js'; import './colorv2/ColorV2Configuration.js'; import './configmacros/ConfigMacrosConfiguration.js'; @@ -57,6 +58,7 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/braket', '[tex]/bussproofs', '[tex]/cancel', + '[tex]/centernot', '[tex]/color', '[tex]/colorv2', '[tex]/enclose', @@ -85,6 +87,7 @@ export const AllPackages: string[] = [ 'braket', 'bussproofs', 'cancel', + 'centernot', 'color', 'enclose', 'extpfeil', diff --git a/ts/input/tex/centernot/CenternotConfiguration.ts b/ts/input/tex/centernot/CenternotConfiguration.ts new file mode 100644 index 000000000..7be989a22 --- /dev/null +++ b/ts/input/tex/centernot/CenternotConfiguration.ts @@ -0,0 +1,81 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the centernot package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import {Configuration} from '../Configuration.js'; +import ParseOptions from '../ParseOptions.js'; +import TexParser from '../TexParser.js'; +import NodeUtil from '../NodeUtil.js'; +import {CommandMap} from '../SymbolMap.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; +import BaseMethods from '../base/BaseMethods.js'; + +new CommandMap('centernot', { + centerOver: 'CenterOver', + centernot: ['Macro', '\\centerOver{#1}{{\u29F8}}', 1] +}, { + /** + * Implements \centerOver{base}{symbol} + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the macro being processed. + */ + CenterOver(parser: TexParser, name: string) { + const arg = '{' + parser.GetArgument(name) + '}'; + const over = parser.ParseArg(name); + const base = new TexParser(arg, parser.stack.env, parser.configuration).mml(); + let mml = parser.create('node', 'TeXAtom', [ + new TexParser(arg, parser.stack.env, parser.configuration).mml(), + parser.create('node', 'mpadded', [ + parser.create('node', 'mpadded', [over], {width: 0, lspace: '-.5width'}), + parser.create('node', 'mphantom', [base]) + ], {width: 0, lspace: '-.5width'}) + ]); + parser.configuration.addNode('centerOver', base); + parser.Push(mml); + }, + Macro: BaseMethods.Macro +}); + +/** + * Filter to copy texClass to the surrounding TeXAtom so that the negated + * item has the same class of the base. + * + * @param {ParseOptions} data The active tex parser. + */ +export function filterCenterOver({data}: {data: ParseOptions}) { + for (const base of data.getList('centerOver')) { + const texClass = NodeUtil.getTexClass(base.childNodes[0].childNodes[0] as MmlNode); + if (texClass !== null) { + NodeUtil.setProperties(base.parent.parent.parent.parent.parent.parent, {texClass}); + } + } +} + + +export const CenternotConfiguration = Configuration.create( + 'centernot', { + handler: {macro: ['centernot']}, + postprocessors: [filterCenterOver] + } +); From 5894d0ba48a43b4aae29a95e4f227e9c345bdf9f Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 25 May 2021 17:36:39 -0400 Subject: [PATCH 081/142] Go back to mhchem package, now that it is es5 --- package-lock.json | 11 + package.json | 1 + ts/input/tex/mhchem/MhchemConfiguration.ts | 2 +- .../tex/mhchem/mhchemparser/mhchemParser.d.ts | 250 --- .../tex/mhchem/mhchemparser/mhchemParser.ts | 1620 ----------------- tsconfig.json | 3 - 6 files changed, 13 insertions(+), 1874 deletions(-) delete mode 100644 ts/input/tex/mhchem/mhchemparser/mhchemParser.d.ts delete mode 100644 ts/input/tex/mhchem/mhchemparser/mhchemParser.ts diff --git a/package-lock.json b/package-lock.json index 7a3b74a50..1f944ffd7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -10,6 +10,7 @@ "license": "Apache-2.0", "dependencies": { "esm": "^3.2.25", + "mhchemparser": "^4.1.0", "mj-context-menu": "^0.6.1", "speech-rule-engine": "^3.2.0" }, @@ -3002,6 +3003,11 @@ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", "dev": true }, + "node_modules/mhchemparser": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/mhchemparser/-/mhchemparser-4.1.0.tgz", + "integrity": "sha512-rFj6nGMLJQQ0WcDw3j4LY/kWCq1EftcsarQWnDg38U47XMR36Tlda19WsN4spHr0Qc9Wn4oj6YtvXuwVnOKC/g==" + }, "node_modules/mime-db": { "version": "1.44.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.44.0.tgz", @@ -6940,6 +6946,11 @@ "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", "dev": true }, + "mhchemparser": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/mhchemparser/-/mhchemparser-4.1.0.tgz", + "integrity": "sha512-rFj6nGMLJQQ0WcDw3j4LY/kWCq1EftcsarQWnDg38U47XMR36Tlda19WsN4spHr0Qc9Wn4oj6YtvXuwVnOKC/g==" + }, "mime-db": { "version": "1.44.0", "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.44.0.tgz", diff --git a/package.json b/package.json index ffe561562..16ee2dc1a 100644 --- a/package.json +++ b/package.json @@ -59,6 +59,7 @@ }, "dependencies": { "esm": "^3.2.25", + "mhchemparser": "^4.1.0", "mj-context-menu": "^0.6.1", "speech-rule-engine": "^3.2.0" } diff --git a/ts/input/tex/mhchem/MhchemConfiguration.ts b/ts/input/tex/mhchem/MhchemConfiguration.ts index 94e7e5cd5..b069e588f 100644 --- a/ts/input/tex/mhchem/MhchemConfiguration.ts +++ b/ts/input/tex/mhchem/MhchemConfiguration.ts @@ -29,7 +29,7 @@ import TexError from '../TexError.js'; import TexParser from '../TexParser.js'; import BaseMethods from '../base/BaseMethods.js'; import {AmsMethods} from '../ams/AmsMethods.js'; -import {mhchemParser} from './mhchemparser/mhchemParser.js'; +import {mhchemParser} from 'mhchemparser/dist/mhchemParser.js'; // Namespace let MhchemMethods: Record = {}; diff --git a/ts/input/tex/mhchem/mhchemparser/mhchemParser.d.ts b/ts/input/tex/mhchem/mhchemparser/mhchemParser.d.ts deleted file mode 100644 index 1bceeec1d..000000000 --- a/ts/input/tex/mhchem/mhchemparser/mhchemParser.d.ts +++ /dev/null @@ -1,250 +0,0 @@ -interface MhchemParser { - go: { (input: string | undefined, stateMachine: StateMachineName): Parsed[]; }; - concatArray: { (a: any[], b: any): void }; - patterns: { - patterns: { - [pattern in PatternNameReturningString]?: - RegExp | PatternFunction - } & { - [pattern in PatternNameReturningArray]?: - RegExp | PatternFunction - }; - findObserveGroups: { - ( - input: string, - begExcl: string | RegExp, - begIncl: string | RegExp, - endIncl: string | RegExp, - endExcl: string | RegExp, - beg2Excl?: string | RegExp, - beg2Incl?: string | RegExp, - end2Incl?: string | RegExp, - end2Excl?: string | RegExp, - combine?: boolean - ): MatchResult - }; - match_: { (m: PatternName, input: string): MatchResult | null }; - }, - actions: ActionList; - stateMachines: { [key in StateMachineName]: StateMachine }; -} - -type PatternFunction = (input: string) => MatchResult | null; -type StateMachineName = "tex" | "ce" | "a" | "o" | "text" | "pq" | "bd" | "oxidation" | "tex-math" | "tex-math tight" | "9,9" | "pu" | "pu-2" | "pu-9,9"; -type MatchResult = { - match_: T; - remainder: string; -} -type StateName = - "0" | // begin of main part (arrow/operator unlikely) - "1" | // next entity - "2" | // next entity (arrow/operator unlikely) - "3" | // next atom - "c" | // macro - "a" | // amount - "o" | // element - "b" | // left-side superscript - "p" | // left-side subscript - "q" | // right-side subscript - "d" | "D" | // right-side superscript - "r" | // arrow - "rd" | // arrow, script above - "f" | "*"; -type StateNameCombined = StateName | "0|1|2" | "0|1|2|3" | "0|1|2|3|a|as|b|p|bp" | "0|1|2|3|a|as|b|p|bp|o" | "0|1|2|3|a|as|b|p|bp|o|c0" | "0|1|2|3|a|as|o" | "0|1|2|3|a|as|o|q|d|D|qd|qD|dq" | "0|1|2|3|as|b|p|bp|o" | "0|1|2|3|b|p|bp|o" | "0|1|2|a|as" | "0|1|2|as" | "0|2" | "0|a" | "0|d" | "1|2" | "1|3" | "3|o" | "a|as" | "a|as|d|D|q|qd|qD|dq" | "a|as|o" | "as" | "as|o" | "b|p|bp" | "d|D" | "d|D|q|qd|qD|dq" | "d|D|qd|qD" | "d|D|qd|qD|dq" | "d|qd|D|qD" | "d|qd|dq" | "D|qD|p" | "dq" | "o|d|D|dq|qd|qD" | "o|d|D|q|qd|qD|dq" | "o|q" | "q|d|D|qd|qD|dq" | "q|dq" | "q|qd|qD|dq" | "qd" | "qD|dq" | "qd|qD" | "r|rt" | "r|rt|rd|rdt|rdq" | "rd|rdt" | "/|q"; - -type ActionList = { - [key in ActionNameUsingMNone]?: ActionFunction -} & { - [key in ActionNameUsingMString]?: ActionFunction -} & { - [key in ActionNameUsingMStringOption]?: ActionFunction -} & { - [key in ActionNameUsingMArray]?: ActionFunction -} -interface ActionFunction { - (buffer: Buffer, m?: T, option?: string | number | boolean): undefined | Parsed | Parsed[]; -} - -type TransitionsRaw = { - [pattern in PatternNameReturningString]?: { - [state in StateNameCombined]?: { - action_: - ActionNameUsingMString | ActionNameUsingMStringOption | ActionNameUsingMNone | - ActionNameWithParameter | ActionNameWithParameter | ActionNameWithParameter | - (ActionNameUsingMString | ActionNameUsingMStringOption | ActionNameUsingMNone | - ActionNameWithParameter | ActionNameWithParameter | ActionNameWithParameter)[]; - nextState?: string; - revisit?: boolean; - toContinue?: boolean; - stateArray?: StateName[]; - } - } -} & { - [pattern in PatternNameReturningArray2]?: { - [state in StateNameCombined]?: { - action_: - ActionNameUsingMArray2 | (ActionNameUsingMArray2 | ActionNameUsingMString | ActionNameUsingMNone | ActionNameWithParameter)[]; // ... list ist not complete - nextState?: string; - revisit?: boolean; - toContinue?: boolean; - stateArray?: StateName[]; - } - } -} & { - [pattern in PatternNameReturningArray3]?: { - [state in StateNameCombined]?: { - action_: ActionNameUsingMArray3 | ActionNameUsingMArray3[]; - nextState?: string; - revisit?: boolean; - toContinue?: boolean; - stateArray?: StateName[]; - } - } -} & { - [pattern in PatternNameReturningArray6]?: { - [state in StateNameCombined]?: { - action_: ActionNameUsingMArray6 | ActionNameUsingMArray6[]; - nextState?: string; - revisit?: boolean; - toContinue?: boolean; - stateArray?: StateName[]; - } - } -} -type PatternNameReturningString = - "empty" | "else" | "else2" | "space" | "space A" | "space$" | "a-z" | "x" | "x$" | "i$" | "letters" | "\\greek" | "one lowercase latin letter $" | "$one lowercase latin letter$ $" | "one lowercase greek letter $" | "digits" | "-9.,9" | "-9.,9 no missing 0" | "state of aggregation $" | "{[(" | ")]}" | ", " | "," | "." | ". __* " | "..." | "^{(...)}" | "^($...$)" | "^a" | "^\\x{}" | "^\\x" | "^(-1)" | "\'" | "_{(...)}" | "_($...$)" | "_9" | "_\\x{}{}" | "_\\x{}" | "_\\x" | "^_" | "{}" | "{...}" | "{(...)}" | "$...$" | "${(...)}$__$(...)$" | "=<>" | "#" | "+" | "-$" | "-9" | "- orbital overlap" | "-" | "pm-operator" | "operator" | "arrowUpDown" | "\\bond{(...)}" | "->" | "CMT" | "[(...)]" | "1st-level escape" | "\\," | "\\x{}" | "\\ca" | "\\x" | "orbital" | "others" | "\\color{(...)}" | "\\ce{(...)}" | "\\pu{(...)}" | "oxidation$" | "d-oxidation$" | "roman numeral" | "1/2$" | "amount" | "amount2" | "(KV letters)," | "formula$" | "uprightEntities" | "/" | "//" | "*" | "\\x{}{}" | "^\\x{}{}" | - "^{(...)}|^($...$)" | "^a|^\\x{}{}|^\\x{}|^\\x|\'" | "_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x" | "\\,|\\x{}{}|\\x{}|\\x" | "{...}|\\,|\\x{}{}|\\x{}|\\x" | "\\x{}{}|\\x{}|\\x" | "-|+" | "{[(|)]}" | "{...}|else" | "^{(...)}|^(-1)"; -type PatternNameReturningArray2 = "_{(state of aggregation)}$" | "\\frac{(...)}" | "\\overset{(...)}" | "\\underset{(...)}" | "\\underbrace{(...)}" | "\\color{(...)}{(...)}"; -type PatternNameReturningArray3 = "(-)(9)^(-9)"; -type PatternNameReturningArray6 = "(-)(9.,9)(e)(99)"; -type PatternName = PatternNameReturningString | PatternNameReturningArray2 | PatternNameReturningArray3 | PatternNameReturningArray6; -type PatternNameReturningArray = PatternNameReturningArray2 | PatternNameReturningArray3 | PatternNameReturningArray6; -type ActionNameUsingMNone = "a to o" | "sb=true" | "sb=false" | "beginsWithBond=true" | "beginsWithBond=false" | "parenthesisLevel++" | "parenthesisLevel--" | "output" | "space" | "cdot" | "output-0" | "output-o" | "tight operator"; -type ActionNameUsingMString = "a=" | "b=" | "p=" | "o=" | "q=" | "d=" | "rm=" | "text=" | "copy" | "rm" | "text" | "tex-math" | "tex-math tight" | "ce" | "pu" | "1/2" | "9,9" | "o after d" | "d= kv" | "charge or bond" | "state of aggregation" | "comma" | "oxidation-output" | "r=" | "rdt=" | "rd=" | "rqt=" | "rq=" | "operator" | "bond" | "color0-output" | "roman-numeral" | "^(-1)"; -type ActionNameUsingMStringOption = "insert" | "insert+p1" | "write" | "bond" | "- after o/d"; -type ActionNameUsingMArray2 = "insert+p1+p2" | "frac-output" | "overset-output" | "underset-output" | "underbrace-output" | "color-output"; -type ActionNameUsingMArray3 = "number^"; -type ActionNameUsingMArray6 = "enumber"; -type ActionName = ActionNameUsingMNone | ActionNameUsingMString | ActionNameUsingMStringOption | ActionNameUsingMArray2 | ActionNameUsingMArray3 | ActionNameUsingMArray6; -type ActionNameUsingMArray = ActionNameUsingMArray2 | ActionNameUsingMArray3 | ActionNameUsingMArray6; - -type StateMachine = { - transitions: Transitions; - actions: ActionList; -} -type Transitions = { - [state in StateName]?: Transition[]; -} -interface Transition { // e.g. { pattern: 'letter', task: { '*': { action_: ['output'], nextState: '1' } } } - pattern: PatternName; - task: Action; -} -interface Action { - action_: ActionNameWithParameter[]; - nextState?: StateName; - revisit?: boolean; - toContinue?: boolean; -} -interface ActionNameWithParameter { - type_: T; - option?: string | number | boolean; -} - - - - -interface Buffer { - a?: string; // amount - o?: string; // element - b?: string; // left-side superscript - p?: string; // left-side subscript - q?: string; // right-side subscript - d?: string; // right-side superscript - dType?: string; - - r?: ArrowName; // arrow - rdt?: string; // arrow, script above, type - rd?: string; // arrow, script above, content - rqt?: string; // arrow, script below, type - rq?: string; // arrow, script below, content - - text_?: string; - rm?: string; - - parenthesisLevel?: number; // starting at 0 - sb?: boolean; // space before - beginsWithBond?: boolean; -} - - - - -type ParsedWithoutString = - { type_: "chemfive", - a: Parsed[], - b: Parsed[], - p: Parsed[], - o: Parsed[], - q: Parsed[], - d: Parsed[], - dType: string } | - { type_: "rm", p1: string } | - { type_: "text", p1: string } | - { type_: "roman numeral", p1: string } | - { type_: "state of aggregation", p1: Parsed[] } | - { type_: "state of aggregation subscript", p1: Parsed[] } | - { type_: "bond", kind_: BondName } | - { type_: "frac", p1: string, p2: string } | - { type_: "pu-frac", p1: Parsed[], p2: Parsed[] } | - { type_: "tex-math", p1: string } | - { type_: "frac-ce", p1: Parsed[], p2: Parsed[] } | - { type_: "overset", p1: Parsed[], p2: Parsed[] } | - { type_: "underset", p1: Parsed[], p2: Parsed[] } | - { type_: "underbrace", p1: Parsed[], p2: Parsed[] } | - { type_: "color", color1: string, color2: Parsed[] } | - { type_: "color0", color: string } | - { type_: "arrow", - r: ArrowName, - rd?: Parsed[], - rq?: Parsed[]} | - { type_: "operator", kind_: OperatorName } | - { type_: "1st-level escape", p1: string } | - { type_: "space" } | - { type_: "entitySkip" } | - { type_: "pu-space-1" } | - { type_: "pu-space-2" } | - { type_: "1000 separator" } | - { type_: "commaDecimal" } | - { type_: "comma enumeration L", p1: string } | - { type_: "comma enumeration M", p1: string } | - { type_: "comma enumeration S", p1: string } | - { type_: "hyphen" } | - { type_: "addition compound" } | - { type_: "electron dot" } | - { type_: "KV x" } | - { type_: "prime" } | - { type_: "cdot" } | - { type_: "tight cdot" } | - { type_: "times" } | - { type_: "circa" } | - { type_: "^" } | - { type_: "v" } | - { type_: "ellipsis" } | - { type_: "/" } | - { type_: " / " }; -type Parsed = ParsedWithoutString | string; -type ArrowName = "->" | "\u2192" | "\u27F6" | "<-" | "<->" | "<-->" | "<=>" | "\u21CC" | "<=>>" | "<<=>"; // keep aligned with definition of pattern '->' -type BondName = "-" | "1" | "=" | "2" | "#" | "3" | "~" | "~-" | "~=" | "~--" | "-~-" | "..." | "...." | "->" | "<-" | "<" | ">"; -type OperatorName = "+" | "-" | "=" | "<" | ">" | "<<" | ">>" | "\\pm" | "\\approx" | "$\\approx$" | "v" | "(v)" | "^" | "(^)"; - - - - -interface MhchemTexify { - go: { (input: Parsed[] | undefined, isInner?: boolean): string; }; - _goInner: { (input: Parsed[]): string}; - _go2: { (input: ParsedWithoutString): string }; - _getArrow: { (input: ArrowName): string }; - _getBond: { (input: BondName): string }; - _getOperator: { (input: OperatorName): string }; -} diff --git a/ts/input/tex/mhchem/mhchemparser/mhchemParser.ts b/ts/input/tex/mhchem/mhchemparser/mhchemParser.ts deleted file mode 100644 index 9540b35df..000000000 --- a/ts/input/tex/mhchem/mhchemparser/mhchemParser.ts +++ /dev/null @@ -1,1620 +0,0 @@ -/*! - ************************************************************************* - * - * mhchemParser.ts - * 4.0.0 - * - * Parser for the \ce command and \pu command for MathJax and Co. - * - * mhchem's \ce is a tool for writing beautiful chemical equations easily. - * mhchem's \pu is a tool for writing physical units easily. - * - * ---------------------------------------------------------------------- - * - * Copyright (c) 2015-2021 Martin Hensel - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * ---------------------------------------------------------------------- - * - * https://github.com/mhchem/mhchemParser - * - */ - - export class mhchemParser { - static toTex(input: string, type: "tex" | "ce" | "pu"): string { - return _mhchemTexify.go(_mhchemParser.go(input, type), type !== "tex"); - } -} - -// -// Coding Style -// - use '' for identifiers that can by minified/uglified -// - use "" for strings that need to stay untouched - -// -// Helper funtion: mhchemCreateTransitions -// convert { 'letter': { 'state': { action_: 'output' } } } to { 'state' => [ { pattern: 'letter', task: { action_: [{type_: 'output'}] } } ] } -// with expansion of 'a|b' to 'a' and 'b' (at 2 places) -// -function mhchemCreateTransitions(o: TransitionsRaw): Transitions { - let pattern: PatternName, state: StateNameCombined; - // - // 1. Collect all states - // - let transitions: Transitions = {}; - for (pattern in o) { - for (state in o[pattern]) { - let stateArray = state.split("|") as StateName[]; - o[pattern][state].stateArray = stateArray; - for (let i=0; i 0) { - if (!task.revisit) { - input = matches.remainder; - } - if (!task.toContinue) { - break iterateTransitions; - } - } else { - return output; - } - } - } - // - // Prevent infinite loop - // - if (watchdog <= 0) { - throw ["MhchemBugU", "mhchem bug U. Please report."]; // Unexpected character - } - } - }, - concatArray: function (a, b) { - if (b) { - if (Array.isArray(b)) { - for (let iB=0; iB, - '_{(state of aggregation)}$': /^_\{(\([a-z]{1,3}\))\}/, - '{[(': /^(?:\\\{|\[|\()/, - ')]}': /^(?:\)|\]|\\\})/, - ', ': /^[,;]\s*/, - ',': /^[,;]/, - '.': /^[.]/, - '. __* ': /^([.\u22C5\u00B7\u2022]|[*])\s*/, - '...': /^\.\.\.(?=$|[^.])/, - '^{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "^{", "", "", "}"); } as PatternFunction, - '^($...$)': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "^", "$", "$", ""); } as PatternFunction, - '^a': /^\^([0-9]+|[^\\_])/, - '^\\x{}{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); } as PatternFunction, - '^\\x{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "^", /^\\[a-zA-Z]+\{/, "}", ""); } as PatternFunction, - '^\\x': /^\^(\\[a-zA-Z]+)\s*/, - '^(-1)': /^\^(-?\d+)/, - '\'': /^'/, - '_{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "_{", "", "", "}"); } as PatternFunction, - '_($...$)': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "_", "$", "$", ""); } as PatternFunction, - '_9': /^_([+\-]?[0-9]+|[^\\])/, - '_\\x{}{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); } as PatternFunction, - '_\\x{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "_", /^\\[a-zA-Z]+\{/, "}", ""); } as PatternFunction, - '_\\x': /^_(\\[a-zA-Z]+)\s*/, - '^_': /^(?:\^(?=_)|\_(?=\^)|[\^_]$)/, - '{}': /^\{\}/, - '{...}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "", "{", "}", ""); } as PatternFunction, - '{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "{", "", "", "}"); } as PatternFunction, - '$...$': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "", "$", "$", ""); } as PatternFunction, - '${(...)}$__$(...)$': function (input) { - return _mhchemParser.patterns.findObserveGroups(input, "${", "", "", "}$") || _mhchemParser.patterns.findObserveGroups(input, "$", "", "", "$"); - } as PatternFunction, - '=<>': /^[=<>]/, - '#': /^[#\u2261]/, - '+': /^\+/, - '-$': /^-(?=[\s_},;\]/]|$|\([a-z]+\))/, // -space -, -; -] -/ -$ -state-of-aggregation - '-9': /^-(?=[0-9])/, - '- orbital overlap': /^-(?=(?:[spd]|sp)(?:$|[\s,;\)\]\}]))/, - '-': /^-/, - 'pm-operator': /^(?:\\pm|\$\\pm\$|\+-|\+\/-)/, - 'operator': /^(?:\+|(?:[\-=<>]|<<|>>|\\approx|\$\\approx\$)(?=\s|$|-?[0-9]))/, - 'arrowUpDown': /^(?:v|\(v\)|\^|\(\^\))(?=$|[\s,;\)\]\}])/, - '\\bond{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\bond{", "", "", "}"); } as PatternFunction, - '->': /^(?:<->|<-->|->|<-|<=>>|<<=>|<=>|[\u2192\u27F6\u21CC])/, - 'CMT': /^[CMT](?=\[)/, - '[(...)]': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "[", "", "", "]"); } as PatternFunction, - '1st-level escape': /^(&|\\\\|\\hline)\s*/, - '\\,': /^(?:\\[,\ ;:])/, // \\x - but output no space before - '\\x{}{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", "", "", "{", "}", "", true); } as PatternFunction, - '\\x{}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "", /^\\[a-zA-Z]+\{/, "}", ""); } as PatternFunction, - '\\ca': /^\\ca(?:\s+|(?![a-zA-Z]))/, - '\\x': /^(?:\\[a-zA-Z]+\s*|\\[_&{}%])/, - 'orbital': /^(?:[0-9]{1,2}[spdfgh]|[0-9]{0,2}sp)(?=$|[^a-zA-Z])/, // only those with numbers in front, because the others will be formatted correctly anyway - 'others': /^[\/~|]/, - '\\frac{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\frac{", "", "", "}", "{", "", "", "}"); } as PatternFunction, - '\\overset{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\overset{", "", "", "}", "{", "", "", "}"); } as PatternFunction, - '\\underset{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\underset{", "", "", "}", "{", "", "", "}"); } as PatternFunction, - '\\underbrace{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\underbrace{", "", "", "}_", "{", "", "", "}"); } as PatternFunction, - '\\color{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}"); } as PatternFunction, - '\\color{(...)}{(...)}': function (input) { - return _mhchemParser.patterns.findObserveGroups(input, "\\color{", "", "", "}", "{", "", "", "}") || - _mhchemParser.patterns.findObserveGroups(input, "\\color", "\\", "", /^(?=\{)/, "{", "", "", "}"); - } as PatternFunction, - '\\ce{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\ce{", "", "", "}"); } as PatternFunction, - '\\pu{(...)}': function (input) { return _mhchemParser.patterns.findObserveGroups(input, "\\pu{", "", "", "}"); } as PatternFunction, - 'oxidation$': /^(?:[+-][IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/, - 'd-oxidation$': /^(?:[+-]?\s?[IVX]+|\\pm\s*0|\$\\pm\$\s*0)$/, // 0 could be oxidation or charge - 'roman numeral': /^[IVX]+/, - '1/2$': /^[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+(?:\$[a-z]\$|[a-z])?$/, - 'amount': function (input) { - let match; - // e.g. 2, 0.5, 1/2, -2, n/2, +; $a$ could be added later in parsing - match = input.match(/^(?:(?:(?:\([+\-]?[0-9]+\/[0-9]+\)|[+\-]?(?:[0-9]+|\$[a-z]\$|[a-z])\/[0-9]+|[+\-]?[0-9]+[.,][0-9]+|[+\-]?\.[0-9]+|[+\-]?[0-9]+)(?:[a-z](?=\s*[A-Z]))?)|[+\-]?[a-z](?=\s*[A-Z])|\+(?!\s))/); - if (match) { - return { match_: match[0], remainder: input.substr(match[0].length) }; - } - const a = _mhchemParser.patterns.findObserveGroups(input, "", "$", "$", "") as MatchResult; - if (a) { // e.g. $2n-1$, $-$ - match = a.match_.match(/^\$(?:\(?[+\-]?(?:[0-9]*[a-z]?[+\-])?[0-9]*[a-z](?:[+\-][0-9]*[a-z]?)?\)?|\+|-)\$$/); - if (match) { - return { match_: match[0], remainder: input.substr(match[0].length) }; - } - } - return null; - }, - 'amount2': function (input) { return this['amount'](input); }, - '(KV letters),': /^(?:[A-Z][a-z]{0,2}|i)(?=,)/, - 'formula$': function (input) { - if (input.match(/^\([a-z]+\)$/)) { return null; } // state of aggregation = no formula - const match = input.match(/^(?:[a-z]|(?:[0-9\ \+\-\,\.\(\)]+[a-z])+[0-9\ \+\-\,\.\(\)]*|(?:[a-z][0-9\ \+\-\,\.\(\)]+)+[a-z]?)$/); - if (match) { - return { match_: match[0], remainder: input.substr(match[0].length) }; - } - return null; - }, - 'uprightEntities': /^(?:pH|pOH|pC|pK|iPr|iBu)(?=$|[^a-zA-Z])/, - '/': /^\s*(\/)\s*/, - '//': /^\s*(\/\/)\s*/, - '*': /^\s*[*.]\s*/ - }, - findObserveGroups: function (input, begExcl, begIncl, endIncl, endExcl, beg2Excl, beg2Incl, end2Incl, end2Excl, combine) { - const _match = function (input: string, pattern: string | RegExp) : string | string[] | null { - if (typeof pattern === "string") { - if (input.indexOf(pattern) !== 0) { return null; } - return pattern; - } else { - const match = input.match(pattern); - if (!match) { return null; } - return match[0]; - } - }; - const _findObserveGroups = function (input: string, i: number, endChars: string | RegExp): {endMatchBegin: number, endMatchEnd: number} | null { - let braces = 0; - while (i < input.length) { - let a = input.charAt(i); - const match = _match(input.substr(i), endChars); - if (match !== null && braces === 0) { - return { endMatchBegin: i, endMatchEnd: i + match.length }; - } else if (a === "{") { - braces++; - } else if (a === "}") { - if (braces === 0) { - throw ["ExtraCloseMissingOpen", "Extra close brace or missing open brace"]; - } else { - braces--; - } - } - i++; - } - if (braces > 0) { - return null; - } - return null; - }; - let match = _match(input, begExcl); - if (match === null) { return null; } - input = input.substr(match.length); - match = _match(input, begIncl); - if (match === null) { return null; } - const e = _findObserveGroups(input, match.length, endIncl || endExcl); - if (e === null) { return null; } - const match1 = input.substring(0, (endIncl ? e.endMatchEnd : e.endMatchBegin)); - if (!(beg2Excl || beg2Incl)) { - return { - match_: match1, - remainder: input.substr(e.endMatchEnd) - }; - } else { - const group2 = this.findObserveGroups(input.substr(e.endMatchEnd), beg2Excl, beg2Incl, end2Incl, end2Excl); - if (group2 === null) { return null; } - const matchRet: string[] = [match1, group2.match_]; - return { - match_: (combine ? matchRet.join("") : matchRet), - remainder: group2.remainder - }; - } - }, - - // - // Matching function - // e.g. match("a", input) will look for the regexp called "a" and see if it matches - // returns null or {match_:"a", remainder:"bc"} - // - match_: function (m, input) { - const pattern = _mhchemParser.patterns.patterns[m]; - if (pattern === undefined) { - throw ["MhchemBugP", "mhchem bug P. Please report. (" + m + ")"]; // Trying to use non-existing pattern - } else if (typeof pattern === "function") { - return (_mhchemParser.patterns.patterns[m] as unknown as PatternFunction)(input); // cannot use cached variable pattern here, because some pattern functions need this===mhchemParser - } else { // RegExp - const match = input.match(pattern); - if (match) { - if (match.length > 2) { - return { match_: match.slice(1), remainder: input.substr(match[0].length) }; - } else { - return { match_: match[1] || match[0], remainder: input.substr(match[0].length) }; - } - } - return null; - } - } - }, - - // - // Generic state machine actions - // - actions: { - 'a=': function (buffer, m) { buffer.a = (buffer.a || "") + m; return undefined; }, - 'b=': function (buffer, m) { buffer.b = (buffer.b || "") + m; return undefined; }, - 'p=': function (buffer, m) { buffer.p = (buffer.p || "") + m; return undefined; }, - 'o=': function (buffer, m) { buffer.o = (buffer.o || "") + m; return undefined; }, - 'q=': function (buffer, m) { buffer.q = (buffer.q || "") + m; return undefined; }, - 'd=': function (buffer, m) { buffer.d = (buffer.d || "") + m; return undefined; }, - 'rm=': function (buffer, m) { buffer.rm = (buffer.rm || "") + m; return undefined; }, - 'text=': function (buffer, m) { buffer.text_ = (buffer.text_ || "") + m; return undefined; }, - 'insert': function (_buffer, _m, a: string) { return { type_: a } as Parsed; }, - 'insert+p1': function (_buffer, m, a) { return { type_: a, p1: m } as Parsed; }, - 'insert+p1+p2': function (_buffer, m, a) { return { type_: a, p1: m[0], p2: m[1] } as Parsed; }, - 'copy': function (_buffer, m) { return m; }, - 'write': function (_buffer, _m, a: string) { return a; }, - 'rm': function (_buffer, m) { return { type_: 'rm', p1: m }; }, - 'text': function (_buffer, m) { return _mhchemParser.go(m, 'text'); }, - 'tex-math': function (_buffer, m) { return _mhchemParser.go(m, 'tex-math'); }, - 'tex-math tight': function (_buffer, m) { return _mhchemParser.go(m, 'tex-math tight'); }, - 'bond': function (_buffer, m: BondName, k: BondName) { return { type_: 'bond', kind_: k || m }; }, - 'color0-output': function (_buffer, m) { return { type_: 'color0', color: m }; }, - 'ce': function (_buffer, m) { return _mhchemParser.go(m, 'ce'); }, - 'pu': function (_buffer, m) { return _mhchemParser.go(m, 'pu'); }, - '1/2': function (_buffer, m) { - let ret: Parsed[] = []; - if (m.match(/^[+\-]/)) { - ret.push(m.substr(0, 1)); - m = m.substr(1); - } - const n = m.match(/^([0-9]+|\$[a-z]\$|[a-z])\/([0-9]+)(\$[a-z]\$|[a-z])?$/); - n[1] = n[1].replace(/\$/g, ""); - ret.push({ type_: 'frac', p1: n[1], p2: n[2] }); - if (n[3]) { - n[3] = n[3].replace(/\$/g, ""); - ret.push({ type_: 'tex-math', p1: n[3] }); - } - return ret; - }, - '9,9': function (_buffer, m) { return _mhchemParser.go(m, '9,9'); } - }, -// -// Definition of state machines -// - stateMachines: { - // - // TeX state machine - // - 'tex': { - transitions: mhchemCreateTransitions({ - 'empty': { - '0': { action_: 'copy' } }, - '\\ce{(...)}': { - '0': { action_: [ { type_: 'write', option: "{" }, 'ce', { type_: 'write', option: "}" }] } }, - '\\pu{(...)}': { - '0': { action_: [ { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" }] } }, - 'else': { - '0': { action_: 'copy' } }, - }), - actions: {} - }, - // - // \ce state machines - // - //#region ce - 'ce': { // main parser - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - 'else': { - '0|1|2': { action_: 'beginsWithBond=false', revisit: true, toContinue: true } }, - 'oxidation$': { - '0': { action_: 'oxidation-output' } }, - 'CMT': { - 'r': { action_: 'rdt=', nextState: 'rt' }, - 'rd': { action_: 'rqt=', nextState: 'rdt' } }, - 'arrowUpDown': { - '0|1|2|as': { action_: [ 'sb=false', 'output', 'operator' ], nextState: '1' } }, - 'uprightEntities': { - '0|1|2': { action_: [ 'o=', 'output' ], nextState: '1' } }, - 'orbital': { - '0|1|2|3': { action_: 'o=', nextState: 'o' } }, - '->': { - '0|1|2|3': { action_: 'r=', nextState: 'r' }, - 'a|as': { action_: [ 'output', 'r=' ], nextState: 'r' }, - '*': { action_: [ 'output', 'r=' ], nextState: 'r' } }, - '+': { - 'o': { action_: 'd= kv', nextState: 'd' }, - 'd|D': { action_: 'd=', nextState: 'd' }, - 'q': { action_: 'd=', nextState: 'qd' }, - 'qd|qD': { action_: 'd=', nextState: 'qd' }, - 'dq': { action_: [ 'output', 'd=' ], nextState: 'd' }, - '3': { action_: [ 'sb=false', 'output', 'operator' ], nextState: '0' } }, - 'amount': { - '0|2': { action_: 'a=', nextState: 'a' } }, - 'pm-operator': { - '0|1|2|a|as': { action_: [ 'sb=false', 'output', { type_: 'operator', option: '\\pm' } ], nextState: '0' } }, - 'operator': { - '0|1|2|a|as': { action_: [ 'sb=false', 'output', 'operator' ], nextState: '0' } }, - '-$': { - 'o|q': { action_: [ 'charge or bond', 'output' ], nextState: 'qd' }, - 'd': { action_: 'd=', nextState: 'd' }, - 'D': { action_: [ 'output', { type_: 'bond', option: "-" } ], nextState: '3' }, - 'q': { action_: 'd=', nextState: 'qd' }, - 'qd': { action_: 'd=', nextState: 'qd' }, - 'qD|dq': { action_: [ 'output', { type_: 'bond', option: "-" } ], nextState: '3' } }, - '-9': { - '3|o': { action_: [ 'output', { type_: 'insert', option: 'hyphen' } ], nextState: '3' } }, - '- orbital overlap': { - 'o': { action_: [ 'output', { type_: 'insert', option: 'hyphen' } ], nextState: '2' }, - 'd': { action_: [ 'output', { type_: 'insert', option: 'hyphen' } ], nextState: '2' } }, - '-': { - '0|1|2': { action_: [ { type_: 'output', option: 1 }, 'beginsWithBond=true', { type_: 'bond', option: "-" } ], nextState: '3' }, - '3': { action_: { type_: 'bond', option: "-" } }, - 'a': { action_: [ 'output', { type_: 'insert', option: 'hyphen' } ], nextState: '2' }, - 'as': { action_: [ { type_: 'output', option: 2 }, { type_: 'bond', option: "-" } ], nextState: '3' }, - 'b': { action_: 'b=' }, - 'o': { action_: { type_: '- after o/d', option: false }, nextState: '2' }, - 'q': { action_: { type_: '- after o/d', option: false }, nextState: '2' }, - 'd|qd|dq': { action_: { type_: '- after o/d', option: true }, nextState: '2' }, - 'D|qD|p': { action_: [ 'output', { type_: 'bond', option: "-" } ], nextState: '3' } }, - 'amount2': { - '1|3': { action_: 'a=', nextState: 'a' } }, - 'letters': { - '0|1|2|3|a|as|b|p|bp|o': { action_: 'o=', nextState: 'o' }, - 'q|dq': { action_: ['output', 'o='], nextState: 'o' }, - 'd|D|qd|qD': { action_: 'o after d', nextState: 'o' } }, - 'digits': { - 'o': { action_: 'q=', nextState: 'q' }, - 'd|D': { action_: 'q=', nextState: 'dq' }, - 'q': { action_: [ 'output', 'o=' ], nextState: 'o' }, - 'a': { action_: 'o=', nextState: 'o' } }, - 'space A': { - 'b|p|bp': { action_: [] } }, - 'space': { - 'a': { action_: [], nextState: 'as' }, - '0': { action_: 'sb=false' }, - '1|2': { action_: 'sb=true' }, - 'r|rt|rd|rdt|rdq': { action_: 'output', nextState: '0' }, - '*': { action_: [ 'output', 'sb=true' ], nextState: '1'} }, - '1st-level escape': { - '1|2': { action_: [ 'output', { type_: 'insert+p1', option: '1st-level escape' } ] }, - '*': { action_: [ 'output', { type_: 'insert+p1', option: '1st-level escape' } ], nextState: '0' } }, - '[(...)]': { - 'r|rt': { action_: 'rd=', nextState: 'rd' }, - 'rd|rdt': { action_: 'rq=', nextState: 'rdq' } }, - '...': { - 'o|d|D|dq|qd|qD': { action_: [ 'output', { type_: 'bond', option: "..." } ], nextState: '3' }, - '*': { action_: [ { type_: 'output', option: 1 }, { type_: 'insert', option: 'ellipsis' } ], nextState: '1' } }, - '. __* ': { - '*': { action_: [ 'output', { type_: 'insert', option: 'addition compound' } ], nextState: '1' } }, - 'state of aggregation $': { - '*': { action_: [ 'output', 'state of aggregation' ], nextState: '1' } }, - '{[(': { - 'a|as|o': { action_: [ 'o=', 'output', 'parenthesisLevel++' ], nextState: '2' }, - '0|1|2|3': { action_: [ 'o=', 'output', 'parenthesisLevel++' ], nextState: '2' }, - '*': { action_: [ 'output', 'o=', 'output', 'parenthesisLevel++' ], nextState: '2' } }, - ')]}': { - '0|1|2|3|b|p|bp|o': { action_: [ 'o=', 'parenthesisLevel--' ], nextState: 'o' }, - 'a|as|d|D|q|qd|qD|dq': { action_: [ 'output', 'o=', 'parenthesisLevel--' ], nextState: 'o' } }, - ', ': { - '*': { action_: [ 'output', 'comma' ], nextState: '0' } }, - '^_': { // ^ and _ without a sensible argument - '*': { action_: [] } }, - '^{(...)}|^($...$)': { - '0|1|2|as': { action_: 'b=', nextState: 'b' }, - 'p': { action_: 'b=', nextState: 'bp' }, - '3|o': { action_: 'd= kv', nextState: 'D' }, - 'q': { action_: 'd=', nextState: 'qD' }, - 'd|D|qd|qD|dq': { action_: [ 'output', 'd=' ], nextState: 'D' } }, - '^a|^\\x{}{}|^\\x{}|^\\x|\'': { - '0|1|2|as': { action_: 'b=', nextState: 'b' }, - 'p': { action_: 'b=', nextState: 'bp' }, - '3|o': { action_: 'd= kv', nextState: 'd' }, - 'q': { action_: 'd=', nextState: 'qd' }, - 'd|qd|D|qD': { action_: 'd=' }, - 'dq': { action_: [ 'output', 'd=' ], nextState: 'd' } }, - '_{(state of aggregation)}$': { - 'd|D|q|qd|qD|dq': { action_: [ 'output', 'q=' ], nextState: 'q' } }, - '_{(...)}|_($...$)|_9|_\\x{}{}|_\\x{}|_\\x': { - '0|1|2|as': { action_: 'p=', nextState: 'p' }, - 'b': { action_: 'p=', nextState: 'bp' }, - '3|o': { action_: 'q=', nextState: 'q' }, - 'd|D': { action_: 'q=', nextState: 'dq' }, - 'q|qd|qD|dq': { action_: [ 'output', 'q=' ], nextState: 'q' } }, - '=<>': { - '0|1|2|3|a|as|o|q|d|D|qd|qD|dq': { action_: [ { type_: 'output', option: 2 }, 'bond' ], nextState: '3' } }, - '#': { - '0|1|2|3|a|as|o': { action_: [ { type_: 'output', option: 2 }, { type_: 'bond', option: "#" } ], nextState: '3' } }, - '{}': { - '*': { action_: { type_: 'output', option: 1 }, nextState: '1' } }, - '{...}': { - '0|1|2|3|a|as|b|p|bp': { action_: 'o=', nextState: 'o' }, - 'o|d|D|q|qd|qD|dq': { action_: [ 'output', 'o=' ], nextState: 'o' } }, - '$...$': { - 'a': { action_: 'a=' }, // 2$n$ - '0|1|2|3|as|b|p|bp|o': { action_: 'o=', nextState: 'o' }, // not 'amount' - 'as|o': { action_: 'o=' }, - 'q|d|D|qd|qD|dq': { action_: [ 'output', 'o=' ], nextState: 'o' } }, - '\\bond{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'bond' ], nextState: "3" } }, - '\\frac{(...)}': { - '*': { action_: [ { type_: 'output', option: 1 }, 'frac-output' ], nextState: '3' } }, - '\\overset{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'overset-output' ], nextState: '3' } }, - '\\underset{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'underset-output' ], nextState: '3' } }, - '\\underbrace{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'underbrace-output' ], nextState: '3' } }, - '\\color{(...)}{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'color-output' ], nextState: '3' } }, - '\\color{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'color0-output' ] } }, - '\\ce{(...)}': { - '*': { action_: [ { type_: 'output', option: 2 }, 'ce' ], nextState: '3' } }, - '\\,': { - '*': { action_: [ { type_: 'output', option: 1 }, 'copy' ], nextState: '1' } }, - '\\pu{(...)}': { - '*': { action_: [ 'output', { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ], nextState: '3' } }, - '\\x{}{}|\\x{}|\\x': { - '0|1|2|3|a|as|b|p|bp|o|c0': { action_: [ 'o=', 'output' ], nextState: '3' }, - '*': { action_: ['output', 'o=', 'output' ], nextState: '3' } }, - 'others': { - '*': { action_: [ { type_: 'output', option: 1 }, 'copy' ], nextState: '3' } }, - 'else2': { - 'a': { action_: 'a to o', nextState: 'o', revisit: true }, - 'as': { action_: [ 'output', 'sb=true' ], nextState: '1', revisit: true }, - 'r|rt|rd|rdt|rdq': { action_: [ 'output' ], nextState: '0', revisit: true }, - '*': { action_: [ 'output', 'copy' ], nextState: '3' } } - }), - actions: { - 'o after d': function (buffer, m) { - let ret; - if ((buffer.d || "").match(/^[0-9]+$/)) { - const tmp = buffer.d; - buffer.d = undefined; - ret = this['output'](buffer); - buffer.b = tmp; - } else { - ret = this['output'](buffer); - } - _mhchemParser.actions['o='](buffer, m); - return ret; - }, - 'd= kv': function (buffer, m) { - buffer.d = m; - buffer.dType = 'kv'; - return undefined; - }, - 'charge or bond': function (buffer, m): undefined | Parsed[] { - if (buffer['beginsWithBond']) { - let ret: Parsed[] = []; - _mhchemParser.concatArray(ret, this['output'](buffer)); - _mhchemParser.concatArray(ret, _mhchemParser.actions['bond'](buffer, m, "-")); - return ret; - } else { - buffer.d = m; - return undefined; - } - }, - '- after o/d': function (buffer, m, isAfterD) { - let c1 = _mhchemParser.patterns.match_('orbital', buffer.o || ""); - const c2 = _mhchemParser.patterns.match_('one lowercase greek letter $', buffer.o || ""); - const c3 = _mhchemParser.patterns.match_('one lowercase latin letter $', buffer.o || ""); - const c4 = _mhchemParser.patterns.match_('$one lowercase latin letter$ $', buffer.o || ""); - const hyphenFollows = m==="-" && ( c1 && c1.remainder==="" || c2 || c3 || c4 ); - if (hyphenFollows && !buffer.a && !buffer.b && !buffer.p && !buffer.d && !buffer.q && !c1 && c3) { - buffer.o = '$' + buffer.o + '$'; - } - let ret: Parsed[] = []; - if (hyphenFollows) { - _mhchemParser.concatArray(ret, this['output'](buffer)); - ret.push({ type_: 'hyphen' }); - } else { - c1 = _mhchemParser.patterns.match_('digits', buffer.d || ""); - if (isAfterD && c1 && c1.remainder==='') { - _mhchemParser.concatArray(ret, _mhchemParser.actions['d='](buffer, m)); - _mhchemParser.concatArray(ret, this['output'](buffer)); - } else { - _mhchemParser.concatArray(ret, this['output'](buffer)); - _mhchemParser.concatArray(ret, _mhchemParser.actions['bond'](buffer, m, "-")); - } - } - return ret; - }, - 'a to o': function (buffer) { - buffer.o = buffer.a; - buffer.a = undefined; - return undefined; - }, - 'sb=true': function (buffer) { buffer.sb = true; return undefined; }, - 'sb=false': function (buffer) { buffer.sb = false; return undefined; }, - 'beginsWithBond=true': function (buffer) { buffer['beginsWithBond'] = true; return undefined; }, - 'beginsWithBond=false': function (buffer) { buffer['beginsWithBond'] = false; return undefined; }, - 'parenthesisLevel++': function (buffer) { buffer['parenthesisLevel']++; return undefined; }, - 'parenthesisLevel--': function (buffer) { buffer['parenthesisLevel']--; return undefined; }, - 'state of aggregation': function (_buffer, m) { - return { type_: 'state of aggregation', p1: _mhchemParser.go(m, 'o') }; - }, - 'comma': function (buffer, m) { - const a = m.replace(/\s*$/, ''); - const withSpace = (a !== m); - if (withSpace && buffer['parenthesisLevel'] === 0) { - return { type_: 'comma enumeration L', p1: a }; - } else { - return { type_: 'comma enumeration M', p1: a }; - } - }, - 'output': function (buffer, _m, entityFollows) { - // entityFollows: - // undefined = if we have nothing else to output, also ignore the just read space (buffer.sb) - // 1 = an entity follows, never omit the space if there was one just read before (can only apply to state 1) - // 2 = 1 + the entity can have an amount, so output a\, instead of converting it to o (can only apply to states a|as) - let ret: Parsed | Parsed[]; - if (!buffer.r) { - ret = []; - if (!buffer.a && !buffer.b && !buffer.p && !buffer.o && !buffer.q && !buffer.d && !entityFollows) { - //ret = []; - } else { - if (buffer.sb) { - ret.push({ type_: 'entitySkip' }); - } - if (!buffer.o && !buffer.q && !buffer.d && !buffer.b && !buffer.p && entityFollows!==2) { - buffer.o = buffer.a; - buffer.a = undefined; - } else if (!buffer.o && !buffer.q && !buffer.d && (buffer.b || buffer.p)) { - buffer.o = buffer.a; - buffer.d = buffer.b; - buffer.q = buffer.p; - buffer.a = buffer.b = buffer.p = undefined; - } else { - if (buffer.o && buffer.dType==='kv' && _mhchemParser.patterns.match_('d-oxidation$', buffer.d || "")) { - buffer.dType = 'oxidation'; - } else if (buffer.o && buffer.dType==='kv' && !buffer.q) { - buffer.dType = undefined; - } - } - ret.push({ - type_: 'chemfive', - a: _mhchemParser.go(buffer.a, 'a'), - b: _mhchemParser.go(buffer.b, 'bd'), - p: _mhchemParser.go(buffer.p, 'pq'), - o: _mhchemParser.go(buffer.o, 'o'), - q: _mhchemParser.go(buffer.q, 'pq'), - d: _mhchemParser.go(buffer.d, (buffer.dType === 'oxidation' ? 'oxidation' : 'bd')), - dType: buffer.dType - }); - } - } else { // r - let rd: Parsed[]; - if (buffer.rdt === 'M') { - rd = _mhchemParser.go(buffer.rd, 'tex-math'); - } else if (buffer.rdt === 'T') { - rd = [ { type_: 'text', p1: buffer.rd || "" } ]; - } else { - rd = _mhchemParser.go(buffer.rd, 'ce'); - } - let rq: Parsed[]; - if (buffer.rqt === 'M') { - rq = _mhchemParser.go(buffer.rq, 'tex-math'); - } else if (buffer.rqt === 'T') { - rq = [ { type_: 'text', p1: buffer.rq || ""} ]; - } else { - rq = _mhchemParser.go(buffer.rq, 'ce'); - } - ret = { - type_: 'arrow', - r: buffer.r, - rd: rd, - rq: rq - }; - } - for (const p in buffer) { - if (p !== 'parenthesisLevel' && p !== 'beginsWithBond') { - //@ts-ignore - delete buffer[p]; - } - } - return ret; - }, - 'oxidation-output': function (_buffer, m) { - let ret = [ "{" ]; - _mhchemParser.concatArray(ret, _mhchemParser.go(m, 'oxidation')); - ret.push("}"); - return ret; - }, - 'frac-output': function (_buffer, m) { - return { type_: 'frac-ce', p1: _mhchemParser.go(m[0], 'ce'), p2: _mhchemParser.go(m[1], 'ce') }; - }, - 'overset-output': function (_buffer, m) { - return { type_: 'overset', p1: _mhchemParser.go(m[0], 'ce'), p2: _mhchemParser.go(m[1], 'ce') }; - }, - 'underset-output': function (_buffer, m) { - return { type_: 'underset', p1: _mhchemParser.go(m[0], 'ce'), p2: _mhchemParser.go(m[1], 'ce') }; - }, - 'underbrace-output': function (_buffer, m) { - return { type_: 'underbrace', p1: _mhchemParser.go(m[0], 'ce'), p2: _mhchemParser.go(m[1], 'ce') }; - }, - 'color-output': function (_buffer, m) { - return { type_: 'color', color1: m[0], color2: _mhchemParser.go(m[1], 'ce') }; - }, - 'r=': function (buffer, m: ArrowName) { buffer.r = m; return undefined; }, - 'rdt=': function (buffer, m) { buffer.rdt = m; return undefined; }, - 'rd=': function (buffer, m) { buffer.rd = m; return undefined; }, - 'rqt=': function (buffer, m) { buffer.rqt = m; return undefined; }, - 'rq=': function (buffer, m) { buffer.rq = m; return undefined; }, - 'operator': function (_buffer, m, p1) { return { type_: 'operator', kind_: (p1 || m) } as Parsed; } - } - }, - 'a': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - '1/2$': { - '0': { action_: '1/2' } }, - 'else': { - '0': { action_: [], nextState: '1', revisit: true } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math tight', nextState: '1' } }, - ',': { - '*': { action_: { type_: 'insert', option: 'commaDecimal' } } }, - 'else2': { - '*': { action_: 'copy' } } - }), - actions: {} - }, - 'o': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - '1/2$': { - '0': { action_: '1/2' } }, - 'else': { - '0': { action_: [], nextState: '1', revisit: true } }, - 'letters': { - '*': { action_: 'rm' } }, - '\\ca': { - '*': { action_: { type_: 'insert', option: 'circa' } } }, - '\\pu{(...)}': { - '*': { action_: [ { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '\\x{}{}|\\x{}|\\x': { - '*': { action_: 'copy' } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math' } }, - '{(...)}': { - '*': { action_: [ { type_: 'write', option: "{" }, 'text', { type_: 'write', option: "}" } ] } }, - 'else2': { - '*': { action_: 'copy' } } - }), - actions: {} - }, - 'text': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - '{...}': { - '*': { action_: 'text=' } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math' } }, - '\\greek': { - '*': { action_: [ 'output', 'rm' ] } }, - '\\pu{(...)}': { - '*': { action_: [ 'output', { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '\\,|\\x{}{}|\\x{}|\\x': { - '*': { action_: [ 'output', 'copy' ] } }, - 'else': { - '*': { action_: 'text=' } } - }), - actions: { - 'output': function (buffer): undefined | Parsed { - if (buffer.text_) { - let ret: Parsed = { type_: 'text', p1: buffer.text_ }; - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - } - return undefined; - } - } - }, - 'pq': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - 'state of aggregation $': { - '*': { action_: 'state of aggregation' } }, - 'i$': { - '0': { action_: [], nextState: '!f', revisit: true } }, - '(KV letters),': { - '0': { action_: 'rm', nextState: '0' } }, - 'formula$': { - '0': { action_: [], nextState: 'f', revisit: true } }, - '1/2$': { - '0': { action_: '1/2' } }, - 'else': { - '0': { action_: [], nextState: '!f', revisit: true } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math' } }, - '{(...)}': { - '*': { action_: 'text' } }, - 'a-z': { - 'f': { action_: 'tex-math' } }, - 'letters': { - '*': { action_: 'rm' } }, - '-9.,9': { - '*': { action_: '9,9' } }, - ',': { - '*': { action_: { type_: 'insert+p1', option: 'comma enumeration S' } } }, - '\\color{(...)}{(...)}': { - '*': { action_: 'color-output' } }, - '\\color{(...)}': { - '*': { action_: 'color0-output' } }, - '\\ce{(...)}': { - '*': { action_: 'ce' } }, - '\\pu{(...)}': { - '*': { action_: [ { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '\\,|\\x{}{}|\\x{}|\\x': { - '*': { action_: 'copy' } }, - 'else2': { - '*': { action_: 'copy' } } - }), - actions: { - 'state of aggregation': function (_buffer, m) { - return { type_: 'state of aggregation subscript', p1: _mhchemParser.go(m, 'o') }; - }, - 'color-output': function (_buffer, m) { - return { type_: 'color', color1: m[0], color2: _mhchemParser.go(m[1], 'pq') }; - } - } - }, - 'bd': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - 'x$': { - '0': { action_: [], nextState: '!f', revisit: true } }, - 'formula$': { - '0': { action_: [], nextState: 'f', revisit: true } }, - 'else': { - '0': { action_: [], nextState: '!f', revisit: true } }, - '-9.,9 no missing 0': { - '*': { action_: '9,9' } }, - '.': { - '*': { action_: { type_: 'insert', option: 'electron dot' } } }, - 'a-z': { - 'f': { action_: 'tex-math' } }, - 'x': { - '*': { action_: { type_: 'insert', option: 'KV x' } } }, - 'letters': { - '*': { action_: 'rm' } }, - '\'': { - '*': { action_: { type_: 'insert', option: 'prime' } } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math' } }, - '{(...)}': { - '*': { action_: 'text' } }, - '\\color{(...)}{(...)}': { - '*': { action_: 'color-output' } }, - '\\color{(...)}': { - '*': { action_: 'color0-output' } }, - '\\ce{(...)}': { - '*': { action_: 'ce' } }, - '\\pu{(...)}': { - '*': { action_: [ { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '\\,|\\x{}{}|\\x{}|\\x': { - '*': { action_: 'copy' } }, - 'else2': { - '*': { action_: 'copy' } } - }), - actions: { - 'color-output': function (_buffer, m) { - return { type_: 'color', color1: m[0], color2: _mhchemParser.go(m[1], 'bd') }; - } - } - }, - 'oxidation': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - 'roman numeral': { - '*': { action_: 'roman-numeral' } }, - '${(...)}$__$(...)$': { - '*': { action_: 'tex-math' } }, - 'else': { - '*': { action_: 'copy' } } - }), - actions: { - 'roman-numeral': function (_buffer, m) { return { type_: 'roman numeral', p1: m }; } - } - }, - 'tex-math': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - '\\ce{(...)}': { - '*': { action_: [ 'output', 'ce' ] } }, - '\\pu{(...)}': { - '*': { action_: [ 'output', { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '{...}|\\,|\\x{}{}|\\x{}|\\x': { - '*': { action_: 'o=' } }, - 'else': { - '*': { action_: 'o=' } } - }), - actions: { - 'output': function (buffer): undefined | Parsed { - if (buffer.o) { - let ret: Parsed = { type_: 'tex-math', p1: buffer.o }; - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - } - return undefined; - } - } - }, - 'tex-math tight': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - '\\ce{(...)}': { - '*': { action_: [ 'output', 'ce' ] } }, - '\\pu{(...)}': { - '*': { action_: [ 'output', { type_: 'write', option: "{" }, 'pu', { type_: 'write', option: "}" } ] } }, - '{...}|\\,|\\x{}{}|\\x{}|\\x': { - '*': { action_: 'o=' } }, - '-|+': { - '*': { action_: 'tight operator' } }, - 'else': { - '*': { action_: 'o=' } } - }), - actions: { - 'tight operator': function (buffer, m) { buffer.o = (buffer.o || "") + "{" + m + "}"; return undefined; }, - 'output': function (buffer): undefined | Parsed { - if (buffer.o) { - let ret: Parsed = { type_: 'tex-math', p1: buffer.o }; - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - } - return undefined; - } - } - }, - '9,9': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: [] } }, - ',': { - '*': { action_: 'comma' } }, - 'else': { - '*': { action_: 'copy' } } - }), - actions: { - 'comma': function () { return { type_: 'commaDecimal' }; } - } - }, - //#endregion - // - // \pu state machines - // - //#region pu - 'pu': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - 'space$': { - '*': { action_: [ 'output', 'space' ] } }, - '{[(|)]}': { - '0|a': { action_: 'copy' } }, - '(-)(9)^(-9)': { - '0': { action_: 'number^', nextState: 'a' } }, - '(-)(9.,9)(e)(99)': { - '0': { action_: 'enumber', nextState: 'a' } }, - 'space': { - '0|a': { action_: [] } }, - 'pm-operator': { - '0|a': { action_: { type_: 'operator', option: '\\pm' }, nextState: '0' } }, - 'operator': { - '0|a': { action_: 'copy', nextState: '0' } }, - '//': { - 'd': { action_: 'o=', nextState: '/' } }, - '/': { - 'd': { action_: 'o=', nextState: '/' } }, - '{...}|else': { - '0|d': { action_: 'd=', nextState: 'd' }, - 'a': { action_: [ 'space', 'd=' ], nextState: 'd' }, - '/|q': { action_: 'q=', nextState: 'q' } } - }), - actions: { - 'enumber': function (_buffer, m) { - let ret: Parsed[] = []; - if (m[0] === "+-" || m[0] === "+/-") { - ret.push("\\pm "); - } else if (m[0]) { - ret.push(m[0]); - } - if (m[1]) { // 1.2 - _mhchemParser.concatArray(ret, _mhchemParser.go(m[1], 'pu-9,9')); - if (m[2]) { - if (m[2].match(/[,.]/)) { // 1.23456(0.01111) - _mhchemParser.concatArray(ret, _mhchemParser.go(m[2], 'pu-9,9')); - } else { // 1.23456(1111) - without spacings - ret.push(m[2]); - } - } - if (m[3] || m[4]) { // 1.2e7 1.2x10^7 - if (m[3] === "e" || m[4] === "*") { - ret.push({ type_: 'cdot' }); - } else { - ret.push({ type_: 'times' }); - } - } - } - if (m[5]) { // 10^7 - ret.push("10^{" + m[5] + "}"); - } - return ret; - }, - 'number^': function (_buffer, m) { - let ret: Parsed[] = []; - if (m[0] === "+-" || m[0] === "+/-") { - ret.push("\\pm "); - } else if (m[0]) { - ret.push(m[0]); - } - _mhchemParser.concatArray(ret, _mhchemParser.go(m[1], 'pu-9,9')); - ret.push("^{" + m[2] + "}"); - return ret; - }, - 'operator': function (_buffer, m, p1) { return { type_: 'operator', kind_: (p1 || m) } as Parsed; }, - 'space': function () { return { type_: 'pu-space-1' }; }, - 'output': function (buffer) { - let ret: Parsed | Parsed[]; - const md = _mhchemParser.patterns.match_('{(...)}', buffer.d || ""); - if (md && md.remainder === '') { buffer.d = md.match_ as string; } - const mq = _mhchemParser.patterns.match_('{(...)}', buffer.q || ""); - if (mq && mq.remainder === '') { buffer.q = mq.match_ as string; } - if (buffer.d) { - buffer.d = buffer.d.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C"); - buffer.d = buffer.d.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F"); - } - if (buffer.q) { // fraction - buffer.q = buffer.q.replace(/\u00B0C|\^oC|\^{o}C/g, "{}^{\\circ}C"); - buffer.q = buffer.q.replace(/\u00B0F|\^oF|\^{o}F/g, "{}^{\\circ}F"); - const b5 = { - d: _mhchemParser.go(buffer.d, 'pu'), - q: _mhchemParser.go(buffer.q, 'pu') - }; - if (buffer.o === '//') { - ret = { type_: 'pu-frac', p1: b5.d, p2: b5.q }; - } else { - ret = b5.d; - if (b5.d.length > 1 || b5.q.length > 1) { - ret.push({ type_: ' / ' }); - } else { - ret.push({ type_: '/' }); - } - _mhchemParser.concatArray(ret, b5.q); - } - } else { // no fraction - ret = _mhchemParser.go(buffer.d, 'pu-2'); - } - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - } - } - }, - 'pu-2': { - transitions: mhchemCreateTransitions({ - 'empty': { - '*': { action_: 'output' } }, - '*': { - '*': { action_: [ 'output', 'cdot' ], nextState: '0' } }, - '\\x': { - '*': { action_: 'rm=' } }, - 'space': { - '*': { action_: [ 'output', 'space' ], nextState: '0' } }, - '^{(...)}|^(-1)': { - '1': { action_: '^(-1)' } }, - '-9.,9': { - '0': { action_: 'rm=', nextState: '0' }, - '1': { action_: '^(-1)', nextState: '0' } }, - '{...}|else': { - '*': { action_: 'rm=', nextState: '1' } } - }), - actions: { - 'cdot': function () { return { type_: 'tight cdot' }; }, - '^(-1)': function (buffer, m) { buffer.rm += "^{" + m + "}"; return undefined; }, - 'space': function () { return { type_: 'pu-space-2' }; }, - 'output': function (buffer) { - let ret: Parsed | Parsed[] = []; - if (buffer.rm) { - const mrm = _mhchemParser.patterns.match_('{(...)}', buffer.rm || "") as MatchResult; - if (mrm && mrm.remainder === '') { - ret = _mhchemParser.go(mrm.match_, 'pu'); - } else { - ret = { type_: 'rm', p1: buffer.rm }; - } - } - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - } - } - }, - 'pu-9,9': { - transitions: mhchemCreateTransitions({ - 'empty': { - '0': { action_: 'output-0' }, - 'o': { action_: 'output-o' } }, - ',': { - '0': { action_: [ 'output-0', 'comma' ], nextState: 'o' } }, - '.': { - '0': { action_: [ 'output-0', 'copy' ], nextState: 'o' } }, - 'else': { - '*': { action_: 'text=' } } - }), - actions: { - 'comma': function () { return { type_: 'commaDecimal' }; }, - 'output-0': function (buffer) { - let ret: Parsed[] = []; - buffer.text_ = buffer.text_ || ""; - if (buffer.text_.length > 4) { - let a = buffer.text_.length % 3; - if (a === 0) { a = 3; } - for (let i=buffer.text_.length-3; i>0; i-=3) { - ret.push(buffer.text_.substr(i, 3)); - ret.push({ type_: '1000 separator' }); - } - ret.push(buffer.text_.substr(0, a)); - ret.reverse(); - } else { - ret.push(buffer.text_); - } - //@ts-ignore - for (const p in buffer) { delete buffer[p]; } - return ret; - }, - 'output-o': function (buffer) { - let ret: Parsed[] = []; - buffer.text_ = buffer.text_ || ""; - if (buffer.text_.length > 4) { - const a = buffer.text_.length - 3; - let i: number; - for (i=0; i" || buf.r === "<=>>" || buf.r === "<<=>" || buf.r === "<-->") { - // arrows that cannot stretch correctly yet, https://github.com/mathjax/MathJax/issues/1491 - arrow = "\\long" + arrow; - if (b6.rd) { arrow = "\\overset{" + b6.rd + "}{" + arrow + "}"; } - if (b6.rq) { - if (buf.r === "<-->") { - arrow = "\\underset{\\lower2mu{" + b6.rq + "}}{" + arrow + "}"; - } else { - arrow = "\\underset{\\lower6mu{" + b6.rq + "}}{" + arrow + "}"; // align with ->[][under] - } - } - arrow = " {}\\mathrel{" + arrow + "}{} "; - } else { - if (b6.rq) { arrow += "[{" + b6.rq + "}]"; } - arrow += "{" + b6.rd + "}"; - arrow = " {}\\mathrel{\\x" + arrow + "}{} "; - } - } else { - arrow = " {}\\mathrel{\\long" + arrow + "}{} "; - } - res = arrow; - break; - case 'operator': - res = _mhchemTexify._getOperator(buf.kind_); - break; - case '1st-level escape': - res = buf.p1 + " "; // &, \\\\, \\hlin - break; - case 'space': - res = " "; - break; - case 'entitySkip': - res = "~"; - break; - case 'pu-space-1': - res = "~"; - break; - case 'pu-space-2': - res = "\\mkern3mu "; - break; - case '1000 separator': - res = "\\mkern2mu "; - break; - case 'commaDecimal': - res = "{,}"; - break; - case 'comma enumeration L': - res = "{" + buf.p1 + "}\\mkern6mu "; - break; - case 'comma enumeration M': - res = "{" + buf.p1 + "}\\mkern3mu "; - break; - case 'comma enumeration S': - res = "{" + buf.p1 + "}\\mkern1mu "; - break; - case 'hyphen': - res = "\\text{-}"; - break; - case 'addition compound': - res = "\\,{\\cdot}\\,"; - break; - case 'electron dot': - res = "\\mkern1mu \\bullet\\mkern1mu "; - break; - case 'KV x': - res = "{\\times}"; - break; - case 'prime': - res = "\\prime "; - break; - case 'cdot': - res = "\\cdot "; - break; - case 'tight cdot': - res = "\\mkern1mu{\\cdot}\\mkern1mu "; - break; - case 'times': - res = "\\times "; - break; - case 'circa': - res = "{\\sim}"; - break; - case '^': - res = "uparrow"; - break; - case 'v': - res = "downarrow"; - break; - case 'ellipsis': - res = "\\ldots "; - break; - case '/': - res = "/"; - break; - case ' / ': - res = "\\,/\\,"; - break; - default: - assertNever(buf); - throw ["MhchemBugT", "mhchem bug T. Please report."]; // Missing mhchemTexify rule or unknown MhchemParser output - } - return res; - }, - _getArrow: function (a) { - switch (a) { - case "->": return "rightarrow"; - case "\u2192": return "rightarrow"; - case "\u27F6": return "rightarrow"; - case "<-": return "leftarrow"; - case "<->": return "leftrightarrow"; - case "<-->": return "leftrightarrows"; - case "<=>": return "rightleftharpoons"; - case "\u21CC": return "rightleftharpoons"; - case "<=>>": return "Rightleftharpoons"; - case "<<=>": return "Leftrightharpoons"; - default: - assertNever(a); - throw ["MhchemBugT", "mhchem bug T. Please report."]; - } - }, - _getBond: function (a) { - switch (a) { - case "-": return "{-}"; - case "1": return "{-}"; - case "=": return "{=}"; - case "2": return "{=}"; - case "#": return "{\\equiv}"; - case "3": return "{\\equiv}"; - case "~": return "{\\tripledash}"; - case "~-": return "{\\rlap{\\lower.1em{-}}\\raise.1em{\\tripledash}}"; - case "~=": return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{\\tripledash}}-}"; - case "~--": return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{\\tripledash}}-}"; - case "-~-": return "{\\rlap{\\lower.2em{-}}\\rlap{\\raise.2em{-}}\\tripledash}"; - case "...": return "{{\\cdot}{\\cdot}{\\cdot}}"; - case "....": return "{{\\cdot}{\\cdot}{\\cdot}{\\cdot}}"; - case "->": return "{\\rightarrow}"; - case "<-": return "{\\leftarrow}"; - case "<": return "{<}"; - case ">": return "{>}"; - default: - assertNever(a); - throw ["MhchemBugT", "mhchem bug T. Please report."]; - } - }, - _getOperator: function (a) { - switch (a) { - case "+": return " {}+{} "; - case "-": return " {}-{} "; - case "=": return " {}={} "; - case "<": return " {}<{} "; - case ">": return " {}>{} "; - case "<<": return " {}\\ll{} "; - case ">>": return " {}\\gg{} "; - case "\\pm": return " {}\\pm{} "; - case "\\approx": return " {}\\approx{} "; - case "$\\approx$": return " {}\\approx{} "; - case "v": return " \\downarrow{} "; - case "(v)": return " \\downarrow{} "; - case "^": return " \\uparrow{} "; - case "(^)": return " \\uparrow{} "; - default: - assertNever(a); - throw ["MhchemBugT", "mhchem bug T. Please report."]; - } - } -}; - -// -// Helpers for code anaylsis -// Will show type error at calling position -// -//@ts-ignore -function assertNever(a: number) {} diff --git a/tsconfig.json b/tsconfig.json index a31b7f54f..932f89d59 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -20,9 +20,6 @@ "outDir": "js", "typeRoots": ["./typings"] }, - "files": [ - "ts/input/tex/mhchem/mhchemparser/mhchemParser.d.ts" - ], "include": ["ts/**/*"], "exclude": ["js", "es5", "components"] } From f059ea7d5410b85f84c9166bd8de6a8fc4eeb2cb Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 26 May 2021 15:36:44 -0400 Subject: [PATCH 082/142] Implement \setOptions to change tex and package options, and allow \require to set options for the package --- components/src/dependencies.js | 2 + .../tex/extensions/setoptions/build.json | 4 + .../tex/extensions/setoptions/setoptions.js | 1 + .../extensions/setoptions/webpack.config.js | 11 ++ components/src/source.js | 1 + ts/input/tex/AllPackages.ts | 4 +- .../tex/setoptions/SetOptionsConfiguration.ts | 176 ++++++++++++++++++ ts/util/Options.ts | 2 +- 8 files changed, 199 insertions(+), 2 deletions(-) create mode 100644 components/src/input/tex/extensions/setoptions/build.json create mode 100644 components/src/input/tex/extensions/setoptions/setoptions.js create mode 100644 components/src/input/tex/extensions/setoptions/webpack.config.js create mode 100644 ts/input/tex/setoptions/SetOptionsConfiguration.ts diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 201d314a8..458ae74f2 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -24,6 +24,7 @@ export const dependencies = { '[tex]/noundefined': ['input/tex-base'], '[tex]/physics': ['input/tex-base'], '[tex]/require': ['input/tex-base'], + '[tex]/setoptions': ['input/tex-base'], '[tex]/tagformat': ['input/tex-base'], '[tex]/textmacros': ['input/tex-base'], '[tex]/unicode': ['input/tex-base'], @@ -55,6 +56,7 @@ const allPackages = [ '[tex]/noundefined', '[tex]/physics', '[tex]/require', + '[tex]/setoptions', '[tex]/tagformat', '[tex]/textmacros', '[tex]/unicode', diff --git a/components/src/input/tex/extensions/setoptions/build.json b/components/src/input/tex/extensions/setoptions/build.json new file mode 100644 index 000000000..d703672ac --- /dev/null +++ b/components/src/input/tex/extensions/setoptions/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/setoptions", + "targets": ["input/tex/setoptions"] +} diff --git a/components/src/input/tex/extensions/setoptions/setoptions.js b/components/src/input/tex/extensions/setoptions/setoptions.js new file mode 100644 index 000000000..299921694 --- /dev/null +++ b/components/src/input/tex/extensions/setoptions/setoptions.js @@ -0,0 +1 @@ +import './lib/setoptions.js'; diff --git a/components/src/input/tex/extensions/setoptions/webpack.config.js b/components/src/input/tex/extensions/setoptions/webpack.config.js new file mode 100644 index 000000000..1260438d7 --- /dev/null +++ b/components/src/input/tex/extensions/setoptions/webpack.config.js @@ -0,0 +1,11 @@ +const PACKAGE = require('../../../../../webpack.common.js'); + +module.exports = PACKAGE( + 'input/tex/extensions/setoptions', // the package to build + '../../../../../../js', // location of the MathJax js library + [ // packages to link to + 'components/src/input/tex-base/lib', + 'components/src/core/lib' + ], + __dirname // our directory +); diff --git a/components/src/source.js b/components/src/source.js index 971d9fa16..836dda067 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -28,6 +28,7 @@ export const source = { '[tex]/noundefined': `${src}/input/tex/extensions/noundefined/noundefined.js`, '[tex]/physics': `${src}/input/tex/extensions/physics/physics.js`, '[tex]/require': `${src}/input/tex/extensions/require/require.js`, + '[tex]/setoptions': `${src}/input/tex/extensions/setoptions/setoptions.js`, '[tex]/tagformat': `${src}/input/tex/extensions/tagformat/tagformat.js`, '[tex]/textmacros': `${src}/input/tex/extensions/textmacros/textmacros.js`, '[tex]/unicode': `${src}/input/tex/extensions/unicode/unicode.js`, diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index 3ed6d1c94..da76a7e0c 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -41,6 +41,7 @@ import './newcommand/NewcommandConfiguration.js'; import './noerrors/NoErrorsConfiguration.js'; import './noundefined/NoUndefinedConfiguration.js'; import './physics/PhysicsConfiguration.js'; +import './setoptions/SetOptionsConfiguration.js'; import './tagformat/TagFormatConfiguration.js'; import './textmacros/TextMacrosConfiguration.js'; import './unicode/UnicodeConfiguration.js'; @@ -71,7 +72,8 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/verb', '[tex]/configmacros', '[tex]/tagformat', - '[tex]/textmacros' + '[tex]/textmacros', + '[tex]/setoptions', ); } diff --git a/ts/input/tex/setoptions/SetOptionsConfiguration.ts b/ts/input/tex/setoptions/SetOptionsConfiguration.ts new file mode 100644 index 000000000..3d1eeee8f --- /dev/null +++ b/ts/input/tex/setoptions/SetOptionsConfiguration.ts @@ -0,0 +1,176 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the setoptions package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + +import {Configuration, ConfigurationHandler, ParserConfiguration} from '../Configuration.js'; +import {TeX} from '../../tex.js'; +import TexParser from '../TexParser.js'; +import {CommandMap} from '../SymbolMap.js'; +import TexError from '../TexError.js'; +import ParseUtil from '../ParseUtil.js'; +import {Macro} from '../Symbol.js'; +import BaseMethods from '../base/BaseMethods.js'; +import {expandable, isObject} from '../../../util/Options.js'; + +export const SetOptionsUtil = { + + /** + * Check if options can be set for a given pacakge, and error otherwise. + * + * @param {TexParser} parser The active tex parser. + * @param {string} extension The name of the package whose option is being set. + * @return {boolean} True when options can be set for this package. + */ + filterPackage(parser: TexParser, extension: string): boolean { + if (extension !== 'tex' && !ConfigurationHandler.get(extension)) { + throw new TexError('NotAPackage', 'Not a defined package: %1', extension); + } + const config = parser.options.setoptions; + const options = config.allowOptions[extension]; + if ((options === undefined && !config.allowPackageDefault) || options === false) { + throw new TexError('PackageNotSettable', 'Options can\'t be set for package "%1"', extension); + } + return true; + }, + + /** + * Check if an option can be set and error otherwise. + * + * @param {TexParser} parser The active tex parser. + * @param {string} extension The name of the package whose option is being set. + * @param {string} option The name of the option being set. + * @return {boolean} True when the option can be set. + */ + filterOption(parser: TexParser, extension: string, option: string): boolean { + const config = parser.options.setoptions; + const options = config.allowOptions[extension] || {}; + const allow = (options.hasOwnProperty(option) && !isObject(options[option]) ? options[option] : null); + if (allow === false || (allow === null && !config.allowOptionsDefault)) { + throw new TexError('OptionNotSettable', 'Option "%1" is not allowed to be set', option); + } + if (!(extension === 'tex' ? parser.options : parser.options[extension])?.hasOwnProperty(option)) { + if (extension === 'tex') { + throw new TexError('InvalidTexOption', 'Invalid TeX option "%1"', option); + } else { + throw new TexError('InvalidOptionKey', 'Invalid option "%1" for package "%2"', option, extension); + } + } + return true; + }, + + /** + * Verify an option's value before setting it. + * + * @param {TexParser} parser The active tex parser. + * @param {string} extension The name of the package whose option this is. + * @param {string} option The name of the option being set. + * @param {string} value The value to give to the option. + * @return {string} The (possibly modified) value for the option + */ + filterValue(_parser: TexParser, _extension: string, _option: string, value: string): string { + return value; + } + +}; + +const setOptionsMap = new CommandMap('setoptions', { + setOptions: 'SetOptions' +}, { + /** + * Implements \setOptions[package]{option-values} + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the macro being processed. + */ + SetOptions(parser: TexParser, name: string) { + const extension = parser.GetBrackets(name) || 'tex'; + const options = ParseUtil.keyvalOptions(parser.GetArgument(name)); + const config = parser.options.setoptions; + if (!config.filterPackage(parser, extension)) return; + for (const key of Object.keys(options)) { + if (config.filterOption(parser, extension, key)) { + (extension === 'tex' ? parser.options : parser.options[extension])[key] = + config.filterValue(parser, extension, key, options[key]); + } + } + } +}); + +/** + * If the require package is available, save the original require, + * and define a macro that loads the extension and sets + * its options, if any. + * + * @param {ParserConfiguration} config The current configuration. + * @param {TeX} jax The active tex input jax. + */ +function setoptionsConfig(_config: ParserConfiguration, jax: TeX) { + const require = jax.parseOptions.handlers.get('macro').lookup('require') as any; + if (require) { + setOptionsMap.add('Require', new Macro('Require', require._func)); + setOptionsMap.add('require', new Macro('require', BaseMethods.Macro, + ['\\Require{#2}\\setOptions[#2]{#1}', 2, ''])); + } +} + +export const SetOptionsConfiguration = Configuration.create( + 'setoptions', { + handler: {macro: ['setoptions']}, + config: setoptionsConfig, + priority: 3, // must be less than the priority of the require package (which is 5). + options: { + setoptions: { + filterPackage: SetOptionsUtil.filterPackage, // filter for whether a package can be configured + filterOption: SetOptionsUtil.filterOption, // filter for whether an option can be set + filterValue: SetOptionsUtil.filterValue, // filter for the value to assign to an option + allowPackageDefault: true, // default for allowing packages if not erxplicitly set in allowOptions + allowOptionsDefault: true, // default for allowing option that isn't explicitly set in allowOptions + allowOptions: expandable({ // list of packages to allow/disablow, and their options to allow/disallow + // + // top-level tex items can be set, but not these + // (that leaves digits and the tagging options) + // + tex: { + FindTeX: false, + formatError: false, + package: false, + baseURL: false, + tags: false, + maxBuffer: false, + maxMaxros: false, + macros: false, + environments: false + }, + // + // These packages can't be configured at all + // + setoptions: false, + autoload: false, + require: false, + configmacros: false, + tagformat: false + }) + } + } + } +); diff --git a/ts/util/Options.ts b/ts/util/Options.ts index f64ff2437..34118d606 100644 --- a/ts/util/Options.ts +++ b/ts/util/Options.ts @@ -29,7 +29,7 @@ const OBJECT = {}.constructor; /** * Check if an object is an object literal (as opposed to an instance of a class) */ -function isObject(obj: any) { +export function isObject(obj: any) { return typeof obj === 'object' && obj !== null && (obj.constructor === OBJECT || obj.constructor === Expandable); } From 88fed2ff268b32d09ba16b0367753cadd5cd6d11 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 09:19:58 -0400 Subject: [PATCH 083/142] Make changes requested in review --- ts/core/MmlTree/MmlNodes/mtable.ts | 2 +- .../tex/mathtools/MathtoolsConfiguration.ts | 2 +- ts/input/tex/mathtools/MathtoolsMethods.ts | 19 ++++++++++++++----- 3 files changed, 16 insertions(+), 7 deletions(-) diff --git a/ts/core/MmlTree/MmlNodes/mtable.ts b/ts/core/MmlTree/MmlNodes/mtable.ts index 870272e98..cc69b9a2d 100644 --- a/ts/core/MmlTree/MmlNodes/mtable.ts +++ b/ts/core/MmlTree/MmlNodes/mtable.ts @@ -127,7 +127,7 @@ export class MmlMtable extends AbstractMmlNode { const ralign = split(this.attributes.get('rowalign') as string); for (const child of this.childNodes) { attributes.rowalign[1] = ralign.shift() || attributes.rowalign[1]; - child.setInheritedAttributes(attributes, display, level, cramped == null ? false : cramped); + child.setInheritedAttributes(attributes, display, level, !!cramped); } } diff --git a/ts/input/tex/mathtools/MathtoolsConfiguration.ts b/ts/input/tex/mathtools/MathtoolsConfiguration.ts index 4cdd91b51..bc504792a 100644 --- a/ts/input/tex/mathtools/MathtoolsConfiguration.ts +++ b/ts/input/tex/mathtools/MathtoolsConfiguration.ts @@ -49,7 +49,7 @@ function initMathtools(config: ParserConfiguration) { } /** - * Add any pre-defined paried delimiters, and subclass the configured tag format. + * Add any pre-defined paired delimiters, and subclass the configured tag format. * @param {ParserConfiguration} config The current configuration. * @param {TeX} jac The TeX input jax */ diff --git a/ts/input/tex/mathtools/MathtoolsMethods.ts b/ts/input/tex/mathtools/MathtoolsMethods.ts index 4562485dc..91f8ee980 100644 --- a/ts/input/tex/mathtools/MathtoolsMethods.ts +++ b/ts/input/tex/mathtools/MathtoolsMethods.ts @@ -41,7 +41,7 @@ import {MathtoolsTags} from './MathtoolsTags.js'; import {MathtoolsUtil} from './MathtoolsUtil.js'; /** - * The implementations for the macros and environemtns for the mathtools package. + * The implementations for the macros and environments for the mathtools package. */ export const MathtoolsMethods: Record = { @@ -104,7 +104,7 @@ export const MathtoolsMethods: Record = { }, /** - * Replacement for the AMS HandleShove that incldues optional spacing values + * Replacement for the AMS HandleShove that includes optional spacing values * * @param {TexParser} parser The active tex parser. * @param {string} name The name of the calling macro. @@ -400,10 +400,17 @@ export const MathtoolsMethods: Record = { const base = new TexParser(arg, parser.stack.env, parser.configuration).mml(); let mml = parser.create('node', 'mpadded', [ parser.create('node', 'mpadded', [ - parser.create('node', 'mo', [parser.create('text', '\u22EE')]) - ], {width: 0, lspace: '-.5width', ...(isFlush ? {height: '-.6em', voffset: '-.18em'} : {})}), + parser.create('node', 'mo', [ + parser.create('text', '\u22EE') + ]) + ], { + width: 0, + lspace: '-.5width', ...(isFlush ? {height: '-.6em', voffset: '-.18em'} : {}) + }), parser.create('node', 'mphantom', [base]) - ], {lspace: '.5width'}); + ], { + lspace: '.5width' + }); parser.Push(mml); }, @@ -573,6 +580,8 @@ export const MathtoolsMethods: Record = { * * @param {TexParser} parser The calling parser. * @param {string} name The macro name. + * @param {string} c The base arrow for the slashed version + * @param {string} dy A vertical offset for the slash */ NArrow(parser: TexParser, _name: string, c: string, dy: string) { parser.Push( From 114c556371ccaadd253865b014084a333b72abff Mon Sep 17 00:00:00 2001 From: zorkow Date: Tue, 1 Jun 2021 17:11:53 +0100 Subject: [PATCH 084/142] Incorporates review suggestions. --- ts/input/tex/physics/PhysicsMappings.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index 7952cb87a..55e5c291d 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -127,13 +127,13 @@ new CommandMap('Physics-expressions-macros', { 'Trace': ['Expression', false, 'Tr'], 'rank': 'NamedFn', 'erf': ['Expression', false], - 'Residue': ['Macro', '{\\rm Res}'], + 'Residue': ['Macro', '\\mathrm{Res}'], 'Res': ['OperatorApplication', '\\Residue', '(', '[', '{'], 'principalvalue': ['OperatorApplication', '{\\cal P}'], 'pv': ['OperatorApplication', '{\\cal P}'], 'PV': ['OperatorApplication', '{\\rm P.V.}'], - 'Re': ['OperatorApplication', '{\\rm Re}', '{'], - 'Im': ['OperatorApplication', '{\\rm Im}', '{'], + 'Re': ['OperatorApplication', '\\mathrm{Re}', '{'], + 'Im': ['OperatorApplication', '\\mathrm{Im}', '{'], // Old named functions. 'sine': ['NamedFn', 'sin'], 'hypsine': ['NamedFn', 'sinh'], From 43db147dcf2c539437f84cdc7dcfdd1e5c5c812d Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 15:08:42 -0400 Subject: [PATCH 085/142] Make changes requested by code review. Also move copyMml() to MmlNode, since it is useful in order situations, as well. --- components/src/dependencies.js | 4 +- .../src/input/tex/extensions/cases/build.json | 4 + .../src/input/tex/extensions/cases/cases.js | 1 + .../{numcases => cases}/webpack.config.js | 2 +- .../input/tex/extensions/numcases/build.json | 4 - .../input/tex/extensions/numcases/numcases.js | 1 - components/src/source.js | 2 +- ts/core/MmlTree/MmlNode.ts | 61 +++++ ts/core/Tree/Node.ts | 17 ++ ts/input/tex/AllPackages.ts | 12 +- .../CasesConfiguration.ts} | 60 ++++- ts/input/tex/empheq/EmpheqConfiguration.ts | 212 +++++----------- ts/input/tex/empheq/EmpheqUtil.ts | 228 ++++++++++++++++++ 13 files changed, 437 insertions(+), 171 deletions(-) create mode 100644 components/src/input/tex/extensions/cases/build.json create mode 100644 components/src/input/tex/extensions/cases/cases.js rename components/src/input/tex/extensions/{numcases => cases}/webpack.config.js (90%) delete mode 100644 components/src/input/tex/extensions/numcases/build.json delete mode 100644 components/src/input/tex/extensions/numcases/numcases.js rename ts/input/tex/{numcases/NumcasesConfiguration.ts => cases/CasesConfiguration.ts} (82%) create mode 100644 ts/input/tex/empheq/EmpheqUtil.ts diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 0309cb069..69bc89ebd 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -28,7 +28,7 @@ export const dependencies = { '[tex]/textmacros': ['input/tex-base'], '[tex]/unicode': ['input/tex-base'], '[tex]/verb': ['input/tex-base'], - '[tex]/numcases': ['[tex]/empheq'], + '[tex]/cases': ['[tex]/empheq'], '[tex]/empheq': ['input/tex-base', '[tex]/ams'] }; @@ -61,7 +61,7 @@ const allPackages = [ '[tex]/textmacros', '[tex]/unicode', '[tex]/verb', - '[tex]/numcases', + '[tex]/cases', '[tex]/empheq' ]; diff --git a/components/src/input/tex/extensions/cases/build.json b/components/src/input/tex/extensions/cases/build.json new file mode 100644 index 000000000..b7549fde4 --- /dev/null +++ b/components/src/input/tex/extensions/cases/build.json @@ -0,0 +1,4 @@ +{ + "component": "input/tex/extensions/cases", + "targets": ["input/tex/cases"] +} diff --git a/components/src/input/tex/extensions/cases/cases.js b/components/src/input/tex/extensions/cases/cases.js new file mode 100644 index 000000000..9102348a7 --- /dev/null +++ b/components/src/input/tex/extensions/cases/cases.js @@ -0,0 +1 @@ +import './lib/cases.js'; diff --git a/components/src/input/tex/extensions/numcases/webpack.config.js b/components/src/input/tex/extensions/cases/webpack.config.js similarity index 90% rename from components/src/input/tex/extensions/numcases/webpack.config.js rename to components/src/input/tex/extensions/cases/webpack.config.js index 5c000550d..8b5ed697e 100644 --- a/components/src/input/tex/extensions/numcases/webpack.config.js +++ b/components/src/input/tex/extensions/cases/webpack.config.js @@ -1,7 +1,7 @@ const PACKAGE = require('../../../../../webpack.common.js'); module.exports = PACKAGE( - 'numcases', // the package to build + 'cases', // the package to build '../../../../../js', // location of the compiled js files [ // packages to link to (relative to Mathjax components) 'components/src/input/tex-base/lib', diff --git a/components/src/input/tex/extensions/numcases/build.json b/components/src/input/tex/extensions/numcases/build.json deleted file mode 100644 index 412c9d56f..000000000 --- a/components/src/input/tex/extensions/numcases/build.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "component": "input/tex/extensions/numcases", - "targets": ["input/tex/numcases"] -} diff --git a/components/src/input/tex/extensions/numcases/numcases.js b/components/src/input/tex/extensions/numcases/numcases.js deleted file mode 100644 index f383ce4ae..000000000 --- a/components/src/input/tex/extensions/numcases/numcases.js +++ /dev/null @@ -1 +0,0 @@ -import './lib/numcases.js'; diff --git a/components/src/source.js b/components/src/source.js index d262b5476..922499811 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -32,7 +32,7 @@ export const source = { '[tex]/textmacros': `${src}/input/tex/extensions/textmacros/textmacros.js`, '[tex]/unicode': `${src}/input/tex/extensions/unicode/unicode.js`, '[tex]/verb': `${src}/input/tex/extensions/verb/verb.js`, - '[tex]/numcases': `${src}/input/tex/extensions/numcases/numcases.js`, + '[tex]/cases': `${src}/input/tex/extensions/cases/cases.js`, '[tex]/empheq': `${src}/input/tex/extensions/empheq/empheq.js`, 'input/mml': `${src}/input/mml/mml.js`, 'input/mml/entities': `${src}/input/mml/entities/entities.js`, diff --git a/ts/core/MmlTree/MmlNode.ts b/ts/core/MmlTree/MmlNode.ts index be06fd06a..02d725dd0 100644 --- a/ts/core/MmlTree/MmlNode.ts +++ b/ts/core/MmlTree/MmlNode.ts @@ -87,6 +87,7 @@ export type MMLNODE = MmlNode | TextNode | XMLNode; */ export interface MmlNode extends Node { + /** * Test various properties of MathML nodes */ @@ -95,21 +96,25 @@ export interface MmlNode extends Node { readonly isSpacelike: boolean; readonly linebreakContainer: boolean; readonly hasNewLine: boolean; + /** * The expected number of children (-1 means use inferred mrow) */ readonly arity: number; readonly isInferred: boolean; + /** * Get the parent node (skipping inferred mrows and * other nodes marked as notParent) */ readonly Parent: MmlNode; readonly notParent: boolean; + /** * The actual parent in the tree */ parent: MmlNode; + /** * values needed for TeX spacing computations */ @@ -127,16 +132,19 @@ export interface MmlNode extends Node { * core node. For non-embellished nodes, the original node. */ core(): MmlNode; + /** * @return {MmlNode} For embellished operators, the core element (at whatever * depth). For non-embellished nodes, the original node itself. */ coreMO(): MmlNode; + /** * @return {number} For embellished operators, the index of the child node containing * the core . For non-embellished nodes, 0. */ coreIndex(): number; + /** * @return {number} The index of this node in its parent's childNodes array. */ @@ -149,10 +157,12 @@ export interface MmlNode extends Node { * in the tree (usually, either the last child, or the node itself) */ setTeXclass(prev: MmlNode): MmlNode; + /** * @return {string} The spacing to use before this element (one of TEXSPACELENGTH array above) */ texSpacing(): string; + /** * @return {boolean} The core mo element has an explicit 'form', 'lspace', or 'rspace' attribute */ @@ -201,10 +211,12 @@ export interface MmlNode extends Node { */ export interface MmlNodeClass extends NodeClass { + /** * The list of default attribute values for nodes of this class */ defaults?: PropertyList; + /** * An MmlNode takes a NodeFactory (so it can create additional nodes as needed), a list * of attributes, and an array of children and returns the desired MmlNode with @@ -216,6 +228,7 @@ export interface MmlNodeClass extends NodeClass { * @param {MmlNode[]} children The initial child nodes (more can be added later) */ new (factory: MmlFactory, attributes?: PropertyList, children?: MmlNode[]): MmlNode; + } @@ -237,6 +250,7 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { // scale all spaces, fractions, etc. dir: INHERIT }; + /** * This lists properties that do NOT get inherited between specific kinds * of nodes. The outer keys are the node kinds that are being inherited FROM, @@ -285,6 +299,7 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { * The TeX class for the preceding node */ public prevClass: number = null; + /** * The scriptlevel of the preceding node */ @@ -299,10 +314,12 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { * Child nodes are MmlNodes (special case of Nodes). */ public childNodes: MmlNode[]; + /** * The parent is an MmlNode */ public parent: MmlNode; + /** * The node factory is an MmlFactory */ @@ -330,6 +347,36 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { this.attributes.setList(attributes); } + /** + * @override + * + * @param {boolean} keepIds True to copy id attributes, false to skip them. + */ + public copy(keepIds: boolean = false): AbstractMmlNode { + const node = this.factory.create(this.kind) as AbstractMmlNode; + node.properties = {...this.properties}; + if (this.attributes) { + const attributes = this.attributes.getAllAttributes(); + for (const name of Object.keys(attributes)) { + if (name !== 'id' || keepIds) { + node.attributes.set(name, attributes[name]); + } + } + } + if (this.childNodes && this.childNodes.length) { + let children = this.childNodes as MmlNode[]; + if (children.length === 1 && children[0].isInferred) { + children = children[0].childNodes as MmlNode[]; + } + for (const child of children) { + if (child) { + node.appendChild(child.copy() as MmlNode); + } + } + } + return node; + } + /** * The TeX class for this node */ @@ -1150,6 +1197,13 @@ export class TextNode extends AbstractMmlEmptyNode { return this; } + /** + * @override + */ + public copy() { + return (this.factory.create(this.kind) as TextNode).setText(this.getText()); + } + /** * Just use the text */ @@ -1208,6 +1262,13 @@ export class XMLNode extends AbstractMmlEmptyNode { return this.adaptor.outerHTML(this.xml); } + /** + * @override + */ + public copy(): XMLNode { + return (this.factory.create(this.kind) as XMLNode).setXML(this.adaptor.clone(this.xml)); + } + /** * Just indicate that this is XML data */ diff --git a/ts/core/Tree/Node.ts b/ts/core/Tree/Node.ts index 75751fe54..c1e7477e0 100644 --- a/ts/core/Tree/Node.ts +++ b/ts/core/Tree/Node.ts @@ -102,6 +102,11 @@ export interface Node { */ childIndex(child: Node): number; + /** + * Make a deep copy of the node (but with no parent). + */ + copy(): Node; + /** * @param {string} kind The kind of nodes to be located in the tree * @return {Node[]} An array of nodes that are children (at any depth) of the given kind @@ -264,6 +269,18 @@ export abstract class AbstractNode implements Node { } + /** + * @override + */ + public copy() { + const node = (this as AbstractNode).factory.create(this.kind) as AbstractNode; + node.properties = {...this.properties}; + for (const child of this.childNodes || []) { + if (child) node.appendChild(child.copy()); + } + return node; + } + /** * @override */ diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index dfb548fc4..c28b91088 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -30,9 +30,11 @@ import './boldsymbol/BoldsymbolConfiguration.js'; import './braket/BraketConfiguration.js'; import './bussproofs/BussproofsConfiguration.js'; import './cancel/CancelConfiguration.js'; +import './cases/CasesConfiguration.js'; import './color/ColorConfiguration.js'; import './colorv2/ColorV2Configuration.js'; import './configmacros/ConfigMacrosConfiguration.js'; +import './empheq/EmpheqConfiguration.js'; import './enclose/EncloseConfiguration.js'; import './extpfeil/ExtpfeilConfiguration.js'; import './html/HtmlConfiguration.js'; @@ -45,8 +47,6 @@ import './tagformat/TagFormatConfiguration.js'; import './textmacros/TextMacrosConfiguration.js'; import './unicode/UnicodeConfiguration.js'; import './verb/VerbConfiguration.js'; -import './numcases/NumcasesConfiguration.js'; -import './empheq/EmpheqConfiguration.js'; declare const MathJax: any; if (typeof MathJax !== 'undefined' && MathJax.loader) { @@ -59,8 +59,10 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/braket', '[tex]/bussproofs', '[tex]/cancel', + '[tex]/cases', '[tex]/color', '[tex]/colorv2', + '[tex]/empheq', '[tex]/enclose', '[tex]/extpfeil', '[tex]/html', @@ -71,8 +73,6 @@ if (typeof MathJax !== 'undefined' && MathJax.loader) { '[tex]/physics', '[tex]/unicode', '[tex]/verb', - '[tex]/numcases', - '[tex]/empheq', '[tex]/configmacros', '[tex]/tagformat', '[tex]/textmacros' @@ -89,7 +89,9 @@ export const AllPackages: string[] = [ 'braket', 'bussproofs', 'cancel', + 'cases', 'color', + 'empheq', 'enclose', 'extpfeil', 'html', @@ -99,8 +101,6 @@ export const AllPackages: string[] = [ 'noundefined', 'unicode', 'verb', - 'numcases', - 'empheq', 'configmacros', 'tagformat', 'textmacros' diff --git a/ts/input/tex/numcases/NumcasesConfiguration.ts b/ts/input/tex/cases/CasesConfiguration.ts similarity index 82% rename from ts/input/tex/numcases/NumcasesConfiguration.ts rename to ts/input/tex/cases/CasesConfiguration.ts index bdf80fc75..dc000c985 100644 --- a/ts/input/tex/numcases/NumcasesConfiguration.ts +++ b/ts/input/tex/cases/CasesConfiguration.ts @@ -8,14 +8,23 @@ import {BeginItem, EqnArrayItem} from '../base/BaseItems.js'; import {AmsTags} from '../ams/AmsConfiguration.js'; import {StackItem, CheckType} from '../StackItem.js'; import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; -import {EmpheqUtil} from '../empheq/EmpheqConfiguration.js'; +import {EmpheqUtil} from '../empheq/EmpheqUtil.js'; +/** + * The StakItem for the numcases environment. + */ export class CasesBeginItem extends BeginItem { + /** + * @override + */ get kind() { return 'cases-begin'; } + /** + * @override + */ public checkItem(item: StackItem) { if (item.isKind('end') && item.getName() === this.getName()) { if (this.getProperty('end')) { @@ -25,16 +34,30 @@ export class CasesBeginItem extends BeginItem { } return super.checkItem(item); } + } +/** + * A tagging class for the subnumcases environment. + */ export class CasesTags extends AmsTags { + + /** + * The counter for the subnumber. + */ protected subcounter = 0; + /** + * @override + */ public start(env: string, taggable: boolean, defaultTags: boolean) { this.subcounter = 0; super.start(env, taggable, defaultTags); } + /** + * @override + */ public autoTag() { if (this.currentTag.tag != null) return; if (this.currentTag.env === 'subnumcases') { @@ -47,6 +70,9 @@ export class CasesTags extends AmsTags { } } + /** + * @override + */ public formatNumber(n: number, m: number = null) { return n.toString() + (m === null ? '' : String.fromCharCode(0x60 + m)); } @@ -54,13 +80,20 @@ export class CasesTags extends AmsTags { } export const NumcasesMethods = { + + /** + * Implements the numcases environment. + * + * @param {TexParser} texparser The active tex parser. + * @param {CasesBeginItem} begin The environment begin item. + */ NumCases(parser: TexParser, begin: CasesBeginItem) { if (parser.stack.env.closing === begin.getName()) { delete parser.stack.env.closing; parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); // finish eqnarray const cases = parser.stack.Top(); const table = cases.Last as MmlMtable; - const original = EmpheqUtil.copyMml(table) as MmlMtable; + const original = table.copy() as MmlMtable; const left = cases.getProperty('left'); EmpheqUtil.left(table, original, left + '\\empheqlbrace\\,', parser, 'numcases-left'); parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); @@ -77,6 +110,9 @@ export const NumcasesMethods = { } }, + /** + * Replacement for & in cases environment. + */ Entry(parser: TexParser, name: string) { if (!parser.stack.Top().getProperty('numCases')) { return BaseMethods.Entry(parser, name); @@ -139,32 +175,38 @@ export const NumcasesMethods = { // // Process the second column as text and continue parsing from there, // - const text = tex.substr(parser.i, i - parser.i); + const text = tex.substr(parser.i, i - parser.i).replace(/^\s*/, ''); parser.PushAll(ParseUtil.internalMath(parser, text, 0)); parser.i = i; } }; -new EnvironmentMap('numcases-env', EmpheqUtil.environment, { +/** + * The environments for this package + */ +new EnvironmentMap('cases-env', EmpheqUtil.environment, { numcases: ['NumCases', 'cases'], subnumcases: ['NumCases', 'cases'] }, NumcasesMethods); -new MacroMap('numcases-macros', { +/** + * The macros for this package + */ +new MacroMap('cases-macros', { '&': 'Entry' }, NumcasesMethods); // // Define the package for our new environment // -export const NumcasesConfiguration = Configuration.create('numcases', { +export const NumcasesConfiguration = Configuration.create('cases', { handler: { - environment: ['numcases-env'], - character: ['numcases-macros'] + environment: ['cases-env'], + character: ['cases-macros'] }, items: { [CasesBeginItem.prototype.kind]: CasesBeginItem }, - tags: {'numcases': CasesTags} + tags: {'cases': CasesTags} }); diff --git a/ts/input/tex/empheq/EmpheqConfiguration.ts b/ts/input/tex/empheq/EmpheqConfiguration.ts index f1d8bdee5..0099a6037 100644 --- a/ts/input/tex/empheq/EmpheqConfiguration.ts +++ b/ts/input/tex/empheq/EmpheqConfiguration.ts @@ -1,172 +1,72 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the empheq package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + + import {Configuration} from '../Configuration.js'; import {CommandMap, EnvironmentMap} from '../SymbolMap.js'; import ParseUtil from '../ParseUtil.js'; import TexParser from '../TexParser.js'; import TexError from '../TexError.js'; -import {AbstractTags} from '../Tags.js'; import {BeginItem} from '../base/BaseItems.js'; import {StackItem} from '../StackItem.js'; -import {AbstractMmlNode, MmlNode, TextNode} from '../../../core/MmlTree/MmlNode.js'; -import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; -import {MmlMtd} from '../../../core/MmlTree/MmlNodes/mtd.js'; +import {EmpheqUtil} from './EmpheqUtil.js'; +/** + * A StackItem for empheq environments. + */ export class EmpheqBeginItem extends BeginItem { - public options = {}; + /** + * @override + */ public get kind() { return 'empheq-begin'; } + /** + * @override + */ public checkItem(item: StackItem) { if (item.isKind('end') && item.getName() === this.getName()) { this.setProperty('end', false); } return super.checkItem(item); } -} - -export const EmpheqUtil = { - - environment(parser: TexParser, env: string, func: Function, args: any[]) { - const name = args[0]; - const item = parser.itemFactory.create(name + '-begin').setProperties({name: env, end: name}); - parser.Push(func(parser, item, ...args.slice(1))); - }, - - copyMml(node: MmlNode) { - if (!node) return null; - const mml = (node as AbstractMmlNode).factory.create(node.kind); - if (node.isKind('text')) { - (mml as TextNode).setText((node as TextNode).getText()); - return mml; - } - if (node.attributes) { - const attributes = node.attributes.getAllAttributes(); - for (const name of Object.keys(attributes)) { - if (name !== 'id') { - mml.attributes.set(name, attributes[name]); - } - } - } - if (node.childNodes && node.childNodes.length) { - let children = node.childNodes; - if (children.length === 1 && children[0].isKind('inferredMrow')) { - children = children[0].childNodes; - } - for (const child of children) { - if (child) mml.appendChild(this.copyMml(child)); - } - } - return mml; - }, - - splitOptions(text: string, allowed: {[key: string]: number} = null) { - return ParseUtil.keyvalOptions(text, allowed, true); - }, - - columnCount(table: MmlMtable) { - let m = 0; - for (const row of table.childNodes) { - const n = row.childNodes.length - (row.isKind('mlabeledtr') ? 1 : 0); - if (n > m) m = n; - } - return m; - }, - - cellBlock(tex: string, table: MmlMtable, parser: TexParser, env: string) { - const mpadded = parser.create('node', 'mpadded', [], {height: 0, depth: 0, voffset: '-1height'}); - const result = new TexParser(tex, parser.stack.env, parser.configuration); - const mml = result.mml(); - if (env && result.configuration.tags.label) { - (result.configuration.tags.currentTag as any).env = env; - (result.configuration.tags as AbstractTags).getTag(true); - } - for (const child of (mml.isInferred ? mml.childNodes : [mml])) { - mpadded.appendChild(child); - } - mpadded.appendChild(parser.create('node', 'mphantom', [ - parser.create('node', 'mpadded', [table], {width: 0}) - ])); - return mpadded; - }, - topRowTable(original: MmlMtable, parser: TexParser) { - const table = this.copyMml(original); - table.setChildren(table.childNodes.slice(0, 1)); - table.attributes.set('align', 'baseline 1'); - return original.factory.create('mphantom', {}, [parser.create('node', 'mpadded', [table], {width: 0})]); - }, - - rowspanCell(mtd: MmlMtd, tex: string, table: MmlMtable, parser: TexParser, env: string) { - mtd.appendChild( - parser.create('node', 'mpadded', [ - this.cellBlock(tex, this.copyMml(table), parser, env), - this.topRowTable(table, parser) - ], {height: 0, depth: 0, voffset: 'height'}) - ); - }, - - left(table: MmlMtable, original: MmlMtable, left: string, parser: TexParser, env: string = '') { - table.attributes.set('columnalign', 'right ' + (table.attributes.get('columnalign') || '')); - table.attributes.set('columnspacing', '0em ' + (table.attributes.get('columnspacing') || '')); - let mtd; - for (const row of table.childNodes.slice(0).reverse()) { - mtd = parser.create('node', 'mtd'); - row.childNodes.unshift(mtd); - row.replaceChild(mtd, mtd); // make sure parent is set - if (row.isKind('mlabeledtr')) { - row.childNodes[0] = row.childNodes[1]; - row.childNodes[1] = mtd; - } - } - this.rowspanCell(mtd, left, original, parser, env); - }, - - right(table: MmlMtable, original: MmlMtable, right: string, parser: TexParser, env: string = '') { - if (table.childNodes.length === 0) { - table.appendChild(parser.create('node', 'mtr')); - } - const m = EmpheqUtil.columnCount(table); - const row = table.childNodes[0]; - while (row.childNodes.length < m) row.appendChild(parser.create('node', 'mtd')); - const mtd = row.appendChild(parser.create('node', 'mtd')) as MmlMtd; - EmpheqUtil.rowspanCell(mtd, right, original, parser, env); - table.attributes.set( - 'columnalign', - (table.attributes.get('columnalign') as string || '').split(/ /).slice(0, m).join(' ') + ' left' - ); - table.attributes.set( - 'columnspacing', - (table.attributes.get('columnspacing') as string || '').split(/ /).slice(0, m - 1).join(' ') + ' 0em' - ); - }, - - adjustTable(empheq: EmpheqBeginItem, parser: TexParser) { - const options = empheq.options as {left: string, right: string}; - if (options.left || options.right) { - const table = empheq.Last; - const original = this.copyMml(table); - if (options.left) this.left(table, original, options.left, parser); - if (options.right) this.right(table, original, options.right, parser); - } - }, - - allowEnv: { - equation: true, - align: true, - gather: true, - flalign: true, - alignat: true, - multline: true - }, - - checkEnv(env: string) { - return this.allowEnv[env.replace(/\*$/, '')] || false; - } - -}; +} +/** + * The methods that implement the empheq package. + */ export const EmpheqMethods = { + + /** + * Handle an empheq environment. + * + * @param {TexParser} parser The active tex parser. + * @param {EmpheqBeginItem} begin The begin item for this environment. + */ Empheq(parser: TexParser, begin: EmpheqBeginItem) { if (parser.stack.env.closing === begin.getName()) { delete parser.stack.env.closing; @@ -183,7 +83,9 @@ export const EmpheqMethods = { if (!EmpheqUtil.checkEnv(env)) { throw new TexError('UnknownEnv', 'Unknown environment "%1"', env); } - begin.options = (opts ? EmpheqUtil.splitOptions(opts, {left: 1, right: 1}) : {}); + if (opts) { + begin.setProperties(EmpheqUtil.splitOptions(opts, {left: 1, right: 1})); + } parser.stack.global.empheq = env; parser.string = '\\begin{' + env + '}' + (n ? '{' + n + '}' : '') + parser.string.slice(parser.i); parser.i = 0; @@ -191,10 +93,23 @@ export const EmpheqMethods = { } }, + /** + * Create an with a given content + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the macro being processed. + * @param {string} c The character for the + */ EmpheqMO(parser: TexParser, _name: string, c: string) { parser.Push(parser.create('token', 'mo', {}, c)); }, + /** + * Create a delimiter with a given character + * + * @param {TexParser} parser The active tex parser. + * @param {string} name The name of the macro being processed. + */ EmpheqDelim(parser: TexParser, name: string) { const c = parser.GetDelimiter(name); parser.Push(parser.create('token', 'mo', {stretchy: true, symmetric: true}, c)); @@ -209,6 +124,9 @@ new EnvironmentMap('empheq-env', EmpheqUtil.environment, { empheq: ['Empheq', 'empheq'], }, EmpheqMethods); +// +// Define the empheq characters +// new CommandMap('empheq-macros', { empheqlbrace: ['EmpheqMO', '{'], empheqrbrace: ['EmpheqMO', '}'], diff --git a/ts/input/tex/empheq/EmpheqUtil.ts b/ts/input/tex/empheq/EmpheqUtil.ts new file mode 100644 index 000000000..46360b793 --- /dev/null +++ b/ts/input/tex/empheq/EmpheqUtil.ts @@ -0,0 +1,228 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Utilities file for the empheq package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + + +import ParseUtil from '../ParseUtil.js'; +import TexParser from '../TexParser.js'; +import {EnvList} from '../StackItem.js'; +import {AbstractTags} from '../Tags.js'; +import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; +import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; +import {MmlMtd} from '../../../core/MmlTree/MmlNodes/mtd.js'; +import {EmpheqBeginItem} from './EmpheqConfiguration.js'; + +export const EmpheqUtil = { + + /** + * Create the needed envonronment and process it by the give function. + * + * @param {TexParser} parser The active tex parser. + * @param {string} env The environment to create. + * @param {Function} func A function to process the environment. + * @param {any[]} args The arguments for func. + */ + environment(parser: TexParser, env: string, func: Function, args: any[]) { + const name = args[0]; + const item = parser.itemFactory.create(name + '-begin').setProperties({name: env, end: name}); + parser.Push(func(parser, item, ...args.slice(1))); + }, + + /** + * Parse an options string. + * + * @param {string} text The string to parse. + * @param {{[key:string]:number} allowed Object containing options to allow + * @return {EnvList} The parsed keys + */ + splitOptions(text: string, allowed: {[key: string]: number} = null): EnvList { + return ParseUtil.keyvalOptions(text, allowed, true); + }, + + /** + * Find the number of columns in the table. + * + * @param {MmlMtable} table The table whose columns to count. + * @return {number} The number of columns in the table. + */ + columnCount(table: MmlMtable): number { + let m = 0; + for (const row of table.childNodes) { + const n = row.childNodes.length - (row.isKind('mlabeledtr') ? 1 : 0); + if (n > m) m = n; + } + return m; + }, + + /** + * Create an mpadded element with no height and depth, but whose + * content is the given TeX code with a phantom that is the height and + * depth of the given table. + * + * @param {string} tex The TeX code to put in the box. + * @param {MmlTable} table The table used to size the box. + * @param {TexParser} parser The active tex parser. + * @param {string} env The name of the current environment. + * @return {MmlNode} The mpadded element. + */ + cellBlock(tex: string, table: MmlMtable, parser: TexParser, env: string): MmlNode { + const mpadded = parser.create('node', 'mpadded', [], {height: 0, depth: 0, voffset: '-1height'}); + const result = new TexParser(tex, parser.stack.env, parser.configuration); + const mml = result.mml(); + if (env && result.configuration.tags.label) { + (result.configuration.tags.currentTag as any).env = env; + (result.configuration.tags as AbstractTags).getTag(true); + } + for (const child of (mml.isInferred ? mml.childNodes : [mml])) { + mpadded.appendChild(child); + } + mpadded.appendChild(parser.create('node', 'mphantom', [ + parser.create('node', 'mpadded', [table], {width: 0}) + ])); + return mpadded; + }, + + /** + * Make a copy of the table with only the first row and create a phantom element + * that has its height and depth. + * + * @param {MmlMtable} original The original table. + * @param {TexParser} parser The active tex parser. + * @return {MmlNode} The resulting mphantom element. + */ + topRowTable(original: MmlMtable, parser: TexParser): MmlNode { + const table = original.copy(); + table.setChildren(table.childNodes.slice(0, 1)); + table.attributes.set('align', 'baseline 1'); + return original.factory.create('mphantom', {}, [parser.create('node', 'mpadded', [table], {width: 0})]); + }, + + /** + * Add an mpadded element that has zero height and depth but whose content is + * the cell block for the given TeX code followed by a struct the size of the top row. + * + * @param {MmlMtd} mtd The mtd to add content to. + * @param {string} tex The TeX string to put into the cell. + * @param {MmlMtable} table The reference table used for its various heights. + * @param {TexParser} parser The active tex parser. + * @param {srting} env The current environment. + */ + rowspanCell(mtd: MmlMtd, tex: string, table: MmlMtable, parser: TexParser, env: string) { + mtd.appendChild( + parser.create('node', 'mpadded', [ + this.cellBlock(tex, table.copy(), parser, env), + this.topRowTable(table, parser) + ], {height: 0, depth: 0, voffset: 'height'}) + ); + }, + + /** + * Add something on the left of the original table. + * + * @param {MmlMtable} table The table to modify. + * @param {MmlMtable} original The original table. + * @param {string} left The TeX code to add to the left. + * @param {TexParser} parser The active tex parser. + * @param {string} env The current environment. + */ + left(table: MmlMtable, original: MmlMtable, left: string, parser: TexParser, env: string = '') { + table.attributes.set('columnalign', 'right ' + (table.attributes.get('columnalign') || '')); + table.attributes.set('columnspacing', '0em ' + (table.attributes.get('columnspacing') || '')); + let mtd; + for (const row of table.childNodes.slice(0).reverse()) { + mtd = parser.create('node', 'mtd'); + row.childNodes.unshift(mtd); + row.replaceChild(mtd, mtd); // make sure parent is set + if (row.isKind('mlabeledtr')) { + row.childNodes[0] = row.childNodes[1]; + row.childNodes[1] = mtd; + } + } + this.rowspanCell(mtd, left, original, parser, env); + }, + + /** + * Add something on the right of the original table. + * + * @param {MmlMtable} table The table to modify. + * @param {MmlMtable} original The original table. + * @param {string} right The TeX code to add to the right. + * @param {TexParser} parser The active tex parser. + * @param {string} env The current environment. + */ + right(table: MmlMtable, original: MmlMtable, right: string, parser: TexParser, env: string = '') { + if (table.childNodes.length === 0) { + table.appendChild(parser.create('node', 'mtr')); + } + const m = EmpheqUtil.columnCount(table); + const row = table.childNodes[0]; + while (row.childNodes.length < m) row.appendChild(parser.create('node', 'mtd')); + const mtd = row.appendChild(parser.create('node', 'mtd')) as MmlMtd; + EmpheqUtil.rowspanCell(mtd, right, original, parser, env); + table.attributes.set( + 'columnalign', + (table.attributes.get('columnalign') as string || '').split(/ /).slice(0, m).join(' ') + ' left' + ); + table.attributes.set( + 'columnspacing', + (table.attributes.get('columnspacing') as string || '').split(/ /).slice(0, m - 1).join(' ') + ' 0em' + ); + }, + + /** + * Add the left- and right-hand material to the table. + */ + adjustTable(empheq: EmpheqBeginItem, parser: TexParser) { + const left = empheq.getProperty('left'); + const right = empheq.getProperty('right'); + if (left || right) { + const table = empheq.Last; + const original = table.copy(); + if (left) this.left(table, original, left, parser); + if (right) this.right(table, original, right, parser); + } + }, + + /** + * The environments allowed to be used in the empheq environment. + */ + allowEnv: { + equation: true, + align: true, + gather: true, + flalign: true, + alignat: true, + multline: true + }, + + /** + * Checks to see if the given environment is one of the allowed ones. + * + * @param {string} env The environment to check. + * @return {boolean} True if the environment is allowed. + */ + checkEnv(env: string): boolean { + return this.allowEnv.hasOwnProperty(env.replace(/\*$/, '')) || false; + } + +}; From f5ba3ef0344a6adeb179098765e5a65ef33a8530 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 15:19:12 -0400 Subject: [PATCH 086/142] Add copyright notice --- ts/input/mathml/mml3/mml3-node.ts | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/ts/input/mathml/mml3/mml3-node.ts b/ts/input/mathml/mml3/mml3-node.ts index 3e3bd71e9..8f35ee786 100644 --- a/ts/input/mathml/mml3/mml3-node.ts +++ b/ts/input/mathml/mml3/mml3-node.ts @@ -1,3 +1,27 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Auxiliary function for elementary MathML3 support (experimental) + * using David Carlisle's XLST transform. + * + * @author dpvc@mathjax.org (Davide Cervone) + */ + /** * Create the transform function that uses Saxon-js to perform the * xslt transformation. From cbff6ea48ce8b301726538ac9ce29a3a53076cef Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 15:23:55 -0400 Subject: [PATCH 087/142] Make changes as per code review --- .../tex/colortbl/ColortblConfiguration.ts | 31 +++++++++++++++++-- 1 file changed, 29 insertions(+), 2 deletions(-) diff --git a/ts/input/tex/colortbl/ColortblConfiguration.ts b/ts/input/tex/colortbl/ColortblConfiguration.ts index 60251fbd2..4ce351c25 100644 --- a/ts/input/tex/colortbl/ColortblConfiguration.ts +++ b/ts/input/tex/colortbl/ColortblConfiguration.ts @@ -1,3 +1,27 @@ +/************************************************************* + * + * Copyright (c) 2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +/** + * @fileoverview Configuration file for the colortbl package. + * + * @author dpvc@mathjax.org (Davide P. Cervone) + */ + import {ArrayItem} from '../base/BaseItems.js'; import {Configuration, ParserConfiguration, ConfigurationHandler} from '../Configuration.js'; import {CommandMap} from '../SymbolMap.js'; @@ -7,11 +31,14 @@ import {MmlNode} from '../../../core/MmlTree/MmlNode.js'; import {TeX} from '../../tex.js'; -export type ColorData = { +/** + * Information about table colors. + */ +export interface ColorData { cell: string; row: string; col: string[]; -}; +} // // Sublcass the ArrayItem to handle colored entries From 185bcfceca45e9e6c2bd8a399b90a9f13519ce09 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 15:42:34 -0400 Subject: [PATCH 088/142] Make changes requested by PR code review. --- ts/ui/lazy/LazyHandler.ts | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts index c6f1eea79..110c2dd4f 100644 --- a/ts/ui/lazy/LazyHandler.ts +++ b/ts/ui/lazy/LazyHandler.ts @@ -356,6 +356,22 @@ B extends MathDocumentConstructor>>( * When one (or more) does, add its math item to or remove it from the set to be processed, and * if added to the set, queue an idle task, if one isn't already pending. * + * The idea is, if you start scrolling and reveal an expression marker, we add it into + * the set and queue an idle task. But if you keep scrolling and the idle task hasn't run + * yet, the mark may move out of view, and we don't want to waste time typesetting it, so + * we remove it from the set. When you stop scrolling and the idle task finally runs, it + * takes the expressions still in the set (those should be the ones still in view) and + * starts typesetting them after having created a new set to add expressions to. If one + * of the expressions loads an extension and the idle task has to pause, you can add new + * expressions into the new list (or remove them from there), but can't affect the + * current idle-task list. Those will be typeset even if they scroll out of view at that + * point. + * + * Note that it is possible that an expression is added to the set and then removed + * before the idle task runs, and it could be that the set is empty when it does. Then + * the idle task does nothing, and new expressions are added to the new set to be + * processed by the next idle task. + * * @param {IntersectionObserverEntry[]} entries The markers that have come into or out of view. */ protected lazyObserve(entries: IntersectionObserverEntry[]) { @@ -430,14 +446,14 @@ B extends MathDocumentConstructor>>( if (!math) return false; let compile = false; for (const item of this.math) { - if (item === math) break; const earlier = item as LazyMathItem; - if (earlier.lazyTex && earlier.lazyCompile) { - earlier.lazyCompile = false; - earlier.lazyMarker && this.lazyObserver.unobserve(earlier.lazyMarker as any as Element); - earlier.state(STATE.COMPILED - 1); - compile = true; + if (earlier === math || !earlier?.lazyCompile) { + break; } + earlier.lazyCompile = false; + earlier.lazyMarker && this.lazyObserver.unobserve(earlier.lazyMarker as any as Element); + earlier.state(STATE.COMPILED - 1); + compile = true; } return compile; } From 25832887ce48bd0270495feb58c7eb4a024177bb Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 16:15:07 -0400 Subject: [PATCH 089/142] Make fixes requested in PR code review. --- ts/output/chtml.ts | 12 ++++++------ ts/output/chtml/Usage.ts | 2 +- ts/output/common/OutputJax.ts | 4 ++-- 3 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index e8ba411c8..9bfdb35ca 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -187,13 +187,13 @@ CommonOutputJax, CHTMLWrapperFactory, CH * @override */ protected addWrapperStyles(styles: CssStyles) { - if (this.options.adaptiveCSS) { - for (const kind of this.wrapperUsage.update()) { - const wrapper = this.factory.getNodeClass(kind) as any as typeof CommonWrapper; - wrapper && this.addClassStyles(wrapper, styles); - } - } else { + if (!this.options.adaptiveCSS) { super.addWrapperStyles(styles); + return; + } + for (const kind of this.wrapperUsage.update()) { + const wrapper = this.factory.getNodeClass(kind) as any as typeof CommonWrapper; + wrapper && this.addClassStyles(wrapper, styles); } } diff --git a/ts/output/chtml/Usage.ts b/ts/output/chtml/Usage.ts index 8baf61199..4c1083dee 100644 --- a/ts/output/chtml/Usage.ts +++ b/ts/output/chtml/Usage.ts @@ -22,7 +22,7 @@ */ /** - * Class used for traking usage of font characters or wrppers + * Class used for tracking usage of font characters or wrappers * (should extend Set, but that doesn't work for compiling to ES2015). */ export class Usage { diff --git a/ts/output/common/OutputJax.ts b/ts/output/common/OutputJax.ts index 585f53819..6e1a19727 100644 --- a/ts/output/common/OutputJax.ts +++ b/ts/output/common/OutputJax.ts @@ -467,14 +467,14 @@ export abstract class CommonOutputJax< } /** - * @param {CssStyles} styles The style obejct to add to + * @param {CssStyles} styles The style object to add to */ protected addFontStyles(styles: CssStyles) { styles.addStyles(this.font.styles); } /** - * @param {CssStyles} styles The style obejct to add to + * @param {CssStyles} styles The style object to add to */ protected addWrapperStyles(styles: CssStyles) { for (const kind of this.factory.getKinds()) { From 71b40b48940d53064646e07ee0a439734161a2b5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 16:21:00 -0400 Subject: [PATCH 090/142] Fix typos in comments. --- ts/input/tex/setoptions/SetOptionsConfiguration.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ts/input/tex/setoptions/SetOptionsConfiguration.ts b/ts/input/tex/setoptions/SetOptionsConfiguration.ts index 3d1eeee8f..21d46e6e8 100644 --- a/ts/input/tex/setoptions/SetOptionsConfiguration.ts +++ b/ts/input/tex/setoptions/SetOptionsConfiguration.ts @@ -143,9 +143,9 @@ export const SetOptionsConfiguration = Configuration.create( filterPackage: SetOptionsUtil.filterPackage, // filter for whether a package can be configured filterOption: SetOptionsUtil.filterOption, // filter for whether an option can be set filterValue: SetOptionsUtil.filterValue, // filter for the value to assign to an option - allowPackageDefault: true, // default for allowing packages if not erxplicitly set in allowOptions + allowPackageDefault: true, // default for allowing packages when not explicitly set in allowOptions allowOptionsDefault: true, // default for allowing option that isn't explicitly set in allowOptions - allowOptions: expandable({ // list of packages to allow/disablow, and their options to allow/disallow + allowOptions: expandable({ // list of packages to allow/disallow, and their options to allow/disallow // // top-level tex items can be set, but not these // (that leaves digits and the tagging options) From 115a7be59e6b2c9ee4385f3720fd0fab7014d26a Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 1 Jun 2021 18:32:38 -0400 Subject: [PATCH 091/142] Disallow several extensions from being required (in particular, setoptions) --- ts/input/tex/require/RequireConfiguration.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ts/input/tex/require/RequireConfiguration.ts b/ts/input/tex/require/RequireConfiguration.ts index 2c529b6d8..c34b395fa 100644 --- a/ts/input/tex/require/RequireConfiguration.ts +++ b/ts/input/tex/require/RequireConfiguration.ts @@ -178,7 +178,11 @@ export const options = { // allow: expandable({ base: false, - 'all-packages': false + 'all-packages': false, + autoload: false, + configmacros: false, + tagformat: false, + setoptions: false }), // // The default allow value if the extension isn't in the list above From 38e067d17d2b5dfabe0b3381cfce20159f5fb5fa Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 2 Jun 2021 07:07:04 -0400 Subject: [PATCH 092/142] Rename Numcases* to Cases* --- ts/input/tex/cases/CasesConfiguration.ts | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/ts/input/tex/cases/CasesConfiguration.ts b/ts/input/tex/cases/CasesConfiguration.ts index dc000c985..51e60c9fd 100644 --- a/ts/input/tex/cases/CasesConfiguration.ts +++ b/ts/input/tex/cases/CasesConfiguration.ts @@ -79,7 +79,7 @@ export class CasesTags extends AmsTags { } -export const NumcasesMethods = { +export const CasesMethods = { /** * Implements the numcases environment. @@ -188,19 +188,19 @@ export const NumcasesMethods = { new EnvironmentMap('cases-env', EmpheqUtil.environment, { numcases: ['NumCases', 'cases'], subnumcases: ['NumCases', 'cases'] -}, NumcasesMethods); +}, CasesMethods); /** * The macros for this package */ new MacroMap('cases-macros', { '&': 'Entry' -}, NumcasesMethods); +}, CasesMethods); // // Define the package for our new environment // -export const NumcasesConfiguration = Configuration.create('cases', { +export const CasesConfiguration = Configuration.create('cases', { handler: { environment: ['cases-env'], character: ['cases-macros'] From 3c40dd90a6400c9470d94f4097f0c3f239aacac2 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 2 Jun 2021 19:28:27 -0400 Subject: [PATCH 093/142] Add copyNode() to ParseUtil and make it save the the nodes in the node lists. Keep track of extra lists that nodes are in so that copies can save to those lists as well. --- ts/core/MmlTree/MmlNode.ts | 2 ++ ts/input/tex/ParseOptions.ts | 9 +++++++++ ts/input/tex/ParseUtil.ts | 12 ++++++++++++ ts/input/tex/cases/CasesConfiguration.ts | 2 +- ts/input/tex/empheq/EmpheqUtil.ts | 6 +++--- 5 files changed, 27 insertions(+), 4 deletions(-) diff --git a/ts/core/MmlTree/MmlNode.ts b/ts/core/MmlTree/MmlNode.ts index 02d725dd0..157d5a6fb 100644 --- a/ts/core/MmlTree/MmlNode.ts +++ b/ts/core/MmlTree/MmlNode.ts @@ -371,6 +371,8 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { for (const child of children) { if (child) { node.appendChild(child.copy() as MmlNode); + } else { + node.childNodes.push(null); } } } diff --git a/ts/input/tex/ParseOptions.ts b/ts/input/tex/ParseOptions.ts index 30bc3b40a..40de12937 100644 --- a/ts/input/tex/ParseOptions.ts +++ b/ts/input/tex/ParseOptions.ts @@ -26,6 +26,7 @@ import StackItemFactory from './StackItemFactory.js'; import {Tags} from './Tags.js'; import {SubHandlers} from './MapHandler.js'; import {NodeFactory} from './NodeFactory.js'; +import NodeUtil from './NodeUtil.js'; import {MmlNode} from '../../core/MmlTree/MmlNode.js'; import TexParser from './TexParser.js'; import {defaultOptions, OptionList} from '../../util/Options.js'; @@ -173,6 +174,14 @@ export default class ParseOptions { list = this.nodeLists[property] = []; } list.push(node); + if (node.kind !== property) { + // + // If the list is not just for its kind, record that it is in this list + // so that if it is copied, the copy can also be added to the list. + // + let lists = (NodeUtil.getProperty(node, 'in-lists') as string || '').split(',').concat(property).join(','); + NodeUtil.setProperty(node, 'in-lists', lists); + } } diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index aa7957932..d98f99374 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -469,6 +469,18 @@ namespace ParseUtil { parser.stack.global.eqnenv = true; } + export function copyNode(node: MmlNode, parser: TexParser): MmlNode { + const tree = node.copy() as MmlNode; + const options = parser.configuration; + tree.walkTree((n: MmlNode) => { + options.addNode(n.kind, n); + const lists = (n.getProperty('in-lists') as string || '').split(/,/); + for (const list of lists) { + options.addNode(list, n); + } + }); + return tree; + } /** * This is a placeholder for future security filtering of attributes. diff --git a/ts/input/tex/cases/CasesConfiguration.ts b/ts/input/tex/cases/CasesConfiguration.ts index 51e60c9fd..7a1b40fd9 100644 --- a/ts/input/tex/cases/CasesConfiguration.ts +++ b/ts/input/tex/cases/CasesConfiguration.ts @@ -93,7 +93,7 @@ export const CasesMethods = { parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); // finish eqnarray const cases = parser.stack.Top(); const table = cases.Last as MmlMtable; - const original = table.copy() as MmlMtable; + const original = ParseUtil.copyNode(table, parser) as MmlMtable; const left = cases.getProperty('left'); EmpheqUtil.left(table, original, left + '\\empheqlbrace\\,', parser, 'numcases-left'); parser.Push(parser.itemFactory.create('end').setProperty('name', begin.getName())); diff --git a/ts/input/tex/empheq/EmpheqUtil.ts b/ts/input/tex/empheq/EmpheqUtil.ts index 46360b793..715c85a74 100644 --- a/ts/input/tex/empheq/EmpheqUtil.ts +++ b/ts/input/tex/empheq/EmpheqUtil.ts @@ -111,7 +111,7 @@ export const EmpheqUtil = { * @return {MmlNode} The resulting mphantom element. */ topRowTable(original: MmlMtable, parser: TexParser): MmlNode { - const table = original.copy(); + const table = ParseUtil.copyNode(original, parser); table.setChildren(table.childNodes.slice(0, 1)); table.attributes.set('align', 'baseline 1'); return original.factory.create('mphantom', {}, [parser.create('node', 'mpadded', [table], {width: 0})]); @@ -130,7 +130,7 @@ export const EmpheqUtil = { rowspanCell(mtd: MmlMtd, tex: string, table: MmlMtable, parser: TexParser, env: string) { mtd.appendChild( parser.create('node', 'mpadded', [ - this.cellBlock(tex, table.copy(), parser, env), + this.cellBlock(tex, ParseUtil.copyNode(table, parser), parser, env), this.topRowTable(table, parser) ], {height: 0, depth: 0, voffset: 'height'}) ); @@ -197,7 +197,7 @@ export const EmpheqUtil = { const right = empheq.getProperty('right'); if (left || right) { const table = empheq.Last; - const original = table.copy(); + const original = ParseUtil.copyNode(table, parser); if (left) this.left(table, original, left, parser); if (right) this.right(table, original, right, parser); } From 3ddd6c34b9723d0a209e62fd193b7831bcd51516 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 3 Jun 2021 07:18:05 -0400 Subject: [PATCH 094/142] Update comments as requested by code review. --- ts/core/MmlTree/MmlNode.ts | 2 ++ ts/core/Tree/Node.ts | 4 +++- ts/input/tex/cases/CasesConfiguration.ts | 2 +- ts/input/tex/empheq/EmpheqUtil.ts | 2 +- 4 files changed, 7 insertions(+), 3 deletions(-) diff --git a/ts/core/MmlTree/MmlNode.ts b/ts/core/MmlTree/MmlNode.ts index 157d5a6fb..a4d3cd607 100644 --- a/ts/core/MmlTree/MmlNode.ts +++ b/ts/core/MmlTree/MmlNode.ts @@ -351,6 +351,8 @@ export abstract class AbstractMmlNode extends AbstractNode implements MmlNode { * @override * * @param {boolean} keepIds True to copy id attributes, false to skip them. + * (May cause error in the future, since not part of the interface.) + * @return {AbstractMmlNode} The copied node tree. */ public copy(keepIds: boolean = false): AbstractMmlNode { const node = this.factory.create(this.kind) as AbstractMmlNode; diff --git a/ts/core/Tree/Node.ts b/ts/core/Tree/Node.ts index c1e7477e0..fe39c679d 100644 --- a/ts/core/Tree/Node.ts +++ b/ts/core/Tree/Node.ts @@ -276,7 +276,9 @@ export abstract class AbstractNode implements Node { const node = (this as AbstractNode).factory.create(this.kind) as AbstractNode; node.properties = {...this.properties}; for (const child of this.childNodes || []) { - if (child) node.appendChild(child.copy()); + if (child) { + node.appendChild(child.copy()); + } } return node; } diff --git a/ts/input/tex/cases/CasesConfiguration.ts b/ts/input/tex/cases/CasesConfiguration.ts index 7a1b40fd9..c7cdd808e 100644 --- a/ts/input/tex/cases/CasesConfiguration.ts +++ b/ts/input/tex/cases/CasesConfiguration.ts @@ -11,7 +11,7 @@ import {MmlMtable} from '../../../core/MmlTree/MmlNodes/mtable.js'; import {EmpheqUtil} from '../empheq/EmpheqUtil.js'; /** - * The StakItem for the numcases environment. + * The StackItem for the numcases environment. */ export class CasesBeginItem extends BeginItem { diff --git a/ts/input/tex/empheq/EmpheqUtil.ts b/ts/input/tex/empheq/EmpheqUtil.ts index 715c85a74..acb65e991 100644 --- a/ts/input/tex/empheq/EmpheqUtil.ts +++ b/ts/input/tex/empheq/EmpheqUtil.ts @@ -35,7 +35,7 @@ import {EmpheqBeginItem} from './EmpheqConfiguration.js'; export const EmpheqUtil = { /** - * Create the needed envonronment and process it by the give function. + * Create the needed envinronment and process it by the give function. * * @param {TexParser} parser The active tex parser. * @param {string} env The environment to create. From c54a9891140b7dff7b7cae1fcfae7a7275e90ed4 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 3 Jun 2021 08:23:31 -0400 Subject: [PATCH 095/142] Improve comments, as request in code review. --- ts/input/tex/base/BaseConfiguration.ts | 21 +++++++++++++++------ ts/input/tex/base/BaseItems.ts | 20 ++++++++++++++------ 2 files changed, 29 insertions(+), 12 deletions(-) diff --git a/ts/input/tex/base/BaseConfiguration.ts b/ts/input/tex/base/BaseConfiguration.ts index 6dbc404c3..e7ab54836 100644 --- a/ts/input/tex/base/BaseConfiguration.ts +++ b/ts/input/tex/base/BaseConfiguration.ts @@ -98,23 +98,32 @@ function envUndefined(_parser: TexParser, env: string) { function filterNonscript({data}: {data: ParseOptions}) { for (const mml of data.getList('nonscript')) { // - // If we are in script or script-script style - // remove the space (either mspace or mrow containing it) - // and remove it (and its contents) from the other lists. - // Otherwise, if it is an mrow (which we added), - // replace the mrow with its contents - // and remove it from its list + // This is the list of mspace elements or mrow > mstyle > mspace + // that followed \nonscript macros to be tested for removal. // if (mml.attributes.get('scriptlevel') > 0) { + // + // The mspace needs to be removed, since we are in a script style. + // Remove it from the DOM and from the list of mspace elements. + // const parent = mml.parent; parent.childNodes.splice(parent.childIndex(mml), 1); data.removeFromList(mml.kind, [mml]); + // + // If it is an mrow > mstyle > mspace, then we have just + // removed the mrow from its list, and must remove + // the mstyle and mspace from their lists as well. + // if (mml.isKind('mrow')) { const mstyle = mml.childNodes[0] as MmlNode; data.removeFromList('mstyle', [mstyle]); data.removeFromList('mspace', mstyle.childNodes[0].childNodes as MmlNode[]); } } else if (mml.isKind('mrow')) { + // + // This is an mrow > mstyle > mspace but we're not in a script + // style, so remove the mrow that we had added in the NonscriptItem. + // mml.parent.replaceChild(mml.childNodes[0], mml); data.removeFromList('mrow', [mml]); } diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index 8b0b720b1..2763c574d 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -774,6 +774,9 @@ export class NotItem extends BaseItem { } } +/** + * A StackItem that removes an mspace that follows it (for \nonscript). + */ export class NonscriptItem extends BaseItem { /** @@ -787,25 +790,30 @@ export class NonscriptItem extends BaseItem { * @override */ public checkItem(item: StackItem): CheckType { + // + // Check if the next item is an mspace (or an mspace in an mstyle) and remove it. + // if (item.isKind('mml') && item.Size() === 1) { let mml = item.First; // - // Space macros like \, wrap with an mstyle to set scriptlevel=0 (so size is independent of level) + // Space macros like \, are wrapped with an mstyle to set scriptlevel="0" + // (so size is independent of level), we look at the contents of the mstyle for the mspace. // if (mml.isKind('mstyle') && mml.notParent) { mml = NodeUtil.getChildren(NodeUtil.getChildren(mml)[0])[0]; } if (mml.isKind('mspace')) { // - // If the space is in an mstyle, wrap it in an mrow so we can test is scriptlevel. - // The mrow will be removed in the post-filter. + // If the space is in an mstyle, wrap it in an mrow so we can test its scriptlevel + // in the post-filter (the mrow will be removed in the filter). We can't test + // the mstyle's scriptlevel, since it is ecxplicitly setting it to 0. // if (mml !== item.First) { - mml = this.create('node', 'mrow', [item.Pop()]); - item.Push(mml); + const mrow = this.create('node', 'mrow', [item.Pop()]); + item.Push(mrow); } // - // Save the item for alter post-processing + // Save the mspace for later post-processing. // this.factory.configuration.addNode('nonscript', item.First); } From 73f794433985ffa38c6887d9310c60ba154d0bfb Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 3 Jun 2021 10:07:17 -0400 Subject: [PATCH 096/142] Properly produce initial CSS when stylesheet is loaded. (Prevents 'blank' formulas on first typeset) --- ts/output/chtml.ts | 2 +- ts/output/chtml/FontData.ts | 50 ++++--------------------------------- 2 files changed, 6 insertions(+), 46 deletions(-) diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index 7e65c5c9d..3938ba6de 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -187,7 +187,7 @@ CommonOutputJax, CHTMLWrapperFactory, CH * @param {CssStyles} styles The styles to update with newly used character styles */ protected updateFontStyles(styles: CssStyles) { - styles.addStyles(this.font.updateStyles()); + styles.addStyles(this.font.updateStyles({})); } /** diff --git a/ts/output/chtml/FontData.ts b/ts/output/chtml/FontData.ts index 292173c0c..576a18574 100644 --- a/ts/output/chtml/FontData.ts +++ b/ts/output/chtml/FontData.ts @@ -183,15 +183,9 @@ export class CHTMLFontData extends FontData Date: Thu, 3 Jun 2021 10:10:19 -0400 Subject: [PATCH 097/142] Add missing jsdoc return value --- ts/output/chtml/FontData.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ts/output/chtml/FontData.ts b/ts/output/chtml/FontData.ts index 576a18574..c2aeffd96 100644 --- a/ts/output/chtml/FontData.ts +++ b/ts/output/chtml/FontData.ts @@ -196,8 +196,9 @@ export class CHTMLFontData extends FontData Date: Thu, 3 Jun 2021 13:48:59 -0400 Subject: [PATCH 098/142] Fix problem with multiline positioning when multlineWidth is not 100% (displayAlign should be respected), and don't use extra spacing next to a label, if any. --- ts/input/tex/ams/AmsMethods.ts | 3 +-- ts/output/common/Wrappers/mtable.ts | 18 +++++++++++++++--- 2 files changed, 16 insertions(+), 5 deletions(-) diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index 8454c5b3a..f53e59f10 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -127,7 +127,6 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b frame: '', // Use frame spacing with no actual frame 'data-width-includes-label': true // take label space out of 100% width }; - parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); return item; }; @@ -191,7 +190,7 @@ AmsMethods.FlalignArray = function(parser: TexParser, begin: StackItem, numbered 'data-width-includes-label': true, }; item.setProperty('zeroWidthLabel', zeroWidthLabel); - parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); +// parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); return item; }; diff --git a/ts/output/common/Wrappers/mtable.ts b/ts/output/common/Wrappers/mtable.ts index 707e2e48b..fb58b43c5 100644 --- a/ts/output/common/Wrappers/mtable.ts +++ b/ts/output/common/Wrappers/mtable.ts @@ -797,9 +797,21 @@ export function CommonMtableMixin< */ public getBBoxLR() { if (this.hasLabels) { - const side = this.node.attributes.get('side') as string; - const [pad, align] = this.getPadAlignShift(side); - return (align === 'center' ? [pad, pad] : + const attributes = this.node.attributes; + const side = attributes.get('side') as string; + let [pad, align] = this.getPadAlignShift(side); + // + // If labels are included in the width, + // remove the frame spacing if there is no frame line (added by multline) + // and use left or right justification rather than centering so that + // there is no extra space reserved for the label on the opposite side, + // (as there usually is to center the equation). + // + const labels = this.hasLabels && !!attributes.get('data-width-includes-label'); + if (labels && this.frame && this.fSpace[0]) { + pad -= this.fSpace[0]; + } + return (align === 'center' && !labels ? [pad, pad] : side === 'left' ? [pad, 0] : [0, pad]); } return [0, 0]; From 3fdd2374401274cac67c89cd7090da6c01cbf5d2 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 3 Jun 2021 13:56:33 -0400 Subject: [PATCH 099/142] Remove commented out code --- ts/input/tex/ams/AmsMethods.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index f53e59f10..fe93252dd 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -190,7 +190,6 @@ AmsMethods.FlalignArray = function(parser: TexParser, begin: StackItem, numbered 'data-width-includes-label': true, }; item.setProperty('zeroWidthLabel', zeroWidthLabel); -// parser.stack.global.indentalign = (item.arraydef.side === 'right' ? 'left' : 'right'); return item; }; From e5e98f988c5627bb6db941c22d1f993182cfe50c Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 08:21:07 -0400 Subject: [PATCH 100/142] Move multline parameters to ams configuration block. --- ts/input/tex/ams/AmsConfiguration.ts | 16 ++++++++++++++-- ts/input/tex/ams/AmsMethods.ts | 4 ++-- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/ts/input/tex/ams/AmsConfiguration.ts b/ts/input/tex/ams/AmsConfiguration.ts index 2f7039d6b..217fbd271 100644 --- a/ts/input/tex/ams/AmsConfiguration.ts +++ b/ts/input/tex/ams/AmsConfiguration.ts @@ -63,9 +63,21 @@ export const AmsConfiguration = Configuration.create( }, tags: {'ams': AmsTags}, 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: '100%', // The width to use for multline environments. - multlineIndent: '1em', // The margin to use on both sides of multline environments. + multlineWidth: '', + ams: { + multlineWidth: '100%', // The width to use for multline environments. + multlineIndent: '1em', // The margin to use on both sides of multline environments. + } } } ); diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index fe93252dd..0622216f7 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -120,10 +120,10 @@ AmsMethods.Multline = function (parser: TexParser, begin: StackItem, numbered: b displaystyle: true, rowspacing: '.5em', columnspacing: '100%', - width: parser.options['multlineWidth'], + width: parser.options.ams['multlineWidth'], side: parser.options['tagSide'], minlabelspacing: parser.options['tagIndent'], - framespacing: parser.options['multlineIndent'] + ' 0', + 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 }; From 20af442a752c26a7fd48dc801018fdc54a236d71 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 12:35:21 -0400 Subject: [PATCH 101/142] Provide switch for warn/error for invalid options, and configure it through startup. --- ts/components/startup.ts | 15 ++++++++++++--- ts/util/Options.ts | 24 +++++++++++++++++++++++- 2 files changed, 35 insertions(+), 4 deletions(-) diff --git a/ts/components/startup.ts b/ts/components/startup.ts index 7463c904a..cfc23886c 100644 --- a/ts/components/startup.ts +++ b/ts/components/startup.ts @@ -35,7 +35,7 @@ import {OutputJax} from '../core/OutputJax.js'; import {CommonOutputJax} from '../output/common/OutputJax.js'; import {DOMAdaptor} from '../core/DOMAdaptor.js'; import {PrioritizedList} from '../util/PrioritizedList.js'; -import {OptionList} from '../util/Options.js'; +import {OptionList, OPTIONS} from '../util/Options.js'; import {TeX} from '../input/tex.js'; @@ -54,6 +54,8 @@ export interface MathJaxConfig extends MJConfig { typeset?: boolean; // Perform initial typeset? ready?: () => void; // Function to perform when components are ready pageReady?: () => void; // Function to perform when page is ready + invalidOption?: 'fatal' | 'warn'; // Do invalid options produce a warning, or throw an error? + optionError?: (message: string, key: string) => void, // Function to report invalid options [name: string]: any; // Other configuration blocks }; } @@ -534,8 +536,8 @@ export const MathJax = MJGlobal as MathJaxObject; /* * If the startup module hasn't been added to the MathJax variable, - * Add the startup configuration and data objects, and create - * the initial typeset and conversion calls. + * Add the startup configuration and data objects, and + * set the method for handling invalid options, if provided. */ if (typeof MathJax._.startup === 'undefined') { @@ -555,6 +557,13 @@ if (typeof MathJax._.startup === 'undefined') { options: {} }); + if (MathJax.config.startup.invalidOption) { + OPTIONS.invalidOption = MathJax.config.startup.invalidOption; + } + if (MathJax.config.startup.optionError) { + OPTIONS.optionError = MathJax.config.startup.optionError; + } + } /** diff --git a/ts/util/Options.ts b/ts/util/Options.ts index 34118d606..98e8b06ef 100644 --- a/ts/util/Options.ts +++ b/ts/util/Options.ts @@ -68,6 +68,27 @@ export const APPEND = '[+]'; */ export const REMOVE = '[-]'; + +/** + * Provides options for the option utlities. + */ +export const OPTIONS = { + invalidOption: 'warn' as ('fatal' | 'warn'), + /** + * Function to report messages for invalid options + * + * @param {string} message The message for the invalid parameter. + * @param {string} key The invalid key itself. + */ + optionError: (message: string, _key: string) => { + if (OPTIONS.invalidOption === 'fatal') { + throw new Error(message); + } + console.warn('MathJax: ' + message); + } +}; + + /** * A Class to use for options that should not produce warnings if an undefined key is used */ @@ -163,7 +184,8 @@ export function insert(dst: OptionList, src: OptionList, warn: boolean = true): if (typeof key === 'symbol') { key = (key as symbol).toString(); } - throw new Error('Invalid option "' + key + '" (no default value).'); + OPTIONS.optionError(`Invalid option "${key}" (no default value).`, key); + continue; } // // Shorthands for the source and destination values From 04353a03dfa3fc662dc5839d256478e9cec9de25 Mon Sep 17 00:00:00 2001 From: zorkow Date: Sun, 6 Jun 2021 14:03:09 +0100 Subject: [PATCH 102/142] Simplifis the oldstyle command table. --- ts/input/tex/textcomp/TextcompMappings.ts | 41 +++++++++++++++-------- 1 file changed, 27 insertions(+), 14 deletions(-) diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index 33f9ff02f..5c8463e44 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -23,10 +23,11 @@ */ -import ParseMethods from '../ParseMethods.js'; import {CharacterMap, CommandMap} from '../SymbolMap.js'; +import {Symbol} from '../Symbol.js'; import {TexConstant} from '../TexConstants.js'; import {TextMacrosMethods} from '../textmacros/TextMacrosMethods.js'; +import TexParser from '../TexParser.js'; /** @@ -160,25 +161,37 @@ new CommandMap('textcomp-macros', { }, TextMacrosMethods); +/** + * Handle old style characters. + * @param {TexParser} parser The current tex parser. + * @param {Symbol} mchar The parsed symbol. + */ +function mathchar0miOldstyle(parser: TexParser, mchar: Symbol) { + const def = mchar.attributes || {}; + def.mathvariant = TexConstant.Variant.OLDSTYLE; + const node = parser.create('token', 'mi', def, mchar.char); + parser.Push(node); +} + /** * Identifiers from the Textcomp package. */ -new CharacterMap('textcomp-oldstyle', ParseMethods.mathchar0mi, { +new CharacterMap('textcomp-oldstyle', mathchar0miOldstyle, { // This is not the correct glyph - 'textcentoldstyle': ['\u00A2', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textcentoldstyle': '\u00A2', // This is not the correct glyph - 'textdollaroldstyle': ['\u0024', {mathvariant: TexConstant.Variant.OLDSTYLE}], + 'textdollaroldstyle': '\u0024', // Table 16: textcomp Old-Style Numerals - 'textzerooldstyle': ['0', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textoneoldstyle': ['1', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'texttwooldstyle': ['2', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textthreeoldstyle': ['3', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textfouroldstyle': ['4', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textfiveoldstyle': ['5', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textsixoldstyle': ['6', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textsevenoldstyle': ['7', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'texteightoldstyle': ['8', {mathvariant: TexConstant.Variant.OLDSTYLE}], - 'textnineoldstyle': ['9', {mathvariant: TexConstant.Variant.OLDSTYLE}] + 'textzerooldstyle': '0', + 'textoneoldstyle': '1', + 'texttwooldstyle': '2', + 'textthreeoldstyle': '3', + 'textfouroldstyle': '4', + 'textfiveoldstyle': '5', + 'textsixoldstyle': '6', + 'textsevenoldstyle': '7', + 'texteightoldstyle': '8', + 'textnineoldstyle': '9' }); From 528378c44d1660255f4be1a3a5f3855943f2c380 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 7 Jun 2021 11:02:28 -0400 Subject: [PATCH 103/142] Add ability to configure loader path filters --- ts/components/loader.ts | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/ts/components/loader.ts b/ts/components/loader.ts index 925fd9b44..a9bdbef6a 100644 --- a/ts/components/loader.ts +++ b/ts/components/loader.ts @@ -42,7 +42,7 @@ declare var document: Document; * Function used to determine path to a given package. */ export type PathFilterFunction = (data: {name: string, original: string, addExtension: boolean}) => boolean; -export type PathFilterList = {[name: string]: PathFilterFunction}; +export type PathFilterList = (PathFilterFunction | [PathFilterFunction, number])[]; /** * Update the configuration structure to include the loader configuration @@ -57,6 +57,7 @@ export interface MathJaxConfig extends MJConfig { ready?: PackageReady; // A function to call when MathJax is ready failed?: PackageFailed; // A function to call when MathJax fails to load require?: (url: string) => any; // A function for loading URLs + pathFilters: PathFilterList; // List of path filters (and optional priorities) to add [name: string]: any; // Other configuration blocks }; } @@ -73,7 +74,7 @@ export interface MathJaxObject extends MJObject { preLoad: (...names: string[]) => void; // Indicate that packages are already loaded by hand defaultReady: () => void; // The function performed when all packages are loaded getRoot: () => string; // Find the root URL for the MathJax files - pathFilters: PathFilterList; // the filters to use for looking for package paths + pathFilters: FunctionList; // the filters to use for looking for package paths }; startup?: any; } @@ -117,6 +118,7 @@ export const PathFilters: {[name: string]: PathFilterFunction} = { } return true; } + }; @@ -216,9 +218,9 @@ export namespace Loader { /** * The default filters to use. */ - pathFilters.add(PathFilters.source, 1); - pathFilters.add(PathFilters.normalize, 2); - pathFilters.add(PathFilters.prefix, 5); + pathFilters.add(PathFilters.source, 0); + pathFilters.add(PathFilters.normalize, 10); + pathFilters.add(PathFilters.prefix, 20); } /** @@ -229,6 +231,7 @@ export const MathJax = MJGlobal as MathJaxObject; /* * If the loader hasn't been added to the MathJax variable, * Add the loader configuration, library, and data objects. + * Add any path filters from the configuration. */ if (typeof MathJax.loader === 'undefined') { @@ -242,12 +245,23 @@ if (typeof MathJax.loader === 'undefined') { load: [], ready: Loader.defaultReady.bind(Loader), failed: (error: PackageError) => console.log(`MathJax(${error.package || '?'}): ${error.message}`), - require: null + require: null, + pathFilters: [], }); combineWithMathJax({ loader: Loader }); + // + // Add any path filters from the configuration + // + for (const filter of MathJax.config.loader.pathFilters) { + if (Array.isArray(filter)) { + Loader.pathFilters.add(filter[0], filter[1]); + } else { + Loader.pathFilters.add(filter); + } + } } /** From 0cc62833eb571ba808ee47de397f00fdf932792d Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 7 Jun 2021 11:46:35 -0400 Subject: [PATCH 104/142] Fix combining of mo elements so that properties don't become attributes --- ts/input/tex/FilterUtil.ts | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/ts/input/tex/FilterUtil.ts b/ts/input/tex/FilterUtil.ts index 470eb3d83..1ced561b9 100644 --- a/ts/input/tex/FilterUtil.ts +++ b/ts/input/tex/FilterUtil.ts @@ -110,7 +110,9 @@ namespace FilterUtil { // This treatment means we might loose some inheritance structure, but // no properties. _copyExplicit(['stretchy', 'rspace'], mo, m2); - NodeUtil.setProperties(mo, m2.getAllProperties()); + for (const name of m2.getPropertyNames()) { + mo.setProperty(name, m2.getProperty(name)); + } children.splice(next, 1); remove.push(m2); m2.parent = null; From 2c8f2783ea47090a56dbb10414fed8af6a32043c Mon Sep 17 00:00:00 2001 From: zorkow Date: Tue, 8 Jun 2021 14:25:47 +0100 Subject: [PATCH 105/142] Resets output jax after a11y menu initialisation. --- ts/ui/menu/Menu.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/ts/ui/menu/Menu.ts b/ts/ui/menu/Menu.ts index 68e2adb3e..638b2c846 100644 --- a/ts/ui/menu/Menu.ts +++ b/ts/ui/menu/Menu.ts @@ -860,6 +860,7 @@ export class Menu { const document = this.document; this.document = startup.document = startup.getDocument(); this.document.menu = this; + this.document.outputJax.reset(); this.transferMathList(document); this.document.processed = document.processed; if (!Menu._loadingPromise) { From ad4be220d9873fd4faf527901f4a37b3888c6248 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 8 Jun 2021 15:28:03 -0400 Subject: [PATCH 106/142] Make pathFilters optional --- ts/components/loader.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/components/loader.ts b/ts/components/loader.ts index a9bdbef6a..5ad995aee 100644 --- a/ts/components/loader.ts +++ b/ts/components/loader.ts @@ -57,7 +57,7 @@ export interface MathJaxConfig extends MJConfig { ready?: PackageReady; // A function to call when MathJax is ready failed?: PackageFailed; // A function to call when MathJax fails to load require?: (url: string) => any; // A function for loading URLs - pathFilters: PathFilterList; // List of path filters (and optional priorities) to add + pathFilters?: PathFilterList; // List of path filters (and optional priorities) to add [name: string]: any; // Other configuration blocks }; } From aad35c326414c403d38f6fc4d6bf59942cdae263 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:10:24 -0400 Subject: [PATCH 107/142] Remove rename.js for old extension name compatibility --- .../src/input/tex/extensions/amscd/amscd.js | 3 --- .../input/tex/extensions/colorv2/colorv2.js | 3 --- .../extensions/configmacros/configmacros.js | 3 --- components/src/input/tex/extensions/rename.js | 18 ------------------ .../tex/extensions/tagformat/tagformat.js | 3 --- 5 files changed, 30 deletions(-) delete mode 100644 components/src/input/tex/extensions/rename.js diff --git a/components/src/input/tex/extensions/amscd/amscd.js b/components/src/input/tex/extensions/amscd/amscd.js index c61dcae7f..7518b2c86 100644 --- a/components/src/input/tex/extensions/amscd/amscd.js +++ b/components/src/input/tex/extensions/amscd/amscd.js @@ -1,4 +1 @@ import './lib/amscd.js'; -import {rename} from '../rename.js'; - -rename('amsCd', 'amscd', true); diff --git a/components/src/input/tex/extensions/colorv2/colorv2.js b/components/src/input/tex/extensions/colorv2/colorv2.js index 51849b591..bbc7ad38d 100644 --- a/components/src/input/tex/extensions/colorv2/colorv2.js +++ b/components/src/input/tex/extensions/colorv2/colorv2.js @@ -1,4 +1 @@ import './lib/colorv2.js'; -import {rename} from '../rename.js'; - -rename('colorV2', 'colorv2', false); diff --git a/components/src/input/tex/extensions/configmacros/configmacros.js b/components/src/input/tex/extensions/configmacros/configmacros.js index 8645dfee9..0dd16952d 100644 --- a/components/src/input/tex/extensions/configmacros/configmacros.js +++ b/components/src/input/tex/extensions/configmacros/configmacros.js @@ -1,4 +1 @@ import './lib/configmacros.js'; -import {rename} from '../rename.js'; - -rename('configMacros', 'configmacros', false); diff --git a/components/src/input/tex/extensions/rename.js b/components/src/input/tex/extensions/rename.js deleted file mode 100644 index 7fe40c2f4..000000000 --- a/components/src/input/tex/extensions/rename.js +++ /dev/null @@ -1,18 +0,0 @@ -import {combineConfig} from '../../../../../js/components/global.js'; - -// -// Look for a package name in the package list and change it to a new name -// and rename tex options for it, if there are any. -// -export function rename(oname, nname, options) { - const tex = MathJax.config.tex; - if (tex && tex.packages) { - const packages = tex.packages; - const n = packages.indexOf(oname); - if (n >= 0) packages[n] = nname; - if (options && tex[oname]) { - combineConfig(tex, {[nname]: tex[oname]}); - delete tex[oname]; - } - } -} diff --git a/components/src/input/tex/extensions/tagformat/tagformat.js b/components/src/input/tex/extensions/tagformat/tagformat.js index 17ee5137a..29b0da313 100644 --- a/components/src/input/tex/extensions/tagformat/tagformat.js +++ b/components/src/input/tex/extensions/tagformat/tagformat.js @@ -1,4 +1 @@ import './lib/tagformat.js'; -import {rename} from '../rename.js'; - -rename('tagFormat', 'tagformat', true); From b00995ba027fd771666bd96610e4e0749e4b05c5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:10:50 -0400 Subject: [PATCH 108/142] Move matchFontHeight to CHTML output jax --- ts/output/chtml.ts | 1 + ts/output/common/OutputJax.ts | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index 3938ba6de..fd1ccf1b3 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -60,6 +60,7 @@ CommonOutputJax, CHTMLWrapperFactory, CH public static OPTIONS: OptionList = { ...CommonOutputJax.OPTIONS, adaptiveCSS: true, // true means only produce CSS that is used in the processed equations + matchFontHeight: true, // true to match ex-height of surrounding font }; /** diff --git a/ts/output/common/OutputJax.ts b/ts/output/common/OutputJax.ts index 57029163b..52030c5e6 100644 --- a/ts/output/common/OutputJax.ts +++ b/ts/output/common/OutputJax.ts @@ -86,7 +86,6 @@ export abstract class CommonOutputJax< ...AbstractOutputJax.OPTIONS, scale: 1, // global scaling factor for all expressions minScale: .5, // smallest scaling factor to use - matchFontHeight: true, // true to match ex-height of surrounding font mtextInheritFont: false, // true to make mtext elements use surrounding font merrorInheritFont: false, // true to make merror text use surrounding font mtextFont: '', // font to use for mtext, if not inheriting (empty means use MathJax fonts) From afb0fb99f1d0d394ae595c70244c838907087f02 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:17:13 -0400 Subject: [PATCH 109/142] Remove compatibilty CssStyles.ts file from output/common --- ts/output/common/CssStyles.ts | 6 ------ 1 file changed, 6 deletions(-) delete mode 100644 ts/output/common/CssStyles.ts diff --git a/ts/output/common/CssStyles.ts b/ts/output/common/CssStyles.ts deleted file mode 100644 index dbd3dc5b4..000000000 --- a/ts/output/common/CssStyles.ts +++ /dev/null @@ -1,6 +0,0 @@ -// -// Temporary compatibility file for renaming of this file to util/StyleList.ts -// (to be removed in the next release) -// -export * from '../../util/StyleList.js'; - From 94e7d27e69cda7c61a49e2fefafc51aedcbc1d22 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:19:16 -0400 Subject: [PATCH 110/142] Remove compatibility BBox.ts files from output directories --- ts/output/chtml/BBox.ts | 24 ------------------------ ts/output/common/BBox.ts | 24 ------------------------ ts/output/svg/BBox.ts | 24 ------------------------ 3 files changed, 72 deletions(-) delete mode 100644 ts/output/chtml/BBox.ts delete mode 100644 ts/output/common/BBox.ts delete mode 100644 ts/output/svg/BBox.ts diff --git a/ts/output/chtml/BBox.ts b/ts/output/chtml/BBox.ts deleted file mode 100644 index edcc347f3..000000000 --- a/ts/output/chtml/BBox.ts +++ /dev/null @@ -1,24 +0,0 @@ -/************************************************************* - * - * Copyright (c) 2017 The MathJax Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * @fileoverview Implements the CHTML bounding box object - * - * @author dpvc@mathjax.org (Davide Cervone) - */ - -export * from '../../util/BBox.js'; diff --git a/ts/output/common/BBox.ts b/ts/output/common/BBox.ts deleted file mode 100644 index 5aadb2d96..000000000 --- a/ts/output/common/BBox.ts +++ /dev/null @@ -1,24 +0,0 @@ -/************************************************************* - * - * Copyright (c) 2017 The MathJax Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * @fileoverview Implements the common bounding box object - * - * @author dpvc@mathjax.org (Davide Cervone) - */ - -export * from '../../util/BBox.js'; diff --git a/ts/output/svg/BBox.ts b/ts/output/svg/BBox.ts deleted file mode 100644 index e1bcf6561..000000000 --- a/ts/output/svg/BBox.ts +++ /dev/null @@ -1,24 +0,0 @@ -/************************************************************* - * - * Copyright (c) 2017 The MathJax Consortium - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * @fileoverview Implements the SVG bounding box object - * - * @author dpvc@mathjax.org (Davide Cervone) - */ - -export * from '../../util/BBox.js'; From 776c9a2d8971b1ca77ea24c2cc36988233298a9f Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:29:25 -0400 Subject: [PATCH 111/142] Remove backward-compatibiliyt handling of options. --- ts/a11y/explorer.ts | 27 --------------------------- ts/a11y/semantic-enrich.ts | 22 ---------------------- 2 files changed, 49 deletions(-) diff --git a/ts/a11y/explorer.ts b/ts/a11y/explorer.ts index ddb48eb5b..e4eb4da05 100644 --- a/ts/a11y/explorer.ts +++ b/ts/a11y/explorer.ts @@ -284,7 +284,6 @@ export function ExplorerMathDocumentMixin(handler: Handler, MmlJax: MathML ); return handler; } - - -// -// TODO(v3.2): This is for backward compatibility of old option parameters. -// -/** - * Processes old enrichment option for backward compatibility. - * @param {OptionList} options The options to process. - */ -function processSreOptions(options: OptionList) { - if (!options) { - return; - } - if (!options.sre) { - options.sre = {}; - } - if (options.enrichSpeech) { - options.sre.speech = options.enrichSpeech; - delete options.enrichSpeech; - } -} From cc7ce062f4d2be87222f659837ac8abc90a0f7f2 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 09:40:38 -0400 Subject: [PATCH 112/142] Remove rename.js from tex-full --- components/src/input/tex-full/tex-full.js | 5 ----- 1 file changed, 5 deletions(-) diff --git a/components/src/input/tex-full/tex-full.js b/components/src/input/tex-full/tex-full.js index 1658d2d05..5a5ebd06d 100644 --- a/components/src/input/tex-full/tex-full.js +++ b/components/src/input/tex-full/tex-full.js @@ -1,7 +1,6 @@ import './lib/tex-full.js'; import {registerTeX} from '../tex/register.js'; -import {rename} from '../tex/extensions/rename.js'; import {Loader} from '../../../../js/components/loader.js'; import {AllPackages} from '../../../../js/input/tex/AllPackages.js'; import '../../../../js/input/tex/require/RequireConfiguration.js'; @@ -13,7 +12,3 @@ Loader.preLoad( ); registerTeX(['require',...AllPackages]); -rename('amsCd', 'amscd', true); -rename('colorV2', 'colorv2', false); -rename('configMacros', 'configmacros', false); -rename('tagFormat', 'tagformat', true); From 8dcbb4fe81fb073b5622b5707b63accc65c00a06 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 4 Jun 2021 11:41:49 -0400 Subject: [PATCH 113/142] Add actions for locale and speechRules, as requested by Volker. --- ts/a11y/explorer.ts | 13 ------------- ts/ui/menu/Menu.ts | 24 +++++++++++++++--------- 2 files changed, 15 insertions(+), 22 deletions(-) diff --git a/ts/a11y/explorer.ts b/ts/a11y/explorer.ts index e4eb4da05..12c83093f 100644 --- a/ts/a11y/explorer.ts +++ b/ts/a11y/explorer.ts @@ -524,19 +524,6 @@ export function setA11yOption(document: HTMLDOCUMENT, option: string, value: str break; } break; - // - // TODO(v3.2): These two cases should be handled directly in the menu - // variable actions. - // - case 'speechRules': - let [domain, style] = (value as string).split('-'); - document.options.sre.domain = domain; - document.options.sre.style = style; - break; - case 'locale': - document.options.sre.locale = value; - SRE.setupEngine({locale: value as string}); - break; default: document.options.a11y[option] = value; } diff --git a/ts/ui/menu/Menu.ts b/ts/ui/menu/Menu.ts index 638b2c846..cdf1037c2 100644 --- a/ts/ui/menu/Menu.ts +++ b/ts/ui/menu/Menu.ts @@ -402,13 +402,13 @@ export class Menu { this.variable('semantics'), this.variable ('zoom'), this.variable ('zscale'), - this.variable ('renderer', (jax: string) => this.setRenderer(jax)), + this.variable ('renderer', (jax) => this.setRenderer(jax)), this.variable('alt'), this.variable('cmd'), this.variable('ctrl'), this.variable('shift'), - this.variable ('scale', (scale: string) => this.setScale(scale)), - this.variable('explorer', (explore: boolean) => this.setExplorer(explore)), + this.variable ('scale', (scale) => this.setScale(scale)), + this.variable('explorer', (explore) => this.setExplorer(explore)), this.a11yVar ('highlight'), this.a11yVar ('backgroundColor'), this.a11yVar ('backgroundOpacity'), @@ -418,8 +418,12 @@ export class Menu { this.a11yVar('subtitles'), this.a11yVar('braille'), this.a11yVar('viewBraille'), - this.a11yVar('locale'), - this.a11yVar ('speechRules'), + this.a11yVar('locale', (value) => SRE.setupEngine({locale: value as string})), + this.a11yVar ('speechRules', (value) => { + const [domain, style] = value.split('-'); + this.document.options.sre.domain = domain; + this.document.options.sre.style = style; + }), this.a11yVar ('magnification'), this.a11yVar ('magnify'), this.a11yVar('treeColoring'), @@ -427,9 +431,9 @@ export class Menu { this.a11yVar('infoRole'), this.a11yVar('infoPrefix'), this.variable('autocollapse'), - this.variable('collapsible', (collapse: boolean) => this.setCollapsible(collapse)), - this.variable('inTabOrder', (tab: boolean) => this.setTabOrder(tab)), - this.variable('assistiveMml', (mml: boolean) => this.setAssistiveMml(mml)) + this.variable('collapsible', (collapse) => this.setCollapsible(collapse)), + this.variable('inTabOrder', (tab) => this.setTabOrder(tab)), + this.variable('assistiveMml', (mml) => this.setAssistiveMml(mml)) ], items: [ this.submenu('Show', 'Show Math As', [ @@ -864,6 +868,7 @@ export class Menu { this.transferMathList(document); this.document.processed = document.processed; if (!Menu._loadingPromise) { + this.document.outputJax.reset(); this.rerender(component === 'complexity' || noEnrich ? STATE.COMPILED : STATE.TYPESET); } }); @@ -1044,7 +1049,7 @@ export class Menu { * * @tempate T The type of variable being defined */ - public a11yVar(name: keyof MenuSettings): Object { + public a11yVar(name: keyof MenuSettings, action?: (value: T) => void): Object { return { name: name, getter: () => this.getA11y(name), @@ -1053,6 +1058,7 @@ export class Menu { let options: {[key: string]: any} = {}; options[name] = value; this.setA11y(options); + action && action(value); this.saveUserSettings(); } }; From c2b91fbb3e9a7d05e1f94829660250d76628809c Mon Sep 17 00:00:00 2001 From: zorkow Date: Tue, 8 Jun 2021 23:41:26 +0100 Subject: [PATCH 114/142] Texcomp integration. --- ts/input/tex/textcomp/TextcompConfiguration.ts | 5 ++++- ts/input/tex/textcomp/TextcompMappings.ts | 6 +++--- 2 files changed, 7 insertions(+), 4 deletions(-) diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts index d9dc89083..651d1fa68 100644 --- a/ts/input/tex/textcomp/TextcompConfiguration.ts +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -27,6 +27,9 @@ import './TextcompMappings.js'; export const TextcompConfiguration = Configuration.create( - 'textcomp', {handler: {macro: ['textcomp-macros', 'textcomp-oldstyle']}} + 'textcomp', { + parser: 'tex', + handler: {macro: ['textcomp-macros', 'textcomp-oldstyle']} + } ); diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index 5c8463e44..88c73c181 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -27,7 +27,7 @@ import {CharacterMap, CommandMap} from '../SymbolMap.js'; import {Symbol} from '../Symbol.js'; import {TexConstant} from '../TexConstants.js'; import {TextMacrosMethods} from '../textmacros/TextMacrosMethods.js'; -import TexParser from '../TexParser.js'; +import {TextParser} from '../textmacros/TextParser.js'; /** @@ -163,10 +163,10 @@ new CommandMap('textcomp-macros', { /** * Handle old style characters. - * @param {TexParser} parser The current tex parser. + * @param {TextParser} parser The current tex parser. * @param {Symbol} mchar The parsed symbol. */ -function mathchar0miOldstyle(parser: TexParser, mchar: Symbol) { +function mathchar0miOldstyle(parser: TextParser, mchar: Symbol) { const def = mchar.attributes || {}; def.mathvariant = TexConstant.Variant.OLDSTYLE; const node = parser.create('token', 'mi', def, mchar.char); From 147c91f1d6b071f9779004393df057ba096d22cd Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Wed, 9 Jun 2021 13:14:28 -0400 Subject: [PATCH 115/142] Work around WebKit bug with CHTML characters. (mathjax/MathJax#2435) --- ts/output/chtml/Wrappers/TextNode.ts | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index 7be2ab889..787e5224c 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -58,6 +58,19 @@ CommonTextNodeMixin>(CHTMLWrapper) { 'mjx-utext': { display: 'inline-block', padding: '.75em 0 .2em 0' + }, + // + // WebKit-specific CSS to handle bug with clipped characters. + // (test found at https://browserstrangeness.bitbucket.io/css_hacks.html#safari) + // + '@supports (-webkit-marquee-repetition:infinite) and (object-fit:fill)': { + // + // We don't really support nested CSS, so fake it byt putting the CSS + // directly in the string, and commenting out the colon that is + // inserted after the selector (that would normally be a CSS property name) + // See issue #2435. + // + 'mjx-c::before/*': '*/ {will-change: opacity}' } }; From bbafaf117faab1a2e89aeb5ce0689ef24d6ec0a3 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 10 Jun 2021 07:52:14 -0400 Subject: [PATCH 116/142] Don't record unkonw characters in the character usage for CHTML --- ts/output/chtml/Wrappers/TextNode.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index 7be2ab889..22c38a14b 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -80,7 +80,7 @@ CommonTextNodeMixin>(CHTMLWrapper) { this.jax.unknownText(String.fromCodePoint(n), variant) : this.html('mjx-c', {class: this.char(n) + font})); adaptor.append(parent, node); - this.font.charUsage.add([variant, n]); + !data.unknown && this.font.charUsage.add([variant, n]); } } } From 217eaae3da63a8478273cb60c9925b85d566b0b9 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 10 Jun 2021 07:59:57 -0400 Subject: [PATCH 117/142] Update css test for Safari to work in more cases --- ts/output/chtml/Wrappers/TextNode.ts | 10 ++-------- 1 file changed, 2 insertions(+), 8 deletions(-) diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index 787e5224c..e6596b494 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -63,14 +63,8 @@ CommonTextNodeMixin>(CHTMLWrapper) { // WebKit-specific CSS to handle bug with clipped characters. // (test found at https://browserstrangeness.bitbucket.io/css_hacks.html#safari) // - '@supports (-webkit-marquee-repetition:infinite) and (object-fit:fill)': { - // - // We don't really support nested CSS, so fake it byt putting the CSS - // directly in the string, and commenting out the colon that is - // inserted after the selector (that would normally be a CSS property name) - // See issue #2435. - // - 'mjx-c::before/*': '*/ {will-change: opacity}' + '_::-webkit-full-page-media, _:future, :root mjx-container': { + 'will-change': 'opacity' } }; From 74df9653e0f89be5630c45b2d5874a834940f1b2 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 10 Jun 2021 10:07:42 -0400 Subject: [PATCH 118/142] Make sure correct class is used for stretchy character CSS when the stretchy character is aliased. --- ts/output/chtml/FontData.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ts/output/chtml/FontData.ts b/ts/output/chtml/FontData.ts index c2aeffd96..949f2cf73 100644 --- a/ts/output/chtml/FontData.ts +++ b/ts/output/chtml/FontData.ts @@ -230,8 +230,9 @@ export class CHTMLFontData extends FontData Date: Thu, 10 Jun 2021 10:08:18 -0400 Subject: [PATCH 119/142] Make sure character CSS is included when a stretchy delimiter is used. --- ts/output/chtml/Wrappers/mo.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/ts/output/chtml/Wrappers/mo.ts b/ts/output/chtml/Wrappers/mo.ts index d9a3391fd..d8c80ae22 100644 --- a/ts/output/chtml/Wrappers/mo.ts +++ b/ts/output/chtml/Wrappers/mo.ts @@ -158,6 +158,7 @@ CommonMoMixin>(CHTMLWrapper) { protected stretchHTML(chtml: N) { const c = this.getText().codePointAt(0); this.font.delimUsage.add(c); + this.childNodes[0].markUsed(); const delim = this.stretch; const stretch = delim.stretch; const content: N[] = []; From 50b6e204db96931c8ce1ff01ac3a9e1f9aa456a6 Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 10 Jun 2021 16:27:36 +0200 Subject: [PATCH 120/142] Old style map separately. --- ts/input/tex/textcomp/TextcompMappings.ts | 31 ++++++++++++++++++----- 1 file changed, 24 insertions(+), 7 deletions(-) diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index 88c73c181..946865dd8 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -27,6 +27,8 @@ import {CharacterMap, CommandMap} from '../SymbolMap.js'; import {Symbol} from '../Symbol.js'; import {TexConstant} from '../TexConstants.js'; import {TextMacrosMethods} from '../textmacros/TextMacrosMethods.js'; +import TexParser from '../TexParser.js'; +import ParseUtil from '../ParseUtil.js'; import {TextParser} from '../textmacros/TextParser.js'; @@ -158,7 +160,15 @@ new CommandMap('textcomp-macros', { 'textdivorced': ['Insert', '\u26AE'], // 'textleaf' 'textmarried': ['Insert', '\u26AD'] -}, TextMacrosMethods); +}, { + Insert: function(parser: TexParser, name: string, c: string) { + if (parser instanceof TextParser) { + TextMacrosMethods.Insert(parser, name, c); + } else { + parser.Push(ParseUtil.internalText(parser, c, {})); + } + } +}); /** @@ -166,17 +176,24 @@ new CommandMap('textcomp-macros', { * @param {TextParser} parser The current tex parser. * @param {Symbol} mchar The parsed symbol. */ -function mathchar0miOldstyle(parser: TextParser, mchar: Symbol) { - const def = mchar.attributes || {}; - def.mathvariant = TexConstant.Variant.OLDSTYLE; - const node = parser.create('token', 'mi', def, mchar.char); - parser.Push(node); +function oldstyleText(parser: TexParser, mchar: Symbol) { + if (!(parser instanceof TextParser)) { + parser.Push(ParseUtil.internalText( + parser, mchar.char, {mathvariant: TexConstant.Variant.OLDSTYLE})); + return; + } + if (parser.stack.env.mathvariant = TexConstant.Variant.OLDSTYLE) { + parser.text += mchar.char; + return; + } + TextMacrosMethods.SetFont(parser, mchar.symbol, TexConstant.Variant.OLDSTYLE); + parser.text = mchar.char; } /** * Identifiers from the Textcomp package. */ -new CharacterMap('textcomp-oldstyle', mathchar0miOldstyle, { +new CharacterMap('textcomp-oldstyle', oldstyleText, { // This is not the correct glyph 'textcentoldstyle': '\u00A2', From 5f71a1d2bf1ebba2497b786a781d5dffce1b7f4c Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 10 Jun 2021 17:21:17 +0200 Subject: [PATCH 121/142] Cleaned up version of textcomp. --- .../tex/textcomp/TextcompConfiguration.ts | 2 +- ts/input/tex/textcomp/TextcompMappings.ts | 75 +++++++------------ 2 files changed, 27 insertions(+), 50 deletions(-) diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts index 651d1fa68..24328e2b0 100644 --- a/ts/input/tex/textcomp/TextcompConfiguration.ts +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -29,7 +29,7 @@ import './TextcompMappings.js'; export const TextcompConfiguration = Configuration.create( 'textcomp', { parser: 'tex', - handler: {macro: ['textcomp-macros', 'textcomp-oldstyle']} + handler: {macro: ['textcomp-macros']} } ); diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index 946865dd8..ffe695266 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -23,8 +23,7 @@ */ -import {CharacterMap, CommandMap} from '../SymbolMap.js'; -import {Symbol} from '../Symbol.js'; +import {CommandMap} from '../SymbolMap.js'; import {TexConstant} from '../TexConstants.js'; import {TextMacrosMethods} from '../textmacros/TextMacrosMethods.js'; import TexParser from '../TexParser.js'; @@ -159,56 +158,34 @@ new CommandMap('textcomp-macros', { 'textdied': ['Insert', '\u2020'], 'textdivorced': ['Insert', '\u26AE'], // 'textleaf' - 'textmarried': ['Insert', '\u26AD'] -}, { - Insert: function(parser: TexParser, name: string, c: string) { - if (parser instanceof TextParser) { - TextMacrosMethods.Insert(parser, name, c); - } else { - parser.Push(ParseUtil.internalText(parser, c, {})); - } - } -}); - - -/** - * Handle old style characters. - * @param {TextParser} parser The current tex parser. - * @param {Symbol} mchar The parsed symbol. - */ -function oldstyleText(parser: TexParser, mchar: Symbol) { - if (!(parser instanceof TextParser)) { - parser.Push(ParseUtil.internalText( - parser, mchar.char, {mathvariant: TexConstant.Variant.OLDSTYLE})); - return; - } - if (parser.stack.env.mathvariant = TexConstant.Variant.OLDSTYLE) { - parser.text += mchar.char; - return; - } - TextMacrosMethods.SetFont(parser, mchar.symbol, TexConstant.Variant.OLDSTYLE); - parser.text = mchar.char; -} - -/** - * Identifiers from the Textcomp package. - */ -new CharacterMap('textcomp-oldstyle', oldstyleText, { + 'textmarried': ['Insert', '\u26AD'], // This is not the correct glyph - 'textcentoldstyle': '\u00A2', + 'textcentoldstyle': ['Insert', '\u00A2', TexConstant.Variant.OLDSTYLE], // This is not the correct glyph - 'textdollaroldstyle': '\u0024', + 'textdollaroldstyle': ['Insert', '\u0024', TexConstant.Variant.OLDSTYLE], // Table 16: textcomp Old-Style Numerals - 'textzerooldstyle': '0', - 'textoneoldstyle': '1', - 'texttwooldstyle': '2', - 'textthreeoldstyle': '3', - 'textfouroldstyle': '4', - 'textfiveoldstyle': '5', - 'textsixoldstyle': '6', - 'textsevenoldstyle': '7', - 'texteightoldstyle': '8', - 'textnineoldstyle': '9' + 'textzerooldstyle': ['Insert', '0', TexConstant.Variant.OLDSTYLE], + 'textoneoldstyle': ['Insert', '1', TexConstant.Variant.OLDSTYLE], + 'texttwooldstyle': ['Insert', '2', TexConstant.Variant.OLDSTYLE], + 'textthreeoldstyle': ['Insert', '3', TexConstant.Variant.OLDSTYLE], + 'textfouroldstyle': ['Insert', '4', TexConstant.Variant.OLDSTYLE], + 'textfiveoldstyle': ['Insert', '5', TexConstant.Variant.OLDSTYLE], + 'textsixoldstyle': ['Insert', '6', TexConstant.Variant.OLDSTYLE], + 'textsevenoldstyle': ['Insert', '7', TexConstant.Variant.OLDSTYLE], + 'texteightoldstyle': ['Insert', '8', TexConstant.Variant.OLDSTYLE], + 'textnineoldstyle': ['Insert', '9', TexConstant.Variant.OLDSTYLE] +}, { + Insert: function(parser: TexParser, name: string, c: string, font: string) { + if (parser instanceof TextParser) { + if (!font) { + TextMacrosMethods.Insert(parser, name, c); + return; + } + parser.saveText(); + } + parser.Push(ParseUtil.internalText( + parser, c, font ? {mathvariant: font} : {})); + } }); From 319487d728a1cb4556bb14ed152a4c7b2e664892 Mon Sep 17 00:00:00 2001 From: zorkow Date: Thu, 10 Jun 2021 21:59:54 +0200 Subject: [PATCH 122/142] Review corrections. --- ts/input/tex/textcomp/TextcompConfiguration.ts | 1 - ts/input/tex/textcomp/TextcompMappings.ts | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts index 24328e2b0..cf88b9f75 100644 --- a/ts/input/tex/textcomp/TextcompConfiguration.ts +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -28,7 +28,6 @@ import './TextcompMappings.js'; export const TextcompConfiguration = Configuration.create( 'textcomp', { - parser: 'tex', handler: {macro: ['textcomp-macros']} } ); diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index ffe695266..eaad857e8 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -96,7 +96,7 @@ new CommandMap('textcomp-macros', { // Table 15: textcomp Legal Symbols 'textcircledP': ['Insert', '\u2117'], 'textcompwordmark': ['Insert', '\u200C'], - 'textcopyleft': ['Insert', '\u1F12F'], + 'textcopyleft': ['Insert', '\u{1F12F}'], 'textcopyright': ['Insert', '\u00A9'], 'textregistered': ['Insert', '\u00AE'], 'textservicemark': ['Insert', '\u2120'], From 740f5ebb8a59fce9d331d499224c3afc2065d60b Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 10 Jun 2021 16:32:01 -0400 Subject: [PATCH 123/142] Remove parentheses, as requested by Volker. --- ts/ui/menu/Menu.ts | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/ts/ui/menu/Menu.ts b/ts/ui/menu/Menu.ts index cdf1037c2..1be13ec5e 100644 --- a/ts/ui/menu/Menu.ts +++ b/ts/ui/menu/Menu.ts @@ -402,13 +402,13 @@ export class Menu { this.variable('semantics'), this.variable ('zoom'), this.variable ('zscale'), - this.variable ('renderer', (jax) => this.setRenderer(jax)), + this.variable ('renderer', jax => this.setRenderer(jax)), this.variable('alt'), this.variable('cmd'), this.variable('ctrl'), this.variable('shift'), - this.variable ('scale', (scale) => this.setScale(scale)), - this.variable('explorer', (explore) => this.setExplorer(explore)), + this.variable ('scale', scale => this.setScale(scale)), + this.variable('explorer', explore => this.setExplorer(explore)), this.a11yVar ('highlight'), this.a11yVar ('backgroundColor'), this.a11yVar ('backgroundOpacity'), @@ -418,8 +418,8 @@ export class Menu { this.a11yVar('subtitles'), this.a11yVar('braille'), this.a11yVar('viewBraille'), - this.a11yVar('locale', (value) => SRE.setupEngine({locale: value as string})), - this.a11yVar ('speechRules', (value) => { + this.a11yVar('locale', value => SRE.setupEngine({locale: value as string})), + this.a11yVar ('speechRules', value => { const [domain, style] = value.split('-'); this.document.options.sre.domain = domain; this.document.options.sre.style = style; @@ -431,9 +431,9 @@ export class Menu { this.a11yVar('infoRole'), this.a11yVar('infoPrefix'), this.variable('autocollapse'), - this.variable('collapsible', (collapse) => this.setCollapsible(collapse)), - this.variable('inTabOrder', (tab) => this.setTabOrder(tab)), - this.variable('assistiveMml', (mml) => this.setAssistiveMml(mml)) + this.variable('collapsible', collapse => this.setCollapsible(collapse)), + this.variable('inTabOrder', tab => this.setTabOrder(tab)), + this.variable('assistiveMml', mml => this.setAssistiveMml(mml)) ], items: [ this.submenu('Show', 'Show Math As', [ @@ -1006,8 +1006,8 @@ export class Menu { const element = math.typesetRoot; element.addEventListener('contextmenu', () => this.menu.mathItem = math, true); element.addEventListener('keydown', () => this.menu.mathItem = math, true); - element.addEventListener('click', (event: MouseEvent) => this.zoom(event, 'Click', math), true); - element.addEventListener('dblclick', (event: MouseEvent) => this.zoom(event, 'DoubleClick', math), true); + element.addEventListener('click', event => this.zoom(event, 'Click', math), true); + element.addEventListener('dblclick', event => this.zoom(event, 'DoubleClick', math), true); this.menu.store.insert(element); } From 490a606ebf27015d1e12a2ec3f61009b5dea1587 Mon Sep 17 00:00:00 2001 From: zorkow Date: Fri, 11 Jun 2021 11:14:51 +0200 Subject: [PATCH 124/142] Updates to latest version of SRE. --- package-lock.json | 14 +++++++------- package.json | 2 +- ts/a11y/explorer.ts | 1 + ts/a11y/explorer/KeyExplorer.ts | 4 +++- 4 files changed, 12 insertions(+), 9 deletions(-) diff --git a/package-lock.json b/package-lock.json index 1f944ffd7..e2fb427c5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -12,7 +12,7 @@ "esm": "^3.2.25", "mhchemparser": "^4.1.0", "mj-context-menu": "^0.6.1", - "speech-rule-engine": "^3.2.0" + "speech-rule-engine": "^3.3.3" }, "devDependencies": { "@babel/core": "^7.13.16", @@ -3627,9 +3627,9 @@ } }, "node_modules/speech-rule-engine": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/speech-rule-engine/-/speech-rule-engine-3.2.0.tgz", - "integrity": "sha512-Vg1pNhl3cdVPk5XWn8su+bUNs+jaY1UmvKLeLui+iJ5/a0Kr7cOfO2gGuYOMd/3+0wLvzEqmou8rtz5REBd9xQ==", + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/speech-rule-engine/-/speech-rule-engine-3.3.3.tgz", + "integrity": "sha512-0exWw+0XauLjat+f/aFeo5T8SiDsO1JtwpY3qgJE4cWt+yL/Stl0WP4VNDWdh7lzGkubUD9lWP4J1ASnORXfyQ==", "dependencies": { "commander": ">=7.0.0", "wicked-good-xpath": "^1.3.0", @@ -7449,9 +7449,9 @@ } }, "speech-rule-engine": { - "version": "3.2.0", - "resolved": "https://registry.npmjs.org/speech-rule-engine/-/speech-rule-engine-3.2.0.tgz", - "integrity": "sha512-Vg1pNhl3cdVPk5XWn8su+bUNs+jaY1UmvKLeLui+iJ5/a0Kr7cOfO2gGuYOMd/3+0wLvzEqmou8rtz5REBd9xQ==", + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/speech-rule-engine/-/speech-rule-engine-3.3.3.tgz", + "integrity": "sha512-0exWw+0XauLjat+f/aFeo5T8SiDsO1JtwpY3qgJE4cWt+yL/Stl0WP4VNDWdh7lzGkubUD9lWP4J1ASnORXfyQ==", "requires": { "commander": ">=7.0.0", "wicked-good-xpath": "^1.3.0", diff --git a/package.json b/package.json index 0b3da7b45..56bbe4e30 100644 --- a/package.json +++ b/package.json @@ -65,6 +65,6 @@ "esm": "^3.2.25", "mhchemparser": "^4.1.0", "mj-context-menu": "^0.6.1", - "speech-rule-engine": "^3.2.0" + "speech-rule-engine": "^3.3.3" } } diff --git a/ts/a11y/explorer.ts b/ts/a11y/explorer.ts index 12c83093f..e8fdade32 100644 --- a/ts/a11y/explorer.ts +++ b/ts/a11y/explorer.ts @@ -628,6 +628,7 @@ const iso: {[locale: string]: string} = { 'en': 'English', 'es': 'Spanish', 'fr': 'French', + 'hi': 'Hindi', 'it': 'Italian' }; diff --git a/ts/a11y/explorer/KeyExplorer.ts b/ts/a11y/explorer/KeyExplorer.ts index 2e6946dad..336ecc045 100644 --- a/ts/a11y/explorer/KeyExplorer.ts +++ b/ts/a11y/explorer/KeyExplorer.ts @@ -252,10 +252,12 @@ export class SpeechExplorer extends AbstractKeyExplorer { */ public Update(force: boolean = false) { super.Update(force); + let options = this.speechGenerator.getOptions(); + SRE.setupEngine({modality: options.modality, + locale: options.locale}); this.region.Update(this.walker.speech()); // This is a necessary in case speech options have changed via keypress // during walking. - let options = this.speechGenerator.getOptions(); if (options.modality === 'speech') { this.document.options.sre.domain = options.domain; this.document.options.sre.style = options.style; From 31e711d1e3759145b8f7d0372a9fb5c3b26a9f4b Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 08:33:33 -0400 Subject: [PATCH 125/142] Adjust components (mml to not incluide mml3, tex to not include entities no longer neeeded). Adjust build to report [components] better, and make-components to be line buffered so that its output in travis is better. --- components/bin/pack | 2 +- components/src/input/mml/build.json | 6 +++++- components/src/input/tex-base/build.json | 5 +---- components/src/input/tex-full/build.json | 8 +------- components/src/input/tex/build.json | 5 +---- package.json | 2 +- 6 files changed, 10 insertions(+), 18 deletions(-) diff --git a/components/bin/pack b/components/bin/pack index d204810b9..ed8789ce4 100755 --- a/components/bin/pack +++ b/components/bin/pack @@ -48,7 +48,7 @@ function fileSize(file) { /** * Regular expressions for the components directory and the MathJax .js location */ -const compRE = fileRegExp(path.dirname(__dirname)); +const compRE = fileRegExp(path.join(path.dirname(__dirname), 'src')); const rootRE = fileRegExp(path.join(path.dirname(path.dirname(__dirname)), 'js')); const nodeRE = fileRegExp(path.join(path.dirname(path.dirname(__dirname)), 'node_modules')); diff --git a/components/src/input/mml/build.json b/components/src/input/mml/build.json index fa63de234..a41d8dfdd 100644 --- a/components/src/input/mml/build.json +++ b/components/src/input/mml/build.json @@ -1,4 +1,8 @@ { "component": "inpu/mml", - "targets": ["input/mathml.ts", "input/mathml"] + "targets": [ + "input/mathml.ts", + "input/mathml" + ], + "excludeSubdirs": "true" } diff --git a/components/src/input/tex-base/build.json b/components/src/input/tex-base/build.json index 41ab4cc42..5e55e12cb 100644 --- a/components/src/input/tex-base/build.json +++ b/components/src/input/tex-base/build.json @@ -3,10 +3,7 @@ "targets": [ "input/tex.ts", "input/tex", - "input/tex/base", - "util/entities/n.ts", - "util/entities/p.ts", - "util/entities/r.ts" + "input/tex/base" ], "exclude": ["input/tex/AllPackages.ts"], "excludeSubdirs": "true" diff --git a/components/src/input/tex-full/build.json b/components/src/input/tex-full/build.json index 626fe3290..a245332b7 100644 --- a/components/src/input/tex-full/build.json +++ b/components/src/input/tex-full/build.json @@ -2,13 +2,7 @@ "component": "input/tex-full", "targets": [ "input/tex.ts", - "input/tex", - "util/entities/n.ts", - "util/entities/p.ts", - "util/entities/r.ts" - ], - "exclude": [ - "input/tex/mhchem/mhchem_parser.d.ts" + "input/tex" ] } diff --git a/components/src/input/tex/build.json b/components/src/input/tex/build.json index 72e5b9c9b..1c7005b61 100644 --- a/components/src/input/tex/build.json +++ b/components/src/input/tex/build.json @@ -9,10 +9,7 @@ "input/tex/noundefined", "input/tex/require", "input/tex/autoload", - "input/tex/configmacros", - "util/entities/n.ts", - "util/entities/p.ts", - "util/entities/r.ts" + "input/tex/configmacros" ], "exclude": ["input/tex/AllPackages.ts"], "excludeSubdirs": "true" diff --git a/package.json b/package.json index 56bbe4e30..193bdc2ed 100644 --- a/package.json +++ b/package.json @@ -39,7 +39,7 @@ "compile": "npx tsc", "postcompile": "npm run --silent copy:mj2 && npm run --silent copy:mml3", "premake-components": "npm run --silent clean:es5 && npm run --silent clean:lib", - "make-components": "cd components && node bin/makeAll src | grep 'Building\\|Webpacking\\|Copying\\|npx'", + "make-components": "cd components && node bin/makeAll src | grep --line-buffered 'Building\\|Webpacking\\|Copying\\|npx'", "premake-mml3-xslt": "cd ts/input/mathml/mml3 && grep '^\\s*\\(<\\|or\\|xmlns\\|excl\\|\">\\)' mml3.ts > mml3.xsl", "make-mml3-xslt": "cd ts/input/mathml/mml3 && npx xslt3 -t -xsl:mml3.xsl -export:mml3.sef.json -nogo", "postmake-mml3-xslt": "rpx rimraf ts/input/mathml/mml3/mml3.xsl" From 9c0eee73d34ad197f5e8c94596ae23b4f79adc21 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 08:35:16 -0400 Subject: [PATCH 126/142] Update version number to 3.2 --- package.json | 2 +- ts/components/global.ts | 2 +- ts/mathjax.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/package.json b/package.json index 193bdc2ed..f285e4b5d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "mathjax-full", - "version": "3.1.4", + "version": "3.2.0", "description": "Beautiful and accessible math in all browsers. MathJax is an open-source JavaScript display engine for LaTeX, MathML, and AsciiMath notation that works in all browsers and in server-side node applications. This package includes the source code as well as the packaged components.", "license": "Apache-2.0", "main": "components/src/node-main/node-main.js", diff --git a/ts/components/global.ts b/ts/components/global.ts index bc0808c44..33e146988 100644 --- a/ts/components/global.ts +++ b/ts/components/global.ts @@ -127,7 +127,7 @@ if (typeof global.MathJax === 'undefined') { */ if (!(global.MathJax as MathJaxObject).version) { global.MathJax = { - version: '3.1.4', + version: '3.2.0', _: {}, config: global.MathJax }; diff --git a/ts/mathjax.ts b/ts/mathjax.ts index 82d95e1ca..307b59768 100644 --- a/ts/mathjax.ts +++ b/ts/mathjax.ts @@ -34,7 +34,7 @@ export const mathjax = { /** * The MathJax version number */ - version: '3.1.4', + version: '3.2.0', /** * The list of registers document handlers From 779ef0f1805900a738b9c136120b279df7f1df6f Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 08:43:24 -0400 Subject: [PATCH 127/142] Move Safari work-around to main styles, so it is always added to the initial stylesheet, otherwise is can cause errors in non-WebKit browsers when added dynamically --- ts/output/chtml.ts | 11 ++++++++++- ts/output/chtml/Wrappers/TextNode.ts | 7 ------- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index fd1ccf1b3..4b73cf47f 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -113,8 +113,17 @@ CommonOutputJax, CHTMLWrapperFactory, CH color: 'red', 'background-color': 'yellow' }, - 'mjx-mphantom': {visibility: 'hidden'} + 'mjx-mphantom': { + visibility: 'hidden' + }, + // + // WebKit-specific CSS to handle bug with clipped characters. + // (test found at https://browserstrangeness.bitbucket.io/css_hacks.html#safari) + // + '_::-webkit-full-page-media, _:future, :root mjx-container': { + 'will-change': 'opacity' + } }; /** diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index 1733e3d8b..22c38a14b 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -58,13 +58,6 @@ CommonTextNodeMixin>(CHTMLWrapper) { 'mjx-utext': { display: 'inline-block', padding: '.75em 0 .2em 0' - }, - // - // WebKit-specific CSS to handle bug with clipped characters. - // (test found at https://browserstrangeness.bitbucket.io/css_hacks.html#safari) - // - '_::-webkit-full-page-media, _:future, :root mjx-container': { - 'will-change': 'opacity' } }; From 7981d2e792f3554e24479617d23620b3277435f3 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 09:07:38 -0400 Subject: [PATCH 128/142] Update dependencies (except typescript) --- package-lock.json | 2537 +++++++++++++++++++++++++-------------------- package.json | 10 +- 2 files changed, 1433 insertions(+), 1114 deletions(-) diff --git a/package-lock.json b/package-lock.json index e2fb427c5..f975164d9 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "mathjax-full", - "version": "3.1.4", + "version": "3.2.0", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "mathjax-full", - "version": "3.1.4", + "version": "3.2.0", "license": "Apache-2.0", "dependencies": { "esm": "^3.2.25", @@ -15,53 +15,59 @@ "speech-rule-engine": "^3.3.3" }, "devDependencies": { - "@babel/core": "^7.13.16", - "@babel/preset-env": "^7.13.15", + "@babel/core": "^7.14.5", + "@babel/preset-env": "^7.14.5", "babel-loader": "^8.2.2", "copyfiles": "^2.4.1", "diff": "^5.0.0", "rimraf": "^3.0.2", "tape": "^5.2.2", - "terser-webpack-plugin": "^5.1.1", + "terser-webpack-plugin": "^5.1.3", "tslint": "^6.1.3", "tslint-jsdoc-rules": "^0.2.0", "tslint-unix-formatter": "^0.2.0", "typescript": "^4.2.4", "typescript-tools": "^0.3.1", - "webpack": "^5.35.0", - "webpack-cli": "^4.6.0" + "webpack": "^5.38.1", + "webpack-cli": "^4.7.2" } }, "node_modules/@babel/code-frame": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz", - "integrity": "sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.14.5.tgz", + "integrity": "sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==", "dev": true, "dependencies": { - "@babel/highlight": "^7.12.13" + "@babel/highlight": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/compat-data": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.13.15.tgz", - "integrity": "sha512-ltnibHKR1VnrU4ymHyQ/CXtNXI6yZC0oJThyW78Hft8XndANwi+9H+UIklBDraIjFEJzw8wmcM427oDd9KS5wA==", - "dev": true + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.14.5.tgz", + "integrity": "sha512-kixrYn4JwfAVPa0f2yfzc2AWti6WRRyO3XjWW5PJAvtE11qhSayrrcrEnee05KAtNaPC+EwehE8Qt1UedEVB8w==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } }, "node_modules/@babel/core": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.13.16.tgz", - "integrity": "sha512-sXHpixBiWWFti0AV2Zq7avpTasr6sIAu7Y396c608541qAU2ui4a193m0KSQmfPSKFZLnQ3cvlKDOm3XkuXm3Q==", - "dev": true, - "dependencies": { - "@babel/code-frame": "^7.12.13", - "@babel/generator": "^7.13.16", - "@babel/helper-compilation-targets": "^7.13.16", - "@babel/helper-module-transforms": "^7.13.14", - "@babel/helpers": "^7.13.16", - "@babel/parser": "^7.13.16", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.15", - "@babel/types": "^7.13.16", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.14.5.tgz", + "integrity": "sha512-RN/AwP2DJmQTZSfiDaD+JQQ/J99KsIpOCfBE5pL+5jJSt7nI3nYGoAXZu+ffYSQ029NLs2DstZb+eR81uuARgg==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.14.5", + "@babel/generator": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helpers": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5", "convert-source-map": "^1.7.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -102,46 +108,58 @@ } }, "node_modules/@babel/generator": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.13.16.tgz", - "integrity": "sha512-grBBR75UnKOcUWMp8WoDxNsWCFl//XCK6HWTrBQKTr5SV9f5g0pNOjdyzi/DTBv12S9GnYPInIXQBTky7OXEMg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.14.5.tgz", + "integrity": "sha512-y3rlP+/G25OIX3mYKKIOlQRcqj7YgrvHxOLbVmyLJ9bPmi5ttvUmpydVjcFjZphOktWuA7ovbx91ECloWTfjIA==", "dev": true, "dependencies": { - "@babel/types": "^7.13.16", + "@babel/types": "^7.14.5", "jsesc": "^2.5.1", "source-map": "^0.5.0" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-annotate-as-pure": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz", - "integrity": "sha512-7YXfX5wQ5aYM/BOlbSccHDbuXXFPxeoUmfWtz8le2yTkTZc+BxsiEnENFoi2SlmA8ewDkG2LgIMIVzzn2h8kfw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.14.5.tgz", + "integrity": "sha512-EivH9EgBIb+G8ij1B2jAwSH36WnGvkQSEC6CkX/6v6ZFlw5fVOHvsgGF4uiEHO2GzMvunZb6tDLQEQSdrdocrA==", "dev": true, "dependencies": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-builder-binary-assignment-operator-visitor": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz", - "integrity": "sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.14.5.tgz", + "integrity": "sha512-YTA/Twn0vBXDVGJuAX6PwW7x5zQei1luDDo2Pl6q1qZ7hVNl0RZrhHCQG/ArGpR29Vl7ETiB8eJyrvpuRp300w==", "dev": true, "dependencies": { - "@babel/helper-explode-assignable-expression": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/helper-explode-assignable-expression": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-compilation-targets": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.16.tgz", - "integrity": "sha512-3gmkYIrpqsLlieFwjkGgLaSHmhnvlAYzZLlYVjlW+QwI+1zE17kGxuJGmIqDQdYp56XdmGeD+Bswx0UTyG18xA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.5.tgz", + "integrity": "sha512-v+QtZqXEiOnpO6EYvlImB6zCD2Lel06RzOPzmkz/D/XgQiUu3C/Jb1LOqSt/AIA34TYi/Q+KlT8vTQrgdxkbLw==", "dev": true, "dependencies": { - "@babel/compat-data": "^7.13.15", - "@babel/helper-validator-option": "^7.12.17", - "browserslist": "^4.14.5", + "@babel/compat-data": "^7.14.5", + "@babel/helper-validator-option": "^7.14.5", + "browserslist": "^4.16.6", "semver": "^6.3.0" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0" } @@ -156,38 +174,45 @@ } }, "node_modules/@babel/helper-create-class-features-plugin": { - "version": "7.13.11", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz", - "integrity": "sha512-ays0I7XYq9xbjCSvT+EvysLgfc3tOkwCULHjrnscGT3A9qD4sk3wXnJ3of0MAWsWGjdinFvajHU2smYuqXKMrw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.14.5.tgz", + "integrity": "sha512-Uq9z2e7ZtcnDMirRqAGLRaLwJn+Lrh388v5ETrR3pALJnElVh2zqQmdbz4W2RUJYohAPh2mtyPUgyMHMzXMncQ==", "dev": true, "dependencies": { - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-member-expression-to-functions": "^7.13.0", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/helper-replace-supers": "^7.13.0", - "@babel/helper-split-export-declaration": "^7.12.13" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-member-expression-to-functions": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "node_modules/@babel/helper-create-regexp-features-plugin": { - "version": "7.12.17", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.17.tgz", - "integrity": "sha512-p2VGmBu9oefLZ2nQpgnEnG0ZlRPvL8gAGvPUMQwUdaE8k49rOMuZpOwdQoy5qJf6K8jL3bcAMhVUlHAjIgJHUg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.14.5.tgz", + "integrity": "sha512-TLawwqpOErY2HhWbGJ2nZT5wSkR192QpN+nBg1THfBfftrlvOh+WbhrxXCH4q4xJ9Gl16BGPR/48JA+Ryiho/A==", "dev": true, "dependencies": { - "@babel/helper-annotate-as-pure": "^7.12.13", + "@babel/helper-annotate-as-pure": "^7.14.5", "regexpu-core": "^4.7.1" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "node_modules/@babel/helper-define-polyfill-provider": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.2.0.tgz", - "integrity": "sha512-JT8tHuFjKBo8NnaUbblz7mIu1nnvUDiHVjXXkulZULyidvo/7P6TY7+YqpV37IfF+KUFxmlK04elKtGKXaiVgw==", + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.2.3.tgz", + "integrity": "sha512-RH3QDAfRMzj7+0Nqu5oqgO5q9mFtQEVvCRsi8qCEfzLR9p2BHfn5FzhSB2oj1fF7I2+DcTORkYaQ6aTR9Cofew==", "dev": true, "dependencies": { "@babel/helper-compilation-targets": "^7.13.0", @@ -213,193 +238,249 @@ } }, "node_modules/@babel/helper-explode-assignable-expression": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz", - "integrity": "sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.14.5.tgz", + "integrity": "sha512-Htb24gnGJdIGT4vnRKMdoXiOIlqOLmdiUYpAQ0mYfgVT/GDm8GOYhgi4GL+hMKrkiPRohO4ts34ELFsGAPQLDQ==", "dev": true, "dependencies": { - "@babel/types": "^7.13.0" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-function-name": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz", - "integrity": "sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.14.5.tgz", + "integrity": "sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ==", "dev": true, "dependencies": { - "@babel/helper-get-function-arity": "^7.12.13", - "@babel/template": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/helper-get-function-arity": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-get-function-arity": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz", - "integrity": "sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.14.5.tgz", + "integrity": "sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg==", "dev": true, "dependencies": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-hoist-variables": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.16.tgz", - "integrity": "sha512-1eMtTrXtrwscjcAeO4BVK+vvkxaLJSPFz1w1KLawz6HLNi9bPFGBNwwDyVfiu1Tv/vRRFYfoGaKhmAQPGPn5Wg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.14.5.tgz", + "integrity": "sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ==", "dev": true, "dependencies": { - "@babel/traverse": "^7.13.15", - "@babel/types": "^7.13.16" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-member-expression-to-functions": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz", - "integrity": "sha512-48ql1CLL59aKbU94Y88Xgb2VFy7a95ykGRbJJaaVv+LX5U8wFpLfiGXJJGUozsmA1oEh/o5Bp60Voq7ACyA/Sw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.14.5.tgz", + "integrity": "sha512-UxUeEYPrqH1Q/k0yRku1JE7dyfyehNwT6SVkMHvYvPDv4+uu627VXBckVj891BO8ruKBkiDoGnZf4qPDD8abDQ==", "dev": true, "dependencies": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-imports": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz", - "integrity": "sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.14.5.tgz", + "integrity": "sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ==", "dev": true, "dependencies": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-module-transforms": { - "version": "7.13.14", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz", - "integrity": "sha512-QuU/OJ0iAOSIatyVZmfqB0lbkVP0kDRiKj34xy+QNsnVZi/PA6BoSoreeqnxxa9EHFAIL0R9XOaAR/G9WlIy5g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.14.5.tgz", + "integrity": "sha512-iXpX4KW8LVODuAieD7MzhNjmM6dzYY5tfRqT+R9HDXWl0jPn/djKmA+G9s/2C2T9zggw5tK1QNqZ70USfedOwA==", "dev": true, "dependencies": { - "@babel/helper-module-imports": "^7.13.12", - "@babel/helper-replace-supers": "^7.13.12", - "@babel/helper-simple-access": "^7.13.12", - "@babel/helper-split-export-declaration": "^7.12.13", - "@babel/helper-validator-identifier": "^7.12.11", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.13", - "@babel/types": "^7.13.14" + "@babel/helper-module-imports": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-simple-access": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", + "@babel/helper-validator-identifier": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-optimise-call-expression": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz", - "integrity": "sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.14.5.tgz", + "integrity": "sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA==", "dev": true, "dependencies": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-plugin-utils": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz", - "integrity": "sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==", - "dev": true + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.14.5.tgz", + "integrity": "sha512-/37qQCE3K0vvZKwoK4XU/irIJQdIfCJuhU5eKnNxpFDsOkgFaUAwbv+RYw6eYgsC0E4hS7r5KqGULUogqui0fQ==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } }, "node_modules/@babel/helper-remap-async-to-generator": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz", - "integrity": "sha512-pUQpFBE9JvC9lrQbpX0TmeNIy5s7GnZjna2lhhcHC7DzgBs6fWn722Y5cfwgrtrqc7NAJwMvOa0mKhq6XaE4jg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.14.5.tgz", + "integrity": "sha512-rLQKdQU+HYlxBwQIj8dk4/0ENOUEhA/Z0l4hN8BexpvmSMN9oA9EagjnhnDpNsRdWCfjwa4mn/HyBXO9yhQP6A==", "dev": true, "dependencies": { - "@babel/helper-annotate-as-pure": "^7.12.13", - "@babel/helper-wrap-function": "^7.13.0", - "@babel/types": "^7.13.0" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-wrap-function": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-replace-supers": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz", - "integrity": "sha512-Gz1eiX+4yDO8mT+heB94aLVNCL+rbuT2xy4YfyNqu8F+OI6vMvJK891qGBTqL9Uc8wxEvRW92Id6G7sDen3fFw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.14.5.tgz", + "integrity": "sha512-3i1Qe9/8x/hCHINujn+iuHy+mMRLoc77b2nI9TB0zjH1hvn9qGlXjWlggdwUcju36PkPCy/lpM7LLUdcTyH4Ow==", "dev": true, "dependencies": { - "@babel/helper-member-expression-to-functions": "^7.13.12", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/traverse": "^7.13.0", - "@babel/types": "^7.13.12" + "@babel/helper-member-expression-to-functions": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-simple-access": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz", - "integrity": "sha512-7FEjbrx5SL9cWvXioDbnlYTppcZGuCY6ow3/D5vMggb2Ywgu4dMrpTJX0JdQAIcRRUElOIxF3yEooa9gUb9ZbA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.14.5.tgz", + "integrity": "sha512-nfBN9xvmCt6nrMZjfhkl7i0oTV3yxR4/FztsbOASyTvVcoYd0TRHh7eMLdlEcCqobydC0LAF3LtC92Iwxo0wyw==", "dev": true, "dependencies": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-skip-transparent-expression-wrappers": { - "version": "7.12.1", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz", - "integrity": "sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.14.5.tgz", + "integrity": "sha512-dmqZB7mrb94PZSAOYtr+ZN5qt5owZIAgqtoTuqiFbHFtxgEcmQlRJVI+bO++fciBunXtB6MK7HrzrfcAzIz2NQ==", "dev": true, "dependencies": { - "@babel/types": "^7.12.1" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-split-export-declaration": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz", - "integrity": "sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.14.5.tgz", + "integrity": "sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA==", "dev": true, "dependencies": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helper-validator-identifier": { - "version": "7.12.11", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz", - "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==", - "dev": true + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz", + "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } }, "node_modules/@babel/helper-validator-option": { - "version": "7.12.17", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz", - "integrity": "sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==", - "dev": true + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.14.5.tgz", + "integrity": "sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } }, "node_modules/@babel/helper-wrap-function": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz", - "integrity": "sha512-1UX9F7K3BS42fI6qd2A4BjKzgGjToscyZTdp1DjknHLCIvpgne6918io+aL5LXFcER/8QWiwpoY902pVEqgTXA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.14.5.tgz", + "integrity": "sha512-YEdjTCq+LNuNS1WfxsDCNpgXkJaIyqco6DAelTUjT4f2KIWC1nBcaCaSdHTBqQVLnTBexBcVcFhLSU1KnYuePQ==", "dev": true, "dependencies": { - "@babel/helper-function-name": "^7.12.13", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.0", - "@babel/types": "^7.13.0" + "@babel/helper-function-name": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/helpers": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.13.17.tgz", - "integrity": "sha512-Eal4Gce4kGijo1/TGJdqp3WuhllaMLSrW6XcL0ulyUAQOuxHcCafZE8KHg9857gcTehsm/v7RcOx2+jp0Ryjsg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.14.5.tgz", + "integrity": "sha512-xtcWOuN9VL6nApgVHtq3PPcQv5qFBJzoSZzJ/2c0QK/IP/gxVcoWSNQwFEGvmbQsuS9rhYqjILDGGXcTkA705Q==", "dev": true, "dependencies": { - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.17", - "@babel/types": "^7.13.17" + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/highlight": { - "version": "7.13.10", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz", - "integrity": "sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.5.tgz", + "integrity": "sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==", "dev": true, "dependencies": { - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-validator-identifier": "^7.14.5", "chalk": "^2.0.0", "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/parser": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.13.16.tgz", - "integrity": "sha512-6bAg36mCwuqLO0hbR+z7PHuqWiCeP7Dzg73OpQwsAB1Eb8HnGEz5xYBzCfbu+YjoaJsJs+qheDxVAuqbt3ILEw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.14.5.tgz", + "integrity": "sha512-TM8C+xtH/9n1qzX+JNHi7AN2zHMTiPUtspO0ZdHflW8KaskkALhMmuMHb4bCmNdv9VAPzJX3/bXqkVLnAvsPfg==", "dev": true, "bin": { "parser": "bin/babel-parser.js" @@ -409,188 +490,262 @@ } }, "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz", - "integrity": "sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.14.5.tgz", + "integrity": "sha512-ZoJS2XCKPBfTmL122iP6NM9dOg+d4lc9fFk3zxc8iDjvt8Pk4+TlsHSKhIPf6X+L5ORCdBzqMZDjL/WHj7WknQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1", - "@babel/plugin-proposal-optional-chaining": "^7.13.12" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5", + "@babel/plugin-proposal-optional-chaining": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.13.0" } }, "node_modules/@babel/plugin-proposal-async-generator-functions": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.15.tgz", - "integrity": "sha512-VapibkWzFeoa6ubXy/NgV5U2U4MVnUlvnx6wo1XhlsaTrLYWE0UFpDQsVrmn22q5CzeloqJ8gEMHSKxuee6ZdA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.14.5.tgz", + "integrity": "sha512-tbD/CG3l43FIXxmu4a7RBe4zH7MLJ+S/lFowPFO7HetS2hyOZ/0nnnznegDuzFzfkyQYTxqdTH/hKmuBngaDAA==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-remap-async-to-generator": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-remap-async-to-generator": "^7.14.5", "@babel/plugin-syntax-async-generators": "^7.8.4" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-class-properties": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz", - "integrity": "sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.14.5.tgz", + "integrity": "sha512-q/PLpv5Ko4dVc1LYMpCY7RVAAO4uk55qPwrIuJ5QJ8c6cVuAmhu7I/49JOppXL6gXf7ZHzpRVEUZdYoPLM04Gg==", "dev": true, "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-proposal-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.14.5.tgz", + "integrity": "sha512-KBAH5ksEnYHCegqseI5N9skTdxgJdmDoAOc0uXa+4QMYKeZD0w5IARh4FMlTNtaHhbB8v+KzMdTgxMMzsIy6Yg==", + "dev": true, + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/plugin-syntax-class-static-block": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, "node_modules/@babel/plugin-proposal-dynamic-import": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz", - "integrity": "sha512-ONWKj0H6+wIRCkZi9zSbZtE/r73uOhMVHh256ys0UzfM7I3d4n+spZNWjOnJv2gzopumP2Wxi186vI8N0Y2JyQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.14.5.tgz", + "integrity": "sha512-ExjiNYc3HDN5PXJx+bwC50GIx/KKanX2HiggnIUAYedbARdImiCU4RhhHfdf0Kd7JNXGpsBBBCOm+bBVy3Gb0g==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-export-namespace-from": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz", - "integrity": "sha512-INAgtFo4OnLN3Y/j0VwAgw3HDXcDtX+C/erMvWzuV9v71r7urb6iyMXu7eM9IgLr1ElLlOkaHjJ0SbCmdOQ3Iw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.14.5.tgz", + "integrity": "sha512-g5POA32bXPMmSBu5Dx/iZGLGnKmKPc5AiY7qfZgurzrCYgIztDlHFbznSNCoQuv57YQLnQfaDi7dxCtLDIdXdA==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-export-namespace-from": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-json-strings": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz", - "integrity": "sha512-w4zOPKUFPX1mgvTmL/fcEqy34hrQ1CRcGxdphBc6snDnnqJ47EZDIyop6IwXzAC8G916hsIuXB2ZMBCExC5k7Q==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.14.5.tgz", + "integrity": "sha512-NSq2fczJYKVRIsUJyNxrVUMhB27zb7N7pOFGQOhBKJrChbGcgEAqyZrmZswkPk18VMurEeJAaICbfm57vUeTbQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-json-strings": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-logical-assignment-operators": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz", - "integrity": "sha512-aul6znYB4N4HGweImqKn59Su9RS8lbUIqxtXTOcAGtNIDczoEFv+l1EhmX8rUBp3G1jMjKJm8m0jXVp63ZpS4A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.14.5.tgz", + "integrity": "sha512-YGn2AvZAo9TwyhlLvCCWxD90Xq8xJ4aSgaX3G5D/8DW94L8aaT+dS5cSP+Z06+rCJERGSr9GxMBZ601xoc2taw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-nullish-coalescing-operator": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz", - "integrity": "sha512-iePlDPBn//UhxExyS9KyeYU7RM9WScAG+D3Hhno0PLJebAEpDZMocbDe64eqynhNAnwz/vZoL/q/QB2T1OH39A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.14.5.tgz", + "integrity": "sha512-gun/SOnMqjSb98Nkaq2rTKMwervfdAoz6NphdY0vTfuzMfryj+tDGb2n6UkDKwez+Y8PZDhE3D143v6Gepp4Hg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-numeric-separator": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz", - "integrity": "sha512-O1jFia9R8BUCl3ZGB7eitaAPu62TXJRHn7rh+ojNERCFyqRwJMTmhz+tJ+k0CwI6CLjX/ee4qW74FSqlq9I35w==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.14.5.tgz", + "integrity": "sha512-yiclALKe0vyZRZE0pS6RXgjUOt87GWv6FYa5zqj15PvhOGFO69R5DusPlgK/1K5dVnCtegTiWu9UaBSrLLJJBg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-numeric-separator": "^7.10.4" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-object-rest-spread": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz", - "integrity": "sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.14.5.tgz", + "integrity": "sha512-VzMyY6PWNPPT3pxc5hi9LloKNr4SSrVCg7Yr6aZpW4Ym07r7KqSU/QXYwjXLVxqwSv0t/XSXkFoKBPUkZ8vb2A==", "dev": true, "dependencies": { - "@babel/compat-data": "^7.13.8", - "@babel/helper-compilation-targets": "^7.13.8", - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/compat-data": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-object-rest-spread": "^7.8.3", - "@babel/plugin-transform-parameters": "^7.13.0" + "@babel/plugin-transform-parameters": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-optional-catch-binding": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz", - "integrity": "sha512-0wS/4DUF1CuTmGo+NiaHfHcVSeSLj5S3e6RivPTg/2k3wOv3jO35tZ6/ZWsQhQMvdgI7CwphjQa/ccarLymHVA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.14.5.tgz", + "integrity": "sha512-3Oyiixm0ur7bzO5ybNcZFlmVsygSIQgdOa7cTfOYCMY+wEPAYhZAJxi3mixKFCTCKUhQXuCTtQ1MzrpL3WT8ZQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-optional-chaining": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz", - "integrity": "sha512-fcEdKOkIB7Tf4IxrgEVeFC4zeJSTr78no9wTdBuZZbqF64kzllU0ybo2zrzm7gUQfxGhBgq4E39oRs8Zx/RMYQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.14.5.tgz", + "integrity": "sha512-ycz+VOzo2UbWNI1rQXxIuMOzrDdHGrI23fRiz/Si2R4kv2XZQ1BK8ccdHwehMKBlcH/joGW/tzrUmo67gbJHlQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5", "@babel/plugin-syntax-optional-chaining": "^7.8.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-private-methods": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz", - "integrity": "sha512-MXyyKQd9inhx1kDYPkFRVOBXQ20ES8Pto3T7UZ92xj2mY0EVD8oAVzeyYuVfy/mxAdTSIayOvg+aVzcHV2bn6Q==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.14.5.tgz", + "integrity": "sha512-838DkdUA1u+QTCplatfq4B7+1lnDa/+QMI89x5WZHBcnNv+47N8QEj2k9I2MUU9xIv8XJ4XvPCviM/Dj7Uwt9g==", + "dev": true, + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-62EyfyA3WA0mZiF2e2IV9mc9Ghwxcg8YTu8BS4Wss4Y3PY725OmS9M0qLORbJwLqFtGh+jiE4wAmocK2CTUK2Q==", "dev": true, "dependencies": { - "@babel/helper-create-class-features-plugin": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-proposal-unicode-property-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz", - "integrity": "sha512-XyJmZidNfofEkqFV5VC/bLabGmO5QzenPO/YOfGuEbgU+2sSwMmio3YLb4WtBgcmmdwZHyVyv8on77IUjQ5Gvg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.14.5.tgz", + "integrity": "sha512-6axIeOU5LnY471KenAB9vI8I5j7NQ2d652hIYwVyRfgaZT5UpiqFKCuVXCDMSrU+3VFafnu2c5m3lrWIlr6A5Q==", "dev": true, "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" }, "engines": { "node": ">=4" @@ -623,6 +778,21 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/plugin-syntax-dynamic-import": { "version": "7.8.3", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz", @@ -731,452 +901,569 @@ "@babel/core": "^7.0.0-0" } }, + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "dev": true, + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, "node_modules/@babel/plugin-syntax-top-level-await": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz", - "integrity": "sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-arrow-functions": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz", - "integrity": "sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.14.5.tgz", + "integrity": "sha512-KOnO0l4+tD5IfOdi4x8C1XmEIRWUjNRV8wc6K2vz/3e8yAOoZZvsRXRRIF/yo/MAOFb4QjtAw9xSxMXbSMRy8A==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-async-to-generator": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz", - "integrity": "sha512-3j6E004Dx0K3eGmhxVJxwwI89CTJrce7lg3UrtFuDAVQ/2+SJ/h/aSFOeE6/n0WB1GsOffsJp6MnPQNQ8nmwhg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.14.5.tgz", + "integrity": "sha512-szkbzQ0mNk0rpu76fzDdqSyPu0MuvpXgC+6rz5rpMb5OIRxdmHfQxrktL8CYolL2d8luMCZTR0DpIMIdL27IjA==", "dev": true, "dependencies": { - "@babel/helper-module-imports": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-remap-async-to-generator": "^7.13.0" + "@babel/helper-module-imports": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-remap-async-to-generator": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-block-scoped-functions": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz", - "integrity": "sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.14.5.tgz", + "integrity": "sha512-dtqWqdWZ5NqBX3KzsVCWfQI3A53Ft5pWFCT2eCVUftWZgjc5DpDponbIF1+c+7cSGk2wN0YK7HGL/ezfRbpKBQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-block-scoping": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.13.16.tgz", - "integrity": "sha512-ad3PHUxGnfWF4Efd3qFuznEtZKoBp0spS+DgqzVzRPV7urEBvPLue3y2j80w4Jf2YLzZHj8TOv/Lmvdmh3b2xg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.14.5.tgz", + "integrity": "sha512-LBYm4ZocNgoCqyxMLoOnwpsmQ18HWTQvql64t3GvMUzLQrNoV1BDG0lNftC8QKYERkZgCCT/7J5xWGObGAyHDw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-classes": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz", - "integrity": "sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.14.5.tgz", + "integrity": "sha512-J4VxKAMykM06K/64z9rwiL6xnBHgB1+FVspqvlgCdwD1KUbQNfszeKVVOMh59w3sztHYIZDgnhOC4WbdEfHFDA==", "dev": true, "dependencies": { - "@babel/helper-annotate-as-pure": "^7.12.13", - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-replace-supers": "^7.13.0", - "@babel/helper-split-export-declaration": "^7.12.13", + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", "globals": "^11.1.0" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-computed-properties": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz", - "integrity": "sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.14.5.tgz", + "integrity": "sha512-pWM+E4283UxaVzLb8UBXv4EIxMovU4zxT1OPnpHJcmnvyY9QbPPTKZfEj31EUvG3/EQRbYAGaYEUZ4yWOBC2xg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-destructuring": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.17.tgz", - "integrity": "sha512-UAUqiLv+uRLO+xuBKKMEpC+t7YRNVRqBsWWq1yKXbBZBje/t3IXCiSinZhjn/DC3qzBfICeYd2EFGEbHsh5RLA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.14.5.tgz", + "integrity": "sha512-wU9tYisEbRMxqDezKUqC9GleLycCRoUsai9ddlsq54r8QRLaeEhc+d+9DqCG+kV9W2GgQjTZESPTpn5bAFMDww==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-dotall-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz", - "integrity": "sha512-foDrozE65ZFdUC2OfgeOCrEPTxdB3yjqxpXh8CH+ipd9CHd4s/iq81kcUpyH8ACGNEPdFqbtzfgzbT/ZGlbDeQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.14.5.tgz", + "integrity": "sha512-loGlnBdj02MDsFaHhAIJzh7euK89lBrGIdM9EAtHFo6xKygCUGuuWe07o1oZVk287amtW1n0808sQM99aZt3gw==", "dev": true, "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-duplicate-keys": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz", - "integrity": "sha512-NfADJiiHdhLBW3pulJlJI2NB0t4cci4WTZ8FtdIuNc2+8pslXdPtRRAEWqUY+m9kNOk2eRYbTAOipAxlrOcwwQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.14.5.tgz", + "integrity": "sha512-iJjbI53huKbPDAsJ8EmVmvCKeeq21bAze4fu9GBQtSLqfvzj2oRuHVx4ZkDwEhg1htQ+5OBZh/Ab0XDf5iBZ7A==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-exponentiation-operator": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz", - "integrity": "sha512-fbUelkM1apvqez/yYx1/oICVnGo2KM5s63mhGylrmXUxK/IAXSIf87QIxVfZldWf4QsOafY6vV3bX8aMHSvNrA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.14.5.tgz", + "integrity": "sha512-jFazJhMBc9D27o9jDnIE5ZErI0R0m7PbKXVq77FFvqFbzvTMuv8jaAwLZ5PviOLSFttqKIW0/wxNSDbjLk0tYA==", "dev": true, "dependencies": { - "@babel/helper-builder-binary-assignment-operator-visitor": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-for-of": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz", - "integrity": "sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.14.5.tgz", + "integrity": "sha512-CfmqxSUZzBl0rSjpoQSFoR9UEj3HzbGuGNL21/iFTmjb5gFggJp3ph0xR1YBhexmLoKRHzgxuFvty2xdSt6gTA==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-function-name": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz", - "integrity": "sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.14.5.tgz", + "integrity": "sha512-vbO6kv0fIzZ1GpmGQuvbwwm+O4Cbm2NrPzwlup9+/3fdkuzo1YqOZcXw26+YUJB84Ja7j9yURWposEHLYwxUfQ==", "dev": true, "dependencies": { - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz", - "integrity": "sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.14.5.tgz", + "integrity": "sha512-ql33+epql2F49bi8aHXxvLURHkxJbSmMKl9J5yHqg4PLtdE6Uc48CH1GS6TQvZ86eoB/ApZXwm7jlA+B3kra7A==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-member-expression-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz", - "integrity": "sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.14.5.tgz", + "integrity": "sha512-WkNXxH1VXVTKarWFqmso83xl+2V3Eo28YY5utIkbsmXoItO8Q3aZxN4BTS2k0hz9dGUloHK26mJMyQEYfkn/+Q==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-modules-amd": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz", - "integrity": "sha512-EKy/E2NHhY/6Vw5d1k3rgoobftcNUmp9fGjb9XZwQLtTctsRBOTRO7RHHxfIky1ogMN5BxN7p9uMA3SzPfotMQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.14.5.tgz", + "integrity": "sha512-3lpOU8Vxmp3roC4vzFpSdEpGUWSMsHFreTWOMMLzel2gNGfHE5UWIh/LN6ghHs2xurUp4jRFYMUIZhuFbody1g==", "dev": true, "dependencies": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-modules-commonjs": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz", - "integrity": "sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.14.5.tgz", + "integrity": "sha512-en8GfBtgnydoao2PS+87mKyw62k02k7kJ9ltbKe0fXTHrQmG6QZZflYuGI1VVG7sVpx4E1n7KBpNlPb8m78J+A==", "dev": true, "dependencies": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-simple-access": "^7.12.13", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-simple-access": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-modules-systemjs": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz", - "integrity": "sha512-hwqctPYjhM6cWvVIlOIe27jCIBgHCsdH2xCJVAYQm7V5yTMoilbVMi9f6wKg0rpQAOn6ZG4AOyvCqFF/hUh6+A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.14.5.tgz", + "integrity": "sha512-mNMQdvBEE5DcMQaL5LbzXFMANrQjd2W7FPzg34Y4yEz7dBgdaC+9B84dSO+/1Wba98zoDbInctCDo4JGxz1VYA==", "dev": true, "dependencies": { - "@babel/helper-hoist-variables": "^7.13.0", - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-hoist-variables": "^7.14.5", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-validator-identifier": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-modules-umd": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz", - "integrity": "sha512-D/ILzAh6uyvkWjKKyFE/W0FzWwasv6vPTSqPcjxFqn6QpX3u8DjRVliq4F2BamO2Wee/om06Vyy+vPkNrd4wxw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.14.5.tgz", + "integrity": "sha512-RfPGoagSngC06LsGUYyM9QWSXZ8MysEjDJTAea1lqRjNECE3y0qIJF/qbvJxc4oA4s99HumIMdXOrd+TdKaAAA==", "dev": true, "dependencies": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz", - "integrity": "sha512-Xsm8P2hr5hAxyYblrfACXpQKdQbx4m2df9/ZZSQ8MAhsadw06+jW7s9zsSw6he+mJZXRlVMyEnVktJo4zjk1WA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.14.5.tgz", + "integrity": "sha512-+Xe5+6MWFo311U8SchgeX5c1+lJM+eZDBZgD+tvXu9VVQPXwwVzeManMMjYX6xw2HczngfOSZjoFYKwdeB/Jvw==", "dev": true, "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0" } }, "node_modules/@babel/plugin-transform-new-target": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz", - "integrity": "sha512-/KY2hbLxrG5GTQ9zzZSc3xWiOy379pIETEhbtzwZcw9rvuaVV4Fqy7BYGYOWZnaoXIQYbbJ0ziXLa/sKcGCYEQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.14.5.tgz", + "integrity": "sha512-Nx054zovz6IIRWEB49RDRuXGI4Gy0GMgqG0cII9L3MxqgXz/+rgII+RU58qpo4g7tNEx1jG7rRVH4ihZoP4esQ==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-object-super": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz", - "integrity": "sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.14.5.tgz", + "integrity": "sha512-MKfOBWzK0pZIrav9z/hkRqIk/2bTv9qvxHzPQc12RcVkMOzpIKnFCNYJip00ssKWYkd8Sf5g0Wr7pqJ+cmtuFg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13", - "@babel/helper-replace-supers": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-parameters": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz", - "integrity": "sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.14.5.tgz", + "integrity": "sha512-Tl7LWdr6HUxTmzQtzuU14SqbgrSKmaR77M0OKyq4njZLQTPfOvzblNKyNkGwOfEFCEx7KeYHQHDI0P3F02IVkA==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-property-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz", - "integrity": "sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.14.5.tgz", + "integrity": "sha512-r1uilDthkgXW8Z1vJz2dKYLV1tuw2xsbrp3MrZmD99Wh9vsfKoob+JTgri5VUb/JqyKRXotlOtwgu4stIYCmnw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-regenerator": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.13.15.tgz", - "integrity": "sha512-Bk9cOLSz8DiurcMETZ8E2YtIVJbFCPGW28DJWUakmyVWtQSm6Wsf0p4B4BfEr/eL2Nkhe/CICiUiMOCi1TPhuQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.14.5.tgz", + "integrity": "sha512-NVIY1W3ITDP5xQl50NgTKlZ0GrotKtLna08/uGY6ErQt6VEQZXla86x/CTddm5gZdcr+5GSsvMeTmWA5Ii6pkg==", "dev": true, "dependencies": { "regenerator-transform": "^0.14.2" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-reserved-words": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz", - "integrity": "sha512-xhUPzDXxZN1QfiOy/I5tyye+TRz6lA7z6xaT4CLOjPRMVg1ldRf0LHw0TDBpYL4vG78556WuHdyO9oi5UmzZBg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.14.5.tgz", + "integrity": "sha512-cv4F2rv1nD4qdexOGsRQXJrOcyb5CrgjUH9PKrrtyhSDBNWGxd0UIitjyJiWagS+EbUGjG++22mGH1Pub8D6Vg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-shorthand-properties": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz", - "integrity": "sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.14.5.tgz", + "integrity": "sha512-xLucks6T1VmGsTB+GWK5Pl9Jl5+nRXD1uoFdA5TSO6xtiNjtXTjKkmPdFXVLGlK5A2/or/wQMKfmQ2Y0XJfn5g==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-spread": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz", - "integrity": "sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.14.5.tgz", + "integrity": "sha512-/3iqoQdiWergnShZYl0xACb4ADeYCJ7X/RgmwtXshn6cIvautRPAFzhd58frQlokLO6Jb4/3JXvmm6WNTPtiTw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-sticky-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz", - "integrity": "sha512-Jc3JSaaWT8+fr7GRvQP02fKDsYk4K/lYwWq38r/UGfaxo89ajud321NH28KRQ7xy1Ybc0VUE5Pz8psjNNDUglg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.14.5.tgz", + "integrity": "sha512-Z7F7GyvEMzIIbwnziAZmnSNpdijdr4dWt+FJNBnBLz5mwDFkqIXU9wmBcWWad3QeJF5hMTkRe4dAq2sUZiG+8A==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-template-literals": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz", - "integrity": "sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.14.5.tgz", + "integrity": "sha512-22btZeURqiepOfuy/VkFr+zStqlujWaarpMErvay7goJS6BWwdd6BY9zQyDLDa4x2S3VugxFb162IZ4m/S/+Gg==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-typeof-symbol": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz", - "integrity": "sha512-eKv/LmUJpMnu4npgfvs3LiHhJua5fo/CysENxa45YCQXZwKnGCQKAg87bvoqSW1fFT+HA32l03Qxsm8ouTY3ZQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.14.5.tgz", + "integrity": "sha512-lXzLD30ffCWseTbMQzrvDWqljvZlHkXU+CnseMhkMNqU1sASnCsz3tSzAaH3vCUXb9PHeUb90ZT1BdFTm1xxJw==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-unicode-escapes": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz", - "integrity": "sha512-0bHEkdwJ/sN/ikBHfSmOXPypN/beiGqjo+o4/5K+vxEFNPRPdImhviPakMKG4x96l85emoa0Z6cDflsdBusZbw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.14.5.tgz", + "integrity": "sha512-crTo4jATEOjxj7bt9lbYXcBAM3LZaUrbP2uUdxb6WIorLmjNKSpHfIybgY4B8SRpbf8tEVIWH3Vtm7ayCrKocA==", "dev": true, "dependencies": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/plugin-transform-unicode-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz", - "integrity": "sha512-mDRzSNY7/zopwisPZ5kM9XKCfhchqIYwAKRERtEnhYscZB79VRekuRSoYbN0+KVe3y8+q1h6A4svXtP7N+UoCA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.14.5.tgz", + "integrity": "sha512-UygduJpC5kHeCiRw/xDVzC+wj8VaYSoKl5JNVmbP7MadpNinAm3SvZCxZ42H37KZBKztz46YC73i9yV34d0Tzw==", "dev": true, "dependencies": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" }, "peerDependencies": { "@babel/core": "^7.0.0-0" } }, "node_modules/@babel/preset-env": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.13.15.tgz", - "integrity": "sha512-D4JAPMXcxk69PKe81jRJ21/fP/uYdcTZ3hJDF5QX2HSI9bBxxYw/dumdR6dGumhjxlprHPE4XWoPaqzZUVy2MA==", - "dev": true, - "dependencies": { - "@babel/compat-data": "^7.13.15", - "@babel/helper-compilation-targets": "^7.13.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-validator-option": "^7.12.17", - "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.13.12", - "@babel/plugin-proposal-async-generator-functions": "^7.13.15", - "@babel/plugin-proposal-class-properties": "^7.13.0", - "@babel/plugin-proposal-dynamic-import": "^7.13.8", - "@babel/plugin-proposal-export-namespace-from": "^7.12.13", - "@babel/plugin-proposal-json-strings": "^7.13.8", - "@babel/plugin-proposal-logical-assignment-operators": "^7.13.8", - "@babel/plugin-proposal-nullish-coalescing-operator": "^7.13.8", - "@babel/plugin-proposal-numeric-separator": "^7.12.13", - "@babel/plugin-proposal-object-rest-spread": "^7.13.8", - "@babel/plugin-proposal-optional-catch-binding": "^7.13.8", - "@babel/plugin-proposal-optional-chaining": "^7.13.12", - "@babel/plugin-proposal-private-methods": "^7.13.0", - "@babel/plugin-proposal-unicode-property-regex": "^7.12.13", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.14.5.tgz", + "integrity": "sha512-ci6TsS0bjrdPpWGnQ+m4f+JSSzDKlckqKIJJt9UZ/+g7Zz9k0N8lYU8IeLg/01o2h8LyNZDMLGgRLDTxpudLsA==", + "dev": true, + "dependencies": { + "@babel/compat-data": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-validator-option": "^7.14.5", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.14.5", + "@babel/plugin-proposal-async-generator-functions": "^7.14.5", + "@babel/plugin-proposal-class-properties": "^7.14.5", + "@babel/plugin-proposal-class-static-block": "^7.14.5", + "@babel/plugin-proposal-dynamic-import": "^7.14.5", + "@babel/plugin-proposal-export-namespace-from": "^7.14.5", + "@babel/plugin-proposal-json-strings": "^7.14.5", + "@babel/plugin-proposal-logical-assignment-operators": "^7.14.5", + "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.5", + "@babel/plugin-proposal-numeric-separator": "^7.14.5", + "@babel/plugin-proposal-object-rest-spread": "^7.14.5", + "@babel/plugin-proposal-optional-catch-binding": "^7.14.5", + "@babel/plugin-proposal-optional-chaining": "^7.14.5", + "@babel/plugin-proposal-private-methods": "^7.14.5", + "@babel/plugin-proposal-private-property-in-object": "^7.14.5", + "@babel/plugin-proposal-unicode-property-regex": "^7.14.5", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3", "@babel/plugin-syntax-export-namespace-from": "^7.8.3", "@babel/plugin-syntax-json-strings": "^7.8.3", @@ -1186,47 +1473,51 @@ "@babel/plugin-syntax-object-rest-spread": "^7.8.3", "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", "@babel/plugin-syntax-optional-chaining": "^7.8.3", - "@babel/plugin-syntax-top-level-await": "^7.12.13", - "@babel/plugin-transform-arrow-functions": "^7.13.0", - "@babel/plugin-transform-async-to-generator": "^7.13.0", - "@babel/plugin-transform-block-scoped-functions": "^7.12.13", - "@babel/plugin-transform-block-scoping": "^7.12.13", - "@babel/plugin-transform-classes": "^7.13.0", - "@babel/plugin-transform-computed-properties": "^7.13.0", - "@babel/plugin-transform-destructuring": "^7.13.0", - "@babel/plugin-transform-dotall-regex": "^7.12.13", - "@babel/plugin-transform-duplicate-keys": "^7.12.13", - "@babel/plugin-transform-exponentiation-operator": "^7.12.13", - "@babel/plugin-transform-for-of": "^7.13.0", - "@babel/plugin-transform-function-name": "^7.12.13", - "@babel/plugin-transform-literals": "^7.12.13", - "@babel/plugin-transform-member-expression-literals": "^7.12.13", - "@babel/plugin-transform-modules-amd": "^7.13.0", - "@babel/plugin-transform-modules-commonjs": "^7.13.8", - "@babel/plugin-transform-modules-systemjs": "^7.13.8", - "@babel/plugin-transform-modules-umd": "^7.13.0", - "@babel/plugin-transform-named-capturing-groups-regex": "^7.12.13", - "@babel/plugin-transform-new-target": "^7.12.13", - "@babel/plugin-transform-object-super": "^7.12.13", - "@babel/plugin-transform-parameters": "^7.13.0", - "@babel/plugin-transform-property-literals": "^7.12.13", - "@babel/plugin-transform-regenerator": "^7.13.15", - "@babel/plugin-transform-reserved-words": "^7.12.13", - "@babel/plugin-transform-shorthand-properties": "^7.12.13", - "@babel/plugin-transform-spread": "^7.13.0", - "@babel/plugin-transform-sticky-regex": "^7.12.13", - "@babel/plugin-transform-template-literals": "^7.13.0", - "@babel/plugin-transform-typeof-symbol": "^7.12.13", - "@babel/plugin-transform-unicode-escapes": "^7.12.13", - "@babel/plugin-transform-unicode-regex": "^7.12.13", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5", + "@babel/plugin-transform-arrow-functions": "^7.14.5", + "@babel/plugin-transform-async-to-generator": "^7.14.5", + "@babel/plugin-transform-block-scoped-functions": "^7.14.5", + "@babel/plugin-transform-block-scoping": "^7.14.5", + "@babel/plugin-transform-classes": "^7.14.5", + "@babel/plugin-transform-computed-properties": "^7.14.5", + "@babel/plugin-transform-destructuring": "^7.14.5", + "@babel/plugin-transform-dotall-regex": "^7.14.5", + "@babel/plugin-transform-duplicate-keys": "^7.14.5", + "@babel/plugin-transform-exponentiation-operator": "^7.14.5", + "@babel/plugin-transform-for-of": "^7.14.5", + "@babel/plugin-transform-function-name": "^7.14.5", + "@babel/plugin-transform-literals": "^7.14.5", + "@babel/plugin-transform-member-expression-literals": "^7.14.5", + "@babel/plugin-transform-modules-amd": "^7.14.5", + "@babel/plugin-transform-modules-commonjs": "^7.14.5", + "@babel/plugin-transform-modules-systemjs": "^7.14.5", + "@babel/plugin-transform-modules-umd": "^7.14.5", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.14.5", + "@babel/plugin-transform-new-target": "^7.14.5", + "@babel/plugin-transform-object-super": "^7.14.5", + "@babel/plugin-transform-parameters": "^7.14.5", + "@babel/plugin-transform-property-literals": "^7.14.5", + "@babel/plugin-transform-regenerator": "^7.14.5", + "@babel/plugin-transform-reserved-words": "^7.14.5", + "@babel/plugin-transform-shorthand-properties": "^7.14.5", + "@babel/plugin-transform-spread": "^7.14.5", + "@babel/plugin-transform-sticky-regex": "^7.14.5", + "@babel/plugin-transform-template-literals": "^7.14.5", + "@babel/plugin-transform-typeof-symbol": "^7.14.5", + "@babel/plugin-transform-unicode-escapes": "^7.14.5", + "@babel/plugin-transform-unicode-regex": "^7.14.5", "@babel/preset-modules": "^0.1.4", - "@babel/types": "^7.13.14", - "babel-plugin-polyfill-corejs2": "^0.2.0", - "babel-plugin-polyfill-corejs3": "^0.2.0", - "babel-plugin-polyfill-regenerator": "^0.2.0", - "core-js-compat": "^3.9.0", + "@babel/types": "^7.14.5", + "babel-plugin-polyfill-corejs2": "^0.2.2", + "babel-plugin-polyfill-corejs3": "^0.2.2", + "babel-plugin-polyfill-regenerator": "^0.2.2", + "core-js-compat": "^3.14.0", "semver": "^6.3.0" }, + "engines": { + "node": ">=6.9.0" + }, "peerDependencies": { "@babel/core": "^7.0.0-0" } @@ -1254,49 +1545,62 @@ } }, "node_modules/@babel/runtime": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.13.17.tgz", - "integrity": "sha512-NCdgJEelPTSh+FEFylhnP1ylq848l1z9t9N0j1Lfbcw0+KXGjsTvUmkxy+voLLXB5SOKMbLLx4jxYliGrYQseA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.14.5.tgz", + "integrity": "sha512-121rumjddw9c3NCQ55KGkyE1h/nzWhU/owjhw0l4mQrkzz4x9SGS1X8gFLraHwX7td3Yo4QTL+qj0NcIzN87BA==", "dev": true, "dependencies": { "regenerator-runtime": "^0.13.4" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/template": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.12.13.tgz", - "integrity": "sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.14.5.tgz", + "integrity": "sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g==", "dev": true, "dependencies": { - "@babel/code-frame": "^7.12.13", - "@babel/parser": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/code-frame": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/types": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/traverse": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.13.17.tgz", - "integrity": "sha512-BMnZn0R+X6ayqm3C3To7o1j7Q020gWdqdyP50KEoVqaCO2c/Im7sYZSmVgvefp8TTMQ+9CtwuBp0Z1CZ8V3Pvg==", - "dev": true, - "dependencies": { - "@babel/code-frame": "^7.12.13", - "@babel/generator": "^7.13.16", - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-split-export-declaration": "^7.12.13", - "@babel/parser": "^7.13.16", - "@babel/types": "^7.13.17", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.14.5.tgz", + "integrity": "sha512-G3BiS15vevepdmFqmUc9X+64y0viZYygubAMO8SvBmKARuF6CPSZtH4Ng9vi/lrWlZFGe3FWdXNy835akH8Glg==", + "dev": true, + "dependencies": { + "@babel/code-frame": "^7.14.5", + "@babel/generator": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-hoist-variables": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/types": "^7.14.5", "debug": "^4.1.0", "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@babel/types": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.13.17.tgz", - "integrity": "sha512-RawydLgxbOPDlTLJNtoIypwdmAy//uQIzlKt2+iBiJaRlVuI6QLUxVAyWGNfOzp8Yu4L4lLIacoCyTNtpb4wiA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.14.5.tgz", + "integrity": "sha512-M/NzBpEL95I5Hh4dwhin5JlE7EzO5PHMAuzjxss3tiOBD46KfQvVedN/3jEPZvdRvtsK2222XfdHogNIttFgcg==", "dev": true, "dependencies": { - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-validator-identifier": "^7.14.5", "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" } }, "node_modules/@discoveryjs/json-ext": { @@ -1341,9 +1645,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "14.14.6", - "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.6.tgz", - "integrity": "sha512-6QlRuqsQ/Ox/aJEQWBEJG7A9+u7oSYl3mem/K8IzxXG/kAGbV1YPD9Bg9Zw3vyxC/YP+zONKwy8hGkSt1jxFMw==", + "version": "15.12.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-15.12.2.tgz", + "integrity": "sha512-zjQ69G564OCIWIOHSXyQEEDpdpGl+G348RAKY0XXy9Z5kU9Vzv1GMNnkar/ZJ8dzXB3COzD9Mo9NtRZ4xfgUww==", "dev": true }, "node_modules/@webassemblyjs/ast": { @@ -1493,9 +1797,9 @@ } }, "node_modules/@webpack-cli/configtest": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.0.2.tgz", - "integrity": "sha512-3OBzV2fBGZ5TBfdW50cha1lHDVf9vlvRXnjpVbJBa20pSZQaSkMJZiwA8V2vD9ogyeXn8nU5s5A6mHyf5jhMzA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.0.4.tgz", + "integrity": "sha512-cs3XLy+UcxiP6bj0A6u7MLLuwdXJ1c3Dtc0RkKg+wiI1g/Ti1om8+/2hc2A2B60NbBNAbMgyBMHvyymWm/j4wQ==", "dev": true, "peerDependencies": { "webpack": "4.x.x || 5.x.x", @@ -1503,9 +1807,9 @@ } }, "node_modules/@webpack-cli/info": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.2.3.tgz", - "integrity": "sha512-lLek3/T7u40lTqzCGpC6CAbY6+vXhdhmwFRxZLMnRm6/sIF/7qMpT8MocXCRQfz0JAh63wpbXLMnsQ5162WS7Q==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.3.0.tgz", + "integrity": "sha512-ASiVB3t9LOKHs5DyVUcxpraBXDOKubYu/ihHhU+t1UPpxsivg6Od2E2qU4gJCekfEddzRBzHhzA/Acyw/mlK/w==", "dev": true, "dependencies": { "envinfo": "^7.7.3" @@ -1515,9 +1819,9 @@ } }, "node_modules/@webpack-cli/serve": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.3.1.tgz", - "integrity": "sha512-0qXvpeYO6vaNoRBI52/UsbcaBydJCggoBBnIo/ovQQdn6fug0BgwsjorV1hVS7fMqGVTZGcVxv8334gjmbj5hw==", + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.5.1.tgz", + "integrity": "sha512-4vSVUiOPJLmr45S8rMGy7WDvpWxfFxfP/Qx/cxZFCfvoypTYpPPL1X8VIZMe0WTA+Jr7blUxwUSEZNkjoMTgSw==", "dev": true, "peerDependencies": { "webpack-cli": "4.x.x" @@ -1541,9 +1845,9 @@ "dev": true }, "node_modules/acorn": { - "version": "8.0.4", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.0.4.tgz", - "integrity": "sha512-XNP0PqF1XD19ZlLKvB7cMmnZswW4C/03pRHgirB30uSJTaS3A3V1/P4sS3HPvFmjoriPCJQs+JDSbm4bL1TxGQ==", + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.3.0.tgz", + "integrity": "sha512-tqPKHZ5CaBJw0Xmy0ZZvLs1qTV+BNFSyvn77ASXkpBNfIRk8ev26fKrD9iLGwGA9zedPao52GSHzq8lyZG0NUw==", "dev": true, "bin": { "acorn": "bin/acorn" @@ -1570,15 +1874,6 @@ "integrity": "sha512-RO1ibKvd27e6FEShVFfPALuHI3WjSVNeK5FIsmme/LYRNxjKuNj+Dt7bucLa6NdSv3JcVTyMlm9kGR84z1XpaQ==", "dev": true }, - "node_modules/ansi-colors": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", - "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", - "dev": true, - "engines": { - "node": ">=6" - } - }, "node_modules/ansi-regex": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", @@ -1685,13 +1980,13 @@ } }, "node_modules/babel-plugin-polyfill-corejs2": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.2.0.tgz", - "integrity": "sha512-9bNwiR0dS881c5SHnzCmmGlMkJLl0OUZvxrxHo9w/iNoRuqaPjqlvBf4HrovXtQs/au5yKkpcdgfT1cC5PAZwg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.2.2.tgz", + "integrity": "sha512-kISrENsJ0z5dNPq5eRvcctITNHYXWOA4DUZRFYCz3jYCcvTb/A546LIddmoGNMVYg2U38OyFeNosQwI9ENTqIQ==", "dev": true, "dependencies": { "@babel/compat-data": "^7.13.11", - "@babel/helper-define-polyfill-provider": "^0.2.0", + "@babel/helper-define-polyfill-provider": "^0.2.2", "semver": "^6.1.1" }, "peerDependencies": { @@ -1708,12 +2003,12 @@ } }, "node_modules/babel-plugin-polyfill-corejs3": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.2.0.tgz", - "integrity": "sha512-zZyi7p3BCUyzNxLx8KV61zTINkkV65zVkDAFNZmrTCRVhjo1jAS+YLvDJ9Jgd/w2tsAviCwFHReYfxO3Iql8Yg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.2.2.tgz", + "integrity": "sha512-l1Cf8PKk12eEk5QP/NQ6TH8A1pee6wWDJ96WjxrMXFLHLOBFzYM4moG80HFgduVhTqAFez4alnZKEhP/bYHg0A==", "dev": true, "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.2.0", + "@babel/helper-define-polyfill-provider": "^0.2.2", "core-js-compat": "^3.9.1" }, "peerDependencies": { @@ -1721,12 +2016,12 @@ } }, "node_modules/babel-plugin-polyfill-regenerator": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.2.0.tgz", - "integrity": "sha512-J7vKbCuD2Xi/eEHxquHN14bXAW9CXtecwuLrOIDJtcZzTaPzV1VdEfoUf9AzcRBMolKUQKM9/GVojeh0hFiqMg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.2.2.tgz", + "integrity": "sha512-Goy5ghsc21HgPDFtzRkSirpZVW35meGoTmTOb2bxqdl60ghub4xOidgNTHaZfQ2FaxQsKmwvXtOAkcIS4SMBWg==", "dev": true, "dependencies": { - "@babel/helper-define-polyfill-provider": "^0.2.0" + "@babel/helper-define-polyfill-provider": "^0.2.2" }, "peerDependencies": { "@babel/core": "^7.0.0-0" @@ -1758,14 +2053,14 @@ } }, "node_modules/browserslist": { - "version": "4.16.5", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.5.tgz", - "integrity": "sha512-C2HAjrM1AI/djrpAUU/tr4pml1DqLIzJKSLDBXBrNErl9ZCCTXdhwxdJjYc16953+mBWf7Lw+uUJgpgb8cN71A==", + "version": "4.16.6", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.6.tgz", + "integrity": "sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==", "dev": true, "dependencies": { - "caniuse-lite": "^1.0.30001214", + "caniuse-lite": "^1.0.30001219", "colorette": "^1.2.2", - "electron-to-chromium": "^1.3.719", + "electron-to-chromium": "^1.3.723", "escalade": "^3.1.1", "node-releases": "^1.1.71" }, @@ -1809,10 +2104,14 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001214", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001214.tgz", - "integrity": "sha512-O2/SCpuaU3eASWVaesQirZv1MSjUNOvmugaD8zNSJqw6Vv5SGwoOpA9LJs3pNPfM745nxqPvfZY3MQKY4AKHYg==", - "dev": true + "version": "1.0.30001236", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001236.tgz", + "integrity": "sha512-o0PRQSrSCGJKCPZcgMzl5fUaj5xHe8qA2m4QRvnyY4e1lITqoNkr7q/Oh1NcpGSy0Th97UZ35yoKcINPoq7YOQ==", + "dev": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + } }, "node_modules/chalk": { "version": "2.4.2", @@ -1947,12 +2246,12 @@ } }, "node_modules/core-js-compat": { - "version": "3.11.0", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.11.0.tgz", - "integrity": "sha512-3wsN9YZJohOSDCjVB0GequOyHax8zFiogSX3XWLE28M1Ew7dTU57tgHjIylSBKSIouwmLBp3g61sKMz/q3xEGA==", + "version": "3.14.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.14.0.tgz", + "integrity": "sha512-R4NS2eupxtiJU+VwgkF9WTpnSfZW4pogwKHd8bclWU2sp93Pr5S1uYJI84cMOubJRou7bcfL0vmwtLslWN5p3A==", "dev": true, "dependencies": { - "browserslist": "^4.16.4", + "browserslist": "^4.16.6", "semver": "7.0.0" }, "funding": { @@ -2078,9 +2377,9 @@ } }, "node_modules/electron-to-chromium": { - "version": "1.3.719", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.719.tgz", - "integrity": "sha512-heM78GKSqrIzO9Oz0/y22nTBN7bqSP1Pla2SyU9DiSnQD+Ea9SyyN5RWWlgqsqeBLNDkSlE9J9EHFmdMPzxB/g==", + "version": "1.3.752", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.752.tgz", + "integrity": "sha512-2Tg+7jSl3oPxgsBsWKh5H83QazTkmWG/cnNwJplmyZc7KcN61+I10oUgaXSVk/NwfvN3BdkKDR4FYuRBQQ2v0A==", "dev": true }, "node_modules/emoji-regex": { @@ -2111,18 +2410,6 @@ "node": ">=10.13.0" } }, - "node_modules/enquirer": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz", - "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==", - "dev": true, - "dependencies": { - "ansi-colors": "^4.1.1" - }, - "engines": { - "node": ">=8.6" - } - }, "node_modules/envinfo": { "version": "7.8.1", "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.8.1.tgz", @@ -2834,14 +3121,14 @@ } }, "node_modules/jest-worker": { - "version": "26.6.2", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", - "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "version": "27.0.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.0.2.tgz", + "integrity": "sha512-EoBdilOTTyOgmHXtw/cPc+ZrCA0KJMrkXzkrPGNwLmnvvlN1nj7MPrxpT7m+otSv2e1TLaVffzDnE/LB14zJMg==", "dev": true, "dependencies": { "@types/node": "*", "merge-stream": "^2.0.0", - "supports-color": "^7.0.0" + "supports-color": "^8.0.0" }, "engines": { "node": ">= 10.13.0" @@ -2857,15 +3144,18 @@ } }, "node_modules/jest-worker/node_modules/supports-color": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "dependencies": { "has-flag": "^4.0.0" }, "engines": { - "node": ">=8" + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" } }, "node_modules/js-tokens": { @@ -3815,9 +4105,9 @@ } }, "node_modules/terser": { - "version": "5.6.1", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.6.1.tgz", - "integrity": "sha512-yv9YLFQQ+3ZqgWCUk+pvNJwgUTdlIxUk1WTN+RnaFJe2L7ipG2csPT0ra2XRm7Cs8cxN7QXmK1rFzEwYEQkzXw==", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.7.0.tgz", + "integrity": "sha512-HP5/9hp2UaZt5fYkuhNBR8YyRcT8juw8+uFbAme53iN9hblvKnLUTKkmwJG6ocWpIKf8UK4DoeWG4ty0J6S6/g==", "dev": true, "dependencies": { "commander": "^2.20.0", @@ -3832,17 +4122,17 @@ } }, "node_modules/terser-webpack-plugin": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.1.1.tgz", - "integrity": "sha512-5XNNXZiR8YO6X6KhSGXfY0QrGrCRlSwAEjIIrlRQR4W8nP69TaJUlh3bkuac6zzgspiGPfKEHcY295MMVExl5Q==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.1.3.tgz", + "integrity": "sha512-cxGbMqr6+A2hrIB5ehFIF+F/iST5ZOxvOmy9zih9ySbP1C2oEWQSOUS+2SNBTjzx5xLKO4xnod9eywdfq1Nb9A==", "dev": true, "dependencies": { - "jest-worker": "^26.6.2", + "jest-worker": "^27.0.2", "p-limit": "^3.1.0", "schema-utils": "^3.0.0", "serialize-javascript": "^5.0.1", "source-map": "^0.6.1", - "terser": "^5.5.1" + "terser": "^5.7.0" }, "engines": { "node": ">= 10.13.0" @@ -4222,9 +4512,9 @@ "dev": true }, "node_modules/watchpack": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.0.1.tgz", - "integrity": "sha512-vO8AKGX22ZRo6PiOFM9dC0re8IcKh8Kd/aH2zeqUc6w4/jBGlTy2P7fTC6ekT0NjVeGjgU2dGC5rNstKkeLEQg==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.2.0.tgz", + "integrity": "sha512-up4YAn/XHgZHIxFBVCdlMiWDj6WaLKpwVeGQk2I5thdYxF/KmF0aaz6TfJZ/hfl1h/XlcDr7k1KH7ThDagpFaA==", "dev": true, "dependencies": { "glob-to-regexp": "^0.4.1", @@ -4235,9 +4525,9 @@ } }, "node_modules/webpack": { - "version": "5.35.0", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.35.0.tgz", - "integrity": "sha512-au3gu55yYF/h6NXFr0KZPZAYxS6Nlc595BzYPke8n0CSff5WXcoixtjh5LC/8mXunkRKxhymhXmBY0+kEbR6jg==", + "version": "5.38.1", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.38.1.tgz", + "integrity": "sha512-OqRmYD1OJbHZph6RUMD93GcCZy4Z4wC0ele4FXyYF0J6AxO1vOSuIlU1hkS/lDlR9CDYBz64MZRmdbdnFFoT2g==", "dev": true, "dependencies": { "@types/eslint-scope": "^3.7.0", @@ -4245,12 +4535,12 @@ "@webassemblyjs/ast": "1.11.0", "@webassemblyjs/wasm-edit": "1.11.0", "@webassemblyjs/wasm-parser": "1.11.0", - "acorn": "^8.0.4", + "acorn": "^8.2.1", "browserslist": "^4.14.5", "chrome-trace-event": "^1.0.2", "enhanced-resolve": "^5.8.0", "es-module-lexer": "^0.4.0", - "eslint-scope": "^5.1.1", + "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.2.4", @@ -4261,8 +4551,8 @@ "schema-utils": "^3.0.0", "tapable": "^2.1.1", "terser-webpack-plugin": "^5.1.1", - "watchpack": "^2.0.0", - "webpack-sources": "^2.1.1" + "watchpack": "^2.2.0", + "webpack-sources": "^2.3.0" }, "bin": { "webpack": "bin/webpack.js" @@ -4281,18 +4571,17 @@ } }, "node_modules/webpack-cli": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.6.0.tgz", - "integrity": "sha512-9YV+qTcGMjQFiY7Nb1kmnupvb1x40lfpj8pwdO/bom+sQiP4OBMKjHq29YQrlDWDPZO9r/qWaRRywKaRDKqBTA==", + "version": "4.7.2", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.7.2.tgz", + "integrity": "sha512-mEoLmnmOIZQNiRl0ebnjzQ74Hk0iKS5SiEEnpq3dRezoyR3yPaeQZCMCe+db4524pj1Pd5ghZXjT41KLzIhSLw==", "dev": true, "dependencies": { "@discoveryjs/json-ext": "^0.5.0", - "@webpack-cli/configtest": "^1.0.2", - "@webpack-cli/info": "^1.2.3", - "@webpack-cli/serve": "^1.3.1", + "@webpack-cli/configtest": "^1.0.4", + "@webpack-cli/info": "^1.3.0", + "@webpack-cli/serve": "^1.5.1", "colorette": "^1.2.1", "commander": "^7.0.0", - "enquirer": "^2.3.6", "execa": "^5.0.0", "fastest-levenshtein": "^1.0.12", "import-local": "^3.0.2", @@ -4339,9 +4628,9 @@ } }, "node_modules/webpack-sources": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.2.0.tgz", - "integrity": "sha512-bQsA24JLwcnWGArOKUxYKhX3Mz/nK1Xf6hxullKERyktjNMC4x8koOeaDNTA2fEJ09BdWLbM/iTW0ithREUP0w==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.3.0.tgz", + "integrity": "sha512-WyOdtwSvOML1kbgtXbTDnEW0jkJ7hZr/bDByIwszhWd/4XX1A3XMkrbFMsuH4+/MfLlZCUzlAdg4r7jaGKEIgQ==", "dev": true, "dependencies": { "source-list-map": "^2.0.1", @@ -4562,35 +4851,35 @@ }, "dependencies": { "@babel/code-frame": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.12.13.tgz", - "integrity": "sha512-HV1Cm0Q3ZrpCR93tkWOYiuYIgLxZXZFVG2VgK+MBWjUqZTundupbfx2aXarXuw5Ko5aMcjtJgbSs4vUGBS5v6g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.14.5.tgz", + "integrity": "sha512-9pzDqyc6OLDaqe+zbACgFkb6fKMNG6CObKpnYXChRsvYGyEdc7CA2BaqeOM+vOtCS5ndmJicPJhKAwYRI6UfFw==", "dev": true, "requires": { - "@babel/highlight": "^7.12.13" + "@babel/highlight": "^7.14.5" } }, "@babel/compat-data": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.13.15.tgz", - "integrity": "sha512-ltnibHKR1VnrU4ymHyQ/CXtNXI6yZC0oJThyW78Hft8XndANwi+9H+UIklBDraIjFEJzw8wmcM427oDd9KS5wA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.14.5.tgz", + "integrity": "sha512-kixrYn4JwfAVPa0f2yfzc2AWti6WRRyO3XjWW5PJAvtE11qhSayrrcrEnee05KAtNaPC+EwehE8Qt1UedEVB8w==", "dev": true }, "@babel/core": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.13.16.tgz", - "integrity": "sha512-sXHpixBiWWFti0AV2Zq7avpTasr6sIAu7Y396c608541qAU2ui4a193m0KSQmfPSKFZLnQ3cvlKDOm3XkuXm3Q==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.12.13", - "@babel/generator": "^7.13.16", - "@babel/helper-compilation-targets": "^7.13.16", - "@babel/helper-module-transforms": "^7.13.14", - "@babel/helpers": "^7.13.16", - "@babel/parser": "^7.13.16", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.15", - "@babel/types": "^7.13.16", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.14.5.tgz", + "integrity": "sha512-RN/AwP2DJmQTZSfiDaD+JQQ/J99KsIpOCfBE5pL+5jJSt7nI3nYGoAXZu+ffYSQ029NLs2DstZb+eR81uuARgg==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.14.5", + "@babel/generator": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helpers": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5", "convert-source-map": "^1.7.0", "debug": "^4.1.0", "gensync": "^1.0.0-beta.2", @@ -4617,44 +4906,44 @@ } }, "@babel/generator": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.13.16.tgz", - "integrity": "sha512-grBBR75UnKOcUWMp8WoDxNsWCFl//XCK6HWTrBQKTr5SV9f5g0pNOjdyzi/DTBv12S9GnYPInIXQBTky7OXEMg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.14.5.tgz", + "integrity": "sha512-y3rlP+/G25OIX3mYKKIOlQRcqj7YgrvHxOLbVmyLJ9bPmi5ttvUmpydVjcFjZphOktWuA7ovbx91ECloWTfjIA==", "dev": true, "requires": { - "@babel/types": "^7.13.16", + "@babel/types": "^7.14.5", "jsesc": "^2.5.1", "source-map": "^0.5.0" } }, "@babel/helper-annotate-as-pure": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.12.13.tgz", - "integrity": "sha512-7YXfX5wQ5aYM/BOlbSccHDbuXXFPxeoUmfWtz8le2yTkTZc+BxsiEnENFoi2SlmA8ewDkG2LgIMIVzzn2h8kfw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-annotate-as-pure/-/helper-annotate-as-pure-7.14.5.tgz", + "integrity": "sha512-EivH9EgBIb+G8ij1B2jAwSH36WnGvkQSEC6CkX/6v6ZFlw5fVOHvsgGF4uiEHO2GzMvunZb6tDLQEQSdrdocrA==", "dev": true, "requires": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" } }, "@babel/helper-builder-binary-assignment-operator-visitor": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.12.13.tgz", - "integrity": "sha512-CZOv9tGphhDRlVjVkAgm8Nhklm9RzSmWpX2my+t7Ua/KT616pEzXsQCjinzvkRvHWJ9itO4f296efroX23XCMA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-builder-binary-assignment-operator-visitor/-/helper-builder-binary-assignment-operator-visitor-7.14.5.tgz", + "integrity": "sha512-YTA/Twn0vBXDVGJuAX6PwW7x5zQei1luDDo2Pl6q1qZ7hVNl0RZrhHCQG/ArGpR29Vl7ETiB8eJyrvpuRp300w==", "dev": true, "requires": { - "@babel/helper-explode-assignable-expression": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/helper-explode-assignable-expression": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helper-compilation-targets": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.13.16.tgz", - "integrity": "sha512-3gmkYIrpqsLlieFwjkGgLaSHmhnvlAYzZLlYVjlW+QwI+1zE17kGxuJGmIqDQdYp56XdmGeD+Bswx0UTyG18xA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.14.5.tgz", + "integrity": "sha512-v+QtZqXEiOnpO6EYvlImB6zCD2Lel06RzOPzmkz/D/XgQiUu3C/Jb1LOqSt/AIA34TYi/Q+KlT8vTQrgdxkbLw==", "dev": true, "requires": { - "@babel/compat-data": "^7.13.15", - "@babel/helper-validator-option": "^7.12.17", - "browserslist": "^4.14.5", + "@babel/compat-data": "^7.14.5", + "@babel/helper-validator-option": "^7.14.5", + "browserslist": "^4.16.6", "semver": "^6.3.0" }, "dependencies": { @@ -4667,32 +4956,33 @@ } }, "@babel/helper-create-class-features-plugin": { - "version": "7.13.11", - "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.13.11.tgz", - "integrity": "sha512-ays0I7XYq9xbjCSvT+EvysLgfc3tOkwCULHjrnscGT3A9qD4sk3wXnJ3of0MAWsWGjdinFvajHU2smYuqXKMrw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-class-features-plugin/-/helper-create-class-features-plugin-7.14.5.tgz", + "integrity": "sha512-Uq9z2e7ZtcnDMirRqAGLRaLwJn+Lrh388v5ETrR3pALJnElVh2zqQmdbz4W2RUJYohAPh2mtyPUgyMHMzXMncQ==", "dev": true, "requires": { - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-member-expression-to-functions": "^7.13.0", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/helper-replace-supers": "^7.13.0", - "@babel/helper-split-export-declaration": "^7.12.13" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-member-expression-to-functions": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5" } }, "@babel/helper-create-regexp-features-plugin": { - "version": "7.12.17", - "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.12.17.tgz", - "integrity": "sha512-p2VGmBu9oefLZ2nQpgnEnG0ZlRPvL8gAGvPUMQwUdaE8k49rOMuZpOwdQoy5qJf6K8jL3bcAMhVUlHAjIgJHUg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-create-regexp-features-plugin/-/helper-create-regexp-features-plugin-7.14.5.tgz", + "integrity": "sha512-TLawwqpOErY2HhWbGJ2nZT5wSkR192QpN+nBg1THfBfftrlvOh+WbhrxXCH4q4xJ9Gl16BGPR/48JA+Ryiho/A==", "dev": true, "requires": { - "@babel/helper-annotate-as-pure": "^7.12.13", + "@babel/helper-annotate-as-pure": "^7.14.5", "regexpu-core": "^4.7.1" } }, "@babel/helper-define-polyfill-provider": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.2.0.tgz", - "integrity": "sha512-JT8tHuFjKBo8NnaUbblz7mIu1nnvUDiHVjXXkulZULyidvo/7P6TY7+YqpV37IfF+KUFxmlK04elKtGKXaiVgw==", + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/@babel/helper-define-polyfill-provider/-/helper-define-polyfill-provider-0.2.3.tgz", + "integrity": "sha512-RH3QDAfRMzj7+0Nqu5oqgO5q9mFtQEVvCRsi8qCEfzLR9p2BHfn5FzhSB2oj1fF7I2+DcTORkYaQ6aTR9Cofew==", "dev": true, "requires": { "@babel/helper-compilation-targets": "^7.13.0", @@ -4714,339 +5004,361 @@ } }, "@babel/helper-explode-assignable-expression": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.13.0.tgz", - "integrity": "sha512-qS0peLTDP8kOisG1blKbaoBg/o9OSa1qoumMjTK5pM+KDTtpxpsiubnCGP34vK8BXGcb2M9eigwgvoJryrzwWA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-explode-assignable-expression/-/helper-explode-assignable-expression-7.14.5.tgz", + "integrity": "sha512-Htb24gnGJdIGT4vnRKMdoXiOIlqOLmdiUYpAQ0mYfgVT/GDm8GOYhgi4GL+hMKrkiPRohO4ts34ELFsGAPQLDQ==", "dev": true, "requires": { - "@babel/types": "^7.13.0" + "@babel/types": "^7.14.5" } }, "@babel/helper-function-name": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.12.13.tgz", - "integrity": "sha512-TZvmPn0UOqmvi5G4vvw0qZTpVptGkB1GL61R6lKvrSdIxGm5Pky7Q3fpKiIkQCAtRCBUwB0PaThlx9vebCDSwA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-function-name/-/helper-function-name-7.14.5.tgz", + "integrity": "sha512-Gjna0AsXWfFvrAuX+VKcN/aNNWonizBj39yGwUzVDVTlMYJMK2Wp6xdpy72mfArFq5uK+NOuexfzZlzI1z9+AQ==", "dev": true, "requires": { - "@babel/helper-get-function-arity": "^7.12.13", - "@babel/template": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/helper-get-function-arity": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helper-get-function-arity": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.12.13.tgz", - "integrity": "sha512-DjEVzQNz5LICkzN0REdpD5prGoidvbdYk1BVgRUOINaWJP2t6avB27X1guXK1kXNrX0WMfsrm1A/ZBthYuIMQg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-get-function-arity/-/helper-get-function-arity-7.14.5.tgz", + "integrity": "sha512-I1Db4Shst5lewOM4V+ZKJzQ0JGGaZ6VY1jYvMghRjqs6DWgxLCIyFt30GlnKkfUeFLpJt2vzbMVEXVSXlIFYUg==", "dev": true, "requires": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" } }, "@babel/helper-hoist-variables": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.13.16.tgz", - "integrity": "sha512-1eMtTrXtrwscjcAeO4BVK+vvkxaLJSPFz1w1KLawz6HLNi9bPFGBNwwDyVfiu1Tv/vRRFYfoGaKhmAQPGPn5Wg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-hoist-variables/-/helper-hoist-variables-7.14.5.tgz", + "integrity": "sha512-R1PXiz31Uc0Vxy4OEOm07x0oSjKAdPPCh3tPivn/Eo8cvz6gveAeuyUUPB21Hoiif0uoPQSSdhIPS3352nvdyQ==", "dev": true, "requires": { - "@babel/traverse": "^7.13.15", - "@babel/types": "^7.13.16" + "@babel/types": "^7.14.5" } }, "@babel/helper-member-expression-to-functions": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.13.12.tgz", - "integrity": "sha512-48ql1CLL59aKbU94Y88Xgb2VFy7a95ykGRbJJaaVv+LX5U8wFpLfiGXJJGUozsmA1oEh/o5Bp60Voq7ACyA/Sw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.14.5.tgz", + "integrity": "sha512-UxUeEYPrqH1Q/k0yRku1JE7dyfyehNwT6SVkMHvYvPDv4+uu627VXBckVj891BO8ruKBkiDoGnZf4qPDD8abDQ==", "dev": true, "requires": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" } }, "@babel/helper-module-imports": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.13.12.tgz", - "integrity": "sha512-4cVvR2/1B693IuOvSI20xqqa/+bl7lqAMR59R4iu39R9aOX8/JoYY1sFaNvUMyMBGnHdwvJgUrzNLoUZxXypxA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.14.5.tgz", + "integrity": "sha512-SwrNHu5QWS84XlHwGYPDtCxcA0hrSlL2yhWYLgeOc0w7ccOl2qv4s/nARI0aYZW+bSwAL5CukeXA47B/1NKcnQ==", "dev": true, "requires": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" } }, "@babel/helper-module-transforms": { - "version": "7.13.14", - "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.13.14.tgz", - "integrity": "sha512-QuU/OJ0iAOSIatyVZmfqB0lbkVP0kDRiKj34xy+QNsnVZi/PA6BoSoreeqnxxa9EHFAIL0R9XOaAR/G9WlIy5g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.14.5.tgz", + "integrity": "sha512-iXpX4KW8LVODuAieD7MzhNjmM6dzYY5tfRqT+R9HDXWl0jPn/djKmA+G9s/2C2T9zggw5tK1QNqZ70USfedOwA==", "dev": true, "requires": { - "@babel/helper-module-imports": "^7.13.12", - "@babel/helper-replace-supers": "^7.13.12", - "@babel/helper-simple-access": "^7.13.12", - "@babel/helper-split-export-declaration": "^7.12.13", - "@babel/helper-validator-identifier": "^7.12.11", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.13", - "@babel/types": "^7.13.14" + "@babel/helper-module-imports": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-simple-access": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", + "@babel/helper-validator-identifier": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helper-optimise-call-expression": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.12.13.tgz", - "integrity": "sha512-BdWQhoVJkp6nVjB7nkFWcn43dkprYauqtk++Py2eaf/GRDFm5BxRqEIZCiHlZUGAVmtwKcsVL1dC68WmzeFmiA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-optimise-call-expression/-/helper-optimise-call-expression-7.14.5.tgz", + "integrity": "sha512-IqiLIrODUOdnPU9/F8ib1Fx2ohlgDhxnIDU7OEVi+kAbEZcyiF7BLU8W6PfvPi9LzztjS7kcbzbmL7oG8kD6VA==", "dev": true, "requires": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" } }, "@babel/helper-plugin-utils": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.13.0.tgz", - "integrity": "sha512-ZPafIPSwzUlAoWT8DKs1W2VyF2gOWthGd5NGFMsBcMMol+ZhK+EQY/e6V96poa6PA/Bh+C9plWN0hXO1uB8AfQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.14.5.tgz", + "integrity": "sha512-/37qQCE3K0vvZKwoK4XU/irIJQdIfCJuhU5eKnNxpFDsOkgFaUAwbv+RYw6eYgsC0E4hS7r5KqGULUogqui0fQ==", "dev": true }, "@babel/helper-remap-async-to-generator": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.13.0.tgz", - "integrity": "sha512-pUQpFBE9JvC9lrQbpX0TmeNIy5s7GnZjna2lhhcHC7DzgBs6fWn722Y5cfwgrtrqc7NAJwMvOa0mKhq6XaE4jg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-remap-async-to-generator/-/helper-remap-async-to-generator-7.14.5.tgz", + "integrity": "sha512-rLQKdQU+HYlxBwQIj8dk4/0ENOUEhA/Z0l4hN8BexpvmSMN9oA9EagjnhnDpNsRdWCfjwa4mn/HyBXO9yhQP6A==", "dev": true, "requires": { - "@babel/helper-annotate-as-pure": "^7.12.13", - "@babel/helper-wrap-function": "^7.13.0", - "@babel/types": "^7.13.0" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-wrap-function": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helper-replace-supers": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.13.12.tgz", - "integrity": "sha512-Gz1eiX+4yDO8mT+heB94aLVNCL+rbuT2xy4YfyNqu8F+OI6vMvJK891qGBTqL9Uc8wxEvRW92Id6G7sDen3fFw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-replace-supers/-/helper-replace-supers-7.14.5.tgz", + "integrity": "sha512-3i1Qe9/8x/hCHINujn+iuHy+mMRLoc77b2nI9TB0zjH1hvn9qGlXjWlggdwUcju36PkPCy/lpM7LLUdcTyH4Ow==", "dev": true, "requires": { - "@babel/helper-member-expression-to-functions": "^7.13.12", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/traverse": "^7.13.0", - "@babel/types": "^7.13.12" + "@babel/helper-member-expression-to-functions": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helper-simple-access": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.13.12.tgz", - "integrity": "sha512-7FEjbrx5SL9cWvXioDbnlYTppcZGuCY6ow3/D5vMggb2Ywgu4dMrpTJX0JdQAIcRRUElOIxF3yEooa9gUb9ZbA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-simple-access/-/helper-simple-access-7.14.5.tgz", + "integrity": "sha512-nfBN9xvmCt6nrMZjfhkl7i0oTV3yxR4/FztsbOASyTvVcoYd0TRHh7eMLdlEcCqobydC0LAF3LtC92Iwxo0wyw==", "dev": true, "requires": { - "@babel/types": "^7.13.12" + "@babel/types": "^7.14.5" } }, "@babel/helper-skip-transparent-expression-wrappers": { - "version": "7.12.1", - "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.12.1.tgz", - "integrity": "sha512-Mf5AUuhG1/OCChOJ/HcADmvcHM42WJockombn8ATJG3OnyiSxBK/Mm5x78BQWvmtXZKHgbjdGL2kin/HOLlZGA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-skip-transparent-expression-wrappers/-/helper-skip-transparent-expression-wrappers-7.14.5.tgz", + "integrity": "sha512-dmqZB7mrb94PZSAOYtr+ZN5qt5owZIAgqtoTuqiFbHFtxgEcmQlRJVI+bO++fciBunXtB6MK7HrzrfcAzIz2NQ==", "dev": true, "requires": { - "@babel/types": "^7.12.1" + "@babel/types": "^7.14.5" } }, "@babel/helper-split-export-declaration": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.12.13.tgz", - "integrity": "sha512-tCJDltF83htUtXx5NLcaDqRmknv652ZWCHyoTETf1CXYJdPC7nohZohjUgieXhv0hTJdRf2FjDueFehdNucpzg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-split-export-declaration/-/helper-split-export-declaration-7.14.5.tgz", + "integrity": "sha512-hprxVPu6e5Kdp2puZUmvOGjaLv9TCe58E/Fl6hRq4YiVQxIcNvuq6uTM2r1mT/oPskuS9CgR+I94sqAYv0NGKA==", "dev": true, "requires": { - "@babel/types": "^7.12.13" + "@babel/types": "^7.14.5" } }, "@babel/helper-validator-identifier": { - "version": "7.12.11", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.12.11.tgz", - "integrity": "sha512-np/lG3uARFybkoHokJUmf1QfEvRVCPbmQeUQpKow5cQ3xWrV9i3rUHodKDJPQfTVX61qKi+UdYk8kik84n7XOw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.14.5.tgz", + "integrity": "sha512-5lsetuxCLilmVGyiLEfoHBRX8UCFD+1m2x3Rj97WrW3V7H3u4RWRXA4evMjImCsin2J2YT0QaVDGf+z8ondbAg==", "dev": true }, "@babel/helper-validator-option": { - "version": "7.12.17", - "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.12.17.tgz", - "integrity": "sha512-TopkMDmLzq8ngChwRlyjR6raKD6gMSae4JdYDB8bByKreQgG0RBTuKe9LRxW3wFtUnjxOPRKBDwEH6Mg5KeDfw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.14.5.tgz", + "integrity": "sha512-OX8D5eeX4XwcroVW45NMvoYaIuFI+GQpA2a8Gi+X/U/cDUIRsV37qQfF905F0htTRCREQIB4KqPeaveRJUl3Ow==", "dev": true }, "@babel/helper-wrap-function": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.13.0.tgz", - "integrity": "sha512-1UX9F7K3BS42fI6qd2A4BjKzgGjToscyZTdp1DjknHLCIvpgne6918io+aL5LXFcER/8QWiwpoY902pVEqgTXA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helper-wrap-function/-/helper-wrap-function-7.14.5.tgz", + "integrity": "sha512-YEdjTCq+LNuNS1WfxsDCNpgXkJaIyqco6DAelTUjT4f2KIWC1nBcaCaSdHTBqQVLnTBexBcVcFhLSU1KnYuePQ==", "dev": true, "requires": { - "@babel/helper-function-name": "^7.12.13", - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.0", - "@babel/types": "^7.13.0" + "@babel/helper-function-name": "^7.14.5", + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/helpers": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.13.17.tgz", - "integrity": "sha512-Eal4Gce4kGijo1/TGJdqp3WuhllaMLSrW6XcL0ulyUAQOuxHcCafZE8KHg9857gcTehsm/v7RcOx2+jp0Ryjsg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.14.5.tgz", + "integrity": "sha512-xtcWOuN9VL6nApgVHtq3PPcQv5qFBJzoSZzJ/2c0QK/IP/gxVcoWSNQwFEGvmbQsuS9rhYqjILDGGXcTkA705Q==", "dev": true, "requires": { - "@babel/template": "^7.12.13", - "@babel/traverse": "^7.13.17", - "@babel/types": "^7.13.17" + "@babel/template": "^7.14.5", + "@babel/traverse": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/highlight": { - "version": "7.13.10", - "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.13.10.tgz", - "integrity": "sha512-5aPpe5XQPzflQrFwL1/QoeHkP2MsA4JCntcXHRhEsdsfPVkvPi2w7Qix4iV7t5S/oC9OodGrggd8aco1g3SZFg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.14.5.tgz", + "integrity": "sha512-qf9u2WFWVV0MppaL877j2dBtQIDgmidgjGk5VIMw3OadXvYaXn66U1BFlH2t4+t3i+8PhedppRv+i40ABzd+gg==", "dev": true, "requires": { - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-validator-identifier": "^7.14.5", "chalk": "^2.0.0", "js-tokens": "^4.0.0" } }, "@babel/parser": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.13.16.tgz", - "integrity": "sha512-6bAg36mCwuqLO0hbR+z7PHuqWiCeP7Dzg73OpQwsAB1Eb8HnGEz5xYBzCfbu+YjoaJsJs+qheDxVAuqbt3ILEw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.14.5.tgz", + "integrity": "sha512-TM8C+xtH/9n1qzX+JNHi7AN2zHMTiPUtspO0ZdHflW8KaskkALhMmuMHb4bCmNdv9VAPzJX3/bXqkVLnAvsPfg==", "dev": true }, "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.13.12.tgz", - "integrity": "sha512-d0u3zWKcoZf379fOeJdr1a5WPDny4aOFZ6hlfKivgK0LY7ZxNfoaHL2fWwdGtHyVvra38FC+HVYkO+byfSA8AQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining/-/plugin-bugfix-v8-spread-parameters-in-optional-chaining-7.14.5.tgz", + "integrity": "sha512-ZoJS2XCKPBfTmL122iP6NM9dOg+d4lc9fFk3zxc8iDjvt8Pk4+TlsHSKhIPf6X+L5ORCdBzqMZDjL/WHj7WknQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1", - "@babel/plugin-proposal-optional-chaining": "^7.13.12" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5", + "@babel/plugin-proposal-optional-chaining": "^7.14.5" } }, "@babel/plugin-proposal-async-generator-functions": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.13.15.tgz", - "integrity": "sha512-VapibkWzFeoa6ubXy/NgV5U2U4MVnUlvnx6wo1XhlsaTrLYWE0UFpDQsVrmn22q5CzeloqJ8gEMHSKxuee6ZdA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.14.5.tgz", + "integrity": "sha512-tbD/CG3l43FIXxmu4a7RBe4zH7MLJ+S/lFowPFO7HetS2hyOZ/0nnnznegDuzFzfkyQYTxqdTH/hKmuBngaDAA==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-remap-async-to-generator": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-remap-async-to-generator": "^7.14.5", "@babel/plugin-syntax-async-generators": "^7.8.4" } }, "@babel/plugin-proposal-class-properties": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.13.0.tgz", - "integrity": "sha512-KnTDjFNC1g+45ka0myZNvSBFLhNCLN+GeGYLDEA8Oq7MZ6yMgfLoIRh86GRT0FjtJhZw8JyUskP9uvj5pHM9Zg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.14.5.tgz", + "integrity": "sha512-q/PLpv5Ko4dVc1LYMpCY7RVAAO4uk55qPwrIuJ5QJ8c6cVuAmhu7I/49JOppXL6gXf7ZHzpRVEUZdYoPLM04Gg==", + "dev": true, + "requires": { + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + } + }, + "@babel/plugin-proposal-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-static-block/-/plugin-proposal-class-static-block-7.14.5.tgz", + "integrity": "sha512-KBAH5ksEnYHCegqseI5N9skTdxgJdmDoAOc0uXa+4QMYKeZD0w5IARh4FMlTNtaHhbB8v+KzMdTgxMMzsIy6Yg==", "dev": true, "requires": { - "@babel/helper-create-class-features-plugin": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/plugin-syntax-class-static-block": "^7.14.5" } }, "@babel/plugin-proposal-dynamic-import": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.13.8.tgz", - "integrity": "sha512-ONWKj0H6+wIRCkZi9zSbZtE/r73uOhMVHh256ys0UzfM7I3d4n+spZNWjOnJv2gzopumP2Wxi186vI8N0Y2JyQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-dynamic-import/-/plugin-proposal-dynamic-import-7.14.5.tgz", + "integrity": "sha512-ExjiNYc3HDN5PXJx+bwC50GIx/KKanX2HiggnIUAYedbARdImiCU4RhhHfdf0Kd7JNXGpsBBBCOm+bBVy3Gb0g==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3" } }, "@babel/plugin-proposal-export-namespace-from": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.12.13.tgz", - "integrity": "sha512-INAgtFo4OnLN3Y/j0VwAgw3HDXcDtX+C/erMvWzuV9v71r7urb6iyMXu7eM9IgLr1ElLlOkaHjJ0SbCmdOQ3Iw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-export-namespace-from/-/plugin-proposal-export-namespace-from-7.14.5.tgz", + "integrity": "sha512-g5POA32bXPMmSBu5Dx/iZGLGnKmKPc5AiY7qfZgurzrCYgIztDlHFbznSNCoQuv57YQLnQfaDi7dxCtLDIdXdA==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-export-namespace-from": "^7.8.3" } }, "@babel/plugin-proposal-json-strings": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.13.8.tgz", - "integrity": "sha512-w4zOPKUFPX1mgvTmL/fcEqy34hrQ1CRcGxdphBc6snDnnqJ47EZDIyop6IwXzAC8G916hsIuXB2ZMBCExC5k7Q==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-json-strings/-/plugin-proposal-json-strings-7.14.5.tgz", + "integrity": "sha512-NSq2fczJYKVRIsUJyNxrVUMhB27zb7N7pOFGQOhBKJrChbGcgEAqyZrmZswkPk18VMurEeJAaICbfm57vUeTbQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-json-strings": "^7.8.3" } }, "@babel/plugin-proposal-logical-assignment-operators": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.13.8.tgz", - "integrity": "sha512-aul6znYB4N4HGweImqKn59Su9RS8lbUIqxtXTOcAGtNIDczoEFv+l1EhmX8rUBp3G1jMjKJm8m0jXVp63ZpS4A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-logical-assignment-operators/-/plugin-proposal-logical-assignment-operators-7.14.5.tgz", + "integrity": "sha512-YGn2AvZAo9TwyhlLvCCWxD90Xq8xJ4aSgaX3G5D/8DW94L8aaT+dS5cSP+Z06+rCJERGSr9GxMBZ601xoc2taw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" } }, "@babel/plugin-proposal-nullish-coalescing-operator": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.13.8.tgz", - "integrity": "sha512-iePlDPBn//UhxExyS9KyeYU7RM9WScAG+D3Hhno0PLJebAEpDZMocbDe64eqynhNAnwz/vZoL/q/QB2T1OH39A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-nullish-coalescing-operator/-/plugin-proposal-nullish-coalescing-operator-7.14.5.tgz", + "integrity": "sha512-gun/SOnMqjSb98Nkaq2rTKMwervfdAoz6NphdY0vTfuzMfryj+tDGb2n6UkDKwez+Y8PZDhE3D143v6Gepp4Hg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" } }, "@babel/plugin-proposal-numeric-separator": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.12.13.tgz", - "integrity": "sha512-O1jFia9R8BUCl3ZGB7eitaAPu62TXJRHn7rh+ojNERCFyqRwJMTmhz+tJ+k0CwI6CLjX/ee4qW74FSqlq9I35w==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.14.5.tgz", + "integrity": "sha512-yiclALKe0vyZRZE0pS6RXgjUOt87GWv6FYa5zqj15PvhOGFO69R5DusPlgK/1K5dVnCtegTiWu9UaBSrLLJJBg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-numeric-separator": "^7.10.4" } }, "@babel/plugin-proposal-object-rest-spread": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.13.8.tgz", - "integrity": "sha512-DhB2EuB1Ih7S3/IRX5AFVgZ16k3EzfRbq97CxAVI1KSYcW+lexV8VZb7G7L8zuPVSdQMRn0kiBpf/Yzu9ZKH0g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.14.5.tgz", + "integrity": "sha512-VzMyY6PWNPPT3pxc5hi9LloKNr4SSrVCg7Yr6aZpW4Ym07r7KqSU/QXYwjXLVxqwSv0t/XSXkFoKBPUkZ8vb2A==", "dev": true, "requires": { - "@babel/compat-data": "^7.13.8", - "@babel/helper-compilation-targets": "^7.13.8", - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/compat-data": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-object-rest-spread": "^7.8.3", - "@babel/plugin-transform-parameters": "^7.13.0" + "@babel/plugin-transform-parameters": "^7.14.5" } }, "@babel/plugin-proposal-optional-catch-binding": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.13.8.tgz", - "integrity": "sha512-0wS/4DUF1CuTmGo+NiaHfHcVSeSLj5S3e6RivPTg/2k3wOv3jO35tZ6/ZWsQhQMvdgI7CwphjQa/ccarLymHVA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.14.5.tgz", + "integrity": "sha512-3Oyiixm0ur7bzO5ybNcZFlmVsygSIQgdOa7cTfOYCMY+wEPAYhZAJxi3mixKFCTCKUhQXuCTtQ1MzrpL3WT8ZQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-plugin-utils": "^7.14.5", "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" } }, "@babel/plugin-proposal-optional-chaining": { - "version": "7.13.12", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.13.12.tgz", - "integrity": "sha512-fcEdKOkIB7Tf4IxrgEVeFC4zeJSTr78no9wTdBuZZbqF64kzllU0ybo2zrzm7gUQfxGhBgq4E39oRs8Zx/RMYQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.14.5.tgz", + "integrity": "sha512-ycz+VOzo2UbWNI1rQXxIuMOzrDdHGrI23fRiz/Si2R4kv2XZQ1BK8ccdHwehMKBlcH/joGW/tzrUmo67gbJHlQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5", "@babel/plugin-syntax-optional-chaining": "^7.8.3" } }, "@babel/plugin-proposal-private-methods": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.13.0.tgz", - "integrity": "sha512-MXyyKQd9inhx1kDYPkFRVOBXQ20ES8Pto3T7UZ92xj2mY0EVD8oAVzeyYuVfy/mxAdTSIayOvg+aVzcHV2bn6Q==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-methods/-/plugin-proposal-private-methods-7.14.5.tgz", + "integrity": "sha512-838DkdUA1u+QTCplatfq4B7+1lnDa/+QMI89x5WZHBcnNv+47N8QEj2k9I2MUU9xIv8XJ4XvPCviM/Dj7Uwt9g==", + "dev": true, + "requires": { + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" + } + }, + "@babel/plugin-proposal-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-private-property-in-object/-/plugin-proposal-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-62EyfyA3WA0mZiF2e2IV9mc9Ghwxcg8YTu8BS4Wss4Y3PY725OmS9M0qLORbJwLqFtGh+jiE4wAmocK2CTUK2Q==", "dev": true, "requires": { - "@babel/helper-create-class-features-plugin": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-create-class-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" } }, "@babel/plugin-proposal-unicode-property-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.12.13.tgz", - "integrity": "sha512-XyJmZidNfofEkqFV5VC/bLabGmO5QzenPO/YOfGuEbgU+2sSwMmio3YLb4WtBgcmmdwZHyVyv8on77IUjQ5Gvg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-proposal-unicode-property-regex/-/plugin-proposal-unicode-property-regex-7.14.5.tgz", + "integrity": "sha512-6axIeOU5LnY471KenAB9vI8I5j7NQ2d652hIYwVyRfgaZT5UpiqFKCuVXCDMSrU+3VFafnu2c5m3lrWIlr6A5Q==", "dev": true, "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-syntax-async-generators": { @@ -5067,6 +5379,15 @@ "@babel/helper-plugin-utils": "^7.12.13" } }, + "@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-class-static-block/-/plugin-syntax-class-static-block-7.14.5.tgz", + "integrity": "sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.14.5" + } + }, "@babel/plugin-syntax-dynamic-import": { "version": "7.8.3", "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-dynamic-import/-/plugin-syntax-dynamic-import-7.8.3.tgz", @@ -5148,353 +5469,365 @@ "@babel/helper-plugin-utils": "^7.8.0" } }, + "@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-private-property-in-object/-/plugin-syntax-private-property-in-object-7.14.5.tgz", + "integrity": "sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==", + "dev": true, + "requires": { + "@babel/helper-plugin-utils": "^7.14.5" + } + }, "@babel/plugin-syntax-top-level-await": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.12.13.tgz", - "integrity": "sha512-A81F9pDwyS7yM//KwbCSDqy3Uj4NMIurtplxphWxoYtNPov7cJsDkAFNNyVlIZ3jwGycVsurZ+LtOA8gZ376iQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-syntax-top-level-await/-/plugin-syntax-top-level-await-7.14.5.tgz", + "integrity": "sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-arrow-functions": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.13.0.tgz", - "integrity": "sha512-96lgJagobeVmazXFaDrbmCLQxBysKu7U6Do3mLsx27gf5Dk85ezysrs2BZUpXD703U/Su1xTBDxxar2oa4jAGg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-arrow-functions/-/plugin-transform-arrow-functions-7.14.5.tgz", + "integrity": "sha512-KOnO0l4+tD5IfOdi4x8C1XmEIRWUjNRV8wc6K2vz/3e8yAOoZZvsRXRRIF/yo/MAOFb4QjtAw9xSxMXbSMRy8A==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-async-to-generator": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.13.0.tgz", - "integrity": "sha512-3j6E004Dx0K3eGmhxVJxwwI89CTJrce7lg3UrtFuDAVQ/2+SJ/h/aSFOeE6/n0WB1GsOffsJp6MnPQNQ8nmwhg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-async-to-generator/-/plugin-transform-async-to-generator-7.14.5.tgz", + "integrity": "sha512-szkbzQ0mNk0rpu76fzDdqSyPu0MuvpXgC+6rz5rpMb5OIRxdmHfQxrktL8CYolL2d8luMCZTR0DpIMIdL27IjA==", "dev": true, "requires": { - "@babel/helper-module-imports": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-remap-async-to-generator": "^7.13.0" + "@babel/helper-module-imports": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-remap-async-to-generator": "^7.14.5" } }, "@babel/plugin-transform-block-scoped-functions": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.12.13.tgz", - "integrity": "sha512-zNyFqbc3kI/fVpqwfqkg6RvBgFpC4J18aKKMmv7KdQ/1GgREapSJAykLMVNwfRGO3BtHj3YQZl8kxCXPcVMVeg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoped-functions/-/plugin-transform-block-scoped-functions-7.14.5.tgz", + "integrity": "sha512-dtqWqdWZ5NqBX3KzsVCWfQI3A53Ft5pWFCT2eCVUftWZgjc5DpDponbIF1+c+7cSGk2wN0YK7HGL/ezfRbpKBQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-block-scoping": { - "version": "7.13.16", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.13.16.tgz", - "integrity": "sha512-ad3PHUxGnfWF4Efd3qFuznEtZKoBp0spS+DgqzVzRPV7urEBvPLue3y2j80w4Jf2YLzZHj8TOv/Lmvdmh3b2xg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-block-scoping/-/plugin-transform-block-scoping-7.14.5.tgz", + "integrity": "sha512-LBYm4ZocNgoCqyxMLoOnwpsmQ18HWTQvql64t3GvMUzLQrNoV1BDG0lNftC8QKYERkZgCCT/7J5xWGObGAyHDw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-classes": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.13.0.tgz", - "integrity": "sha512-9BtHCPUARyVH1oXGcSJD3YpsqRLROJx5ZNP6tN5vnk17N0SVf9WCtf8Nuh1CFmgByKKAIMstitKduoCmsaDK5g==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-classes/-/plugin-transform-classes-7.14.5.tgz", + "integrity": "sha512-J4VxKAMykM06K/64z9rwiL6xnBHgB1+FVspqvlgCdwD1KUbQNfszeKVVOMh59w3sztHYIZDgnhOC4WbdEfHFDA==", "dev": true, "requires": { - "@babel/helper-annotate-as-pure": "^7.12.13", - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-optimise-call-expression": "^7.12.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-replace-supers": "^7.13.0", - "@babel/helper-split-export-declaration": "^7.12.13", + "@babel/helper-annotate-as-pure": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-optimise-call-expression": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", "globals": "^11.1.0" } }, "@babel/plugin-transform-computed-properties": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.13.0.tgz", - "integrity": "sha512-RRqTYTeZkZAz8WbieLTvKUEUxZlUTdmL5KGMyZj7FnMfLNKV4+r5549aORG/mgojRmFlQMJDUupwAMiF2Q7OUg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-computed-properties/-/plugin-transform-computed-properties-7.14.5.tgz", + "integrity": "sha512-pWM+E4283UxaVzLb8UBXv4EIxMovU4zxT1OPnpHJcmnvyY9QbPPTKZfEj31EUvG3/EQRbYAGaYEUZ4yWOBC2xg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-destructuring": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.13.17.tgz", - "integrity": "sha512-UAUqiLv+uRLO+xuBKKMEpC+t7YRNVRqBsWWq1yKXbBZBje/t3IXCiSinZhjn/DC3qzBfICeYd2EFGEbHsh5RLA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-destructuring/-/plugin-transform-destructuring-7.14.5.tgz", + "integrity": "sha512-wU9tYisEbRMxqDezKUqC9GleLycCRoUsai9ddlsq54r8QRLaeEhc+d+9DqCG+kV9W2GgQjTZESPTpn5bAFMDww==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-dotall-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.12.13.tgz", - "integrity": "sha512-foDrozE65ZFdUC2OfgeOCrEPTxdB3yjqxpXh8CH+ipd9CHd4s/iq81kcUpyH8ACGNEPdFqbtzfgzbT/ZGlbDeQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-dotall-regex/-/plugin-transform-dotall-regex-7.14.5.tgz", + "integrity": "sha512-loGlnBdj02MDsFaHhAIJzh7euK89lBrGIdM9EAtHFo6xKygCUGuuWe07o1oZVk287amtW1n0808sQM99aZt3gw==", "dev": true, "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-duplicate-keys": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.12.13.tgz", - "integrity": "sha512-NfADJiiHdhLBW3pulJlJI2NB0t4cci4WTZ8FtdIuNc2+8pslXdPtRRAEWqUY+m9kNOk2eRYbTAOipAxlrOcwwQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-duplicate-keys/-/plugin-transform-duplicate-keys-7.14.5.tgz", + "integrity": "sha512-iJjbI53huKbPDAsJ8EmVmvCKeeq21bAze4fu9GBQtSLqfvzj2oRuHVx4ZkDwEhg1htQ+5OBZh/Ab0XDf5iBZ7A==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-exponentiation-operator": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.12.13.tgz", - "integrity": "sha512-fbUelkM1apvqez/yYx1/oICVnGo2KM5s63mhGylrmXUxK/IAXSIf87QIxVfZldWf4QsOafY6vV3bX8aMHSvNrA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-exponentiation-operator/-/plugin-transform-exponentiation-operator-7.14.5.tgz", + "integrity": "sha512-jFazJhMBc9D27o9jDnIE5ZErI0R0m7PbKXVq77FFvqFbzvTMuv8jaAwLZ5PviOLSFttqKIW0/wxNSDbjLk0tYA==", "dev": true, "requires": { - "@babel/helper-builder-binary-assignment-operator-visitor": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-for-of": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.13.0.tgz", - "integrity": "sha512-IHKT00mwUVYE0zzbkDgNRP6SRzvfGCYsOxIRz8KsiaaHCcT9BWIkO+H9QRJseHBLOGBZkHUdHiqj6r0POsdytg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-for-of/-/plugin-transform-for-of-7.14.5.tgz", + "integrity": "sha512-CfmqxSUZzBl0rSjpoQSFoR9UEj3HzbGuGNL21/iFTmjb5gFggJp3ph0xR1YBhexmLoKRHzgxuFvty2xdSt6gTA==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-function-name": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.12.13.tgz", - "integrity": "sha512-6K7gZycG0cmIwwF7uMK/ZqeCikCGVBdyP2J5SKNCXO5EOHcqi+z7Jwf8AmyDNcBgxET8DrEtCt/mPKPyAzXyqQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-function-name/-/plugin-transform-function-name-7.14.5.tgz", + "integrity": "sha512-vbO6kv0fIzZ1GpmGQuvbwwm+O4Cbm2NrPzwlup9+/3fdkuzo1YqOZcXw26+YUJB84Ja7j9yURWposEHLYwxUfQ==", "dev": true, "requires": { - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.12.13.tgz", - "integrity": "sha512-FW+WPjSR7hiUxMcKqyNjP05tQ2kmBCdpEpZHY1ARm96tGQCCBvXKnpjILtDplUnJ/eHZ0lALLM+d2lMFSpYJrQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-literals/-/plugin-transform-literals-7.14.5.tgz", + "integrity": "sha512-ql33+epql2F49bi8aHXxvLURHkxJbSmMKl9J5yHqg4PLtdE6Uc48CH1GS6TQvZ86eoB/ApZXwm7jlA+B3kra7A==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-member-expression-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.12.13.tgz", - "integrity": "sha512-kxLkOsg8yir4YeEPHLuO2tXP9R/gTjpuTOjshqSpELUN3ZAg2jfDnKUvzzJxObun38sw3wm4Uu69sX/zA7iRvg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-member-expression-literals/-/plugin-transform-member-expression-literals-7.14.5.tgz", + "integrity": "sha512-WkNXxH1VXVTKarWFqmso83xl+2V3Eo28YY5utIkbsmXoItO8Q3aZxN4BTS2k0hz9dGUloHK26mJMyQEYfkn/+Q==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-modules-amd": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.13.0.tgz", - "integrity": "sha512-EKy/E2NHhY/6Vw5d1k3rgoobftcNUmp9fGjb9XZwQLtTctsRBOTRO7RHHxfIky1ogMN5BxN7p9uMA3SzPfotMQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-amd/-/plugin-transform-modules-amd-7.14.5.tgz", + "integrity": "sha512-3lpOU8Vxmp3roC4vzFpSdEpGUWSMsHFreTWOMMLzel2gNGfHE5UWIh/LN6ghHs2xurUp4jRFYMUIZhuFbody1g==", "dev": true, "requires": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" } }, "@babel/plugin-transform-modules-commonjs": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.13.8.tgz", - "integrity": "sha512-9QiOx4MEGglfYZ4XOnU79OHr6vIWUakIj9b4mioN8eQIoEh+pf5p/zEB36JpDFWA12nNMiRf7bfoRvl9Rn79Bw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-commonjs/-/plugin-transform-modules-commonjs-7.14.5.tgz", + "integrity": "sha512-en8GfBtgnydoao2PS+87mKyw62k02k7kJ9ltbKe0fXTHrQmG6QZZflYuGI1VVG7sVpx4E1n7KBpNlPb8m78J+A==", "dev": true, "requires": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-simple-access": "^7.12.13", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-simple-access": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" } }, "@babel/plugin-transform-modules-systemjs": { - "version": "7.13.8", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.13.8.tgz", - "integrity": "sha512-hwqctPYjhM6cWvVIlOIe27jCIBgHCsdH2xCJVAYQm7V5yTMoilbVMi9f6wKg0rpQAOn6ZG4AOyvCqFF/hUh6+A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-systemjs/-/plugin-transform-modules-systemjs-7.14.5.tgz", + "integrity": "sha512-mNMQdvBEE5DcMQaL5LbzXFMANrQjd2W7FPzg34Y4yEz7dBgdaC+9B84dSO+/1Wba98zoDbInctCDo4JGxz1VYA==", "dev": true, "requires": { - "@babel/helper-hoist-variables": "^7.13.0", - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-hoist-variables": "^7.14.5", + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-validator-identifier": "^7.14.5", "babel-plugin-dynamic-import-node": "^2.3.3" } }, "@babel/plugin-transform-modules-umd": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.13.0.tgz", - "integrity": "sha512-D/ILzAh6uyvkWjKKyFE/W0FzWwasv6vPTSqPcjxFqn6QpX3u8DjRVliq4F2BamO2Wee/om06Vyy+vPkNrd4wxw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-modules-umd/-/plugin-transform-modules-umd-7.14.5.tgz", + "integrity": "sha512-RfPGoagSngC06LsGUYyM9QWSXZ8MysEjDJTAea1lqRjNECE3y0qIJF/qbvJxc4oA4s99HumIMdXOrd+TdKaAAA==", "dev": true, "requires": { - "@babel/helper-module-transforms": "^7.13.0", - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-module-transforms": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-named-capturing-groups-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.12.13.tgz", - "integrity": "sha512-Xsm8P2hr5hAxyYblrfACXpQKdQbx4m2df9/ZZSQ8MAhsadw06+jW7s9zsSw6he+mJZXRlVMyEnVktJo4zjk1WA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-named-capturing-groups-regex/-/plugin-transform-named-capturing-groups-regex-7.14.5.tgz", + "integrity": "sha512-+Xe5+6MWFo311U8SchgeX5c1+lJM+eZDBZgD+tvXu9VVQPXwwVzeManMMjYX6xw2HczngfOSZjoFYKwdeB/Jvw==", "dev": true, "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5" } }, "@babel/plugin-transform-new-target": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.12.13.tgz", - "integrity": "sha512-/KY2hbLxrG5GTQ9zzZSc3xWiOy379pIETEhbtzwZcw9rvuaVV4Fqy7BYGYOWZnaoXIQYbbJ0ziXLa/sKcGCYEQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-new-target/-/plugin-transform-new-target-7.14.5.tgz", + "integrity": "sha512-Nx054zovz6IIRWEB49RDRuXGI4Gy0GMgqG0cII9L3MxqgXz/+rgII+RU58qpo4g7tNEx1jG7rRVH4ihZoP4esQ==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-object-super": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.12.13.tgz", - "integrity": "sha512-JzYIcj3XtYspZDV8j9ulnoMPZZnF/Cj0LUxPOjR89BdBVx+zYJI9MdMIlUZjbXDX+6YVeS6I3e8op+qQ3BYBoQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-object-super/-/plugin-transform-object-super-7.14.5.tgz", + "integrity": "sha512-MKfOBWzK0pZIrav9z/hkRqIk/2bTv9qvxHzPQc12RcVkMOzpIKnFCNYJip00ssKWYkd8Sf5g0Wr7pqJ+cmtuFg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13", - "@babel/helper-replace-supers": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-replace-supers": "^7.14.5" } }, "@babel/plugin-transform-parameters": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.13.0.tgz", - "integrity": "sha512-Jt8k/h/mIwE2JFEOb3lURoY5C85ETcYPnbuAJ96zRBzh1XHtQZfs62ChZ6EP22QlC8c7Xqr9q+e1SU5qttwwjw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-parameters/-/plugin-transform-parameters-7.14.5.tgz", + "integrity": "sha512-Tl7LWdr6HUxTmzQtzuU14SqbgrSKmaR77M0OKyq4njZLQTPfOvzblNKyNkGwOfEFCEx7KeYHQHDI0P3F02IVkA==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-property-literals": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.12.13.tgz", - "integrity": "sha512-nqVigwVan+lR+g8Fj8Exl0UQX2kymtjcWfMOYM1vTYEKujeyv2SkMgazf2qNcK7l4SDiKyTA/nHCPqL4e2zo1A==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-property-literals/-/plugin-transform-property-literals-7.14.5.tgz", + "integrity": "sha512-r1uilDthkgXW8Z1vJz2dKYLV1tuw2xsbrp3MrZmD99Wh9vsfKoob+JTgri5VUb/JqyKRXotlOtwgu4stIYCmnw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-regenerator": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.13.15.tgz", - "integrity": "sha512-Bk9cOLSz8DiurcMETZ8E2YtIVJbFCPGW28DJWUakmyVWtQSm6Wsf0p4B4BfEr/eL2Nkhe/CICiUiMOCi1TPhuQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-regenerator/-/plugin-transform-regenerator-7.14.5.tgz", + "integrity": "sha512-NVIY1W3ITDP5xQl50NgTKlZ0GrotKtLna08/uGY6ErQt6VEQZXla86x/CTddm5gZdcr+5GSsvMeTmWA5Ii6pkg==", "dev": true, "requires": { "regenerator-transform": "^0.14.2" } }, "@babel/plugin-transform-reserved-words": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.12.13.tgz", - "integrity": "sha512-xhUPzDXxZN1QfiOy/I5tyye+TRz6lA7z6xaT4CLOjPRMVg1ldRf0LHw0TDBpYL4vG78556WuHdyO9oi5UmzZBg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-reserved-words/-/plugin-transform-reserved-words-7.14.5.tgz", + "integrity": "sha512-cv4F2rv1nD4qdexOGsRQXJrOcyb5CrgjUH9PKrrtyhSDBNWGxd0UIitjyJiWagS+EbUGjG++22mGH1Pub8D6Vg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-shorthand-properties": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.12.13.tgz", - "integrity": "sha512-xpL49pqPnLtf0tVluuqvzWIgLEhuPpZzvs2yabUHSKRNlN7ScYU7aMlmavOeyXJZKgZKQRBlh8rHbKiJDraTSw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-shorthand-properties/-/plugin-transform-shorthand-properties-7.14.5.tgz", + "integrity": "sha512-xLucks6T1VmGsTB+GWK5Pl9Jl5+nRXD1uoFdA5TSO6xtiNjtXTjKkmPdFXVLGlK5A2/or/wQMKfmQ2Y0XJfn5g==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-spread": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.13.0.tgz", - "integrity": "sha512-V6vkiXijjzYeFmQTr3dBxPtZYLPcUfY34DebOU27jIl2M/Y8Egm52Hw82CSjjPqd54GTlJs5x+CR7HeNr24ckg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-spread/-/plugin-transform-spread-7.14.5.tgz", + "integrity": "sha512-/3iqoQdiWergnShZYl0xACb4ADeYCJ7X/RgmwtXshn6cIvautRPAFzhd58frQlokLO6Jb4/3JXvmm6WNTPtiTw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-skip-transparent-expression-wrappers": "^7.12.1" + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.14.5" } }, "@babel/plugin-transform-sticky-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.12.13.tgz", - "integrity": "sha512-Jc3JSaaWT8+fr7GRvQP02fKDsYk4K/lYwWq38r/UGfaxo89ajud321NH28KRQ7xy1Ybc0VUE5Pz8psjNNDUglg==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-sticky-regex/-/plugin-transform-sticky-regex-7.14.5.tgz", + "integrity": "sha512-Z7F7GyvEMzIIbwnziAZmnSNpdijdr4dWt+FJNBnBLz5mwDFkqIXU9wmBcWWad3QeJF5hMTkRe4dAq2sUZiG+8A==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-template-literals": { - "version": "7.13.0", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.13.0.tgz", - "integrity": "sha512-d67umW6nlfmr1iehCcBv69eSUSySk1EsIS8aTDX4Xo9qajAh6mYtcl4kJrBkGXuxZPEgVr7RVfAvNW6YQkd4Mw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-template-literals/-/plugin-transform-template-literals-7.14.5.tgz", + "integrity": "sha512-22btZeURqiepOfuy/VkFr+zStqlujWaarpMErvay7goJS6BWwdd6BY9zQyDLDa4x2S3VugxFb162IZ4m/S/+Gg==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.13.0" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-typeof-symbol": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.12.13.tgz", - "integrity": "sha512-eKv/LmUJpMnu4npgfvs3LiHhJua5fo/CysENxa45YCQXZwKnGCQKAg87bvoqSW1fFT+HA32l03Qxsm8ouTY3ZQ==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-typeof-symbol/-/plugin-transform-typeof-symbol-7.14.5.tgz", + "integrity": "sha512-lXzLD30ffCWseTbMQzrvDWqljvZlHkXU+CnseMhkMNqU1sASnCsz3tSzAaH3vCUXb9PHeUb90ZT1BdFTm1xxJw==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-unicode-escapes": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.12.13.tgz", - "integrity": "sha512-0bHEkdwJ/sN/ikBHfSmOXPypN/beiGqjo+o4/5K+vxEFNPRPdImhviPakMKG4x96l85emoa0Z6cDflsdBusZbw==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-escapes/-/plugin-transform-unicode-escapes-7.14.5.tgz", + "integrity": "sha512-crTo4jATEOjxj7bt9lbYXcBAM3LZaUrbP2uUdxb6WIorLmjNKSpHfIybgY4B8SRpbf8tEVIWH3Vtm7ayCrKocA==", "dev": true, "requires": { - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/plugin-transform-unicode-regex": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.12.13.tgz", - "integrity": "sha512-mDRzSNY7/zopwisPZ5kM9XKCfhchqIYwAKRERtEnhYscZB79VRekuRSoYbN0+KVe3y8+q1h6A4svXtP7N+UoCA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/plugin-transform-unicode-regex/-/plugin-transform-unicode-regex-7.14.5.tgz", + "integrity": "sha512-UygduJpC5kHeCiRw/xDVzC+wj8VaYSoKl5JNVmbP7MadpNinAm3SvZCxZ42H37KZBKztz46YC73i9yV34d0Tzw==", "dev": true, "requires": { - "@babel/helper-create-regexp-features-plugin": "^7.12.13", - "@babel/helper-plugin-utils": "^7.12.13" + "@babel/helper-create-regexp-features-plugin": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5" } }, "@babel/preset-env": { - "version": "7.13.15", - "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.13.15.tgz", - "integrity": "sha512-D4JAPMXcxk69PKe81jRJ21/fP/uYdcTZ3hJDF5QX2HSI9bBxxYw/dumdR6dGumhjxlprHPE4XWoPaqzZUVy2MA==", - "dev": true, - "requires": { - "@babel/compat-data": "^7.13.15", - "@babel/helper-compilation-targets": "^7.13.13", - "@babel/helper-plugin-utils": "^7.13.0", - "@babel/helper-validator-option": "^7.12.17", - "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.13.12", - "@babel/plugin-proposal-async-generator-functions": "^7.13.15", - "@babel/plugin-proposal-class-properties": "^7.13.0", - "@babel/plugin-proposal-dynamic-import": "^7.13.8", - "@babel/plugin-proposal-export-namespace-from": "^7.12.13", - "@babel/plugin-proposal-json-strings": "^7.13.8", - "@babel/plugin-proposal-logical-assignment-operators": "^7.13.8", - "@babel/plugin-proposal-nullish-coalescing-operator": "^7.13.8", - "@babel/plugin-proposal-numeric-separator": "^7.12.13", - "@babel/plugin-proposal-object-rest-spread": "^7.13.8", - "@babel/plugin-proposal-optional-catch-binding": "^7.13.8", - "@babel/plugin-proposal-optional-chaining": "^7.13.12", - "@babel/plugin-proposal-private-methods": "^7.13.0", - "@babel/plugin-proposal-unicode-property-regex": "^7.12.13", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/preset-env/-/preset-env-7.14.5.tgz", + "integrity": "sha512-ci6TsS0bjrdPpWGnQ+m4f+JSSzDKlckqKIJJt9UZ/+g7Zz9k0N8lYU8IeLg/01o2h8LyNZDMLGgRLDTxpudLsA==", + "dev": true, + "requires": { + "@babel/compat-data": "^7.14.5", + "@babel/helper-compilation-targets": "^7.14.5", + "@babel/helper-plugin-utils": "^7.14.5", + "@babel/helper-validator-option": "^7.14.5", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.14.5", + "@babel/plugin-proposal-async-generator-functions": "^7.14.5", + "@babel/plugin-proposal-class-properties": "^7.14.5", + "@babel/plugin-proposal-class-static-block": "^7.14.5", + "@babel/plugin-proposal-dynamic-import": "^7.14.5", + "@babel/plugin-proposal-export-namespace-from": "^7.14.5", + "@babel/plugin-proposal-json-strings": "^7.14.5", + "@babel/plugin-proposal-logical-assignment-operators": "^7.14.5", + "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.5", + "@babel/plugin-proposal-numeric-separator": "^7.14.5", + "@babel/plugin-proposal-object-rest-spread": "^7.14.5", + "@babel/plugin-proposal-optional-catch-binding": "^7.14.5", + "@babel/plugin-proposal-optional-chaining": "^7.14.5", + "@babel/plugin-proposal-private-methods": "^7.14.5", + "@babel/plugin-proposal-private-property-in-object": "^7.14.5", + "@babel/plugin-proposal-unicode-property-regex": "^7.14.5", "@babel/plugin-syntax-async-generators": "^7.8.4", "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", "@babel/plugin-syntax-dynamic-import": "^7.8.3", "@babel/plugin-syntax-export-namespace-from": "^7.8.3", "@babel/plugin-syntax-json-strings": "^7.8.3", @@ -5504,45 +5837,46 @@ "@babel/plugin-syntax-object-rest-spread": "^7.8.3", "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", "@babel/plugin-syntax-optional-chaining": "^7.8.3", - "@babel/plugin-syntax-top-level-await": "^7.12.13", - "@babel/plugin-transform-arrow-functions": "^7.13.0", - "@babel/plugin-transform-async-to-generator": "^7.13.0", - "@babel/plugin-transform-block-scoped-functions": "^7.12.13", - "@babel/plugin-transform-block-scoping": "^7.12.13", - "@babel/plugin-transform-classes": "^7.13.0", - "@babel/plugin-transform-computed-properties": "^7.13.0", - "@babel/plugin-transform-destructuring": "^7.13.0", - "@babel/plugin-transform-dotall-regex": "^7.12.13", - "@babel/plugin-transform-duplicate-keys": "^7.12.13", - "@babel/plugin-transform-exponentiation-operator": "^7.12.13", - "@babel/plugin-transform-for-of": "^7.13.0", - "@babel/plugin-transform-function-name": "^7.12.13", - "@babel/plugin-transform-literals": "^7.12.13", - "@babel/plugin-transform-member-expression-literals": "^7.12.13", - "@babel/plugin-transform-modules-amd": "^7.13.0", - "@babel/plugin-transform-modules-commonjs": "^7.13.8", - "@babel/plugin-transform-modules-systemjs": "^7.13.8", - "@babel/plugin-transform-modules-umd": "^7.13.0", - "@babel/plugin-transform-named-capturing-groups-regex": "^7.12.13", - "@babel/plugin-transform-new-target": "^7.12.13", - "@babel/plugin-transform-object-super": "^7.12.13", - "@babel/plugin-transform-parameters": "^7.13.0", - "@babel/plugin-transform-property-literals": "^7.12.13", - "@babel/plugin-transform-regenerator": "^7.13.15", - "@babel/plugin-transform-reserved-words": "^7.12.13", - "@babel/plugin-transform-shorthand-properties": "^7.12.13", - "@babel/plugin-transform-spread": "^7.13.0", - "@babel/plugin-transform-sticky-regex": "^7.12.13", - "@babel/plugin-transform-template-literals": "^7.13.0", - "@babel/plugin-transform-typeof-symbol": "^7.12.13", - "@babel/plugin-transform-unicode-escapes": "^7.12.13", - "@babel/plugin-transform-unicode-regex": "^7.12.13", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5", + "@babel/plugin-transform-arrow-functions": "^7.14.5", + "@babel/plugin-transform-async-to-generator": "^7.14.5", + "@babel/plugin-transform-block-scoped-functions": "^7.14.5", + "@babel/plugin-transform-block-scoping": "^7.14.5", + "@babel/plugin-transform-classes": "^7.14.5", + "@babel/plugin-transform-computed-properties": "^7.14.5", + "@babel/plugin-transform-destructuring": "^7.14.5", + "@babel/plugin-transform-dotall-regex": "^7.14.5", + "@babel/plugin-transform-duplicate-keys": "^7.14.5", + "@babel/plugin-transform-exponentiation-operator": "^7.14.5", + "@babel/plugin-transform-for-of": "^7.14.5", + "@babel/plugin-transform-function-name": "^7.14.5", + "@babel/plugin-transform-literals": "^7.14.5", + "@babel/plugin-transform-member-expression-literals": "^7.14.5", + "@babel/plugin-transform-modules-amd": "^7.14.5", + "@babel/plugin-transform-modules-commonjs": "^7.14.5", + "@babel/plugin-transform-modules-systemjs": "^7.14.5", + "@babel/plugin-transform-modules-umd": "^7.14.5", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.14.5", + "@babel/plugin-transform-new-target": "^7.14.5", + "@babel/plugin-transform-object-super": "^7.14.5", + "@babel/plugin-transform-parameters": "^7.14.5", + "@babel/plugin-transform-property-literals": "^7.14.5", + "@babel/plugin-transform-regenerator": "^7.14.5", + "@babel/plugin-transform-reserved-words": "^7.14.5", + "@babel/plugin-transform-shorthand-properties": "^7.14.5", + "@babel/plugin-transform-spread": "^7.14.5", + "@babel/plugin-transform-sticky-regex": "^7.14.5", + "@babel/plugin-transform-template-literals": "^7.14.5", + "@babel/plugin-transform-typeof-symbol": "^7.14.5", + "@babel/plugin-transform-unicode-escapes": "^7.14.5", + "@babel/plugin-transform-unicode-regex": "^7.14.5", "@babel/preset-modules": "^0.1.4", - "@babel/types": "^7.13.14", - "babel-plugin-polyfill-corejs2": "^0.2.0", - "babel-plugin-polyfill-corejs3": "^0.2.0", - "babel-plugin-polyfill-regenerator": "^0.2.0", - "core-js-compat": "^3.9.0", + "@babel/types": "^7.14.5", + "babel-plugin-polyfill-corejs2": "^0.2.2", + "babel-plugin-polyfill-corejs3": "^0.2.2", + "babel-plugin-polyfill-regenerator": "^0.2.2", + "core-js-compat": "^3.14.0", "semver": "^6.3.0" }, "dependencies": { @@ -5568,48 +5902,49 @@ } }, "@babel/runtime": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.13.17.tgz", - "integrity": "sha512-NCdgJEelPTSh+FEFylhnP1ylq848l1z9t9N0j1Lfbcw0+KXGjsTvUmkxy+voLLXB5SOKMbLLx4jxYliGrYQseA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.14.5.tgz", + "integrity": "sha512-121rumjddw9c3NCQ55KGkyE1h/nzWhU/owjhw0l4mQrkzz4x9SGS1X8gFLraHwX7td3Yo4QTL+qj0NcIzN87BA==", "dev": true, "requires": { "regenerator-runtime": "^0.13.4" } }, "@babel/template": { - "version": "7.12.13", - "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.12.13.tgz", - "integrity": "sha512-/7xxiGA57xMo/P2GVvdEumr8ONhFOhfgq2ihK3h1e6THqzTAkHbkXgB0xI9yeTfIUoH3+oAeHhqm/I43OTbbjA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.14.5.tgz", + "integrity": "sha512-6Z3Po85sfxRGachLULUhOmvAaOo7xCvqGQtxINai2mEGPFm6pQ4z5QInFnUrRpfoSV60BnjyF5F3c+15fxFV1g==", "dev": true, "requires": { - "@babel/code-frame": "^7.12.13", - "@babel/parser": "^7.12.13", - "@babel/types": "^7.12.13" + "@babel/code-frame": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/types": "^7.14.5" } }, "@babel/traverse": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.13.17.tgz", - "integrity": "sha512-BMnZn0R+X6ayqm3C3To7o1j7Q020gWdqdyP50KEoVqaCO2c/Im7sYZSmVgvefp8TTMQ+9CtwuBp0Z1CZ8V3Pvg==", - "dev": true, - "requires": { - "@babel/code-frame": "^7.12.13", - "@babel/generator": "^7.13.16", - "@babel/helper-function-name": "^7.12.13", - "@babel/helper-split-export-declaration": "^7.12.13", - "@babel/parser": "^7.13.16", - "@babel/types": "^7.13.17", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.14.5.tgz", + "integrity": "sha512-G3BiS15vevepdmFqmUc9X+64y0viZYygubAMO8SvBmKARuF6CPSZtH4Ng9vi/lrWlZFGe3FWdXNy835akH8Glg==", + "dev": true, + "requires": { + "@babel/code-frame": "^7.14.5", + "@babel/generator": "^7.14.5", + "@babel/helper-function-name": "^7.14.5", + "@babel/helper-hoist-variables": "^7.14.5", + "@babel/helper-split-export-declaration": "^7.14.5", + "@babel/parser": "^7.14.5", + "@babel/types": "^7.14.5", "debug": "^4.1.0", "globals": "^11.1.0" } }, "@babel/types": { - "version": "7.13.17", - "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.13.17.tgz", - "integrity": "sha512-RawydLgxbOPDlTLJNtoIypwdmAy//uQIzlKt2+iBiJaRlVuI6QLUxVAyWGNfOzp8Yu4L4lLIacoCyTNtpb4wiA==", + "version": "7.14.5", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.14.5.tgz", + "integrity": "sha512-M/NzBpEL95I5Hh4dwhin5JlE7EzO5PHMAuzjxss3tiOBD46KfQvVedN/3jEPZvdRvtsK2222XfdHogNIttFgcg==", "dev": true, "requires": { - "@babel/helper-validator-identifier": "^7.12.11", + "@babel/helper-validator-identifier": "^7.14.5", "to-fast-properties": "^2.0.0" } }, @@ -5652,9 +5987,9 @@ "dev": true }, "@types/node": { - "version": "14.14.6", - "resolved": "https://registry.npmjs.org/@types/node/-/node-14.14.6.tgz", - "integrity": "sha512-6QlRuqsQ/Ox/aJEQWBEJG7A9+u7oSYl3mem/K8IzxXG/kAGbV1YPD9Bg9Zw3vyxC/YP+zONKwy8hGkSt1jxFMw==", + "version": "15.12.2", + "resolved": "https://registry.npmjs.org/@types/node/-/node-15.12.2.tgz", + "integrity": "sha512-zjQ69G564OCIWIOHSXyQEEDpdpGl+G348RAKY0XXy9Z5kU9Vzv1GMNnkar/ZJ8dzXB3COzD9Mo9NtRZ4xfgUww==", "dev": true }, "@webassemblyjs/ast": { @@ -5804,25 +6139,25 @@ } }, "@webpack-cli/configtest": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.0.2.tgz", - "integrity": "sha512-3OBzV2fBGZ5TBfdW50cha1lHDVf9vlvRXnjpVbJBa20pSZQaSkMJZiwA8V2vD9ogyeXn8nU5s5A6mHyf5jhMzA==", + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/@webpack-cli/configtest/-/configtest-1.0.4.tgz", + "integrity": "sha512-cs3XLy+UcxiP6bj0A6u7MLLuwdXJ1c3Dtc0RkKg+wiI1g/Ti1om8+/2hc2A2B60NbBNAbMgyBMHvyymWm/j4wQ==", "dev": true, "requires": {} }, "@webpack-cli/info": { - "version": "1.2.3", - "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.2.3.tgz", - "integrity": "sha512-lLek3/T7u40lTqzCGpC6CAbY6+vXhdhmwFRxZLMnRm6/sIF/7qMpT8MocXCRQfz0JAh63wpbXLMnsQ5162WS7Q==", + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@webpack-cli/info/-/info-1.3.0.tgz", + "integrity": "sha512-ASiVB3t9LOKHs5DyVUcxpraBXDOKubYu/ihHhU+t1UPpxsivg6Od2E2qU4gJCekfEddzRBzHhzA/Acyw/mlK/w==", "dev": true, "requires": { "envinfo": "^7.7.3" } }, "@webpack-cli/serve": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.3.1.tgz", - "integrity": "sha512-0qXvpeYO6vaNoRBI52/UsbcaBydJCggoBBnIo/ovQQdn6fug0BgwsjorV1hVS7fMqGVTZGcVxv8334gjmbj5hw==", + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.5.1.tgz", + "integrity": "sha512-4vSVUiOPJLmr45S8rMGy7WDvpWxfFxfP/Qx/cxZFCfvoypTYpPPL1X8VIZMe0WTA+Jr7blUxwUSEZNkjoMTgSw==", "dev": true, "requires": {} }, @@ -5839,9 +6174,9 @@ "dev": true }, "acorn": { - "version": "8.0.4", - "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.0.4.tgz", - "integrity": "sha512-XNP0PqF1XD19ZlLKvB7cMmnZswW4C/03pRHgirB30uSJTaS3A3V1/P4sS3HPvFmjoriPCJQs+JDSbm4bL1TxGQ==", + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.3.0.tgz", + "integrity": "sha512-tqPKHZ5CaBJw0Xmy0ZZvLs1qTV+BNFSyvn77ASXkpBNfIRk8ev26fKrD9iLGwGA9zedPao52GSHzq8lyZG0NUw==", "dev": true }, "ajv": { @@ -5862,12 +6197,6 @@ "integrity": "sha512-RO1ibKvd27e6FEShVFfPALuHI3WjSVNeK5FIsmme/LYRNxjKuNj+Dt7bucLa6NdSv3JcVTyMlm9kGR84z1XpaQ==", "dev": true }, - "ansi-colors": { - "version": "4.1.1", - "resolved": "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.1.tgz", - "integrity": "sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==", - "dev": true - }, "ansi-regex": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.0.tgz", @@ -5954,13 +6283,13 @@ } }, "babel-plugin-polyfill-corejs2": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.2.0.tgz", - "integrity": "sha512-9bNwiR0dS881c5SHnzCmmGlMkJLl0OUZvxrxHo9w/iNoRuqaPjqlvBf4HrovXtQs/au5yKkpcdgfT1cC5PAZwg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs2/-/babel-plugin-polyfill-corejs2-0.2.2.tgz", + "integrity": "sha512-kISrENsJ0z5dNPq5eRvcctITNHYXWOA4DUZRFYCz3jYCcvTb/A546LIddmoGNMVYg2U38OyFeNosQwI9ENTqIQ==", "dev": true, "requires": { "@babel/compat-data": "^7.13.11", - "@babel/helper-define-polyfill-provider": "^0.2.0", + "@babel/helper-define-polyfill-provider": "^0.2.2", "semver": "^6.1.1" }, "dependencies": { @@ -5973,22 +6302,22 @@ } }, "babel-plugin-polyfill-corejs3": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.2.0.tgz", - "integrity": "sha512-zZyi7p3BCUyzNxLx8KV61zTINkkV65zVkDAFNZmrTCRVhjo1jAS+YLvDJ9Jgd/w2tsAviCwFHReYfxO3Iql8Yg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-corejs3/-/babel-plugin-polyfill-corejs3-0.2.2.tgz", + "integrity": "sha512-l1Cf8PKk12eEk5QP/NQ6TH8A1pee6wWDJ96WjxrMXFLHLOBFzYM4moG80HFgduVhTqAFez4alnZKEhP/bYHg0A==", "dev": true, "requires": { - "@babel/helper-define-polyfill-provider": "^0.2.0", + "@babel/helper-define-polyfill-provider": "^0.2.2", "core-js-compat": "^3.9.1" } }, "babel-plugin-polyfill-regenerator": { - "version": "0.2.0", - "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.2.0.tgz", - "integrity": "sha512-J7vKbCuD2Xi/eEHxquHN14bXAW9CXtecwuLrOIDJtcZzTaPzV1VdEfoUf9AzcRBMolKUQKM9/GVojeh0hFiqMg==", + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/babel-plugin-polyfill-regenerator/-/babel-plugin-polyfill-regenerator-0.2.2.tgz", + "integrity": "sha512-Goy5ghsc21HgPDFtzRkSirpZVW35meGoTmTOb2bxqdl60ghub4xOidgNTHaZfQ2FaxQsKmwvXtOAkcIS4SMBWg==", "dev": true, "requires": { - "@babel/helper-define-polyfill-provider": "^0.2.0" + "@babel/helper-define-polyfill-provider": "^0.2.2" } }, "balanced-match": { @@ -6014,14 +6343,14 @@ } }, "browserslist": { - "version": "4.16.5", - "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.5.tgz", - "integrity": "sha512-C2HAjrM1AI/djrpAUU/tr4pml1DqLIzJKSLDBXBrNErl9ZCCTXdhwxdJjYc16953+mBWf7Lw+uUJgpgb8cN71A==", + "version": "4.16.6", + "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.16.6.tgz", + "integrity": "sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==", "dev": true, "requires": { - "caniuse-lite": "^1.0.30001214", + "caniuse-lite": "^1.0.30001219", "colorette": "^1.2.2", - "electron-to-chromium": "^1.3.719", + "electron-to-chromium": "^1.3.723", "escalade": "^3.1.1", "node-releases": "^1.1.71" } @@ -6049,9 +6378,9 @@ } }, "caniuse-lite": { - "version": "1.0.30001214", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001214.tgz", - "integrity": "sha512-O2/SCpuaU3eASWVaesQirZv1MSjUNOvmugaD8zNSJqw6Vv5SGwoOpA9LJs3pNPfM745nxqPvfZY3MQKY4AKHYg==", + "version": "1.0.30001236", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001236.tgz", + "integrity": "sha512-o0PRQSrSCGJKCPZcgMzl5fUaj5xHe8qA2m4QRvnyY4e1lITqoNkr7q/Oh1NcpGSy0Th97UZ35yoKcINPoq7YOQ==", "dev": true }, "chalk": { @@ -6167,12 +6496,12 @@ } }, "core-js-compat": { - "version": "3.11.0", - "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.11.0.tgz", - "integrity": "sha512-3wsN9YZJohOSDCjVB0GequOyHax8zFiogSX3XWLE28M1Ew7dTU57tgHjIylSBKSIouwmLBp3g61sKMz/q3xEGA==", + "version": "3.14.0", + "resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.14.0.tgz", + "integrity": "sha512-R4NS2eupxtiJU+VwgkF9WTpnSfZW4pogwKHd8bclWU2sp93Pr5S1uYJI84cMOubJRou7bcfL0vmwtLslWN5p3A==", "dev": true, "requires": { - "browserslist": "^4.16.4", + "browserslist": "^4.16.6", "semver": "7.0.0" }, "dependencies": { @@ -6272,9 +6601,9 @@ } }, "electron-to-chromium": { - "version": "1.3.719", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.719.tgz", - "integrity": "sha512-heM78GKSqrIzO9Oz0/y22nTBN7bqSP1Pla2SyU9DiSnQD+Ea9SyyN5RWWlgqsqeBLNDkSlE9J9EHFmdMPzxB/g==", + "version": "1.3.752", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.3.752.tgz", + "integrity": "sha512-2Tg+7jSl3oPxgsBsWKh5H83QazTkmWG/cnNwJplmyZc7KcN61+I10oUgaXSVk/NwfvN3BdkKDR4FYuRBQQ2v0A==", "dev": true }, "emoji-regex": { @@ -6299,15 +6628,6 @@ "tapable": "^2.2.0" } }, - "enquirer": { - "version": "2.3.6", - "resolved": "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz", - "integrity": "sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==", - "dev": true, - "requires": { - "ansi-colors": "^4.1.1" - } - }, "envinfo": { "version": "7.8.1", "resolved": "https://registry.npmjs.org/envinfo/-/envinfo-7.8.1.tgz", @@ -6815,14 +7135,14 @@ "dev": true }, "jest-worker": { - "version": "26.6.2", - "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-26.6.2.tgz", - "integrity": "sha512-KWYVV1c4i+jbMpaBC+U++4Va0cp8OisU185o73T1vo99hqi7w8tSJfUXYswwqqrjzwxa6KpRK54WhPvwf5w6PQ==", + "version": "27.0.2", + "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.0.2.tgz", + "integrity": "sha512-EoBdilOTTyOgmHXtw/cPc+ZrCA0KJMrkXzkrPGNwLmnvvlN1nj7MPrxpT7m+otSv2e1TLaVffzDnE/LB14zJMg==", "dev": true, "requires": { "@types/node": "*", "merge-stream": "^2.0.0", - "supports-color": "^7.0.0" + "supports-color": "^8.0.0" }, "dependencies": { "has-flag": { @@ -6832,9 +7152,9 @@ "dev": true }, "supports-color": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", "dev": true, "requires": { "has-flag": "^4.0.0" @@ -7600,9 +7920,9 @@ } }, "terser": { - "version": "5.6.1", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.6.1.tgz", - "integrity": "sha512-yv9YLFQQ+3ZqgWCUk+pvNJwgUTdlIxUk1WTN+RnaFJe2L7ipG2csPT0ra2XRm7Cs8cxN7QXmK1rFzEwYEQkzXw==", + "version": "5.7.0", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.7.0.tgz", + "integrity": "sha512-HP5/9hp2UaZt5fYkuhNBR8YyRcT8juw8+uFbAme53iN9hblvKnLUTKkmwJG6ocWpIKf8UK4DoeWG4ty0J6S6/g==", "dev": true, "requires": { "commander": "^2.20.0", @@ -7625,17 +7945,17 @@ } }, "terser-webpack-plugin": { - "version": "5.1.1", - "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.1.1.tgz", - "integrity": "sha512-5XNNXZiR8YO6X6KhSGXfY0QrGrCRlSwAEjIIrlRQR4W8nP69TaJUlh3bkuac6zzgspiGPfKEHcY295MMVExl5Q==", + "version": "5.1.3", + "resolved": "https://registry.npmjs.org/terser-webpack-plugin/-/terser-webpack-plugin-5.1.3.tgz", + "integrity": "sha512-cxGbMqr6+A2hrIB5ehFIF+F/iST5ZOxvOmy9zih9ySbP1C2oEWQSOUS+2SNBTjzx5xLKO4xnod9eywdfq1Nb9A==", "dev": true, "requires": { - "jest-worker": "^26.6.2", + "jest-worker": "^27.0.2", "p-limit": "^3.1.0", "schema-utils": "^3.0.0", "serialize-javascript": "^5.0.1", "source-map": "^0.6.1", - "terser": "^5.5.1" + "terser": "^5.7.0" }, "dependencies": { "p-limit": { @@ -7933,9 +8253,9 @@ "dev": true }, "watchpack": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.0.1.tgz", - "integrity": "sha512-vO8AKGX22ZRo6PiOFM9dC0re8IcKh8Kd/aH2zeqUc6w4/jBGlTy2P7fTC6ekT0NjVeGjgU2dGC5rNstKkeLEQg==", + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.2.0.tgz", + "integrity": "sha512-up4YAn/XHgZHIxFBVCdlMiWDj6WaLKpwVeGQk2I5thdYxF/KmF0aaz6TfJZ/hfl1h/XlcDr7k1KH7ThDagpFaA==", "dev": true, "requires": { "glob-to-regexp": "^0.4.1", @@ -7943,9 +8263,9 @@ } }, "webpack": { - "version": "5.35.0", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.35.0.tgz", - "integrity": "sha512-au3gu55yYF/h6NXFr0KZPZAYxS6Nlc595BzYPke8n0CSff5WXcoixtjh5LC/8mXunkRKxhymhXmBY0+kEbR6jg==", + "version": "5.38.1", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.38.1.tgz", + "integrity": "sha512-OqRmYD1OJbHZph6RUMD93GcCZy4Z4wC0ele4FXyYF0J6AxO1vOSuIlU1hkS/lDlR9CDYBz64MZRmdbdnFFoT2g==", "dev": true, "requires": { "@types/eslint-scope": "^3.7.0", @@ -7953,12 +8273,12 @@ "@webassemblyjs/ast": "1.11.0", "@webassemblyjs/wasm-edit": "1.11.0", "@webassemblyjs/wasm-parser": "1.11.0", - "acorn": "^8.0.4", + "acorn": "^8.2.1", "browserslist": "^4.14.5", "chrome-trace-event": "^1.0.2", "enhanced-resolve": "^5.8.0", "es-module-lexer": "^0.4.0", - "eslint-scope": "^5.1.1", + "eslint-scope": "5.1.1", "events": "^3.2.0", "glob-to-regexp": "^0.4.1", "graceful-fs": "^4.2.4", @@ -7969,23 +8289,22 @@ "schema-utils": "^3.0.0", "tapable": "^2.1.1", "terser-webpack-plugin": "^5.1.1", - "watchpack": "^2.0.0", - "webpack-sources": "^2.1.1" + "watchpack": "^2.2.0", + "webpack-sources": "^2.3.0" } }, "webpack-cli": { - "version": "4.6.0", - "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.6.0.tgz", - "integrity": "sha512-9YV+qTcGMjQFiY7Nb1kmnupvb1x40lfpj8pwdO/bom+sQiP4OBMKjHq29YQrlDWDPZO9r/qWaRRywKaRDKqBTA==", + "version": "4.7.2", + "resolved": "https://registry.npmjs.org/webpack-cli/-/webpack-cli-4.7.2.tgz", + "integrity": "sha512-mEoLmnmOIZQNiRl0ebnjzQ74Hk0iKS5SiEEnpq3dRezoyR3yPaeQZCMCe+db4524pj1Pd5ghZXjT41KLzIhSLw==", "dev": true, "requires": { "@discoveryjs/json-ext": "^0.5.0", - "@webpack-cli/configtest": "^1.0.2", - "@webpack-cli/info": "^1.2.3", - "@webpack-cli/serve": "^1.3.1", + "@webpack-cli/configtest": "^1.0.4", + "@webpack-cli/info": "^1.3.0", + "@webpack-cli/serve": "^1.5.1", "colorette": "^1.2.1", "commander": "^7.0.0", - "enquirer": "^2.3.6", "execa": "^5.0.0", "fastest-levenshtein": "^1.0.12", "import-local": "^3.0.2", @@ -8006,9 +8325,9 @@ } }, "webpack-sources": { - "version": "2.2.0", - "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.2.0.tgz", - "integrity": "sha512-bQsA24JLwcnWGArOKUxYKhX3Mz/nK1Xf6hxullKERyktjNMC4x8koOeaDNTA2fEJ09BdWLbM/iTW0ithREUP0w==", + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-2.3.0.tgz", + "integrity": "sha512-WyOdtwSvOML1kbgtXbTDnEW0jkJ7hZr/bDByIwszhWd/4XX1A3XMkrbFMsuH4+/MfLlZCUzlAdg4r7jaGKEIgQ==", "dev": true, "requires": { "source-list-map": "^2.0.1", diff --git a/package.json b/package.json index f285e4b5d..009b73f48 100644 --- a/package.json +++ b/package.json @@ -45,21 +45,21 @@ "postmake-mml3-xslt": "rpx rimraf ts/input/mathml/mml3/mml3.xsl" }, "devDependencies": { - "@babel/core": "^7.13.16", - "@babel/preset-env": "^7.13.15", + "@babel/core": "^7.14.5", + "@babel/preset-env": "^7.14.5", "babel-loader": "^8.2.2", "copyfiles": "^2.4.1", "diff": "^5.0.0", "rimraf": "^3.0.2", "tape": "^5.2.2", - "terser-webpack-plugin": "^5.1.1", + "terser-webpack-plugin": "^5.1.3", "tslint": "^6.1.3", "tslint-jsdoc-rules": "^0.2.0", "tslint-unix-formatter": "^0.2.0", "typescript": "^4.2.4", "typescript-tools": "^0.3.1", - "webpack": "^5.35.0", - "webpack-cli": "^4.6.0" + "webpack": "^5.38.1", + "webpack-cli": "^4.7.2" }, "dependencies": { "esm": "^3.2.25", From a627a53510563d4dff5d735b0474cfde6755f290 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 09:15:25 -0400 Subject: [PATCH 129/142] Remove vasting of parent node (not needed, and causes circular reference in SVGmtable in typescript 4.3 --- ts/output/svg/Wrappers/mtr.ts | 6 ------ 1 file changed, 6 deletions(-) diff --git a/ts/output/svg/Wrappers/mtr.ts b/ts/output/svg/Wrappers/mtr.ts index f8f80714b..dae67c338 100644 --- a/ts/output/svg/Wrappers/mtr.ts +++ b/ts/output/svg/Wrappers/mtr.ts @@ -25,7 +25,6 @@ import {SVGWrapper, SVGConstructor, Constructor} from '../Wrapper.js'; import {CommonMtrMixin} from '../../common/Wrappers/mtr.js'; import {CommonMlabeledtrMixin} from '../../common/Wrappers/mtr.js'; -import {SVGmtable} from './mtable.js'; import {SVGmtd} from './mtd.js'; import {MmlMtr, MmlMlabeledtr} from '../../../core/MmlTree/MmlNodes/mtr.js'; @@ -59,11 +58,6 @@ CommonMtrMixin, SVGConstructor>(SVGWrapper) */ public static kind = MmlMtr.prototype.kind; - /** - * The mtable in which this mtr appears - */ - public parent: SVGmtable; - /** * The height of the row */ From f8bea728ed706f5dfd8b1806c7ef70ebf5c6aaf5 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 09:16:46 -0400 Subject: [PATCH 130/142] Update dependencies --- package-lock.json | 14 +++++++------- package.json | 2 +- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/package-lock.json b/package-lock.json index f975164d9..f4034b67e 100644 --- a/package-lock.json +++ b/package-lock.json @@ -26,7 +26,7 @@ "tslint": "^6.1.3", "tslint-jsdoc-rules": "^0.2.0", "tslint-unix-formatter": "^0.2.0", - "typescript": "^4.2.4", + "typescript": "^4.3.2", "typescript-tools": "^0.3.1", "webpack": "^5.38.1", "webpack-cli": "^4.7.2" @@ -4405,9 +4405,9 @@ } }, "node_modules/typescript": { - "version": "4.2.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz", - "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==", + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.2.tgz", + "integrity": "sha512-zZ4hShnmnoVnAHpVHWpTcxdv7dWP60S2FsydQLV8V5PbS3FifjWFFRiHSWpDJahly88PRyV5teTSLoq4eG7mKw==", "dev": true, "bin": { "tsc": "bin/tsc", @@ -8174,9 +8174,9 @@ } }, "typescript": { - "version": "4.2.4", - "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.2.4.tgz", - "integrity": "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg==", + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.3.2.tgz", + "integrity": "sha512-zZ4hShnmnoVnAHpVHWpTcxdv7dWP60S2FsydQLV8V5PbS3FifjWFFRiHSWpDJahly88PRyV5teTSLoq4eG7mKw==", "dev": true }, "typescript-tools": { diff --git a/package.json b/package.json index 009b73f48..7e4e977af 100644 --- a/package.json +++ b/package.json @@ -56,7 +56,7 @@ "tslint": "^6.1.3", "tslint-jsdoc-rules": "^0.2.0", "tslint-unix-formatter": "^0.2.0", - "typescript": "^4.2.4", + "typescript": "^4.3.2", "typescript-tools": "^0.3.1", "webpack": "^5.38.1", "webpack-cli": "^4.7.2" From 331fea0f86be6b56341aecf5e28bbb8d3b0c4c54 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 10:15:11 -0400 Subject: [PATCH 131/142] Revert change to Em() that caused problems with mu conversion. --- ts/input/tex/ParseUtil.ts | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 8c5b07033..606debdbe 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -31,7 +31,6 @@ import TexParser from './TexParser.js'; import TexError from './TexError.js'; import {entities} from '../../util/Entities.js'; import {MmlMunderover} from '../../core/MmlTree/MmlNodes/munderover.js'; -import {em} from '../../util/lengths.js'; namespace ParseUtil { @@ -107,7 +106,10 @@ namespace ParseUtil { * @return {string} The em dimension string. */ export function Em(m: number): string { - return em(m); + if (Math.abs(m) < .0006) { + return '0em'; + } + return m.toFixed(3).replace(/\.?0+$/, '') + 'em'; } @@ -525,6 +527,13 @@ namespace ParseUtil { parser.stack.global.eqnenv = true; } + /** + * Copy an MmlNode and add it (and its children) to the proper lists. + * + * @param {MmlNode} node The MmlNode to copy + * @param {TexParser} parser The active tex parser + * @return {MmlNode} The duplicate tree + */ export function copyNode(node: MmlNode, parser: TexParser): MmlNode { const tree = node.copy() as MmlNode; const options = parser.configuration; From 5209d6d1afa947cd757f07f78f62b72b14ec7211 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 11:08:08 -0400 Subject: [PATCH 132/142] Use 'overflow: clip visible' for stretchy characters to avoid unwanted clipping in the non-stretching direction. (mathjax/MathJax#2701) --- ts/adaptors/HTMLAdaptor.ts | 8 ++++++-- ts/output/chtml/Wrappers/mo.ts | 6 ++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index 774a2d2e5..c4a20e411 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -69,7 +69,7 @@ export interface MinHTMLElement { className: string; classList: DOMTokenList; style: OptionList; - sheet?: {insertRule: (rule: string) => void}; + sheet?: {insertRule: (rule: string, index?: number) => void}; childNodes: (N | T)[] | NodeList; firstChild: N | T | Node; @@ -518,7 +518,11 @@ AbstractDOMAdaptor implements MinHTMLAdaptor { */ public insertRules(node: N, rules: string[]) { for (const rule of rules.reverse()) { - node.sheet.insertRule(rule); + try { + node.sheet.insertRule(rule, 0); + } catch (e) { + console.warn(`MathJax: can't insert css rule '${rule}': ${e.message}`); + } } } diff --git a/ts/output/chtml/Wrappers/mo.ts b/ts/output/chtml/Wrappers/mo.ts index d8c80ae22..99e9b5f49 100644 --- a/ts/output/chtml/Wrappers/mo.ts +++ b/ts/output/chtml/Wrappers/mo.ts @@ -65,7 +65,8 @@ CommonMoMixin>(CHTMLWrapper) { width: 'initial' }, 'mjx-stretchy-h > mjx-ext': { - overflow: 'hidden', + '/* IE */ overflow': 'hidden', + '/* others */ overflow': 'clip visible', width: '100%' }, 'mjx-stretchy-h > mjx-ext > mjx-c::before': { @@ -103,7 +104,8 @@ CommonMoMixin>(CHTMLWrapper) { height: '100%', 'box-sizing': 'border-box', border: '0px solid transparent', - overflow: 'hidden' + '/* IE */ overflow': 'hidden', + '/* others */ overflow': 'visible clip', }, 'mjx-stretchy-v > mjx-ext > mjx-c::before': { width: 'initial', From b179a3e9372d06822baa53cf4cd55e5ad5d697b7 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 14:31:34 -0400 Subject: [PATCH 133/142] Use try/catch around the loop for efficiency. --- ts/adaptors/HTMLAdaptor.ts | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index c4a20e411..f911c66db 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -517,12 +517,13 @@ AbstractDOMAdaptor implements MinHTMLAdaptor { * @override */ public insertRules(node: N, rules: string[]) { - for (const rule of rules.reverse()) { - try { + let rule; + try { + for (rule of rules.reverse()) { node.sheet.insertRule(rule, 0); - } catch (e) { - console.warn(`MathJax: can't insert css rule '${rule}': ${e.message}`); } + } catch (e) { + console.warn(`MathJax: can't insert css rule '${rule}': ${e.message}`); } } From 4d36dadba53b87e00925370781f329f763921aac Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Fri, 11 Jun 2021 14:36:10 -0400 Subject: [PATCH 134/142] Put back original handlign or failed rules, so that we process any remaining rules (oops). --- ts/adaptors/HTMLAdaptor.ts | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index f911c66db..c4a20e411 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -517,13 +517,12 @@ AbstractDOMAdaptor implements MinHTMLAdaptor { * @override */ public insertRules(node: N, rules: string[]) { - let rule; - try { - for (rule of rules.reverse()) { + for (const rule of rules.reverse()) { + try { node.sheet.insertRule(rule, 0); + } catch (e) { + console.warn(`MathJax: can't insert css rule '${rule}': ${e.message}`); } - } catch (e) { - console.warn(`MathJax: can't insert css rule '${rule}': ${e.message}`); } } From f680979ebfffd1a5dda7b49f5fa3b47b980e20a0 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 14 Jun 2021 11:10:07 -0400 Subject: [PATCH 135/142] Fix typo in comment --- ts/mathjax.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/mathjax.ts b/ts/mathjax.ts index 307b59768..11b5e305a 100644 --- a/ts/mathjax.ts +++ b/ts/mathjax.ts @@ -45,7 +45,7 @@ export const mathjax = { * Creates a MathDocument using a registered handler that knows how to handl it * * @param {any} document The document to handle - * @param {OptionLis} options The options to use for the document (e.g., input and output jax) + * @param {OptionList} options The options to use for the document (e.g., input and output jax) * @return {MathDocument} The MathDocument to handle the document */ document: function (document: any, options: OptionList): MathDocument { From 7c43778bf52fc7dab02965d0dd60fc505612cb64 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Mon, 14 Jun 2021 11:10:54 -0400 Subject: [PATCH 136/142] Make mml3 extension only add to MathML prefilters once. --- ts/input/mathml/mml3/mml3.ts | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/ts/input/mathml/mml3/mml3.ts b/ts/input/mathml/mml3/mml3.ts index c0ed2009b..cd74d4856 100644 --- a/ts/input/mathml/mml3/mml3.ts +++ b/ts/input/mathml/mml3/mml3.ts @@ -104,8 +104,11 @@ export function Mml3Handler(handler: Handler): Handler Date: Tue, 15 Jun 2021 09:02:46 -0400 Subject: [PATCH 137/142] Fix setting of movablelimits to false for \overset, \unserset, \overunderset, and ParseUtil.underOver(). (mathjax/MathJax#2709) --- ts/input/tex/ParseUtil.ts | 18 +++++++++++++----- ts/input/tex/base/BaseMethods.ts | 13 +++---------- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 606debdbe..3a8486b66 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -374,11 +374,7 @@ namespace ParseUtil { */ export function underOver(parser: TexParser, base: MmlNode, script: MmlNode, pos: string, stack: boolean): MmlNode { // @test Overline - const symbol = NodeUtil.getForm(base); - if ((symbol && symbol[3] && symbol[3]['movablelimits']) || NodeUtil.getProperty(base, 'movablelimits')) { - // @test Overline Sum - NodeUtil.setProperties(base, {'movablelimits': false}); - } + ParseUtil.checkMovableLimits(base); if (NodeUtil.isType(base, 'munderover') && NodeUtil.isEmbellished(base)) { // @test Overline Limits NodeUtil.setProperties(NodeUtil.getCoreMO(base), {lspace: 0, rspace: 0}); @@ -397,6 +393,18 @@ namespace ParseUtil { return node; } + /** + * Set movablelimits to false if necessary. + * @param {MmlNode} base The base node being tested. + */ + export function checkMovableLimits(base: MmlNode) { + const symbol = (NodeUtil.isType(base, 'mo') ? NodeUtil.getForm(base) : null); + if (NodeUtil.getProperty(base, 'movablelimits') || (symbol && symbol[3] && symbol[3].movablelimits)) { + // @test Overline Sum + NodeUtil.setProperties(base, {movablelimits: false}); + } + } + /** * Trim spaces from a string. * @param {string} text The string to clean. diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 8a63a64a7..0bf2e6397 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -625,9 +625,7 @@ BaseMethods.Overset = function(parser: TexParser, name: string) { // @test Overset const top = parser.ParseArg(name); const base = parser.ParseArg(name); - if (NodeUtil.getAttribute(base, 'movablelimits') || NodeUtil.getProperty(base, 'movablelimits')) { - NodeUtil.setProperties(base, {'movablelimits': false}); - } + ParseUtil.checkMovableLimits(base); const node = parser.create('node', 'mover', [base, top]); parser.Push(node); }; @@ -642,10 +640,7 @@ BaseMethods.Underset = function(parser: TexParser, name: string) { // @test Underset const bot = parser.ParseArg(name); const base = parser.ParseArg(name); - if (NodeUtil.isType(base, 'mo') || NodeUtil.getProperty(base, 'movablelimits')) { - // @test Overline Sum - NodeUtil.setProperties(base, {'movablelimits': false}); - } + ParseUtil.checkMovableLimits(base); const node = parser.create('node', 'munder', [base, bot]); parser.Push(node); }; @@ -660,9 +655,7 @@ BaseMethods.Overunderset = function(parser: TexParser, name: string) { const top = parser.ParseArg(name); const bot = parser.ParseArg(name); const base = parser.ParseArg(name); - if (NodeUtil.isType(base, 'mo') || NodeUtil.getProperty(base, 'movablelimits')) { - NodeUtil.setProperties(base, {'movablelimits': false}); - } + ParseUtil.checkMovableLimits(base); const node = parser.create('node', 'munderover', [base, bot, top]); parser.Push(node); }; From 124ab5f26276c79bf20d1967d564e1b92fb05fac Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 15 Jun 2021 15:23:21 -0400 Subject: [PATCH 138/142] Split Latin-1 Supplement into two ranges (mo and mi). --- ts/core/MmlTree/OperatorDictionary.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ts/core/MmlTree/OperatorDictionary.ts b/ts/core/MmlTree/OperatorDictionary.ts index a4474fc2b..76ca17a32 100644 --- a/ts/core/MmlTree/OperatorDictionary.ts +++ b/ts/core/MmlTree/OperatorDictionary.ts @@ -81,7 +81,8 @@ export const MO = { */ export const RANGES: RangeDef[] = [ [0x0020, 0x007F, TEXCLASS.REL, 'mo'], // Basic Latin - [0x00A0, 0x024F, TEXCLASS.ORD, 'mi'], // Latin-1 Supplement, Latin Extended-A, Latin Extended-B + [0x00A0, 0x00BF, TEXCLASS.ORD, 'mo'], // Latin-1 Supplement symbols + [0x00C0, 0x024F, TEXCLASS.ORD, 'mi'], // Latin-1 Supplement, Latin Extended-A, Latin Extended-B [0x02B0, 0x036F, TEXCLASS.ORD, 'mo'], // Spacing modifier letters, Combining Diacritical Marks [0x0370, 0x1A20, TEXCLASS.ORD, 'mi'], // Greek and Coptic (through) Tai Tham [0x1AB0, 0x1AFF, TEXCLASS.ORD, 'mo'], // Combining Diacritical Marks Extended From 049035e6a846fec3bb7088a4e73d7a9360501628 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Tue, 15 Jun 2021 15:23:49 -0400 Subject: [PATCH 139/142] Avoid empty string in in-lists array. --- ts/input/tex/ParseOptions.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/ts/input/tex/ParseOptions.ts b/ts/input/tex/ParseOptions.ts index 7a49da722..36b92b862 100644 --- a/ts/input/tex/ParseOptions.ts +++ b/ts/input/tex/ParseOptions.ts @@ -179,7 +179,8 @@ export default class ParseOptions { // If the list is not just for its kind, record that it is in this list // so that if it is copied, the copy can also be added to the list. // - let lists = (NodeUtil.getProperty(node, 'in-lists') as string || '').split(',').concat(property).join(','); + const inlists = (NodeUtil.getProperty(node, 'in-lists') as string || ''); + const lists = (inlists ? inlists.split(/,/) : []).concat(property).join(','); NodeUtil.setProperty(node, 'in-lists', lists); } } From 7821c1865806decb79ca5c45da5ee64d47f96dee Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 17 Jun 2021 08:23:47 -0400 Subject: [PATCH 140/142] Add missing property to the pathFilter data. --- ts/components/package.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ts/components/package.ts b/ts/components/package.ts index 9e38777a8..f0b805fd2 100644 --- a/ts/components/package.ts +++ b/ts/components/package.ts @@ -151,7 +151,7 @@ export class Package { * @return {string} The path (file or URL) for this package */ public static resolvePath(name: string, addExtension: boolean = true): string { - const data = {name, addExtension}; + const data = {name, original: name, addExtension}; Loader.pathFilters.execute(data); return data.name; } From 7032879d416da47efebf89f26c12d2dab877e5cd Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 17 Jun 2021 08:32:20 -0400 Subject: [PATCH 141/142] Update copyright dates --- ts/a11y/assistive-mml.ts | 2 +- ts/a11y/complexity.ts | 2 +- ts/a11y/complexity/collapse.ts | 2 +- ts/a11y/complexity/visitor.ts | 2 +- ts/a11y/explorer.ts | 2 +- ts/a11y/explorer/Explorer.ts | 2 +- ts/a11y/explorer/KeyExplorer.ts | 2 +- ts/a11y/explorer/MouseExplorer.ts | 2 +- ts/a11y/explorer/Region.ts | 2 +- ts/a11y/explorer/TreeExplorer.ts | 2 +- ts/a11y/semantic-enrich.ts | 2 +- ts/a11y/sre-node.ts | 2 +- ts/a11y/sre.ts | 2 +- ts/adaptors/HTMLAdaptor.ts | 2 +- ts/adaptors/browserAdaptor.ts | 2 +- ts/adaptors/chooseAdaptor.ts | 2 +- ts/adaptors/jsdomAdaptor.ts | 2 +- ts/adaptors/lite/Document.ts | 2 +- ts/adaptors/lite/Element.ts | 2 +- ts/adaptors/lite/List.ts | 2 +- ts/adaptors/lite/Parser.ts | 2 +- ts/adaptors/lite/Text.ts | 2 +- ts/adaptors/lite/Window.ts | 2 +- ts/adaptors/liteAdaptor.ts | 2 +- ts/components/global.ts | 2 +- ts/components/latest.ts | 2 +- ts/components/loader.ts | 2 +- ts/components/package.ts | 2 +- ts/components/startup.ts | 2 +- ts/core/DOMAdaptor.ts | 2 +- ts/core/FindMath.ts | 2 +- ts/core/Handler.ts | 2 +- ts/core/HandlerList.ts | 2 +- ts/core/InputJax.ts | 2 +- ts/core/MathDocument.ts | 2 +- ts/core/MathItem.ts | 2 +- ts/core/MathList.ts | 2 +- ts/core/MmlTree/Attributes.ts | 2 +- ts/core/MmlTree/JsonMmlVisitor.ts | 2 +- ts/core/MmlTree/LegacyMmlVisitor.ts | 2 +- ts/core/MmlTree/MML.ts | 2 +- ts/core/MmlTree/MathMLVisitor.ts | 2 +- ts/core/MmlTree/MmlFactory.ts | 2 +- ts/core/MmlTree/MmlNode.ts | 2 +- ts/core/MmlTree/MmlNodes/TeXAtom.ts | 2 +- ts/core/MmlTree/MmlNodes/maction.ts | 2 +- ts/core/MmlTree/MmlNodes/maligngroup.ts | 2 +- ts/core/MmlTree/MmlNodes/malignmark.ts | 2 +- ts/core/MmlTree/MmlNodes/math.ts | 2 +- ts/core/MmlTree/MmlNodes/mathchoice.ts | 2 +- ts/core/MmlTree/MmlNodes/menclose.ts | 2 +- ts/core/MmlTree/MmlNodes/merror.ts | 2 +- ts/core/MmlTree/MmlNodes/mfenced.ts | 2 +- ts/core/MmlTree/MmlNodes/mfrac.ts | 2 +- ts/core/MmlTree/MmlNodes/mglyph.ts | 2 +- ts/core/MmlTree/MmlNodes/mi.ts | 2 +- ts/core/MmlTree/MmlNodes/mmultiscripts.ts | 2 +- ts/core/MmlTree/MmlNodes/mn.ts | 2 +- ts/core/MmlTree/MmlNodes/mo.ts | 2 +- ts/core/MmlTree/MmlNodes/mpadded.ts | 2 +- ts/core/MmlTree/MmlNodes/mphantom.ts | 2 +- ts/core/MmlTree/MmlNodes/mroot.ts | 2 +- ts/core/MmlTree/MmlNodes/mrow.ts | 2 +- ts/core/MmlTree/MmlNodes/ms.ts | 2 +- ts/core/MmlTree/MmlNodes/mspace.ts | 2 +- ts/core/MmlTree/MmlNodes/msqrt.ts | 2 +- ts/core/MmlTree/MmlNodes/mstyle.ts | 2 +- ts/core/MmlTree/MmlNodes/msubsup.ts | 2 +- ts/core/MmlTree/MmlNodes/mtable.ts | 2 +- ts/core/MmlTree/MmlNodes/mtd.ts | 2 +- ts/core/MmlTree/MmlNodes/mtext.ts | 2 +- ts/core/MmlTree/MmlNodes/mtr.ts | 2 +- ts/core/MmlTree/MmlNodes/munderover.ts | 2 +- ts/core/MmlTree/MmlNodes/semantics.ts | 2 +- ts/core/MmlTree/MmlVisitor.ts | 2 +- ts/core/MmlTree/OperatorDictionary.ts | 2 +- ts/core/MmlTree/SerializedMmlVisitor.ts | 2 +- ts/core/MmlTree/TestMmlVisitor.ts | 2 +- ts/core/OutputJax.ts | 2 +- ts/core/Tree/Factory.ts | 2 +- ts/core/Tree/Node.ts | 2 +- ts/core/Tree/NodeFactory.ts | 2 +- ts/core/Tree/Visitor.ts | 2 +- ts/core/Tree/Wrapper.ts | 2 +- ts/core/Tree/WrapperFactory.ts | 2 +- ts/handlers/html.ts | 2 +- ts/handlers/html/HTMLDocument.ts | 2 +- ts/handlers/html/HTMLDomStrings.ts | 2 +- ts/handlers/html/HTMLHandler.ts | 2 +- ts/handlers/html/HTMLMathItem.ts | 2 +- ts/handlers/html/HTMLMathList.ts | 2 +- ts/input/asciimath.ts | 2 +- ts/input/asciimath/FindAsciiMath.ts | 2 +- ts/input/mathml.ts | 2 +- ts/input/mathml/FindMathML.ts | 2 +- ts/input/mathml/MathMLCompile.ts | 2 +- ts/input/mathml/mml3/mml3-node.ts | 2 +- ts/input/mathml/mml3/mml3.ts | 2 +- ts/input/tex.ts | 2 +- ts/input/tex/AllPackages.ts | 2 +- ts/input/tex/Configuration.ts | 2 +- ts/input/tex/FilterUtil.ts | 2 +- ts/input/tex/FindTeX.ts | 2 +- ts/input/tex/MapHandler.ts | 2 +- ts/input/tex/NodeFactory.ts | 2 +- ts/input/tex/NodeUtil.ts | 2 +- ts/input/tex/ParseMethods.ts | 2 +- ts/input/tex/ParseOptions.ts | 2 +- ts/input/tex/ParseUtil.ts | 2 +- ts/input/tex/Stack.ts | 2 +- ts/input/tex/StackItem.ts | 2 +- ts/input/tex/StackItemFactory.ts | 2 +- ts/input/tex/Symbol.ts | 2 +- ts/input/tex/SymbolMap.ts | 2 +- ts/input/tex/Tags.ts | 2 +- ts/input/tex/TexConstants.ts | 2 +- ts/input/tex/TexError.ts | 2 +- ts/input/tex/TexParser.ts | 2 +- ts/input/tex/Types.ts | 2 +- ts/input/tex/action/ActionConfiguration.ts | 2 +- ts/input/tex/ams/AmsConfiguration.ts | 2 +- ts/input/tex/ams/AmsItems.ts | 2 +- ts/input/tex/ams/AmsMappings.ts | 2 +- ts/input/tex/ams/AmsMethods.ts | 2 +- ts/input/tex/amscd/AmsCdConfiguration.ts | 2 +- ts/input/tex/amscd/AmsCdMappings.ts | 2 +- ts/input/tex/amscd/AmsCdMethods.ts | 2 +- ts/input/tex/autoload/AutoloadConfiguration.ts | 2 +- ts/input/tex/base/BaseConfiguration.ts | 2 +- ts/input/tex/base/BaseItems.ts | 2 +- ts/input/tex/base/BaseMappings.ts | 2 +- ts/input/tex/base/BaseMethods.ts | 2 +- ts/input/tex/bbox/BboxConfiguration.ts | 2 +- ts/input/tex/boldsymbol/BoldsymbolConfiguration.ts | 2 +- ts/input/tex/braket/BraketConfiguration.ts | 2 +- ts/input/tex/braket/BraketItems.ts | 2 +- ts/input/tex/braket/BraketMappings.ts | 2 +- ts/input/tex/braket/BraketMethods.ts | 2 +- ts/input/tex/bussproofs/BussproofsConfiguration.ts | 2 +- ts/input/tex/bussproofs/BussproofsItems.ts | 2 +- ts/input/tex/bussproofs/BussproofsMappings.ts | 2 +- ts/input/tex/bussproofs/BussproofsMethods.ts | 2 +- ts/input/tex/bussproofs/BussproofsUtil.ts | 2 +- ts/input/tex/cancel/CancelConfiguration.ts | 2 +- ts/input/tex/centernot/CenternotConfiguration.ts | 2 +- ts/input/tex/color/ColorConfiguration.ts | 2 +- ts/input/tex/color/ColorConstants.ts | 2 +- ts/input/tex/color/ColorMethods.ts | 2 +- ts/input/tex/color/ColorUtil.ts | 2 +- ts/input/tex/colortbl/ColortblConfiguration.ts | 2 +- ts/input/tex/colorv2/ColorV2Configuration.ts | 2 +- ts/input/tex/configmacros/ConfigMacrosConfiguration.ts | 2 +- ts/input/tex/empheq/EmpheqConfiguration.ts | 2 +- ts/input/tex/empheq/EmpheqUtil.ts | 2 +- ts/input/tex/enclose/EncloseConfiguration.ts | 2 +- ts/input/tex/extpfeil/ExtpfeilConfiguration.ts | 2 +- ts/input/tex/gensymb/GensymbConfiguration.ts | 2 +- ts/input/tex/html/HtmlConfiguration.ts | 2 +- ts/input/tex/html/HtmlMethods.ts | 2 +- ts/input/tex/mathtools/MathtoolsTags.ts | 2 +- ts/input/tex/mathtools/MathtoolsUtil.ts | 2 +- ts/input/tex/mhchem/MhchemConfiguration.ts | 2 +- ts/input/tex/newcommand/NewcommandConfiguration.ts | 2 +- ts/input/tex/newcommand/NewcommandItems.ts | 2 +- ts/input/tex/newcommand/NewcommandMappings.ts | 2 +- ts/input/tex/newcommand/NewcommandMethods.ts | 2 +- ts/input/tex/newcommand/NewcommandUtil.ts | 2 +- ts/input/tex/noerrors/NoErrorsConfiguration.ts | 2 +- ts/input/tex/noundefined/NoUndefinedConfiguration.ts | 2 +- ts/input/tex/physics/PhysicsConfiguration.ts | 2 +- ts/input/tex/physics/PhysicsItems.ts | 2 +- ts/input/tex/physics/PhysicsMappings.ts | 2 +- ts/input/tex/physics/PhysicsMethods.ts | 2 +- ts/input/tex/require/RequireConfiguration.ts | 2 +- ts/input/tex/setoptions/SetOptionsConfiguration.ts | 2 +- ts/input/tex/tagformat/TagFormatConfiguration.ts | 2 +- ts/input/tex/textcomp/TextcompConfiguration.ts | 2 +- ts/input/tex/textcomp/TextcompMappings.ts | 2 +- ts/input/tex/textmacros/TextMacrosConfiguration.ts | 2 +- ts/input/tex/textmacros/TextMacrosMappings.ts | 2 +- ts/input/tex/textmacros/TextMacrosMethods.ts | 2 +- ts/input/tex/textmacros/TextParser.ts | 2 +- ts/input/tex/unicode/UnicodeConfiguration.ts | 2 +- ts/input/tex/upgreek/UpgreekConfiguration.ts | 2 +- ts/input/tex/verb/VerbConfiguration.ts | 2 +- ts/mathjax.ts | 2 +- ts/output/chtml.ts | 2 +- ts/output/chtml/FontData.ts | 2 +- ts/output/chtml/Notation.ts | 2 +- ts/output/chtml/Usage.ts | 2 +- ts/output/chtml/Wrapper.ts | 2 +- ts/output/chtml/WrapperFactory.ts | 2 +- ts/output/chtml/Wrappers.ts | 2 +- ts/output/chtml/Wrappers/TeXAtom.ts | 2 +- ts/output/chtml/Wrappers/TextNode.ts | 2 +- ts/output/chtml/Wrappers/maction.ts | 2 +- ts/output/chtml/Wrappers/math.ts | 2 +- ts/output/chtml/Wrappers/menclose.ts | 2 +- ts/output/chtml/Wrappers/mfenced.ts | 2 +- ts/output/chtml/Wrappers/mfrac.ts | 2 +- ts/output/chtml/Wrappers/mglyph.ts | 2 +- ts/output/chtml/Wrappers/mi.ts | 2 +- ts/output/chtml/Wrappers/mmultiscripts.ts | 2 +- ts/output/chtml/Wrappers/mn.ts | 2 +- ts/output/chtml/Wrappers/mo.ts | 2 +- ts/output/chtml/Wrappers/mpadded.ts | 2 +- ts/output/chtml/Wrappers/mroot.ts | 2 +- ts/output/chtml/Wrappers/mrow.ts | 2 +- ts/output/chtml/Wrappers/ms.ts | 2 +- ts/output/chtml/Wrappers/mspace.ts | 2 +- ts/output/chtml/Wrappers/msqrt.ts | 2 +- ts/output/chtml/Wrappers/msubsup.ts | 2 +- ts/output/chtml/Wrappers/mtable.ts | 2 +- ts/output/chtml/Wrappers/mtd.ts | 2 +- ts/output/chtml/Wrappers/mtext.ts | 2 +- ts/output/chtml/Wrappers/mtr.ts | 2 +- ts/output/chtml/Wrappers/munderover.ts | 2 +- ts/output/chtml/Wrappers/scriptbase.ts | 2 +- ts/output/chtml/Wrappers/semantics.ts | 2 +- ts/output/chtml/fonts/tex.ts | 2 +- ts/output/chtml/fonts/tex/bold-italic.ts | 2 +- ts/output/chtml/fonts/tex/bold.ts | 2 +- ts/output/chtml/fonts/tex/double-struck.ts | 2 +- ts/output/chtml/fonts/tex/fraktur-bold.ts | 2 +- ts/output/chtml/fonts/tex/fraktur.ts | 2 +- ts/output/chtml/fonts/tex/italic.ts | 2 +- ts/output/chtml/fonts/tex/largeop.ts | 2 +- ts/output/chtml/fonts/tex/monospace.ts | 2 +- ts/output/chtml/fonts/tex/normal.ts | 2 +- ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts | 2 +- ts/output/chtml/fonts/tex/sans-serif-bold.ts | 2 +- ts/output/chtml/fonts/tex/sans-serif-italic.ts | 2 +- ts/output/chtml/fonts/tex/sans-serif.ts | 2 +- ts/output/chtml/fonts/tex/script-bold.ts | 2 +- ts/output/chtml/fonts/tex/script.ts | 2 +- ts/output/chtml/fonts/tex/smallop.ts | 2 +- ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts | 2 +- ts/output/chtml/fonts/tex/tex-calligraphic.ts | 2 +- ts/output/chtml/fonts/tex/tex-mathit.ts | 2 +- ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts | 2 +- ts/output/chtml/fonts/tex/tex-oldstyle.ts | 2 +- ts/output/chtml/fonts/tex/tex-size3.ts | 2 +- ts/output/chtml/fonts/tex/tex-size4.ts | 2 +- ts/output/chtml/fonts/tex/tex-variant.ts | 2 +- ts/output/common/FontData.ts | 2 +- ts/output/common/Notation.ts | 2 +- ts/output/common/OutputJax.ts | 2 +- ts/output/common/Wrapper.ts | 2 +- ts/output/common/WrapperFactory.ts | 2 +- ts/output/common/Wrappers/TeXAtom.ts | 2 +- ts/output/common/Wrappers/TextNode.ts | 2 +- ts/output/common/Wrappers/maction.ts | 2 +- ts/output/common/Wrappers/math.ts | 2 +- ts/output/common/Wrappers/menclose.ts | 2 +- ts/output/common/Wrappers/mfenced.ts | 2 +- ts/output/common/Wrappers/mfrac.ts | 2 +- ts/output/common/Wrappers/mglyph.ts | 2 +- ts/output/common/Wrappers/mi.ts | 2 +- ts/output/common/Wrappers/mmultiscripts.ts | 2 +- ts/output/common/Wrappers/mn.ts | 2 +- ts/output/common/Wrappers/mo.ts | 2 +- ts/output/common/Wrappers/mpadded.ts | 2 +- ts/output/common/Wrappers/mroot.ts | 2 +- ts/output/common/Wrappers/mrow.ts | 2 +- ts/output/common/Wrappers/ms.ts | 2 +- ts/output/common/Wrappers/mspace.ts | 2 +- ts/output/common/Wrappers/msqrt.ts | 2 +- ts/output/common/Wrappers/msubsup.ts | 2 +- ts/output/common/Wrappers/mtable.ts | 2 +- ts/output/common/Wrappers/mtd.ts | 2 +- ts/output/common/Wrappers/mtext.ts | 2 +- ts/output/common/Wrappers/mtr.ts | 2 +- ts/output/common/Wrappers/munderover.ts | 2 +- ts/output/common/Wrappers/scriptbase.ts | 2 +- ts/output/common/Wrappers/semantics.ts | 2 +- ts/output/common/fonts/tex.ts | 2 +- ts/output/common/fonts/tex/bold-italic.ts | 2 +- ts/output/common/fonts/tex/bold.ts | 2 +- ts/output/common/fonts/tex/delimiters.ts | 2 +- ts/output/common/fonts/tex/double-struck.ts | 2 +- ts/output/common/fonts/tex/fraktur-bold.ts | 2 +- ts/output/common/fonts/tex/fraktur.ts | 2 +- ts/output/common/fonts/tex/italic.ts | 2 +- ts/output/common/fonts/tex/largeop.ts | 2 +- ts/output/common/fonts/tex/monospace.ts | 2 +- ts/output/common/fonts/tex/normal.ts | 2 +- ts/output/common/fonts/tex/sans-serif-bold-italic.ts | 2 +- ts/output/common/fonts/tex/sans-serif-bold.ts | 2 +- ts/output/common/fonts/tex/sans-serif-italic.ts | 2 +- ts/output/common/fonts/tex/sans-serif.ts | 2 +- ts/output/common/fonts/tex/script-bold.ts | 2 +- ts/output/common/fonts/tex/script.ts | 2 +- ts/output/common/fonts/tex/smallop.ts | 2 +- ts/output/common/fonts/tex/tex-calligraphic-bold.ts | 2 +- ts/output/common/fonts/tex/tex-calligraphic.ts | 2 +- ts/output/common/fonts/tex/tex-mathit.ts | 2 +- ts/output/common/fonts/tex/tex-oldstyle-bold.ts | 2 +- ts/output/common/fonts/tex/tex-oldstyle.ts | 2 +- ts/output/common/fonts/tex/tex-size3.ts | 2 +- ts/output/common/fonts/tex/tex-size4.ts | 2 +- ts/output/common/fonts/tex/tex-variant.ts | 2 +- ts/output/svg.ts | 2 +- ts/output/svg/FontCache.ts | 2 +- ts/output/svg/FontData.ts | 2 +- ts/output/svg/Notation.ts | 2 +- ts/output/svg/Wrapper.ts | 2 +- ts/output/svg/WrapperFactory.ts | 2 +- ts/output/svg/Wrappers.ts | 2 +- ts/output/svg/Wrappers/TeXAtom.ts | 2 +- ts/output/svg/Wrappers/TextNode.ts | 2 +- ts/output/svg/Wrappers/maction.ts | 2 +- ts/output/svg/Wrappers/math.ts | 2 +- ts/output/svg/Wrappers/menclose.ts | 2 +- ts/output/svg/Wrappers/merror.ts | 2 +- ts/output/svg/Wrappers/mfenced.ts | 2 +- ts/output/svg/Wrappers/mfrac.ts | 2 +- ts/output/svg/Wrappers/mglyph.ts | 2 +- ts/output/svg/Wrappers/mi.ts | 2 +- ts/output/svg/Wrappers/mmultiscripts.ts | 2 +- ts/output/svg/Wrappers/mn.ts | 2 +- ts/output/svg/Wrappers/mo.ts | 2 +- ts/output/svg/Wrappers/mpadded.ts | 2 +- ts/output/svg/Wrappers/mphantom.ts | 2 +- ts/output/svg/Wrappers/mroot.ts | 2 +- ts/output/svg/Wrappers/mrow.ts | 2 +- ts/output/svg/Wrappers/ms.ts | 2 +- ts/output/svg/Wrappers/mspace.ts | 2 +- ts/output/svg/Wrappers/msqrt.ts | 2 +- ts/output/svg/Wrappers/msubsup.ts | 2 +- ts/output/svg/Wrappers/mtable.ts | 2 +- ts/output/svg/Wrappers/mtd.ts | 2 +- ts/output/svg/Wrappers/mtext.ts | 2 +- ts/output/svg/Wrappers/mtr.ts | 2 +- ts/output/svg/Wrappers/munderover.ts | 2 +- ts/output/svg/Wrappers/scriptbase.ts | 2 +- ts/output/svg/Wrappers/semantics.ts | 2 +- ts/output/svg/fonts/tex.ts | 2 +- ts/output/svg/fonts/tex/bold-italic.ts | 2 +- ts/output/svg/fonts/tex/bold.ts | 2 +- ts/output/svg/fonts/tex/double-struck.ts | 2 +- ts/output/svg/fonts/tex/fraktur-bold.ts | 2 +- ts/output/svg/fonts/tex/fraktur.ts | 2 +- ts/output/svg/fonts/tex/italic.ts | 2 +- ts/output/svg/fonts/tex/largeop.ts | 2 +- ts/output/svg/fonts/tex/monospace.ts | 2 +- ts/output/svg/fonts/tex/normal.ts | 2 +- ts/output/svg/fonts/tex/sans-serif-bold-italic.ts | 2 +- ts/output/svg/fonts/tex/sans-serif-bold.ts | 2 +- ts/output/svg/fonts/tex/sans-serif-italic.ts | 2 +- ts/output/svg/fonts/tex/sans-serif.ts | 2 +- ts/output/svg/fonts/tex/script-bold.ts | 2 +- ts/output/svg/fonts/tex/script.ts | 2 +- ts/output/svg/fonts/tex/smallop.ts | 2 +- ts/output/svg/fonts/tex/tex-calligraphic-bold.ts | 2 +- ts/output/svg/fonts/tex/tex-calligraphic.ts | 2 +- ts/output/svg/fonts/tex/tex-mathit.ts | 2 +- ts/output/svg/fonts/tex/tex-oldstyle-bold.ts | 2 +- ts/output/svg/fonts/tex/tex-oldstyle.ts | 2 +- ts/output/svg/fonts/tex/tex-size3.ts | 2 +- ts/output/svg/fonts/tex/tex-size4.ts | 2 +- ts/output/svg/fonts/tex/tex-variant.ts | 2 +- ts/ui/lazy/LazyHandler.ts | 2 +- ts/ui/menu/MJContextMenu.ts | 2 +- ts/ui/menu/Menu.ts | 2 +- ts/ui/menu/MenuHandler.ts | 2 +- ts/ui/menu/MmlVisitor.ts | 2 +- ts/ui/menu/SelectableInfo.ts | 2 +- ts/ui/safe/SafeHandler.ts | 2 +- ts/ui/safe/SafeMethods.ts | 2 +- ts/ui/safe/safe.ts | 2 +- ts/util/AsyncLoad.ts | 2 +- ts/util/BBox.ts | 2 +- ts/util/BitField.ts | 2 +- ts/util/Entities.ts | 2 +- ts/util/FunctionList.ts | 2 +- ts/util/LinkedList.ts | 2 +- ts/util/Options.ts | 2 +- ts/util/PrioritizedList.ts | 2 +- ts/util/Retries.ts | 2 +- ts/util/StyleList.ts | 2 +- ts/util/Styles.ts | 2 +- ts/util/asyncLoad/node.ts | 2 +- ts/util/asyncLoad/system.ts | 2 +- ts/util/entities/a.ts | 2 +- ts/util/entities/all.ts | 2 +- ts/util/entities/b.ts | 2 +- ts/util/entities/c.ts | 2 +- ts/util/entities/d.ts | 2 +- ts/util/entities/e.ts | 2 +- ts/util/entities/f.ts | 2 +- ts/util/entities/fr.ts | 2 +- ts/util/entities/g.ts | 2 +- ts/util/entities/h.ts | 2 +- ts/util/entities/i.ts | 2 +- ts/util/entities/j.ts | 2 +- ts/util/entities/k.ts | 2 +- ts/util/entities/l.ts | 2 +- ts/util/entities/m.ts | 2 +- ts/util/entities/n.ts | 2 +- ts/util/entities/o.ts | 2 +- ts/util/entities/opf.ts | 2 +- ts/util/entities/p.ts | 2 +- ts/util/entities/q.ts | 2 +- ts/util/entities/r.ts | 2 +- ts/util/entities/s.ts | 2 +- ts/util/entities/scr.ts | 2 +- ts/util/entities/t.ts | 2 +- ts/util/entities/u.ts | 2 +- ts/util/entities/v.ts | 2 +- ts/util/entities/w.ts | 2 +- ts/util/entities/x.ts | 2 +- ts/util/entities/y.ts | 2 +- ts/util/entities/z.ts | 2 +- ts/util/lengths.ts | 2 +- ts/util/numeric.ts | 2 +- ts/util/string.ts | 2 +- 416 files changed, 416 insertions(+), 416 deletions(-) diff --git a/ts/a11y/assistive-mml.ts b/ts/a11y/assistive-mml.ts index 0ad95cfd6..9be8a6209 100644 --- a/ts/a11y/assistive-mml.ts +++ b/ts/a11y/assistive-mml.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/complexity.ts b/ts/a11y/complexity.ts index 27f478245..cf2193741 100644 --- a/ts/a11y/complexity.ts +++ b/ts/a11y/complexity.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/complexity/collapse.ts b/ts/a11y/complexity/collapse.ts index 4db982399..2eb30c42b 100644 --- a/ts/a11y/complexity/collapse.ts +++ b/ts/a11y/complexity/collapse.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/complexity/visitor.ts b/ts/a11y/complexity/visitor.ts index 3159b2348..688f29a01 100644 --- a/ts/a11y/complexity/visitor.ts +++ b/ts/a11y/complexity/visitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer.ts b/ts/a11y/explorer.ts index e8fdade32..c36c578e5 100644 --- a/ts/a11y/explorer.ts +++ b/ts/a11y/explorer.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer/Explorer.ts b/ts/a11y/explorer/Explorer.ts index e0a2f92ae..0141765d4 100644 --- a/ts/a11y/explorer/Explorer.ts +++ b/ts/a11y/explorer/Explorer.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2019 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer/KeyExplorer.ts b/ts/a11y/explorer/KeyExplorer.ts index 336ecc045..04364595a 100644 --- a/ts/a11y/explorer/KeyExplorer.ts +++ b/ts/a11y/explorer/KeyExplorer.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2019 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer/MouseExplorer.ts b/ts/a11y/explorer/MouseExplorer.ts index 1764d6b7b..ff980c60a 100644 --- a/ts/a11y/explorer/MouseExplorer.ts +++ b/ts/a11y/explorer/MouseExplorer.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2019 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer/Region.ts b/ts/a11y/explorer/Region.ts index 503911299..fc8865782 100644 --- a/ts/a11y/explorer/Region.ts +++ b/ts/a11y/explorer/Region.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2019 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/explorer/TreeExplorer.ts b/ts/a11y/explorer/TreeExplorer.ts index 3c34b5968..dacea9921 100644 --- a/ts/a11y/explorer/TreeExplorer.ts +++ b/ts/a11y/explorer/TreeExplorer.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2019 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/semantic-enrich.ts b/ts/a11y/semantic-enrich.ts index aa8b4c0a2..d841acbed 100644 --- a/ts/a11y/semantic-enrich.ts +++ b/ts/a11y/semantic-enrich.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/sre-node.ts b/ts/a11y/sre-node.ts index 589b2b188..6630fdf41 100644 --- a/ts/a11y/sre-node.ts +++ b/ts/a11y/sre-node.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/a11y/sre.ts b/ts/a11y/sre.ts index 589e83bc4..1dee990cb 100644 --- a/ts/a11y/sre.ts +++ b/ts/a11y/sre.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/HTMLAdaptor.ts b/ts/adaptors/HTMLAdaptor.ts index c4a20e411..3f577780a 100644 --- a/ts/adaptors/HTMLAdaptor.ts +++ b/ts/adaptors/HTMLAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/browserAdaptor.ts b/ts/adaptors/browserAdaptor.ts index b86a914a9..eb6079995 100644 --- a/ts/adaptors/browserAdaptor.ts +++ b/ts/adaptors/browserAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/chooseAdaptor.ts b/ts/adaptors/chooseAdaptor.ts index 65a366839..3283adfd9 100644 --- a/ts/adaptors/chooseAdaptor.ts +++ b/ts/adaptors/chooseAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/jsdomAdaptor.ts b/ts/adaptors/jsdomAdaptor.ts index d22ca6ca4..ce7253811 100644 --- a/ts/adaptors/jsdomAdaptor.ts +++ b/ts/adaptors/jsdomAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/Document.ts b/ts/adaptors/lite/Document.ts index c0ebe8fe1..4ccf75043 100644 --- a/ts/adaptors/lite/Document.ts +++ b/ts/adaptors/lite/Document.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/Element.ts b/ts/adaptors/lite/Element.ts index 5455f34cf..80ea482c2 100644 --- a/ts/adaptors/lite/Element.ts +++ b/ts/adaptors/lite/Element.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/List.ts b/ts/adaptors/lite/List.ts index c1c9116e7..f0c5bac4b 100644 --- a/ts/adaptors/lite/List.ts +++ b/ts/adaptors/lite/List.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/Parser.ts b/ts/adaptors/lite/Parser.ts index edbc6a8fd..ef6f2d3a1 100644 --- a/ts/adaptors/lite/Parser.ts +++ b/ts/adaptors/lite/Parser.ts @@ -1,7 +1,7 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/Text.ts b/ts/adaptors/lite/Text.ts index 9a442e340..7828a1d81 100644 --- a/ts/adaptors/lite/Text.ts +++ b/ts/adaptors/lite/Text.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/lite/Window.ts b/ts/adaptors/lite/Window.ts index 8c1e550c4..0e3e907b7 100644 --- a/ts/adaptors/lite/Window.ts +++ b/ts/adaptors/lite/Window.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/adaptors/liteAdaptor.ts b/ts/adaptors/liteAdaptor.ts index 558cd4371..7df1cf1bf 100644 --- a/ts/adaptors/liteAdaptor.ts +++ b/ts/adaptors/liteAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/components/global.ts b/ts/components/global.ts index 33e146988..e6fafd8ce 100644 --- a/ts/components/global.ts +++ b/ts/components/global.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/components/latest.ts b/ts/components/latest.ts index 5a7a2b495..684c5c0bd 100644 --- a/ts/components/latest.ts +++ b/ts/components/latest.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/components/loader.ts b/ts/components/loader.ts index 5ad995aee..fa5b2501e 100644 --- a/ts/components/loader.ts +++ b/ts/components/loader.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/components/package.ts b/ts/components/package.ts index f0b805fd2..4446cf6a6 100644 --- a/ts/components/package.ts +++ b/ts/components/package.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/components/startup.ts b/ts/components/startup.ts index cfc23886c..8444a0baa 100644 --- a/ts/components/startup.ts +++ b/ts/components/startup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/DOMAdaptor.ts b/ts/core/DOMAdaptor.ts index 6d6796f3e..97c421dc4 100644 --- a/ts/core/DOMAdaptor.ts +++ b/ts/core/DOMAdaptor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/FindMath.ts b/ts/core/FindMath.ts index 9fb6d7621..e0051ebfe 100644 --- a/ts/core/FindMath.ts +++ b/ts/core/FindMath.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Handler.ts b/ts/core/Handler.ts index f61ce7321..dc3997551 100644 --- a/ts/core/Handler.ts +++ b/ts/core/Handler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/HandlerList.ts b/ts/core/HandlerList.ts index 77ef6e795..325d71742 100644 --- a/ts/core/HandlerList.ts +++ b/ts/core/HandlerList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/InputJax.ts b/ts/core/InputJax.ts index 1a6fd6496..a1832459f 100644 --- a/ts/core/InputJax.ts +++ b/ts/core/InputJax.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MathDocument.ts b/ts/core/MathDocument.ts index 08dc99318..a9dcd03b7 100644 --- a/ts/core/MathDocument.ts +++ b/ts/core/MathDocument.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MathItem.ts b/ts/core/MathItem.ts index 622793538..84daf26fc 100644 --- a/ts/core/MathItem.ts +++ b/ts/core/MathItem.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MathList.ts b/ts/core/MathList.ts index 265449c95..fcb41ef34 100644 --- a/ts/core/MathList.ts +++ b/ts/core/MathList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/Attributes.ts b/ts/core/MmlTree/Attributes.ts index b61687135..7207e7eda 100644 --- a/ts/core/MmlTree/Attributes.ts +++ b/ts/core/MmlTree/Attributes.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/JsonMmlVisitor.ts b/ts/core/MmlTree/JsonMmlVisitor.ts index 6c539b399..4ae729fc5 100644 --- a/ts/core/MmlTree/JsonMmlVisitor.ts +++ b/ts/core/MmlTree/JsonMmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/LegacyMmlVisitor.ts b/ts/core/MmlTree/LegacyMmlVisitor.ts index 6fc781735..660f60aeb 100644 --- a/ts/core/MmlTree/LegacyMmlVisitor.ts +++ b/ts/core/MmlTree/LegacyMmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MML.ts b/ts/core/MmlTree/MML.ts index fb4f040e5..9b9b1ef18 100644 --- a/ts/core/MmlTree/MML.ts +++ b/ts/core/MmlTree/MML.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MathMLVisitor.ts b/ts/core/MmlTree/MathMLVisitor.ts index df34ea26d..a7f502ae4 100644 --- a/ts/core/MmlTree/MathMLVisitor.ts +++ b/ts/core/MmlTree/MathMLVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlFactory.ts b/ts/core/MmlTree/MmlFactory.ts index 83a35073a..a6e3e6e7a 100644 --- a/ts/core/MmlTree/MmlFactory.ts +++ b/ts/core/MmlTree/MmlFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNode.ts b/ts/core/MmlTree/MmlNode.ts index a439d2c7e..01d29fb09 100644 --- a/ts/core/MmlTree/MmlNode.ts +++ b/ts/core/MmlTree/MmlNode.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/TeXAtom.ts b/ts/core/MmlTree/MmlNodes/TeXAtom.ts index edd63cbae..b92bc8c2e 100644 --- a/ts/core/MmlTree/MmlNodes/TeXAtom.ts +++ b/ts/core/MmlTree/MmlNodes/TeXAtom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/maction.ts b/ts/core/MmlTree/MmlNodes/maction.ts index 473ceef3a..4d047c69a 100644 --- a/ts/core/MmlTree/MmlNodes/maction.ts +++ b/ts/core/MmlTree/MmlNodes/maction.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/maligngroup.ts b/ts/core/MmlTree/MmlNodes/maligngroup.ts index 04a43b690..8a9d72aa6 100644 --- a/ts/core/MmlTree/MmlNodes/maligngroup.ts +++ b/ts/core/MmlTree/MmlNodes/maligngroup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/malignmark.ts b/ts/core/MmlTree/MmlNodes/malignmark.ts index 2bb204fce..4aa54d4d8 100644 --- a/ts/core/MmlTree/MmlNodes/malignmark.ts +++ b/ts/core/MmlTree/MmlNodes/malignmark.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/math.ts b/ts/core/MmlTree/MmlNodes/math.ts index 348f260ad..6a7435da7 100644 --- a/ts/core/MmlTree/MmlNodes/math.ts +++ b/ts/core/MmlTree/MmlNodes/math.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mathchoice.ts b/ts/core/MmlTree/MmlNodes/mathchoice.ts index afbaeadd7..527373c02 100644 --- a/ts/core/MmlTree/MmlNodes/mathchoice.ts +++ b/ts/core/MmlTree/MmlNodes/mathchoice.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/menclose.ts b/ts/core/MmlTree/MmlNodes/menclose.ts index 86377a5ed..933c0ea75 100644 --- a/ts/core/MmlTree/MmlNodes/menclose.ts +++ b/ts/core/MmlTree/MmlNodes/menclose.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/merror.ts b/ts/core/MmlTree/MmlNodes/merror.ts index 4ec6f74cf..c191665af 100644 --- a/ts/core/MmlTree/MmlNodes/merror.ts +++ b/ts/core/MmlTree/MmlNodes/merror.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mfenced.ts b/ts/core/MmlTree/MmlNodes/mfenced.ts index aeac5618e..84feadaae 100644 --- a/ts/core/MmlTree/MmlNodes/mfenced.ts +++ b/ts/core/MmlTree/MmlNodes/mfenced.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mfrac.ts b/ts/core/MmlTree/MmlNodes/mfrac.ts index 265aca06b..7a9b3b4f5 100644 --- a/ts/core/MmlTree/MmlNodes/mfrac.ts +++ b/ts/core/MmlTree/MmlNodes/mfrac.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mglyph.ts b/ts/core/MmlTree/MmlNodes/mglyph.ts index 857999f21..f9874a144 100644 --- a/ts/core/MmlTree/MmlNodes/mglyph.ts +++ b/ts/core/MmlTree/MmlNodes/mglyph.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mi.ts b/ts/core/MmlTree/MmlNodes/mi.ts index 4ccd5e9c3..f28dbbab1 100644 --- a/ts/core/MmlTree/MmlNodes/mi.ts +++ b/ts/core/MmlTree/MmlNodes/mi.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mmultiscripts.ts b/ts/core/MmlTree/MmlNodes/mmultiscripts.ts index a83b51725..1eb06ee65 100644 --- a/ts/core/MmlTree/MmlNodes/mmultiscripts.ts +++ b/ts/core/MmlTree/MmlNodes/mmultiscripts.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mn.ts b/ts/core/MmlTree/MmlNodes/mn.ts index 13b8d1e9b..5a6505207 100644 --- a/ts/core/MmlTree/MmlNodes/mn.ts +++ b/ts/core/MmlTree/MmlNodes/mn.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mo.ts b/ts/core/MmlTree/MmlNodes/mo.ts index 2e990b57e..b307583a3 100644 --- a/ts/core/MmlTree/MmlNodes/mo.ts +++ b/ts/core/MmlTree/MmlNodes/mo.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mpadded.ts b/ts/core/MmlTree/MmlNodes/mpadded.ts index e612571a7..2a0518bb0 100644 --- a/ts/core/MmlTree/MmlNodes/mpadded.ts +++ b/ts/core/MmlTree/MmlNodes/mpadded.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mphantom.ts b/ts/core/MmlTree/MmlNodes/mphantom.ts index 3e1cfacc3..0b43634ca 100644 --- a/ts/core/MmlTree/MmlNodes/mphantom.ts +++ b/ts/core/MmlTree/MmlNodes/mphantom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mroot.ts b/ts/core/MmlTree/MmlNodes/mroot.ts index f4b22d750..c130a71c9 100644 --- a/ts/core/MmlTree/MmlNodes/mroot.ts +++ b/ts/core/MmlTree/MmlNodes/mroot.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mrow.ts b/ts/core/MmlTree/MmlNodes/mrow.ts index 77c24df2d..b88b0afda 100644 --- a/ts/core/MmlTree/MmlNodes/mrow.ts +++ b/ts/core/MmlTree/MmlNodes/mrow.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/ms.ts b/ts/core/MmlTree/MmlNodes/ms.ts index 8e59f3414..548765fa9 100644 --- a/ts/core/MmlTree/MmlNodes/ms.ts +++ b/ts/core/MmlTree/MmlNodes/ms.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mspace.ts b/ts/core/MmlTree/MmlNodes/mspace.ts index e4eff1eb7..af193d936 100644 --- a/ts/core/MmlTree/MmlNodes/mspace.ts +++ b/ts/core/MmlTree/MmlNodes/mspace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/msqrt.ts b/ts/core/MmlTree/MmlNodes/msqrt.ts index 94f2d6e07..9fe9b1593 100644 --- a/ts/core/MmlTree/MmlNodes/msqrt.ts +++ b/ts/core/MmlTree/MmlNodes/msqrt.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mstyle.ts b/ts/core/MmlTree/MmlNodes/mstyle.ts index 070dd30f6..2e43eaa09 100644 --- a/ts/core/MmlTree/MmlNodes/mstyle.ts +++ b/ts/core/MmlTree/MmlNodes/mstyle.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/msubsup.ts b/ts/core/MmlTree/MmlNodes/msubsup.ts index f0dd98102..974c5e80b 100644 --- a/ts/core/MmlTree/MmlNodes/msubsup.ts +++ b/ts/core/MmlTree/MmlNodes/msubsup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mtable.ts b/ts/core/MmlTree/MmlNodes/mtable.ts index cc69b9a2d..ed41b0508 100644 --- a/ts/core/MmlTree/MmlNodes/mtable.ts +++ b/ts/core/MmlTree/MmlNodes/mtable.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mtd.ts b/ts/core/MmlTree/MmlNodes/mtd.ts index 4e01c0ea6..2295154df 100644 --- a/ts/core/MmlTree/MmlNodes/mtd.ts +++ b/ts/core/MmlTree/MmlNodes/mtd.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mtext.ts b/ts/core/MmlTree/MmlNodes/mtext.ts index 237b03e03..ed9f6be3f 100644 --- a/ts/core/MmlTree/MmlNodes/mtext.ts +++ b/ts/core/MmlTree/MmlNodes/mtext.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/mtr.ts b/ts/core/MmlTree/MmlNodes/mtr.ts index fabb03139..57c43e54a 100644 --- a/ts/core/MmlTree/MmlNodes/mtr.ts +++ b/ts/core/MmlTree/MmlNodes/mtr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/munderover.ts b/ts/core/MmlTree/MmlNodes/munderover.ts index 3cf871fad..6e434081a 100644 --- a/ts/core/MmlTree/MmlNodes/munderover.ts +++ b/ts/core/MmlTree/MmlNodes/munderover.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlNodes/semantics.ts b/ts/core/MmlTree/MmlNodes/semantics.ts index 7b7eb955b..3034c2d25 100644 --- a/ts/core/MmlTree/MmlNodes/semantics.ts +++ b/ts/core/MmlTree/MmlNodes/semantics.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/MmlVisitor.ts b/ts/core/MmlTree/MmlVisitor.ts index d3c2a02ba..53a7bf132 100644 --- a/ts/core/MmlTree/MmlVisitor.ts +++ b/ts/core/MmlTree/MmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/OperatorDictionary.ts b/ts/core/MmlTree/OperatorDictionary.ts index 76ca17a32..99561c21c 100644 --- a/ts/core/MmlTree/OperatorDictionary.ts +++ b/ts/core/MmlTree/OperatorDictionary.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/SerializedMmlVisitor.ts b/ts/core/MmlTree/SerializedMmlVisitor.ts index f571a8aa0..0b5abc245 100644 --- a/ts/core/MmlTree/SerializedMmlVisitor.ts +++ b/ts/core/MmlTree/SerializedMmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/MmlTree/TestMmlVisitor.ts b/ts/core/MmlTree/TestMmlVisitor.ts index 03d958341..83418ceeb 100644 --- a/ts/core/MmlTree/TestMmlVisitor.ts +++ b/ts/core/MmlTree/TestMmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/OutputJax.ts b/ts/core/OutputJax.ts index 1464113bf..d7df433b7 100644 --- a/ts/core/OutputJax.ts +++ b/ts/core/OutputJax.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/Factory.ts b/ts/core/Tree/Factory.ts index 538d16f3a..bd8fa158b 100644 --- a/ts/core/Tree/Factory.ts +++ b/ts/core/Tree/Factory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/Node.ts b/ts/core/Tree/Node.ts index fe39c679d..3ce209720 100644 --- a/ts/core/Tree/Node.ts +++ b/ts/core/Tree/Node.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/NodeFactory.ts b/ts/core/Tree/NodeFactory.ts index a56b489ca..466b8c83f 100644 --- a/ts/core/Tree/NodeFactory.ts +++ b/ts/core/Tree/NodeFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/Visitor.ts b/ts/core/Tree/Visitor.ts index 3bd0f5d3a..aeab5f3e5 100644 --- a/ts/core/Tree/Visitor.ts +++ b/ts/core/Tree/Visitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/Wrapper.ts b/ts/core/Tree/Wrapper.ts index 6ba6e8f33..945edefd6 100644 --- a/ts/core/Tree/Wrapper.ts +++ b/ts/core/Tree/Wrapper.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/core/Tree/WrapperFactory.ts b/ts/core/Tree/WrapperFactory.ts index a2e46e639..4539ba6a1 100644 --- a/ts/core/Tree/WrapperFactory.ts +++ b/ts/core/Tree/WrapperFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html.ts b/ts/handlers/html.ts index 154d8ed80..887335de3 100644 --- a/ts/handlers/html.ts +++ b/ts/handlers/html.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html/HTMLDocument.ts b/ts/handlers/html/HTMLDocument.ts index 2b847f046..bd2f215ee 100644 --- a/ts/handlers/html/HTMLDocument.ts +++ b/ts/handlers/html/HTMLDocument.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html/HTMLDomStrings.ts b/ts/handlers/html/HTMLDomStrings.ts index 389eaa387..33a436953 100644 --- a/ts/handlers/html/HTMLDomStrings.ts +++ b/ts/handlers/html/HTMLDomStrings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html/HTMLHandler.ts b/ts/handlers/html/HTMLHandler.ts index 48e01c08a..d0067a972 100644 --- a/ts/handlers/html/HTMLHandler.ts +++ b/ts/handlers/html/HTMLHandler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html/HTMLMathItem.ts b/ts/handlers/html/HTMLMathItem.ts index 7b076d43d..53363bb2b 100644 --- a/ts/handlers/html/HTMLMathItem.ts +++ b/ts/handlers/html/HTMLMathItem.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/handlers/html/HTMLMathList.ts b/ts/handlers/html/HTMLMathList.ts index c90e55d29..608644c1f 100644 --- a/ts/handlers/html/HTMLMathList.ts +++ b/ts/handlers/html/HTMLMathList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/asciimath.ts b/ts/input/asciimath.ts index d456537b0..8f6b8e2d7 100644 --- a/ts/input/asciimath.ts +++ b/ts/input/asciimath.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/asciimath/FindAsciiMath.ts b/ts/input/asciimath/FindAsciiMath.ts index a36f107b8..c7d69e2e0 100644 --- a/ts/input/asciimath/FindAsciiMath.ts +++ b/ts/input/asciimath/FindAsciiMath.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/mathml.ts b/ts/input/mathml.ts index c529ab80c..9319c1594 100644 --- a/ts/input/mathml.ts +++ b/ts/input/mathml.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/mathml/FindMathML.ts b/ts/input/mathml/FindMathML.ts index 7c5d9d04d..0a036fd3e 100644 --- a/ts/input/mathml/FindMathML.ts +++ b/ts/input/mathml/FindMathML.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/mathml/MathMLCompile.ts b/ts/input/mathml/MathMLCompile.ts index 45a47a096..ea89be1be 100644 --- a/ts/input/mathml/MathMLCompile.ts +++ b/ts/input/mathml/MathMLCompile.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/mathml/mml3/mml3-node.ts b/ts/input/mathml/mml3/mml3-node.ts index 8f35ee786..c8cf064ff 100644 --- a/ts/input/mathml/mml3/mml3-node.ts +++ b/ts/input/mathml/mml3/mml3-node.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/mathml/mml3/mml3.ts b/ts/input/mathml/mml3/mml3.ts index cd74d4856..7afda0b28 100644 --- a/ts/input/mathml/mml3/mml3.ts +++ b/ts/input/mathml/mml3/mml3.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex.ts b/ts/input/tex.ts index cbcfbdca2..2023d053f 100644 --- a/ts/input/tex.ts +++ b/ts/input/tex.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/AllPackages.ts b/ts/input/tex/AllPackages.ts index aa4802af8..bc4e9c39d 100644 --- a/ts/input/tex/AllPackages.ts +++ b/ts/input/tex/AllPackages.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/Configuration.ts b/ts/input/tex/Configuration.ts index ac51dc6ce..d118d06ba 100644 --- a/ts/input/tex/Configuration.ts +++ b/ts/input/tex/Configuration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/FilterUtil.ts b/ts/input/tex/FilterUtil.ts index 1ced561b9..8a7337d61 100644 --- a/ts/input/tex/FilterUtil.ts +++ b/ts/input/tex/FilterUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/FindTeX.ts b/ts/input/tex/FindTeX.ts index 1ab9179f6..78ee66103 100644 --- a/ts/input/tex/FindTeX.ts +++ b/ts/input/tex/FindTeX.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/MapHandler.ts b/ts/input/tex/MapHandler.ts index 9aac54ffd..23bac1bd2 100644 --- a/ts/input/tex/MapHandler.ts +++ b/ts/input/tex/MapHandler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/NodeFactory.ts b/ts/input/tex/NodeFactory.ts index c96730f4f..2a5e6b615 100644 --- a/ts/input/tex/NodeFactory.ts +++ b/ts/input/tex/NodeFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/NodeUtil.ts b/ts/input/tex/NodeUtil.ts index f99ae0f53..2e76fbef4 100644 --- a/ts/input/tex/NodeUtil.ts +++ b/ts/input/tex/NodeUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ParseMethods.ts b/ts/input/tex/ParseMethods.ts index a90e93770..ec87d6b57 100644 --- a/ts/input/tex/ParseMethods.ts +++ b/ts/input/tex/ParseMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ParseOptions.ts b/ts/input/tex/ParseOptions.ts index 36b92b862..0240d9341 100644 --- a/ts/input/tex/ParseOptions.ts +++ b/ts/input/tex/ParseOptions.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ParseUtil.ts b/ts/input/tex/ParseUtil.ts index 3a8486b66..9bd3427c0 100644 --- a/ts/input/tex/ParseUtil.ts +++ b/ts/input/tex/ParseUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2017 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/Stack.ts b/ts/input/tex/Stack.ts index 56f0da3dc..8eb20ffd1 100644 --- a/ts/input/tex/Stack.ts +++ b/ts/input/tex/Stack.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2017 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/StackItem.ts b/ts/input/tex/StackItem.ts index 084dea098..f6d01417c 100644 --- a/ts/input/tex/StackItem.ts +++ b/ts/input/tex/StackItem.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/StackItemFactory.ts b/ts/input/tex/StackItemFactory.ts index cce8d42e2..eb5b607de 100644 --- a/ts/input/tex/StackItemFactory.ts +++ b/ts/input/tex/StackItemFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/Symbol.ts b/ts/input/tex/Symbol.ts index c8904db52..3cafba3db 100644 --- a/ts/input/tex/Symbol.ts +++ b/ts/input/tex/Symbol.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/SymbolMap.ts b/ts/input/tex/SymbolMap.ts index 38e428cde..1c9f10231 100644 --- a/ts/input/tex/SymbolMap.ts +++ b/ts/input/tex/SymbolMap.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/Tags.ts b/ts/input/tex/Tags.ts index 16f088a14..66c8227da 100644 --- a/ts/input/tex/Tags.ts +++ b/ts/input/tex/Tags.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/TexConstants.ts b/ts/input/tex/TexConstants.ts index 27f87c942..7472c564d 100644 --- a/ts/input/tex/TexConstants.ts +++ b/ts/input/tex/TexConstants.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/TexError.ts b/ts/input/tex/TexError.ts index 1a3fc7fa4..c47080b9f 100644 --- a/ts/input/tex/TexError.ts +++ b/ts/input/tex/TexError.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/TexParser.ts b/ts/input/tex/TexParser.ts index cfa98f479..f8706c57f 100644 --- a/ts/input/tex/TexParser.ts +++ b/ts/input/tex/TexParser.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/Types.ts b/ts/input/tex/Types.ts index dd6c8a058..87a0f64a5 100644 --- a/ts/input/tex/Types.ts +++ b/ts/input/tex/Types.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/action/ActionConfiguration.ts b/ts/input/tex/action/ActionConfiguration.ts index cb1814e25..8e583502d 100644 --- a/ts/input/tex/action/ActionConfiguration.ts +++ b/ts/input/tex/action/ActionConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ams/AmsConfiguration.ts b/ts/input/tex/ams/AmsConfiguration.ts index 217fbd271..0fd4f7ce2 100644 --- a/ts/input/tex/ams/AmsConfiguration.ts +++ b/ts/input/tex/ams/AmsConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ams/AmsItems.ts b/ts/input/tex/ams/AmsItems.ts index 595a33b4a..8f40ca863 100644 --- a/ts/input/tex/ams/AmsItems.ts +++ b/ts/input/tex/ams/AmsItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ams/AmsMappings.ts b/ts/input/tex/ams/AmsMappings.ts index 4a2a40eac..974929baf 100644 --- a/ts/input/tex/ams/AmsMappings.ts +++ b/ts/input/tex/ams/AmsMappings.ts @@ -1,7 +1,7 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/ams/AmsMethods.ts b/ts/input/tex/ams/AmsMethods.ts index 0622216f7..dfaa98e79 100644 --- a/ts/input/tex/ams/AmsMethods.ts +++ b/ts/input/tex/ams/AmsMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/amscd/AmsCdConfiguration.ts b/ts/input/tex/amscd/AmsCdConfiguration.ts index 9ff13231f..85e69a47a 100644 --- a/ts/input/tex/amscd/AmsCdConfiguration.ts +++ b/ts/input/tex/amscd/AmsCdConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/amscd/AmsCdMappings.ts b/ts/input/tex/amscd/AmsCdMappings.ts index 8412105b3..722c27754 100644 --- a/ts/input/tex/amscd/AmsCdMappings.ts +++ b/ts/input/tex/amscd/AmsCdMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/amscd/AmsCdMethods.ts b/ts/input/tex/amscd/AmsCdMethods.ts index 1b65a7796..78cadddee 100644 --- a/ts/input/tex/amscd/AmsCdMethods.ts +++ b/ts/input/tex/amscd/AmsCdMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/autoload/AutoloadConfiguration.ts b/ts/input/tex/autoload/AutoloadConfiguration.ts index c1131acb2..aeb7888c1 100644 --- a/ts/input/tex/autoload/AutoloadConfiguration.ts +++ b/ts/input/tex/autoload/AutoloadConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/base/BaseConfiguration.ts b/ts/input/tex/base/BaseConfiguration.ts index e7ab54836..590ef1da6 100644 --- a/ts/input/tex/base/BaseConfiguration.ts +++ b/ts/input/tex/base/BaseConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/base/BaseItems.ts b/ts/input/tex/base/BaseItems.ts index 735d6fa67..04a751396 100644 --- a/ts/input/tex/base/BaseItems.ts +++ b/ts/input/tex/base/BaseItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/base/BaseMappings.ts b/ts/input/tex/base/BaseMappings.ts index ac0aa263b..6c15c6e2b 100644 --- a/ts/input/tex/base/BaseMappings.ts +++ b/ts/input/tex/base/BaseMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/base/BaseMethods.ts b/ts/input/tex/base/BaseMethods.ts index 0bf2e6397..9cb0651a0 100644 --- a/ts/input/tex/base/BaseMethods.ts +++ b/ts/input/tex/base/BaseMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bbox/BboxConfiguration.ts b/ts/input/tex/bbox/BboxConfiguration.ts index f27131599..9aa2ee69d 100644 --- a/ts/input/tex/bbox/BboxConfiguration.ts +++ b/ts/input/tex/bbox/BboxConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/boldsymbol/BoldsymbolConfiguration.ts b/ts/input/tex/boldsymbol/BoldsymbolConfiguration.ts index e2f059415..12fefaeb5 100644 --- a/ts/input/tex/boldsymbol/BoldsymbolConfiguration.ts +++ b/ts/input/tex/boldsymbol/BoldsymbolConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/braket/BraketConfiguration.ts b/ts/input/tex/braket/BraketConfiguration.ts index 39e016bae..e83e62bfe 100644 --- a/ts/input/tex/braket/BraketConfiguration.ts +++ b/ts/input/tex/braket/BraketConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/braket/BraketItems.ts b/ts/input/tex/braket/BraketItems.ts index 57f94df2a..ef1271aac 100644 --- a/ts/input/tex/braket/BraketItems.ts +++ b/ts/input/tex/braket/BraketItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/braket/BraketMappings.ts b/ts/input/tex/braket/BraketMappings.ts index d32e32454..00a48497a 100644 --- a/ts/input/tex/braket/BraketMappings.ts +++ b/ts/input/tex/braket/BraketMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/braket/BraketMethods.ts b/ts/input/tex/braket/BraketMethods.ts index f918a108d..b719fbbdc 100644 --- a/ts/input/tex/braket/BraketMethods.ts +++ b/ts/input/tex/braket/BraketMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bussproofs/BussproofsConfiguration.ts b/ts/input/tex/bussproofs/BussproofsConfiguration.ts index 3ae1d59ce..8b97ac029 100644 --- a/ts/input/tex/bussproofs/BussproofsConfiguration.ts +++ b/ts/input/tex/bussproofs/BussproofsConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bussproofs/BussproofsItems.ts b/ts/input/tex/bussproofs/BussproofsItems.ts index e881625ba..0c44c0e14 100644 --- a/ts/input/tex/bussproofs/BussproofsItems.ts +++ b/ts/input/tex/bussproofs/BussproofsItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bussproofs/BussproofsMappings.ts b/ts/input/tex/bussproofs/BussproofsMappings.ts index 0eef17e38..983ecd7dc 100644 --- a/ts/input/tex/bussproofs/BussproofsMappings.ts +++ b/ts/input/tex/bussproofs/BussproofsMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bussproofs/BussproofsMethods.ts b/ts/input/tex/bussproofs/BussproofsMethods.ts index 5bef39c15..c8a4ebad1 100644 --- a/ts/input/tex/bussproofs/BussproofsMethods.ts +++ b/ts/input/tex/bussproofs/BussproofsMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/bussproofs/BussproofsUtil.ts b/ts/input/tex/bussproofs/BussproofsUtil.ts index 4155d221d..e572bc4b5 100644 --- a/ts/input/tex/bussproofs/BussproofsUtil.ts +++ b/ts/input/tex/bussproofs/BussproofsUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/cancel/CancelConfiguration.ts b/ts/input/tex/cancel/CancelConfiguration.ts index b1377d548..094be3151 100644 --- a/ts/input/tex/cancel/CancelConfiguration.ts +++ b/ts/input/tex/cancel/CancelConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/centernot/CenternotConfiguration.ts b/ts/input/tex/centernot/CenternotConfiguration.ts index 7be989a22..d9b2b3d84 100644 --- a/ts/input/tex/centernot/CenternotConfiguration.ts +++ b/ts/input/tex/centernot/CenternotConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/color/ColorConfiguration.ts b/ts/input/tex/color/ColorConfiguration.ts index f3125a4d4..5ee1ecd5f 100644 --- a/ts/input/tex/color/ColorConfiguration.ts +++ b/ts/input/tex/color/ColorConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 Omar Al-Ithawi and The MathJax Consortium + * Copyright (c) 2018-2021 Omar Al-Ithawi and The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/color/ColorConstants.ts b/ts/input/tex/color/ColorConstants.ts index f1d530af8..bcb52cc67 100644 --- a/ts/input/tex/color/ColorConstants.ts +++ b/ts/input/tex/color/ColorConstants.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 Omar Al-Ithawi and The MathJax Consortium + * Copyright (c) 2018-2021 Omar Al-Ithawi and The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/color/ColorMethods.ts b/ts/input/tex/color/ColorMethods.ts index 4caf5c4f8..ac3783f07 100644 --- a/ts/input/tex/color/ColorMethods.ts +++ b/ts/input/tex/color/ColorMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 Omar Al-Ithawi and The MathJax Consortium + * Copyright (c) 2018-2021 Omar Al-Ithawi and The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/color/ColorUtil.ts b/ts/input/tex/color/ColorUtil.ts index f05b3a02d..b99c4e5d5 100644 --- a/ts/input/tex/color/ColorUtil.ts +++ b/ts/input/tex/color/ColorUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 Omar Al-Ithawi and The MathJax Consortium + * Copyright (c) 2018-2021 Omar Al-Ithawi and The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/colortbl/ColortblConfiguration.ts b/ts/input/tex/colortbl/ColortblConfiguration.ts index 4ce351c25..eef16a3b3 100644 --- a/ts/input/tex/colortbl/ColortblConfiguration.ts +++ b/ts/input/tex/colortbl/ColortblConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/colorv2/ColorV2Configuration.ts b/ts/input/tex/colorv2/ColorV2Configuration.ts index ca7ef8816..8dce6e10a 100644 --- a/ts/input/tex/colorv2/ColorV2Configuration.ts +++ b/ts/input/tex/colorv2/ColorV2Configuration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/configmacros/ConfigMacrosConfiguration.ts b/ts/input/tex/configmacros/ConfigMacrosConfiguration.ts index 4f6ef6110..0a396c76c 100644 --- a/ts/input/tex/configmacros/ConfigMacrosConfiguration.ts +++ b/ts/input/tex/configmacros/ConfigMacrosConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/empheq/EmpheqConfiguration.ts b/ts/input/tex/empheq/EmpheqConfiguration.ts index 0099a6037..ca18e20bb 100644 --- a/ts/input/tex/empheq/EmpheqConfiguration.ts +++ b/ts/input/tex/empheq/EmpheqConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/empheq/EmpheqUtil.ts b/ts/input/tex/empheq/EmpheqUtil.ts index acb65e991..c4f42270b 100644 --- a/ts/input/tex/empheq/EmpheqUtil.ts +++ b/ts/input/tex/empheq/EmpheqUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/enclose/EncloseConfiguration.ts b/ts/input/tex/enclose/EncloseConfiguration.ts index d343b1c3a..31f55b897 100644 --- a/ts/input/tex/enclose/EncloseConfiguration.ts +++ b/ts/input/tex/enclose/EncloseConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/extpfeil/ExtpfeilConfiguration.ts b/ts/input/tex/extpfeil/ExtpfeilConfiguration.ts index 8224becd6..256c4fa08 100644 --- a/ts/input/tex/extpfeil/ExtpfeilConfiguration.ts +++ b/ts/input/tex/extpfeil/ExtpfeilConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/gensymb/GensymbConfiguration.ts b/ts/input/tex/gensymb/GensymbConfiguration.ts index 7a610653a..3e979789a 100644 --- a/ts/input/tex/gensymb/GensymbConfiguration.ts +++ b/ts/input/tex/gensymb/GensymbConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/html/HtmlConfiguration.ts b/ts/input/tex/html/HtmlConfiguration.ts index c0ddd5491..15340802c 100644 --- a/ts/input/tex/html/HtmlConfiguration.ts +++ b/ts/input/tex/html/HtmlConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/html/HtmlMethods.ts b/ts/input/tex/html/HtmlMethods.ts index 26c96a45a..859294b05 100644 --- a/ts/input/tex/html/HtmlMethods.ts +++ b/ts/input/tex/html/HtmlMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/mathtools/MathtoolsTags.ts b/ts/input/tex/mathtools/MathtoolsTags.ts index 48bedf70c..bebf669d3 100644 --- a/ts/input/tex/mathtools/MathtoolsTags.ts +++ b/ts/input/tex/mathtools/MathtoolsTags.ts @@ -1,5 +1,5 @@ /************************************************************* - * Copyright (c) 2021 MathJax Consortium + * Copyright (c) 2021-2021 MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/mathtools/MathtoolsUtil.ts b/ts/input/tex/mathtools/MathtoolsUtil.ts index 2b77d60e0..653009b02 100644 --- a/ts/input/tex/mathtools/MathtoolsUtil.ts +++ b/ts/input/tex/mathtools/MathtoolsUtil.ts @@ -1,5 +1,5 @@ /************************************************************* - * Copyright (c) 2021 MathJax Consortium + * Copyright (c) 2021-2021 MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/mhchem/MhchemConfiguration.ts b/ts/input/tex/mhchem/MhchemConfiguration.ts index 9ebca30fc..d45edb066 100644 --- a/ts/input/tex/mhchem/MhchemConfiguration.ts +++ b/ts/input/tex/mhchem/MhchemConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/newcommand/NewcommandConfiguration.ts b/ts/input/tex/newcommand/NewcommandConfiguration.ts index e91b1fce4..c9bdad17f 100644 --- a/ts/input/tex/newcommand/NewcommandConfiguration.ts +++ b/ts/input/tex/newcommand/NewcommandConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/newcommand/NewcommandItems.ts b/ts/input/tex/newcommand/NewcommandItems.ts index 2ad8674ce..b605fd764 100644 --- a/ts/input/tex/newcommand/NewcommandItems.ts +++ b/ts/input/tex/newcommand/NewcommandItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/newcommand/NewcommandMappings.ts b/ts/input/tex/newcommand/NewcommandMappings.ts index 4bc419bf2..64478fa83 100644 --- a/ts/input/tex/newcommand/NewcommandMappings.ts +++ b/ts/input/tex/newcommand/NewcommandMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/newcommand/NewcommandMethods.ts b/ts/input/tex/newcommand/NewcommandMethods.ts index a9993e7aa..5fda1b7a4 100644 --- a/ts/input/tex/newcommand/NewcommandMethods.ts +++ b/ts/input/tex/newcommand/NewcommandMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/newcommand/NewcommandUtil.ts b/ts/input/tex/newcommand/NewcommandUtil.ts index 45e2b7a74..47822ea1c 100644 --- a/ts/input/tex/newcommand/NewcommandUtil.ts +++ b/ts/input/tex/newcommand/NewcommandUtil.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2017 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/noerrors/NoErrorsConfiguration.ts b/ts/input/tex/noerrors/NoErrorsConfiguration.ts index c70958d35..d289bcffe 100644 --- a/ts/input/tex/noerrors/NoErrorsConfiguration.ts +++ b/ts/input/tex/noerrors/NoErrorsConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/noundefined/NoUndefinedConfiguration.ts b/ts/input/tex/noundefined/NoUndefinedConfiguration.ts index 2cb6e2262..351b79867 100644 --- a/ts/input/tex/noundefined/NoUndefinedConfiguration.ts +++ b/ts/input/tex/noundefined/NoUndefinedConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/physics/PhysicsConfiguration.ts b/ts/input/tex/physics/PhysicsConfiguration.ts index fb4ba553e..533dedc65 100644 --- a/ts/input/tex/physics/PhysicsConfiguration.ts +++ b/ts/input/tex/physics/PhysicsConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/physics/PhysicsItems.ts b/ts/input/tex/physics/PhysicsItems.ts index 1d1aa4367..07c0c90f7 100644 --- a/ts/input/tex/physics/PhysicsItems.ts +++ b/ts/input/tex/physics/PhysicsItems.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2009-2018 The MathJax Consortium + * Copyright (c) 2009-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/physics/PhysicsMappings.ts b/ts/input/tex/physics/PhysicsMappings.ts index 55e5c291d..6629ecd42 100644 --- a/ts/input/tex/physics/PhysicsMappings.ts +++ b/ts/input/tex/physics/PhysicsMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/physics/PhysicsMethods.ts b/ts/input/tex/physics/PhysicsMethods.ts index 4296fda84..e94c7b866 100644 --- a/ts/input/tex/physics/PhysicsMethods.ts +++ b/ts/input/tex/physics/PhysicsMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/require/RequireConfiguration.ts b/ts/input/tex/require/RequireConfiguration.ts index c34b395fa..2921a34fb 100644 --- a/ts/input/tex/require/RequireConfiguration.ts +++ b/ts/input/tex/require/RequireConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/setoptions/SetOptionsConfiguration.ts b/ts/input/tex/setoptions/SetOptionsConfiguration.ts index 21d46e6e8..7af747ffe 100644 --- a/ts/input/tex/setoptions/SetOptionsConfiguration.ts +++ b/ts/input/tex/setoptions/SetOptionsConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/tagformat/TagFormatConfiguration.ts b/ts/input/tex/tagformat/TagFormatConfiguration.ts index 642c76c67..43063bee3 100644 --- a/ts/input/tex/tagformat/TagFormatConfiguration.ts +++ b/ts/input/tex/tagformat/TagFormatConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textcomp/TextcompConfiguration.ts b/ts/input/tex/textcomp/TextcompConfiguration.ts index cf88b9f75..964af9d0f 100644 --- a/ts/input/tex/textcomp/TextcompConfiguration.ts +++ b/ts/input/tex/textcomp/TextcompConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textcomp/TextcompMappings.ts b/ts/input/tex/textcomp/TextcompMappings.ts index eaad857e8..6824fb32e 100644 --- a/ts/input/tex/textcomp/TextcompMappings.ts +++ b/ts/input/tex/textcomp/TextcompMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textmacros/TextMacrosConfiguration.ts b/ts/input/tex/textmacros/TextMacrosConfiguration.ts index 43b8366fb..44ed89f5c 100644 --- a/ts/input/tex/textmacros/TextMacrosConfiguration.ts +++ b/ts/input/tex/textmacros/TextMacrosConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textmacros/TextMacrosMappings.ts b/ts/input/tex/textmacros/TextMacrosMappings.ts index 5231eb9a1..1f0fc8623 100644 --- a/ts/input/tex/textmacros/TextMacrosMappings.ts +++ b/ts/input/tex/textmacros/TextMacrosMappings.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textmacros/TextMacrosMethods.ts b/ts/input/tex/textmacros/TextMacrosMethods.ts index bae57ea70..9868ccf91 100644 --- a/ts/input/tex/textmacros/TextMacrosMethods.ts +++ b/ts/input/tex/textmacros/TextMacrosMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/textmacros/TextParser.ts b/ts/input/tex/textmacros/TextParser.ts index 6bec93da3..e4fec1cb6 100644 --- a/ts/input/tex/textmacros/TextParser.ts +++ b/ts/input/tex/textmacros/TextParser.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/unicode/UnicodeConfiguration.ts b/ts/input/tex/unicode/UnicodeConfiguration.ts index 1b2583916..e3a123ca6 100644 --- a/ts/input/tex/unicode/UnicodeConfiguration.ts +++ b/ts/input/tex/unicode/UnicodeConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/upgreek/UpgreekConfiguration.ts b/ts/input/tex/upgreek/UpgreekConfiguration.ts index d0c9040ee..ae605831d 100644 --- a/ts/input/tex/upgreek/UpgreekConfiguration.ts +++ b/ts/input/tex/upgreek/UpgreekConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/input/tex/verb/VerbConfiguration.ts b/ts/input/tex/verb/VerbConfiguration.ts index 77bcf27d8..5be5da2ac 100644 --- a/ts/input/tex/verb/VerbConfiguration.ts +++ b/ts/input/tex/verb/VerbConfiguration.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/mathjax.ts b/ts/mathjax.ts index 11b5e305a..5273bc1b6 100644 --- a/ts/mathjax.ts +++ b/ts/mathjax.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml.ts b/ts/output/chtml.ts index 4b73cf47f..f508796cd 100644 --- a/ts/output/chtml.ts +++ b/ts/output/chtml.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/FontData.ts b/ts/output/chtml/FontData.ts index 949f2cf73..1e45a48ff 100644 --- a/ts/output/chtml/FontData.ts +++ b/ts/output/chtml/FontData.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Notation.ts b/ts/output/chtml/Notation.ts index ad37128b0..90f8eaf2b 100644 --- a/ts/output/chtml/Notation.ts +++ b/ts/output/chtml/Notation.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Usage.ts b/ts/output/chtml/Usage.ts index 4c1083dee..3f53a6e26 100644 --- a/ts/output/chtml/Usage.ts +++ b/ts/output/chtml/Usage.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrapper.ts b/ts/output/chtml/Wrapper.ts index caeb7c8c0..7972955f9 100644 --- a/ts/output/chtml/Wrapper.ts +++ b/ts/output/chtml/Wrapper.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/WrapperFactory.ts b/ts/output/chtml/WrapperFactory.ts index a06141244..527f924fc 100644 --- a/ts/output/chtml/WrapperFactory.ts +++ b/ts/output/chtml/WrapperFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers.ts b/ts/output/chtml/Wrappers.ts index 8eb565092..a7546ceda 100644 --- a/ts/output/chtml/Wrappers.ts +++ b/ts/output/chtml/Wrappers.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/TeXAtom.ts b/ts/output/chtml/Wrappers/TeXAtom.ts index 826e52671..62c15ceda 100644 --- a/ts/output/chtml/Wrappers/TeXAtom.ts +++ b/ts/output/chtml/Wrappers/TeXAtom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/TextNode.ts b/ts/output/chtml/Wrappers/TextNode.ts index 22c38a14b..603849374 100644 --- a/ts/output/chtml/Wrappers/TextNode.ts +++ b/ts/output/chtml/Wrappers/TextNode.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/maction.ts b/ts/output/chtml/Wrappers/maction.ts index e237a597c..8be0cb54d 100644 --- a/ts/output/chtml/Wrappers/maction.ts +++ b/ts/output/chtml/Wrappers/maction.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/math.ts b/ts/output/chtml/Wrappers/math.ts index edcdfbe61..5f44937f8 100644 --- a/ts/output/chtml/Wrappers/math.ts +++ b/ts/output/chtml/Wrappers/math.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/menclose.ts b/ts/output/chtml/Wrappers/menclose.ts index e2d8c446a..9c0403b1c 100644 --- a/ts/output/chtml/Wrappers/menclose.ts +++ b/ts/output/chtml/Wrappers/menclose.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mfenced.ts b/ts/output/chtml/Wrappers/mfenced.ts index 80e66a4df..3db348400 100644 --- a/ts/output/chtml/Wrappers/mfenced.ts +++ b/ts/output/chtml/Wrappers/mfenced.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mfrac.ts b/ts/output/chtml/Wrappers/mfrac.ts index e4ee24f45..ba1bcaf42 100644 --- a/ts/output/chtml/Wrappers/mfrac.ts +++ b/ts/output/chtml/Wrappers/mfrac.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mglyph.ts b/ts/output/chtml/Wrappers/mglyph.ts index 7286fc54e..707385f34 100644 --- a/ts/output/chtml/Wrappers/mglyph.ts +++ b/ts/output/chtml/Wrappers/mglyph.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mi.ts b/ts/output/chtml/Wrappers/mi.ts index 64d0ab514..51174aff7 100644 --- a/ts/output/chtml/Wrappers/mi.ts +++ b/ts/output/chtml/Wrappers/mi.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mmultiscripts.ts b/ts/output/chtml/Wrappers/mmultiscripts.ts index b4f3d17b7..aeaa7be5a 100644 --- a/ts/output/chtml/Wrappers/mmultiscripts.ts +++ b/ts/output/chtml/Wrappers/mmultiscripts.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mn.ts b/ts/output/chtml/Wrappers/mn.ts index 8f91719dd..84bf1913a 100644 --- a/ts/output/chtml/Wrappers/mn.ts +++ b/ts/output/chtml/Wrappers/mn.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mo.ts b/ts/output/chtml/Wrappers/mo.ts index 99e9b5f49..75126a61c 100644 --- a/ts/output/chtml/Wrappers/mo.ts +++ b/ts/output/chtml/Wrappers/mo.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mpadded.ts b/ts/output/chtml/Wrappers/mpadded.ts index 08c0aad6b..170c98dcf 100644 --- a/ts/output/chtml/Wrappers/mpadded.ts +++ b/ts/output/chtml/Wrappers/mpadded.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mroot.ts b/ts/output/chtml/Wrappers/mroot.ts index c29756abf..edbfae6f6 100644 --- a/ts/output/chtml/Wrappers/mroot.ts +++ b/ts/output/chtml/Wrappers/mroot.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mrow.ts b/ts/output/chtml/Wrappers/mrow.ts index 9bae35cbd..9867e03bf 100644 --- a/ts/output/chtml/Wrappers/mrow.ts +++ b/ts/output/chtml/Wrappers/mrow.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/ms.ts b/ts/output/chtml/Wrappers/ms.ts index 0e17a89ee..ff8f9dcb5 100644 --- a/ts/output/chtml/Wrappers/ms.ts +++ b/ts/output/chtml/Wrappers/ms.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mspace.ts b/ts/output/chtml/Wrappers/mspace.ts index 01e5eae7d..f6f3f43a6 100644 --- a/ts/output/chtml/Wrappers/mspace.ts +++ b/ts/output/chtml/Wrappers/mspace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/msqrt.ts b/ts/output/chtml/Wrappers/msqrt.ts index 18ef4c829..1f85bb175 100644 --- a/ts/output/chtml/Wrappers/msqrt.ts +++ b/ts/output/chtml/Wrappers/msqrt.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/msubsup.ts b/ts/output/chtml/Wrappers/msubsup.ts index 98103ca2c..433d99588 100644 --- a/ts/output/chtml/Wrappers/msubsup.ts +++ b/ts/output/chtml/Wrappers/msubsup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mtable.ts b/ts/output/chtml/Wrappers/mtable.ts index b2da774db..059b00ac0 100644 --- a/ts/output/chtml/Wrappers/mtable.ts +++ b/ts/output/chtml/Wrappers/mtable.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mtd.ts b/ts/output/chtml/Wrappers/mtd.ts index 6f2f1cc5b..02841313a 100644 --- a/ts/output/chtml/Wrappers/mtd.ts +++ b/ts/output/chtml/Wrappers/mtd.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mtext.ts b/ts/output/chtml/Wrappers/mtext.ts index 05746617b..d4d38751d 100644 --- a/ts/output/chtml/Wrappers/mtext.ts +++ b/ts/output/chtml/Wrappers/mtext.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/mtr.ts b/ts/output/chtml/Wrappers/mtr.ts index f9e43291f..c115d8a61 100644 --- a/ts/output/chtml/Wrappers/mtr.ts +++ b/ts/output/chtml/Wrappers/mtr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/munderover.ts b/ts/output/chtml/Wrappers/munderover.ts index c413c5fc4..333320bc1 100644 --- a/ts/output/chtml/Wrappers/munderover.ts +++ b/ts/output/chtml/Wrappers/munderover.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/scriptbase.ts b/ts/output/chtml/Wrappers/scriptbase.ts index da65a8390..ed98e1054 100644 --- a/ts/output/chtml/Wrappers/scriptbase.ts +++ b/ts/output/chtml/Wrappers/scriptbase.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/Wrappers/semantics.ts b/ts/output/chtml/Wrappers/semantics.ts index 1e1995983..ad78ad8fe 100644 --- a/ts/output/chtml/Wrappers/semantics.ts +++ b/ts/output/chtml/Wrappers/semantics.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex.ts b/ts/output/chtml/fonts/tex.ts index 30881088d..957338211 100644 --- a/ts/output/chtml/fonts/tex.ts +++ b/ts/output/chtml/fonts/tex.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/bold-italic.ts b/ts/output/chtml/fonts/tex/bold-italic.ts index 3b30e2717..a2499bdc1 100644 --- a/ts/output/chtml/fonts/tex/bold-italic.ts +++ b/ts/output/chtml/fonts/tex/bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/bold.ts b/ts/output/chtml/fonts/tex/bold.ts index 30e3f5a6e..d2167b1a0 100644 --- a/ts/output/chtml/fonts/tex/bold.ts +++ b/ts/output/chtml/fonts/tex/bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/double-struck.ts b/ts/output/chtml/fonts/tex/double-struck.ts index 1685bb843..870f166ea 100644 --- a/ts/output/chtml/fonts/tex/double-struck.ts +++ b/ts/output/chtml/fonts/tex/double-struck.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/fraktur-bold.ts b/ts/output/chtml/fonts/tex/fraktur-bold.ts index 164ecb9e9..18447ba1b 100644 --- a/ts/output/chtml/fonts/tex/fraktur-bold.ts +++ b/ts/output/chtml/fonts/tex/fraktur-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/fraktur.ts b/ts/output/chtml/fonts/tex/fraktur.ts index 1f2ba4667..7620b94b0 100644 --- a/ts/output/chtml/fonts/tex/fraktur.ts +++ b/ts/output/chtml/fonts/tex/fraktur.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/italic.ts b/ts/output/chtml/fonts/tex/italic.ts index 14a3d4002..379128df7 100644 --- a/ts/output/chtml/fonts/tex/italic.ts +++ b/ts/output/chtml/fonts/tex/italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/largeop.ts b/ts/output/chtml/fonts/tex/largeop.ts index 8d0068a00..256e6dd62 100644 --- a/ts/output/chtml/fonts/tex/largeop.ts +++ b/ts/output/chtml/fonts/tex/largeop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/monospace.ts b/ts/output/chtml/fonts/tex/monospace.ts index 895d0b446..f1b8af728 100644 --- a/ts/output/chtml/fonts/tex/monospace.ts +++ b/ts/output/chtml/fonts/tex/monospace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/normal.ts b/ts/output/chtml/fonts/tex/normal.ts index 26f8d5e96..33b18384e 100644 --- a/ts/output/chtml/fonts/tex/normal.ts +++ b/ts/output/chtml/fonts/tex/normal.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts b/ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts index 7d389ac07..95cbeba3f 100644 --- a/ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts +++ b/ts/output/chtml/fonts/tex/sans-serif-bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/sans-serif-bold.ts b/ts/output/chtml/fonts/tex/sans-serif-bold.ts index 9e0d9fdd9..8f1e45557 100644 --- a/ts/output/chtml/fonts/tex/sans-serif-bold.ts +++ b/ts/output/chtml/fonts/tex/sans-serif-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/sans-serif-italic.ts b/ts/output/chtml/fonts/tex/sans-serif-italic.ts index 742ebc68e..56fe9d509 100644 --- a/ts/output/chtml/fonts/tex/sans-serif-italic.ts +++ b/ts/output/chtml/fonts/tex/sans-serif-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/sans-serif.ts b/ts/output/chtml/fonts/tex/sans-serif.ts index 93d2e5f5f..e5f9777d1 100644 --- a/ts/output/chtml/fonts/tex/sans-serif.ts +++ b/ts/output/chtml/fonts/tex/sans-serif.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/script-bold.ts b/ts/output/chtml/fonts/tex/script-bold.ts index a66e315b9..48a61d723 100644 --- a/ts/output/chtml/fonts/tex/script-bold.ts +++ b/ts/output/chtml/fonts/tex/script-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/script.ts b/ts/output/chtml/fonts/tex/script.ts index 4df632342..41ff98d61 100644 --- a/ts/output/chtml/fonts/tex/script.ts +++ b/ts/output/chtml/fonts/tex/script.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/smallop.ts b/ts/output/chtml/fonts/tex/smallop.ts index 01a656108..99fba5a75 100644 --- a/ts/output/chtml/fonts/tex/smallop.ts +++ b/ts/output/chtml/fonts/tex/smallop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts b/ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts index 55ec667b4..b4f698617 100644 --- a/ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts +++ b/ts/output/chtml/fonts/tex/tex-calligraphic-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-calligraphic.ts b/ts/output/chtml/fonts/tex/tex-calligraphic.ts index a4e14cea8..4a7369623 100644 --- a/ts/output/chtml/fonts/tex/tex-calligraphic.ts +++ b/ts/output/chtml/fonts/tex/tex-calligraphic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-mathit.ts b/ts/output/chtml/fonts/tex/tex-mathit.ts index 79f9f8f78..3128cd6ae 100644 --- a/ts/output/chtml/fonts/tex/tex-mathit.ts +++ b/ts/output/chtml/fonts/tex/tex-mathit.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts b/ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts index 172e6cc7e..4e431f74e 100644 --- a/ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts +++ b/ts/output/chtml/fonts/tex/tex-oldstyle-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-oldstyle.ts b/ts/output/chtml/fonts/tex/tex-oldstyle.ts index e0141f386..dd0ddba9b 100644 --- a/ts/output/chtml/fonts/tex/tex-oldstyle.ts +++ b/ts/output/chtml/fonts/tex/tex-oldstyle.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-size3.ts b/ts/output/chtml/fonts/tex/tex-size3.ts index a73152057..39836f267 100644 --- a/ts/output/chtml/fonts/tex/tex-size3.ts +++ b/ts/output/chtml/fonts/tex/tex-size3.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-size4.ts b/ts/output/chtml/fonts/tex/tex-size4.ts index fc4a3017c..94e603ccd 100644 --- a/ts/output/chtml/fonts/tex/tex-size4.ts +++ b/ts/output/chtml/fonts/tex/tex-size4.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/chtml/fonts/tex/tex-variant.ts b/ts/output/chtml/fonts/tex/tex-variant.ts index 2457ad5be..d23029bb1 100644 --- a/ts/output/chtml/fonts/tex/tex-variant.ts +++ b/ts/output/chtml/fonts/tex/tex-variant.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/FontData.ts b/ts/output/common/FontData.ts index 29104c962..d80df6c58 100644 --- a/ts/output/common/FontData.ts +++ b/ts/output/common/FontData.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Notation.ts b/ts/output/common/Notation.ts index caff348c6..0da59c00b 100644 --- a/ts/output/common/Notation.ts +++ b/ts/output/common/Notation.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/OutputJax.ts b/ts/output/common/OutputJax.ts index 52030c5e6..77a710f98 100644 --- a/ts/output/common/OutputJax.ts +++ b/ts/output/common/OutputJax.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrapper.ts b/ts/output/common/Wrapper.ts index 219c28844..72c5493f5 100644 --- a/ts/output/common/Wrapper.ts +++ b/ts/output/common/Wrapper.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/WrapperFactory.ts b/ts/output/common/WrapperFactory.ts index 485d009b2..5e8d562a4 100644 --- a/ts/output/common/WrapperFactory.ts +++ b/ts/output/common/WrapperFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/TeXAtom.ts b/ts/output/common/Wrappers/TeXAtom.ts index 8b394f613..0d7a41e6e 100644 --- a/ts/output/common/Wrappers/TeXAtom.ts +++ b/ts/output/common/Wrappers/TeXAtom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/TextNode.ts b/ts/output/common/Wrappers/TextNode.ts index f7cad70e1..a26dc0151 100644 --- a/ts/output/common/Wrappers/TextNode.ts +++ b/ts/output/common/Wrappers/TextNode.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/maction.ts b/ts/output/common/Wrappers/maction.ts index 45ac1f95b..913d1d281 100644 --- a/ts/output/common/Wrappers/maction.ts +++ b/ts/output/common/Wrappers/maction.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/math.ts b/ts/output/common/Wrappers/math.ts index 693b96974..ac864b4dc 100644 --- a/ts/output/common/Wrappers/math.ts +++ b/ts/output/common/Wrappers/math.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/menclose.ts b/ts/output/common/Wrappers/menclose.ts index 989ee35dd..4a24bb34e 100644 --- a/ts/output/common/Wrappers/menclose.ts +++ b/ts/output/common/Wrappers/menclose.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mfenced.ts b/ts/output/common/Wrappers/mfenced.ts index 7acb1d9fc..e4294427d 100644 --- a/ts/output/common/Wrappers/mfenced.ts +++ b/ts/output/common/Wrappers/mfenced.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mfrac.ts b/ts/output/common/Wrappers/mfrac.ts index bcdb27cad..fde6a0fa4 100644 --- a/ts/output/common/Wrappers/mfrac.ts +++ b/ts/output/common/Wrappers/mfrac.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mglyph.ts b/ts/output/common/Wrappers/mglyph.ts index eb5f6b3d7..8cc537e33 100644 --- a/ts/output/common/Wrappers/mglyph.ts +++ b/ts/output/common/Wrappers/mglyph.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mi.ts b/ts/output/common/Wrappers/mi.ts index c8497ea79..ee944274b 100644 --- a/ts/output/common/Wrappers/mi.ts +++ b/ts/output/common/Wrappers/mi.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mmultiscripts.ts b/ts/output/common/Wrappers/mmultiscripts.ts index baa857b68..891865286 100644 --- a/ts/output/common/Wrappers/mmultiscripts.ts +++ b/ts/output/common/Wrappers/mmultiscripts.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mn.ts b/ts/output/common/Wrappers/mn.ts index 347e588d1..c764170bb 100644 --- a/ts/output/common/Wrappers/mn.ts +++ b/ts/output/common/Wrappers/mn.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mo.ts b/ts/output/common/Wrappers/mo.ts index 1c292da85..d863b84c0 100644 --- a/ts/output/common/Wrappers/mo.ts +++ b/ts/output/common/Wrappers/mo.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mpadded.ts b/ts/output/common/Wrappers/mpadded.ts index 15f6fb914..2156eadf5 100644 --- a/ts/output/common/Wrappers/mpadded.ts +++ b/ts/output/common/Wrappers/mpadded.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mroot.ts b/ts/output/common/Wrappers/mroot.ts index 0d7bbedde..9e5e4df97 100644 --- a/ts/output/common/Wrappers/mroot.ts +++ b/ts/output/common/Wrappers/mroot.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mrow.ts b/ts/output/common/Wrappers/mrow.ts index 1109c0726..0fe436b89 100644 --- a/ts/output/common/Wrappers/mrow.ts +++ b/ts/output/common/Wrappers/mrow.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/ms.ts b/ts/output/common/Wrappers/ms.ts index 2a06cd58e..585d12f45 100644 --- a/ts/output/common/Wrappers/ms.ts +++ b/ts/output/common/Wrappers/ms.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mspace.ts b/ts/output/common/Wrappers/mspace.ts index 61d1f8599..ce340a057 100644 --- a/ts/output/common/Wrappers/mspace.ts +++ b/ts/output/common/Wrappers/mspace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/msqrt.ts b/ts/output/common/Wrappers/msqrt.ts index 5bc0d395e..46c779b77 100644 --- a/ts/output/common/Wrappers/msqrt.ts +++ b/ts/output/common/Wrappers/msqrt.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/msubsup.ts b/ts/output/common/Wrappers/msubsup.ts index 7370fd54f..555bbcea9 100644 --- a/ts/output/common/Wrappers/msubsup.ts +++ b/ts/output/common/Wrappers/msubsup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mtable.ts b/ts/output/common/Wrappers/mtable.ts index a9335cc9b..8d26b02e2 100644 --- a/ts/output/common/Wrappers/mtable.ts +++ b/ts/output/common/Wrappers/mtable.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mtd.ts b/ts/output/common/Wrappers/mtd.ts index 5e889f848..0bd28610a 100644 --- a/ts/output/common/Wrappers/mtd.ts +++ b/ts/output/common/Wrappers/mtd.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mtext.ts b/ts/output/common/Wrappers/mtext.ts index ad48abd54..a945b514d 100644 --- a/ts/output/common/Wrappers/mtext.ts +++ b/ts/output/common/Wrappers/mtext.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/mtr.ts b/ts/output/common/Wrappers/mtr.ts index dbf5901f9..0a1b68b80 100644 --- a/ts/output/common/Wrappers/mtr.ts +++ b/ts/output/common/Wrappers/mtr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/munderover.ts b/ts/output/common/Wrappers/munderover.ts index 231a83f8a..369a57199 100644 --- a/ts/output/common/Wrappers/munderover.ts +++ b/ts/output/common/Wrappers/munderover.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/scriptbase.ts b/ts/output/common/Wrappers/scriptbase.ts index 1f5b685f3..d077ee286 100644 --- a/ts/output/common/Wrappers/scriptbase.ts +++ b/ts/output/common/Wrappers/scriptbase.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/Wrappers/semantics.ts b/ts/output/common/Wrappers/semantics.ts index 186073659..54c9da33c 100644 --- a/ts/output/common/Wrappers/semantics.ts +++ b/ts/output/common/Wrappers/semantics.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex.ts b/ts/output/common/fonts/tex.ts index 157bba99b..dc1496461 100644 --- a/ts/output/common/fonts/tex.ts +++ b/ts/output/common/fonts/tex.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/bold-italic.ts b/ts/output/common/fonts/tex/bold-italic.ts index 77a4083d0..fccb5bf89 100644 --- a/ts/output/common/fonts/tex/bold-italic.ts +++ b/ts/output/common/fonts/tex/bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/bold.ts b/ts/output/common/fonts/tex/bold.ts index 1b289d0ad..ad87c933d 100644 --- a/ts/output/common/fonts/tex/bold.ts +++ b/ts/output/common/fonts/tex/bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/delimiters.ts b/ts/output/common/fonts/tex/delimiters.ts index eb2522e68..95551c137 100644 --- a/ts/output/common/fonts/tex/delimiters.ts +++ b/ts/output/common/fonts/tex/delimiters.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/double-struck.ts b/ts/output/common/fonts/tex/double-struck.ts index 527eab739..2ee5ab8df 100644 --- a/ts/output/common/fonts/tex/double-struck.ts +++ b/ts/output/common/fonts/tex/double-struck.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/fraktur-bold.ts b/ts/output/common/fonts/tex/fraktur-bold.ts index 896921961..f86b77e4f 100644 --- a/ts/output/common/fonts/tex/fraktur-bold.ts +++ b/ts/output/common/fonts/tex/fraktur-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/fraktur.ts b/ts/output/common/fonts/tex/fraktur.ts index 549632842..6666a7bfc 100644 --- a/ts/output/common/fonts/tex/fraktur.ts +++ b/ts/output/common/fonts/tex/fraktur.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/italic.ts b/ts/output/common/fonts/tex/italic.ts index bd196ea56..bb685ed7d 100644 --- a/ts/output/common/fonts/tex/italic.ts +++ b/ts/output/common/fonts/tex/italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/largeop.ts b/ts/output/common/fonts/tex/largeop.ts index b927f1c8f..495eb611f 100644 --- a/ts/output/common/fonts/tex/largeop.ts +++ b/ts/output/common/fonts/tex/largeop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/monospace.ts b/ts/output/common/fonts/tex/monospace.ts index 7e9f28531..490329f6f 100644 --- a/ts/output/common/fonts/tex/monospace.ts +++ b/ts/output/common/fonts/tex/monospace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/normal.ts b/ts/output/common/fonts/tex/normal.ts index 07a248f00..2821dd251 100644 --- a/ts/output/common/fonts/tex/normal.ts +++ b/ts/output/common/fonts/tex/normal.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/sans-serif-bold-italic.ts b/ts/output/common/fonts/tex/sans-serif-bold-italic.ts index b5a605742..f26abfdd5 100644 --- a/ts/output/common/fonts/tex/sans-serif-bold-italic.ts +++ b/ts/output/common/fonts/tex/sans-serif-bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/sans-serif-bold.ts b/ts/output/common/fonts/tex/sans-serif-bold.ts index 4c907103d..5fce7b22c 100644 --- a/ts/output/common/fonts/tex/sans-serif-bold.ts +++ b/ts/output/common/fonts/tex/sans-serif-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/sans-serif-italic.ts b/ts/output/common/fonts/tex/sans-serif-italic.ts index f376b4270..cabe2b0a4 100644 --- a/ts/output/common/fonts/tex/sans-serif-italic.ts +++ b/ts/output/common/fonts/tex/sans-serif-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/sans-serif.ts b/ts/output/common/fonts/tex/sans-serif.ts index 1f9504015..3754b0c0b 100644 --- a/ts/output/common/fonts/tex/sans-serif.ts +++ b/ts/output/common/fonts/tex/sans-serif.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/script-bold.ts b/ts/output/common/fonts/tex/script-bold.ts index 80b897228..a60462b1d 100644 --- a/ts/output/common/fonts/tex/script-bold.ts +++ b/ts/output/common/fonts/tex/script-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/script.ts b/ts/output/common/fonts/tex/script.ts index d290f8a87..ec4430b25 100644 --- a/ts/output/common/fonts/tex/script.ts +++ b/ts/output/common/fonts/tex/script.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/smallop.ts b/ts/output/common/fonts/tex/smallop.ts index 326ea057f..c06dd3e4d 100644 --- a/ts/output/common/fonts/tex/smallop.ts +++ b/ts/output/common/fonts/tex/smallop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-calligraphic-bold.ts b/ts/output/common/fonts/tex/tex-calligraphic-bold.ts index 0c4fca03d..a9c8329c3 100644 --- a/ts/output/common/fonts/tex/tex-calligraphic-bold.ts +++ b/ts/output/common/fonts/tex/tex-calligraphic-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-calligraphic.ts b/ts/output/common/fonts/tex/tex-calligraphic.ts index 5f20c1ffa..b194f718a 100644 --- a/ts/output/common/fonts/tex/tex-calligraphic.ts +++ b/ts/output/common/fonts/tex/tex-calligraphic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-mathit.ts b/ts/output/common/fonts/tex/tex-mathit.ts index dcc8fa761..d6eddf569 100644 --- a/ts/output/common/fonts/tex/tex-mathit.ts +++ b/ts/output/common/fonts/tex/tex-mathit.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-oldstyle-bold.ts b/ts/output/common/fonts/tex/tex-oldstyle-bold.ts index a51a3f832..9be63ec91 100644 --- a/ts/output/common/fonts/tex/tex-oldstyle-bold.ts +++ b/ts/output/common/fonts/tex/tex-oldstyle-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-oldstyle.ts b/ts/output/common/fonts/tex/tex-oldstyle.ts index 0fc40bd8e..e5aaa9ab0 100644 --- a/ts/output/common/fonts/tex/tex-oldstyle.ts +++ b/ts/output/common/fonts/tex/tex-oldstyle.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-size3.ts b/ts/output/common/fonts/tex/tex-size3.ts index c941b715f..97527cbea 100644 --- a/ts/output/common/fonts/tex/tex-size3.ts +++ b/ts/output/common/fonts/tex/tex-size3.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-size4.ts b/ts/output/common/fonts/tex/tex-size4.ts index b8b45101e..6b0bde957 100644 --- a/ts/output/common/fonts/tex/tex-size4.ts +++ b/ts/output/common/fonts/tex/tex-size4.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/common/fonts/tex/tex-variant.ts b/ts/output/common/fonts/tex/tex-variant.ts index a12533ba6..2052f616c 100644 --- a/ts/output/common/fonts/tex/tex-variant.ts +++ b/ts/output/common/fonts/tex/tex-variant.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg.ts b/ts/output/svg.ts index e64c05a3e..44d534e4d 100644 --- a/ts/output/svg.ts +++ b/ts/output/svg.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/FontCache.ts b/ts/output/svg/FontCache.ts index d9ae87133..8fa04998e 100644 --- a/ts/output/svg/FontCache.ts +++ b/ts/output/svg/FontCache.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/FontData.ts b/ts/output/svg/FontData.ts index aa71130e6..9b4d3fcf5 100644 --- a/ts/output/svg/FontData.ts +++ b/ts/output/svg/FontData.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Notation.ts b/ts/output/svg/Notation.ts index 47c1e6cf2..5e5173565 100644 --- a/ts/output/svg/Notation.ts +++ b/ts/output/svg/Notation.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrapper.ts b/ts/output/svg/Wrapper.ts index 34c2e5a85..e6881c128 100644 --- a/ts/output/svg/Wrapper.ts +++ b/ts/output/svg/Wrapper.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/WrapperFactory.ts b/ts/output/svg/WrapperFactory.ts index f324df2f9..da4a637e4 100644 --- a/ts/output/svg/WrapperFactory.ts +++ b/ts/output/svg/WrapperFactory.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers.ts b/ts/output/svg/Wrappers.ts index 5ac69b826..8693ed325 100644 --- a/ts/output/svg/Wrappers.ts +++ b/ts/output/svg/Wrappers.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/TeXAtom.ts b/ts/output/svg/Wrappers/TeXAtom.ts index 83a7fd51f..7dc3b9987 100644 --- a/ts/output/svg/Wrappers/TeXAtom.ts +++ b/ts/output/svg/Wrappers/TeXAtom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/TextNode.ts b/ts/output/svg/Wrappers/TextNode.ts index f769965a3..01c2755db 100644 --- a/ts/output/svg/Wrappers/TextNode.ts +++ b/ts/output/svg/Wrappers/TextNode.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/maction.ts b/ts/output/svg/Wrappers/maction.ts index 6a6002cbf..05e0eb3ba 100644 --- a/ts/output/svg/Wrappers/maction.ts +++ b/ts/output/svg/Wrappers/maction.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/math.ts b/ts/output/svg/Wrappers/math.ts index e124f2ac3..3e61225e0 100644 --- a/ts/output/svg/Wrappers/math.ts +++ b/ts/output/svg/Wrappers/math.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/menclose.ts b/ts/output/svg/Wrappers/menclose.ts index 7af7e3a61..e5811b3f7 100644 --- a/ts/output/svg/Wrappers/menclose.ts +++ b/ts/output/svg/Wrappers/menclose.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/merror.ts b/ts/output/svg/Wrappers/merror.ts index 9e1423d0c..dc6054c42 100644 --- a/ts/output/svg/Wrappers/merror.ts +++ b/ts/output/svg/Wrappers/merror.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mfenced.ts b/ts/output/svg/Wrappers/mfenced.ts index 59f79040e..ccd0d7880 100644 --- a/ts/output/svg/Wrappers/mfenced.ts +++ b/ts/output/svg/Wrappers/mfenced.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mfrac.ts b/ts/output/svg/Wrappers/mfrac.ts index 39771e2e9..3802377c4 100644 --- a/ts/output/svg/Wrappers/mfrac.ts +++ b/ts/output/svg/Wrappers/mfrac.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mglyph.ts b/ts/output/svg/Wrappers/mglyph.ts index 73acc2a96..e45835a4e 100644 --- a/ts/output/svg/Wrappers/mglyph.ts +++ b/ts/output/svg/Wrappers/mglyph.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mi.ts b/ts/output/svg/Wrappers/mi.ts index d016af103..806345a66 100644 --- a/ts/output/svg/Wrappers/mi.ts +++ b/ts/output/svg/Wrappers/mi.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mmultiscripts.ts b/ts/output/svg/Wrappers/mmultiscripts.ts index 147bcb4ad..1489c5313 100644 --- a/ts/output/svg/Wrappers/mmultiscripts.ts +++ b/ts/output/svg/Wrappers/mmultiscripts.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mn.ts b/ts/output/svg/Wrappers/mn.ts index da71f8bc9..70221e185 100644 --- a/ts/output/svg/Wrappers/mn.ts +++ b/ts/output/svg/Wrappers/mn.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mo.ts b/ts/output/svg/Wrappers/mo.ts index 7fafa6cd8..d3b0b3e48 100644 --- a/ts/output/svg/Wrappers/mo.ts +++ b/ts/output/svg/Wrappers/mo.ts @@ -1,7 +1,7 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mpadded.ts b/ts/output/svg/Wrappers/mpadded.ts index 5a4148b13..7c1673afa 100644 --- a/ts/output/svg/Wrappers/mpadded.ts +++ b/ts/output/svg/Wrappers/mpadded.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mphantom.ts b/ts/output/svg/Wrappers/mphantom.ts index 3a02f2a84..32975c101 100644 --- a/ts/output/svg/Wrappers/mphantom.ts +++ b/ts/output/svg/Wrappers/mphantom.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mroot.ts b/ts/output/svg/Wrappers/mroot.ts index 93d046b46..715bd8b6a 100644 --- a/ts/output/svg/Wrappers/mroot.ts +++ b/ts/output/svg/Wrappers/mroot.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mrow.ts b/ts/output/svg/Wrappers/mrow.ts index 785ae5e53..b98e9c84c 100644 --- a/ts/output/svg/Wrappers/mrow.ts +++ b/ts/output/svg/Wrappers/mrow.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/ms.ts b/ts/output/svg/Wrappers/ms.ts index 05838e2df..16a14dd7b 100644 --- a/ts/output/svg/Wrappers/ms.ts +++ b/ts/output/svg/Wrappers/ms.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mspace.ts b/ts/output/svg/Wrappers/mspace.ts index 895e520e1..da1f5eac4 100644 --- a/ts/output/svg/Wrappers/mspace.ts +++ b/ts/output/svg/Wrappers/mspace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/msqrt.ts b/ts/output/svg/Wrappers/msqrt.ts index 8bb09fb15..10c1358a2 100644 --- a/ts/output/svg/Wrappers/msqrt.ts +++ b/ts/output/svg/Wrappers/msqrt.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/msubsup.ts b/ts/output/svg/Wrappers/msubsup.ts index 298ee976f..6e3cdcf48 100644 --- a/ts/output/svg/Wrappers/msubsup.ts +++ b/ts/output/svg/Wrappers/msubsup.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mtable.ts b/ts/output/svg/Wrappers/mtable.ts index ed07efa2e..0076749de 100644 --- a/ts/output/svg/Wrappers/mtable.ts +++ b/ts/output/svg/Wrappers/mtable.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mtd.ts b/ts/output/svg/Wrappers/mtd.ts index 81e9fbbbc..9aa0ff0e2 100644 --- a/ts/output/svg/Wrappers/mtd.ts +++ b/ts/output/svg/Wrappers/mtd.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mtext.ts b/ts/output/svg/Wrappers/mtext.ts index 8cbbcf31d..0bca1523a 100644 --- a/ts/output/svg/Wrappers/mtext.ts +++ b/ts/output/svg/Wrappers/mtext.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/mtr.ts b/ts/output/svg/Wrappers/mtr.ts index dae67c338..0d640a454 100644 --- a/ts/output/svg/Wrappers/mtr.ts +++ b/ts/output/svg/Wrappers/mtr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/munderover.ts b/ts/output/svg/Wrappers/munderover.ts index 0fef47197..6eb1d2e99 100644 --- a/ts/output/svg/Wrappers/munderover.ts +++ b/ts/output/svg/Wrappers/munderover.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/scriptbase.ts b/ts/output/svg/Wrappers/scriptbase.ts index 611dc5993..0c011b3d5 100644 --- a/ts/output/svg/Wrappers/scriptbase.ts +++ b/ts/output/svg/Wrappers/scriptbase.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/Wrappers/semantics.ts b/ts/output/svg/Wrappers/semantics.ts index 1228ea2f0..41e31ab8c 100644 --- a/ts/output/svg/Wrappers/semantics.ts +++ b/ts/output/svg/Wrappers/semantics.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex.ts b/ts/output/svg/fonts/tex.ts index b0756fa01..59fa94fd3 100644 --- a/ts/output/svg/fonts/tex.ts +++ b/ts/output/svg/fonts/tex.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/bold-italic.ts b/ts/output/svg/fonts/tex/bold-italic.ts index 353802469..2fbcf19d3 100644 --- a/ts/output/svg/fonts/tex/bold-italic.ts +++ b/ts/output/svg/fonts/tex/bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/bold.ts b/ts/output/svg/fonts/tex/bold.ts index 777ee2de4..fc4662b8d 100644 --- a/ts/output/svg/fonts/tex/bold.ts +++ b/ts/output/svg/fonts/tex/bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/double-struck.ts b/ts/output/svg/fonts/tex/double-struck.ts index 1685bb843..870f166ea 100644 --- a/ts/output/svg/fonts/tex/double-struck.ts +++ b/ts/output/svg/fonts/tex/double-struck.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/fraktur-bold.ts b/ts/output/svg/fonts/tex/fraktur-bold.ts index f16491605..6a287641b 100644 --- a/ts/output/svg/fonts/tex/fraktur-bold.ts +++ b/ts/output/svg/fonts/tex/fraktur-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/fraktur.ts b/ts/output/svg/fonts/tex/fraktur.ts index 5b9d82ab8..c2d8e89c8 100644 --- a/ts/output/svg/fonts/tex/fraktur.ts +++ b/ts/output/svg/fonts/tex/fraktur.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/italic.ts b/ts/output/svg/fonts/tex/italic.ts index 49db82b89..a8d29c759 100644 --- a/ts/output/svg/fonts/tex/italic.ts +++ b/ts/output/svg/fonts/tex/italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/largeop.ts b/ts/output/svg/fonts/tex/largeop.ts index e5ba916fd..8e4c87328 100644 --- a/ts/output/svg/fonts/tex/largeop.ts +++ b/ts/output/svg/fonts/tex/largeop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/monospace.ts b/ts/output/svg/fonts/tex/monospace.ts index 7ff098358..e7c4cad04 100644 --- a/ts/output/svg/fonts/tex/monospace.ts +++ b/ts/output/svg/fonts/tex/monospace.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/normal.ts b/ts/output/svg/fonts/tex/normal.ts index 917a3831f..5e450f308 100644 --- a/ts/output/svg/fonts/tex/normal.ts +++ b/ts/output/svg/fonts/tex/normal.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/sans-serif-bold-italic.ts b/ts/output/svg/fonts/tex/sans-serif-bold-italic.ts index 5444a58a5..a8501b9f3 100644 --- a/ts/output/svg/fonts/tex/sans-serif-bold-italic.ts +++ b/ts/output/svg/fonts/tex/sans-serif-bold-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/sans-serif-bold.ts b/ts/output/svg/fonts/tex/sans-serif-bold.ts index 96d6ac813..aa6c22925 100644 --- a/ts/output/svg/fonts/tex/sans-serif-bold.ts +++ b/ts/output/svg/fonts/tex/sans-serif-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/sans-serif-italic.ts b/ts/output/svg/fonts/tex/sans-serif-italic.ts index 611356e30..1faee159c 100644 --- a/ts/output/svg/fonts/tex/sans-serif-italic.ts +++ b/ts/output/svg/fonts/tex/sans-serif-italic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/sans-serif.ts b/ts/output/svg/fonts/tex/sans-serif.ts index 4df7640fb..7d825df1f 100644 --- a/ts/output/svg/fonts/tex/sans-serif.ts +++ b/ts/output/svg/fonts/tex/sans-serif.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/script-bold.ts b/ts/output/svg/fonts/tex/script-bold.ts index a66e315b9..48a61d723 100644 --- a/ts/output/svg/fonts/tex/script-bold.ts +++ b/ts/output/svg/fonts/tex/script-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/script.ts b/ts/output/svg/fonts/tex/script.ts index 4df632342..41ff98d61 100644 --- a/ts/output/svg/fonts/tex/script.ts +++ b/ts/output/svg/fonts/tex/script.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/smallop.ts b/ts/output/svg/fonts/tex/smallop.ts index 62aae0c05..5f12871c0 100644 --- a/ts/output/svg/fonts/tex/smallop.ts +++ b/ts/output/svg/fonts/tex/smallop.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-calligraphic-bold.ts b/ts/output/svg/fonts/tex/tex-calligraphic-bold.ts index 5f863b72b..475b2ea7b 100644 --- a/ts/output/svg/fonts/tex/tex-calligraphic-bold.ts +++ b/ts/output/svg/fonts/tex/tex-calligraphic-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-calligraphic.ts b/ts/output/svg/fonts/tex/tex-calligraphic.ts index a9d8e886c..d5d4bc715 100644 --- a/ts/output/svg/fonts/tex/tex-calligraphic.ts +++ b/ts/output/svg/fonts/tex/tex-calligraphic.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-mathit.ts b/ts/output/svg/fonts/tex/tex-mathit.ts index 272894207..131f99893 100644 --- a/ts/output/svg/fonts/tex/tex-mathit.ts +++ b/ts/output/svg/fonts/tex/tex-mathit.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-oldstyle-bold.ts b/ts/output/svg/fonts/tex/tex-oldstyle-bold.ts index 4ac7a3aab..c8cc6fe7c 100644 --- a/ts/output/svg/fonts/tex/tex-oldstyle-bold.ts +++ b/ts/output/svg/fonts/tex/tex-oldstyle-bold.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-oldstyle.ts b/ts/output/svg/fonts/tex/tex-oldstyle.ts index 9f50393bc..b418dec24 100644 --- a/ts/output/svg/fonts/tex/tex-oldstyle.ts +++ b/ts/output/svg/fonts/tex/tex-oldstyle.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-size3.ts b/ts/output/svg/fonts/tex/tex-size3.ts index f0d8a551f..fa9dce058 100644 --- a/ts/output/svg/fonts/tex/tex-size3.ts +++ b/ts/output/svg/fonts/tex/tex-size3.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-size4.ts b/ts/output/svg/fonts/tex/tex-size4.ts index 1bf29a57d..ed7d47444 100644 --- a/ts/output/svg/fonts/tex/tex-size4.ts +++ b/ts/output/svg/fonts/tex/tex-size4.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/output/svg/fonts/tex/tex-variant.ts b/ts/output/svg/fonts/tex/tex-variant.ts index 2e41073ab..49ee27a26 100644 --- a/ts/output/svg/fonts/tex/tex-variant.ts +++ b/ts/output/svg/fonts/tex/tex-variant.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/lazy/LazyHandler.ts b/ts/ui/lazy/LazyHandler.ts index 110c2dd4f..7f2a73b94 100644 --- a/ts/ui/lazy/LazyHandler.ts +++ b/ts/ui/lazy/LazyHandler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2021 The MathJax Consortium + * Copyright (c) 2021-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/menu/MJContextMenu.ts b/ts/ui/menu/MJContextMenu.ts index f08e8f983..56712087a 100644 --- a/ts/ui/menu/MJContextMenu.ts +++ b/ts/ui/menu/MJContextMenu.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/menu/Menu.ts b/ts/ui/menu/Menu.ts index 1be13ec5e..7553aafc3 100644 --- a/ts/ui/menu/Menu.ts +++ b/ts/ui/menu/Menu.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/menu/MenuHandler.ts b/ts/ui/menu/MenuHandler.ts index ef368ad3e..fe8e4b113 100644 --- a/ts/ui/menu/MenuHandler.ts +++ b/ts/ui/menu/MenuHandler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/menu/MmlVisitor.ts b/ts/ui/menu/MmlVisitor.ts index e8d8cfca0..34097a81e 100644 --- a/ts/ui/menu/MmlVisitor.ts +++ b/ts/ui/menu/MmlVisitor.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/menu/SelectableInfo.ts b/ts/ui/menu/SelectableInfo.ts index bfb004771..6867a03ec 100644 --- a/ts/ui/menu/SelectableInfo.ts +++ b/ts/ui/menu/SelectableInfo.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/safe/SafeHandler.ts b/ts/ui/safe/SafeHandler.ts index a97da1d60..49353e296 100644 --- a/ts/ui/safe/SafeHandler.ts +++ b/ts/ui/safe/SafeHandler.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/safe/SafeMethods.ts b/ts/ui/safe/SafeMethods.ts index 67bc987c6..4e7380fdc 100644 --- a/ts/ui/safe/SafeMethods.ts +++ b/ts/ui/safe/SafeMethods.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/ui/safe/safe.ts b/ts/ui/safe/safe.ts index 07a88e22d..fa074eb2c 100644 --- a/ts/ui/safe/safe.ts +++ b/ts/ui/safe/safe.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2020 The MathJax Consortium + * Copyright (c) 2020-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/AsyncLoad.ts b/ts/util/AsyncLoad.ts index de9a0d2d4..6d8975d42 100644 --- a/ts/util/AsyncLoad.ts +++ b/ts/util/AsyncLoad.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/BBox.ts b/ts/util/BBox.ts index 4d16b6d68..ec5574077 100644 --- a/ts/util/BBox.ts +++ b/ts/util/BBox.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/BitField.ts b/ts/util/BitField.ts index c9ebea670..0f9d66c88 100644 --- a/ts/util/BitField.ts +++ b/ts/util/BitField.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/Entities.ts b/ts/util/Entities.ts index bc441d96c..db95ac8bd 100644 --- a/ts/util/Entities.ts +++ b/ts/util/Entities.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/FunctionList.ts b/ts/util/FunctionList.ts index ff23621cf..2487edba9 100644 --- a/ts/util/FunctionList.ts +++ b/ts/util/FunctionList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/LinkedList.ts b/ts/util/LinkedList.ts index c04994754..0e5b18050 100644 --- a/ts/util/LinkedList.ts +++ b/ts/util/LinkedList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/Options.ts b/ts/util/Options.ts index 32e4cc175..e6c98e40e 100644 --- a/ts/util/Options.ts +++ b/ts/util/Options.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/PrioritizedList.ts b/ts/util/PrioritizedList.ts index 90efce135..a82f3419c 100644 --- a/ts/util/PrioritizedList.ts +++ b/ts/util/PrioritizedList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/Retries.ts b/ts/util/Retries.ts index 4fecd9248..27c884168 100644 --- a/ts/util/Retries.ts +++ b/ts/util/Retries.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/StyleList.ts b/ts/util/StyleList.ts index fa8a927a6..8a5280b0b 100644 --- a/ts/util/StyleList.ts +++ b/ts/util/StyleList.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/Styles.ts b/ts/util/Styles.ts index ab7facddd..d5802ce61 100644 --- a/ts/util/Styles.ts +++ b/ts/util/Styles.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/asyncLoad/node.ts b/ts/util/asyncLoad/node.ts index 785d2fe86..df525f889 100644 --- a/ts/util/asyncLoad/node.ts +++ b/ts/util/asyncLoad/node.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/asyncLoad/system.ts b/ts/util/asyncLoad/system.ts index f16f287eb..0d236e678 100644 --- a/ts/util/asyncLoad/system.ts +++ b/ts/util/asyncLoad/system.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2019 The MathJax Consortium + * Copyright (c) 2019-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/a.ts b/ts/util/entities/a.ts index 067a68d0e..4660658db 100644 --- a/ts/util/entities/a.ts +++ b/ts/util/entities/a.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/all.ts b/ts/util/entities/all.ts index 1515a247b..f03037852 100644 --- a/ts/util/entities/all.ts +++ b/ts/util/entities/all.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/b.ts b/ts/util/entities/b.ts index dc9a5bb75..08f9ab3f4 100644 --- a/ts/util/entities/b.ts +++ b/ts/util/entities/b.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/c.ts b/ts/util/entities/c.ts index 283547cb7..d570a5dde 100644 --- a/ts/util/entities/c.ts +++ b/ts/util/entities/c.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/d.ts b/ts/util/entities/d.ts index d9ddb6b6d..98f9e6b54 100644 --- a/ts/util/entities/d.ts +++ b/ts/util/entities/d.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/e.ts b/ts/util/entities/e.ts index e47091c8c..7ea13cfd9 100644 --- a/ts/util/entities/e.ts +++ b/ts/util/entities/e.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/f.ts b/ts/util/entities/f.ts index 8f98e42df..1b7d73238 100644 --- a/ts/util/entities/f.ts +++ b/ts/util/entities/f.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/fr.ts b/ts/util/entities/fr.ts index a1a9d6973..b39ef554e 100644 --- a/ts/util/entities/fr.ts +++ b/ts/util/entities/fr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/g.ts b/ts/util/entities/g.ts index e205ae2fa..6056859a3 100644 --- a/ts/util/entities/g.ts +++ b/ts/util/entities/g.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/h.ts b/ts/util/entities/h.ts index 9b98fcb20..5d9ee5e38 100644 --- a/ts/util/entities/h.ts +++ b/ts/util/entities/h.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/i.ts b/ts/util/entities/i.ts index b2f68dc0a..0f5feff86 100644 --- a/ts/util/entities/i.ts +++ b/ts/util/entities/i.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/j.ts b/ts/util/entities/j.ts index b59ffe65c..e28e5ed04 100644 --- a/ts/util/entities/j.ts +++ b/ts/util/entities/j.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/k.ts b/ts/util/entities/k.ts index cc3b76335..a6c31cf08 100644 --- a/ts/util/entities/k.ts +++ b/ts/util/entities/k.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/l.ts b/ts/util/entities/l.ts index 8f1995512..9084662b6 100644 --- a/ts/util/entities/l.ts +++ b/ts/util/entities/l.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/m.ts b/ts/util/entities/m.ts index 3217f9e55..7a9d33f92 100644 --- a/ts/util/entities/m.ts +++ b/ts/util/entities/m.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/n.ts b/ts/util/entities/n.ts index 1ee305780..baf57e633 100644 --- a/ts/util/entities/n.ts +++ b/ts/util/entities/n.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/o.ts b/ts/util/entities/o.ts index d6aaa3759..3b9af5363 100644 --- a/ts/util/entities/o.ts +++ b/ts/util/entities/o.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/opf.ts b/ts/util/entities/opf.ts index 58bdefe84..bcb05847d 100644 --- a/ts/util/entities/opf.ts +++ b/ts/util/entities/opf.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/p.ts b/ts/util/entities/p.ts index 8c9a9cded..97c2436bc 100644 --- a/ts/util/entities/p.ts +++ b/ts/util/entities/p.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/q.ts b/ts/util/entities/q.ts index 22a464bbd..a809d2446 100644 --- a/ts/util/entities/q.ts +++ b/ts/util/entities/q.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/r.ts b/ts/util/entities/r.ts index b412f7b27..4504fd6a3 100644 --- a/ts/util/entities/r.ts +++ b/ts/util/entities/r.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/s.ts b/ts/util/entities/s.ts index 4145390ed..c77628ced 100644 --- a/ts/util/entities/s.ts +++ b/ts/util/entities/s.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/scr.ts b/ts/util/entities/scr.ts index 8bc6b4c62..d54e18202 100644 --- a/ts/util/entities/scr.ts +++ b/ts/util/entities/scr.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/t.ts b/ts/util/entities/t.ts index a09dbd2f5..f15648a5d 100644 --- a/ts/util/entities/t.ts +++ b/ts/util/entities/t.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/u.ts b/ts/util/entities/u.ts index a42af68ea..8721dbe61 100644 --- a/ts/util/entities/u.ts +++ b/ts/util/entities/u.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/v.ts b/ts/util/entities/v.ts index d6d2a26f1..db593f9df 100644 --- a/ts/util/entities/v.ts +++ b/ts/util/entities/v.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/w.ts b/ts/util/entities/w.ts index 4612e1c68..8fa8eb369 100644 --- a/ts/util/entities/w.ts +++ b/ts/util/entities/w.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/x.ts b/ts/util/entities/x.ts index 686c9ae38..df1c3b485 100644 --- a/ts/util/entities/x.ts +++ b/ts/util/entities/x.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/y.ts b/ts/util/entities/y.ts index 747dac0a1..274b797d5 100644 --- a/ts/util/entities/y.ts +++ b/ts/util/entities/y.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/entities/z.ts b/ts/util/entities/z.ts index cc0466af2..959f6fd95 100644 --- a/ts/util/entities/z.ts +++ b/ts/util/entities/z.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/lengths.ts b/ts/util/lengths.ts index 286b3180e..dcccb1961 100644 --- a/ts/util/lengths.ts +++ b/ts/util/lengths.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/numeric.ts b/ts/util/numeric.ts index 9452d6197..4b02be82d 100644 --- a/ts/util/numeric.ts +++ b/ts/util/numeric.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2018 The MathJax Consortium + * Copyright (c) 2018-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/ts/util/string.ts b/ts/util/string.ts index b0278619a..7a24b1a14 100644 --- a/ts/util/string.ts +++ b/ts/util/string.ts @@ -1,6 +1,6 @@ /************************************************************* * - * Copyright (c) 2017 The MathJax Consortium + * Copyright (c) 2017-2021 The MathJax Consortium * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. From 331eb8b8144e949076eeeb52a66a2c3c8a60ff13 Mon Sep 17 00:00:00 2001 From: "Davide P. Cervone" Date: Thu, 17 Jun 2021 08:37:30 -0400 Subject: [PATCH 142/142] Add copyright to significant component files --- components/src/dependencies.js | 17 +++++++++++++++++ components/src/node-main/node-main.js | 17 +++++++++++++++++ components/src/source.js | 17 +++++++++++++++++ 3 files changed, 51 insertions(+) diff --git a/components/src/dependencies.js b/components/src/dependencies.js index 8bf4e94a8..f9be6f93e 100644 --- a/components/src/dependencies.js +++ b/components/src/dependencies.js @@ -1,3 +1,20 @@ +/************************************************************* + * + * Copyright (c) 2019-2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + export const dependencies = { 'a11y/semantic-enrich': ['input/mml', '[sre]'], 'a11y/complexity': ['a11y/semantic-enrich'], diff --git a/components/src/node-main/node-main.js b/components/src/node-main/node-main.js index 26178fcbf..574570c44 100644 --- a/components/src/node-main/node-main.js +++ b/components/src/node-main/node-main.js @@ -1,3 +1,20 @@ +/************************************************************* + * + * Copyright (c) 2019-2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + const path = eval("require('path')"); // use actual node version, not webpack's version /* diff --git a/components/src/source.js b/components/src/source.js index d0dc4582e..ba6d68354 100644 --- a/components/src/source.js +++ b/components/src/source.js @@ -1,3 +1,20 @@ +/************************************************************* + * + * Copyright (c) 2019-2021 The MathJax Consortium + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + const src = __dirname; export const source = {