@oat-sa/tao-core-ui 1.64.1 → 1.64.2

package/dist/maths/calculator/core/board.js

@@ -22,176 +22,176 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
     helpers = this.merge(helpers, Handlebars.helpers);  
 
 
-      return "<div class=\"calculator\">\n    <div class=\"screen\"></div>\n    <div class=\"input\"></div>\n    <div class=\"keyboard\"></div>\n</div>";
+      return "<div class=\"calculator\">\r\n    <div class=\"screen\"></div>\r\n    <div class=\"input\"></div>\r\n    <div class=\"keyboard\"></div>\r\n</div>";
       });
     function boardTpl(data, options, asString) {
       var html = Template(data, options);
       return (asString || true) ? html : $(html);
     }
 
-    /**
-     * This program is free software; you can redistribute it and/or
-     * modify it under the terms of the GNU General Public License
-     * as published by the Free Software Foundation; under version 2
-     * of the License (non-upgradable).
-     *
-     * This program is distributed in the hope that it will be useful,
-     * but WITHOUT ANY WARRANTY; without even the implied warranty of
-     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-     * GNU General Public License for more details.
-     *
-     * You should have received a copy of the GNU General Public License
-     * along with this program; if not, write to the Free Software
-     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-     *
-     * Copyright (c) 2018-2019 Open Assessment Technologies SA ;
+    /**
+     * This program is free software; you can redistribute it and/or
+     * modify it under the terms of the GNU General Public License
+     * as published by the Free Software Foundation; under version 2
+     * of the License (non-upgradable).
+     *
+     * This program is distributed in the hope that it will be useful,
+     * but WITHOUT ANY WARRANTY; without even the implied warranty of
+     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     * GNU General Public License for more details.
+     *
+     * You should have received a copy of the GNU General Public License
+     * along with this program; if not, write to the Free Software
+     * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+     *
+     * Copyright (c) 2018-2019 Open Assessment Technologies SA ;
      */
 
-    /**
-     * Default config values
-     * @type {Object}
+    /**
+     * Default config values
+     * @type {Object}
      */
     var defaultConfig = {
       expression: '',
       position: 0
     };
 
-    /**
-     * Name of the variable that contains the last result
-     * @type {String}
+    /**
+     * Name of the variable that contains the last result
+     * @type {String}
      */
     var lastResultVariableName = registeredTerms.ANS.value;
 
-    /**
-     * Regex that matches the prefixed function operators
-     * @type {RegExp}
+    /**
+     * Regex that matches the prefixed function operators
+     * @type {RegExp}
      */
     var rePrefixedTerm = /^@[a-zA-Z_]\w*$/;
 
-    /**
-     * The internal namespace for built-in events listeners
-     * @type {String}
+    /**
+     * The internal namespace for built-in events listeners
+     * @type {String}
      */
     var ns = 'calculator';
 
-    /**
-     * Build the basic UI for a calculator
-     * @param {jQuery|HTMLElement|String} $container
-     * @param {Function[]} pluginFactories
-     * @param {Object} [config]
-     * @param {String} [config.expression=''] - The initial expression
-     * @param {Number} [config.position=0] - The initial position in the expression
-     * @param {Object} [config.maths] - Optional config for the maths evaluator (@see util/mathsEvaluator)
-     * @param {Object} [config.plugins] - Optional config for each plugins
-     * @returns {calculator}
+    /**
+     * Build the basic UI for a calculator
+     * @param {jQuery|HTMLElement|String} $container
+     * @param {Function[]} pluginFactories
+     * @param {Object} [config]
+     * @param {String} [config.expression=''] - The initial expression
+     * @param {Number} [config.position=0] - The initial position in the expression
+     * @param {Object} [config.maths] - Optional config for the maths evaluator (@see util/mathsEvaluator)
+     * @param {Object} [config.plugins] - Optional config for each plugins
+     * @returns {calculator}
      */
     function calculatorBoardFactory($container, pluginFactories, config) {
-      /**
-       * Maths expression parser.
-       * @type {Function}
+      /**
+       * Maths expression parser.
+       * @type {Function}
        */
       var mathsEvaluator;
 
-      /**
-       * Keep the area broker instance
-       * @see ui/maths/calculator/areaBroker
+      /**
+       * Keep the area broker instance
+       * @see ui/maths/calculator/areaBroker
        */
       var areaBroker;
 
-      /**
-       * @type {Object} the registered plugins
+      /**
+       * @type {Object} the registered plugins
        */
       var plugins = {};
 
-      /**
-       * The current expression
-       * @type {String}
+      /**
+       * The current expression
+       * @type {String}
        */
       var expression = '';
 
-      /**
-       * A list of variables that can be used in the expression
-       * @type {Map}
+      /**
+       * A list of variables that can be used in the expression
+       * @type {Map}
        */
       var variables = new collections.Map();
 
-      /**
-       * A list of registered commands that can be used inside the calculator
-       * @type {Map}
+      /**
+       * A list of registered commands that can be used inside the calculator
+       * @type {Map}
        */
       var commands = new collections.Map();
 
-      /**
-       * The current position in the current expression (i.e. the position of the caret)
-       * @type {Number}
+      /**
+       * The current position in the current expression (i.e. the position of the caret)
+       * @type {Number}
        */
       var position = 0;
 
-      /**
-       * The tokenizer utilized to split down the expression
-       * @type {calculatorTokenizer}
+      /**
+       * The tokenizer utilized to split down the expression
+       * @type {calculatorTokenizer}
        */
       var tokenizer = tokenizerFactory();
 
-      /**
-       * The list of tokens extracted from the expression
-       * @type {Array|null}
+      /**
+       * The list of tokens extracted from the expression
+       * @type {Array|null}
        */
       var tokens = null;
 
-      /**
-       *
-       * @type {Object}
+      /**
+       *
+       * @type {Object}
        */
       var calculatorApi = {
-        /**
-         * Returns the current expression
-         * @returns {String}
+        /**
+         * Returns the current expression
+         * @returns {String}
          */
         getExpression: function getExpression() {
           return expression;
         },
-        /**
-         * Changes the current expression
-         * @param {String} expr
-         * @returns {calculator}
-         * @fires expressionchange after the expression has been changed
+        /**
+         * Changes the current expression
+         * @param {String} expr
+         * @returns {calculator}
+         * @fires expressionchange after the expression has been changed
          */
         setExpression: function setExpression(expr) {
           expression = String(expr || '');
           tokens = null;
-          /**
-           * @event expressionchange
-           * @param {String} expression
+          /**
+           * @event expressionchange
+           * @param {String} expression
            */
           this.trigger('expressionchange', expression);
           return this;
         },
-        /**
-         * Gets the current position inside the expression
-         * @returns {Number}
+        /**
+         * Gets the current position inside the expression
+         * @returns {Number}
          */
         getPosition: function getPosition() {
           return position;
         },
-        /**
-         * Sets the current position inside the expression
-         * @param {Number|String} pos
-         * @returns {calculator}
-         * @fires positionchange after the position has been changed
+        /**
+         * Sets the current position inside the expression
+         * @param {Number|String} pos
+         * @returns {calculator}
+         * @fires positionchange after the position has been changed
          */
         setPosition: function setPosition(pos) {
           position = Math.max(0, Math.min(parseInt(pos, 10) || 0, expression.length));
-          /**
-           * @event positionchange
-           * @param {Number} position
+          /**
+           * @event positionchange
+           * @param {Number} position
            */
           this.trigger('positionchange', position);
           return this;
         },
-        /**
-         * Gets the tokens from the current expression
-         * @returns {token[]}
+        /**
+         * Gets the tokens from the current expression
+         * @returns {token[]}
          */
         getTokens: function getTokens() {
           if (tokens === null) {
@@ -199,18 +199,18 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           }
           return tokens;
         },
-        /**
-         * Gets the token at the current position from the current expression
-         * @returns {token|null} Returns the token at the current position, or null if none
+        /**
+         * Gets the token at the current position from the current expression
+         * @returns {token|null} Returns the token at the current position, or null if none
          */
         getToken: function getToken() {
           var tokensList = this.getTokens();
           var index = this.getTokenIndex();
           return tokensList[index] || null;
         },
-        /**
-         * Gets token index from the current position in the expression.
-         * @returns {Number} Returns the index of the token at the current position.
+        /**
+         * Gets token index from the current position in the expression.
+         * @returns {Number} Returns the index of the token at the current position.
          */
         getTokenIndex: function getTokenIndex() {
           var index = 0;
@@ -221,35 +221,35 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           });
           return index;
         },
-        /**
-         * Gets access to the tokenizer
-         * @returns {calculatorTokenizer}
+        /**
+         * Gets access to the tokenizer
+         * @returns {calculatorTokenizer}
          */
         getTokenizer: function getTokenizer() {
           return tokenizer;
         },
-        /**
-         * Gets a variable defined for the expression.
-         * @param {String} name - The variable name
-         * @returns {mathsExpression} The value. Can be another expression.
+        /**
+         * Gets a variable defined for the expression.
+         * @param {String} name - The variable name
+         * @returns {mathsExpression} The value. Can be another expression.
          */
         getVariable: function getVariable(name) {
           return variables.get(name);
         },
-        /**
-         * Checks if a variable is registered
-         * @param {String} name
-         * @returns {Boolean}
+        /**
+         * Checks if a variable is registered
+         * @param {String} name
+         * @returns {Boolean}
          */
         hasVariable: function hasVariable(name) {
           return variables.has(name);
         },
-        /**
-         * Sets a variable that can be used by the expression.
-         * @param {String} name - The variable name
-         * @param {String|Number|mathsExpression} value - The value. Can be another expression.
-         * @returns {calculator}
-         * @fires variableadd after the variable has been set
+        /**
+         * Sets a variable that can be used by the expression.
+         * @param {String} name - The variable name
+         * @param {String|Number|mathsExpression} value - The value. Can be another expression.
+         * @returns {calculator}
+         * @fires variableadd after the variable has been set
          */
         setVariable: function setVariable(name, value) {
           var errValue;
@@ -261,32 +261,32 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             value.expression = errValue;
           }
           variables.set(name, value);
-          /**
-           * @event variableadd
-           * @param {String} name
-           * @param {String} value
+          /**
+           * @event variableadd
+           * @param {String} name
+           * @param {String} value
            */
           this.trigger('variableadd', name, value);
           return this;
         },
-        /**
-         * Deletes a variable defined for the expression.
-         * @param {String} name - The variable name
-         * @returns {calculator}
-         * @fires variabledelete after the variable has been deleted
+        /**
+         * Deletes a variable defined for the expression.
+         * @param {String} name - The variable name
+         * @returns {calculator}
+         * @fires variabledelete after the variable has been deleted
          */
         deleteVariable: function deleteVariable(name) {
           variables.delete(name);
-          /**
-           * @event variabledelete
-           * @param {String} name
+          /**
+           * @event variabledelete
+           * @param {String} name
            */
           this.trigger('variabledelete', name);
           return this;
         },
-        /**
-         * Gets the list of variables defined for the expression.
-         * @returns {Object} The list of defined variables.
+        /**
+         * Gets the list of variables defined for the expression.
+         * @returns {Object} The list of defined variables.
          */
         getVariables: function getVariables() {
           var defs = {};
@@ -295,11 +295,11 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           });
           return defs;
         },
-        /**
-         * Sets a list of variables that can be used by the expression.
-         * @param {Object} defs - A list variables to set.
-         * @returns {calculator}
-         * @fires variableadd after each variable has been set
+        /**
+         * Sets a list of variables that can be used by the expression.
+         * @param {Object} defs - A list variables to set.
+         * @returns {calculator}
+         * @fires variableadd after each variable has been set
          */
         setVariables: function setVariables(defs) {
           var self = this;
@@ -308,25 +308,25 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           });
           return this;
         },
-        /**
-         * Deletes all variables defined for the expression.
-         * @returns {calculator}
-         * @fires variabledelete after the variables has been deleted
+        /**
+         * Deletes all variables defined for the expression.
+         * @returns {calculator}
+         * @fires variabledelete after the variables has been deleted
          */
         deleteVariables: function deleteVariables() {
           variables.clear();
-          /**
-           * @event variabledelete
-           * @param {null} name
+          /**
+           * @event variabledelete
+           * @param {null} name
            */
           this.trigger('variabledelete', null);
           this.setLastResult('0');
           return this;
         },
-        /**
-         * Sets the value of the last result
-         * @param {String|Number|mathsExpression} [result='0']
-         * @returns {calculator}
+        /**
+         * Sets the value of the last result
+         * @param {String|Number|mathsExpression} [result='0']
+         * @returns {calculator}
          */
         setLastResult: function setLastResult(result) {
           if (!result || expressionHelper.containsError(result)) {
@@ -335,20 +335,20 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           this.setVariable(lastResultVariableName, result);
           return this;
         },
-        /**
-         * Gets the value of the last result
-         * @returns {mathsExpression}
+        /**
+         * Gets the value of the last result
+         * @returns {mathsExpression}
          */
         getLastResult: function getLastResult() {
           return this.getVariable(lastResultVariableName);
         },
-        /**
-         * Registers a command
-         * @param {String} name
-         * @param {String} [label]
-         * @param {String} [description]
-         * @returns {calculator}
-         * @fires commandadd after the command has been set
+        /**
+         * Registers a command
+         * @param {String} name
+         * @param {String} [label]
+         * @param {String} [description]
+         * @returns {calculator}
+         * @fires commandadd after the command has been set
          */
         setCommand: function setCommand(name, label, description) {
           commands.set(name, {
@@ -356,23 +356,23 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             label: label,
             description: description
           });
-          /**
-           * @event commandadd
-           * @param {String} name
+          /**
+           * @event commandadd
+           * @param {String} name
            */
           this.trigger('commandadd', name);
           return this;
         },
-        /**
-         * Gets the definition of a registered command
-         * @returns {Object} The registered command
+        /**
+         * Gets the definition of a registered command
+         * @returns {Object} The registered command
          */
         getCommand: function getCommand(name) {
           return commands.get(name);
         },
-        /**
-         * Gets the list of registered commands
-         * @returns {Object} The list of registered commands
+        /**
+         * Gets the list of registered commands
+         * @returns {Object} The list of registered commands
          */
         getCommands: function getCommands() {
           var defs = {};
@@ -381,37 +381,37 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           });
           return defs;
         },
-        /**
-         * Checks if a command is registered
-         * @param {String} name
-         * @returns {Boolean}
+        /**
+         * Checks if a command is registered
+         * @param {String} name
+         * @returns {Boolean}
          */
         hasCommand: function hasCommand(name) {
           return commands.has(name);
         },
-        /**
-         * Delete a registered command
-         * @param {String} name
-         * @returns {calculator}
-         * @fires commanddelete after the command has been deleted
+        /**
+         * Delete a registered command
+         * @param {String} name
+         * @returns {calculator}
+         * @fires commanddelete after the command has been deleted
          */
         deleteCommand: function deleteCommand(name) {
           commands.delete(name);
-          /**
-           * @event commanddelete
-           * @param {String} name
+          /**
+           * @event commanddelete
+           * @param {String} name
            */
           this.trigger('commanddelete', name);
           return this;
         },
-        /**
-         * Inserts a term in the expression at the current position
-         * @param {String} name - The name of the term to insert
-         * @param {Object} term - The definition of the term to insert
-         * @returns {calculator}
-         * @fires termerror if the term to add is invalid
-         * @fires termadd when the term has been added
-         * @fires termadd-<name> when the term has been added
+        /**
+         * Inserts a term in the expression at the current position
+         * @param {String} name - The name of the term to insert
+         * @param {Object} term - The definition of the term to insert
+         * @returns {calculator}
+         * @fires termerror if the term to add is invalid
+         * @fires termadd when the term has been added
+         * @fires termadd-<name> when the term has been added
          */
         addTerm: function addTerm(name, term) {
           var tokensList = this.getTokens();
@@ -425,9 +425,9 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             return tokensHelper.isIdentifier(token) || isIdentifier && !tokensHelper.isSeparator(token);
           }
           if (!_.isPlainObject(term) || 'undefined' === typeof term.value) {
-            /**
-             * @event termerror
-             * @param {TypeError} err
+            /**
+             * @event termerror
+             * @param {TypeError} err
              */
             return this.trigger('termerror', new TypeError('Invalid term: ' + name));
           }
@@ -457,26 +457,26 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             this.insert(value);
           }
 
-          /**
-           * @event termadd
-           * @param {String} name - The name of the added term
-           * @param {Object} term - The descriptor of the added term
+          /**
+           * @event termadd
+           * @param {String} name - The name of the added term
+           * @param {Object} term - The descriptor of the added term
            */
           this.trigger('termadd', name, term);
 
-          /**
-           * @event termadd-<name>
-           * @param {Object} term - The descriptor of the added term
+          /**
+           * @event termadd-<name>
+           * @param {Object} term - The descriptor of the added term
            */
           this.trigger('termadd-' + name, term);
           return this;
         },
-        /**
-         * Inserts a term in the expression at the current position
-         * @param {String} name - The name of the term to insert
-         * @returns {calculator}
-         * @fires termerror if the term to add is invalid
-         * @fires termadd when the term has been added
+        /**
+         * Inserts a term in the expression at the current position
+         * @param {String} name - The name of the term to insert
+         * @returns {calculator}
+         * @fires termerror if the term to add is invalid
+         * @fires termadd when the term has been added
          */
         useTerm: function useTerm(name) {
           var term;
@@ -488,21 +488,21 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             term = registeredTerms[name];
           }
           if ('undefined' === typeof term) {
-            /**
-             * @event termerror
-             * @param {TypeError} err
+            /**
+             * @event termerror
+             * @param {TypeError} err
              */
             return this.trigger('termerror', new TypeError('Invalid term: ' + name));
           }
           return this.addTerm(name, term);
         },
-        /**
-         * Inserts a list of terms in the expression at the current position
-         * @param {String|String[]} names - The names of the terms to insert.
-         *                                  Could be either an array of names or a list separated by spaces.
-         * @returns {calculator}
-         * @fires termerror if a term to add is invalid
-         * @fires termadd when a term has been added
+        /**
+         * Inserts a list of terms in the expression at the current position
+         * @param {String|String[]} names - The names of the terms to insert.
+         *                                  Could be either an array of names or a list separated by spaces.
+         * @returns {calculator}
+         * @fires termerror if a term to add is invalid
+         * @fires termadd when a term has been added
          */
         useTerms: function useTerms(names) {
           if ('string' === typeof names) {
@@ -511,18 +511,18 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           _.forEach(names, this.useTerm.bind(this));
           return this;
         },
-        /**
-         * Inserts a variable as a term in the expression at the current position
-         * @param {String} name - The name of the variable to insert
-         * @returns {calculator}
-         * @fires termerror if the term to add is invalid
-         * @fires termadd when the term has been added
+        /**
+         * Inserts a variable as a term in the expression at the current position
+         * @param {String} name - The name of the variable to insert
+         * @returns {calculator}
+         * @fires termerror if the term to add is invalid
+         * @fires termadd when the term has been added
          */
         useVariable: function useVariable(name) {
           if (!variables.has(name)) {
-            /**
-             * @event termerror
-             * @param {TypeError} err
+            /**
+             * @event termerror
+             * @param {TypeError} err
              */
             return this.trigger('termerror', new TypeError('Invalid variable: ' + name));
           }
@@ -533,96 +533,96 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
             description: __('Variable %s', name)
           });
         },
-        /**
-         * Calls a command
-         * @param {String} name - The name of the called command
-         * @param {*} ... - additional params for the command
-         * @returns {calculator}
-         * @fires command with the name and the parameters of the command
-         * @fires command-<name> with the parameters of the command
-         * @fires commanderror if the command is invalid
+        /**
+         * Calls a command
+         * @param {String} name - The name of the called command
+         * @param {*} ... - additional params for the command
+         * @returns {calculator}
+         * @fires command with the name and the parameters of the command
+         * @fires command-<name> with the parameters of the command
+         * @fires commanderror if the command is invalid
          */
         useCommand: function useCommand(name) {
           if (!commands.has(name)) {
-            /**
-             * @event commanderror
-             * @param {TypeError} err
+            /**
+             * @event commanderror
+             * @param {TypeError} err
              */
             return this.trigger('commanderror', new TypeError('Invalid command: ' + name));
           }
 
-          /**
-           * @event command
-           * @param {String} name - The name of the called command
-           * @param {*} ... - additional params for the command
+          /**
+           * @event command
+           * @param {String} name - The name of the called command
+           * @param {*} ... - additional params for the command
            */
           this.trigger.apply(this, ['command'].concat([].slice.call(arguments)));
 
-          /**
-           * @event command-<name>
-           * @param {*} ... - additional params for the command
+          /**
+           * @event command-<name>
+           * @param {*} ... - additional params for the command
            */
           this.trigger.apply(this, ['command-' + name].concat([].slice.call(arguments, 1)));
           return this;
         },
-        /**
-         * Replaces the expression and move the cursor at the end.
-         * @param {String} newExpression - The new expression to set
-         * @param {Number|String} [newPosition=newExpression.length] - The new position to set
-         * @returns {calculator}
-         * @fires replace after the expression has been replaced
+        /**
+         * Replaces the expression and move the cursor at the end.
+         * @param {String} newExpression - The new expression to set
+         * @param {Number|String} [newPosition=newExpression.length] - The new position to set
+         * @returns {calculator}
+         * @fires replace after the expression has been replaced
          */
         replace: function replace(newExpression, newPosition) {
           var oldExpression = expression;
           var oldPosition = position;
           this.setExpression(newExpression).setPosition('undefined' !== typeof newPosition ? newPosition : expression.length);
 
-          /**
-           * @event replace
-           * @param {String} expression - the replaced expression
-           * @param {Number} position - the replaced position
+          /**
+           * @event replace
+           * @param {String} expression - the replaced expression
+           * @param {Number} position - the replaced position
            */
           this.trigger('replace', oldExpression, oldPosition);
           return this;
         },
-        /**
-         * Inserts a sub-expression in the current expression and move the cursor.
-         * @param {String} subExpression - The sub-expression to insert
-         * @returns {calculator}
-         * @fires insert after the expression has been inserted
+        /**
+         * Inserts a sub-expression in the current expression and move the cursor.
+         * @param {String} subExpression - The sub-expression to insert
+         * @returns {calculator}
+         * @fires insert after the expression has been inserted
          */
         insert: function insert(subExpression) {
           var oldExpression = expression;
           var oldPosition = position;
           this.setExpression(expression.substr(0, position) + subExpression + expression.substr(position)).setPosition(position + subExpression.length);
 
-          /**
-           * @event insert
-           * @param {String} expression - the replaced expression
-           * @param {Number} position - the replaced position
+          /**
+           * @event insert
+           * @param {String} expression - the replaced expression
+           * @param {Number} position - the replaced position
            */
           this.trigger('insert', oldExpression, oldPosition);
           return this;
         },
-        /**
-         * Clears the expression
-         * @returns {calculator}
-         * @fires clear after the expression has been cleared
+        /**
+         * Clears the expression
+         * @returns {calculator}
+         * @fires clear after the expression has been cleared
          */
         clear: function clear() {
           this.setExpression('').setPosition(0);
 
-          /**
-           * @event clear
+          /**
+           * @event clear
            */
           this.trigger('clear');
           return this;
         },
-        /**
-         * Evaluates the current expression
-         * @returns {mathsExpression|null}
-         * @fires evaluate when the expression has been evaluated
-         * @fires syntaxerror when the expression contains an error
+        /**
+         * Evaluates the current expression
+         * @returns {mathsExpression|null}
+         * @fires evaluate when the expression has been evaluated
+         * @fires syntaxerror when the expression contains an error
          */
         evaluate: function evaluate() {
           var result = null;
@@ -633,25 +633,25 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
               result = mathsEvaluator('0');
             }
 
-            /**
-             * @event evaluate
-             * @param {mathsExpression} result
+            /**
+             * @event evaluate
+             * @param {mathsExpression} result
              */
             this.trigger('evaluate', result);
           } catch (e) {
-            /**
-             * @event syntaxerror
-             * @param {Error} err
+            /**
+             * @event syntaxerror
+             * @param {Error} err
              */
             this.trigger('syntaxerror', e);
           }
           return result;
         },
-        /**
-         * Runs a method in all plugins
-         *
-         * @param {String} method - the method to run
-         * @returns {Promise} once that resolve when all plugins are done
+        /**
+         * Runs a method in all plugins
+         *
+         * @param {String} method - the method to run
+         * @returns {Promise} once that resolve when all plugins are done
          */
         runPlugins: function runPlugins(method) {
           var execStack = [];
@@ -662,47 +662,47 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           });
           return Promise.all(execStack);
         },
-        /**
-         * Gets the calculator plugins
-         * @returns {Array} the plugins
+        /**
+         * Gets the calculator plugins
+         * @returns {Array} the plugins
          */
         getPlugins: function getPlugins() {
           return _.toArray(plugins);
         },
-        /**
-         * Gets a plugin
-         * @param {String} name - the plugin name
-         * @returns {plugin} the plugin
+        /**
+         * Gets a plugin
+         * @param {String} name - the plugin name
+         * @returns {plugin} the plugin
          */
         getPlugin: function getPlugin(name) {
           return plugins[name];
         },
-        /**
-         * Gets access to the areaBroker
-         * @returns {areaBroker}
+        /**
+         * Gets access to the areaBroker
+         * @returns {areaBroker}
          */
         getAreaBroker: function getAreaBroker() {
           return areaBroker;
         },
-        /**
-         * Setups the maths evaluator
-         * @returns {calculator}
+        /**
+         * Setups the maths evaluator
+         * @returns {calculator}
          */
         setupMathsEvaluator: function setupMathsEvaluator() {
           mathsEvaluator = mathsEvaluatorFactory(this.getConfig().maths);
           return this;
         },
-        /**
-         * Gets access to the mathsEvaluator
-         * @returns {Function}
+        /**
+         * Gets access to the mathsEvaluator
+         * @returns {Function}
          */
         getMathsEvaluator: function getMathsEvaluator() {
           return mathsEvaluator;
         }
       };
 
-      /**
-       * @typedef {component} calculator
+      /**
+       * @typedef {component} calculator
        */
       var calculator = componentFactory(calculatorApi, defaultConfig).setTemplate(boardTpl).before('init', function () {
         this.setupMathsEvaluator();
@@ -745,8 +745,8 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         }).then(function () {
           return self.runPlugins('render');
         }).then(function () {
-          /**
-           * @event ready
+          /**
+           * @event ready
            */
           self.trigger('ready');
         }).catch(function (err) {