@oat-sa/tao-core-ui 1.60.2 → 1.61.0

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

@@ -28,24 +28,24 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
     hb.registerHelper('__', function (key) {
       return __(key);
     });
-    /**
-     * Register dompurify helper
-     *
-     * https://github.com/cure53/DOMPurify
-     * with config SAFE_FOR_TEMPLATES: true
-     * to make output safe for template systems
+    /**
+     * Register dompurify helper
+     *
+     * https://github.com/cure53/DOMPurify
+     * with config SAFE_FOR_TEMPLATES: true
+     * to make output safe for template systems
      */
 
     hb.registerHelper('dompurify', function (context) {
       return DOMPurify.sanitize(context);
     });
-    /**
-     * Register join helper
-     *
-     * Example :
-     * var values = {a:v1, b:v2, c:v3};
-     * Using {{{join attributes '=' ' ' '"'}}} will return : a="v1" b="v2" c="v3"
-     * Using {{{join values null ' or ' '*'}}} will return : *v1* or *v2* or *v3*
+    /**
+     * Register join helper
+     *
+     * Example :
+     * var values = {a:v1, b:v2, c:v3};
+     * Using {{{join attributes '=' ' ' '"'}}} will return : a="v1" b="v2" c="v3"
+     * Using {{{join values null ' or ' '*'}}} will return : *v1* or *v2* or *v3*
      */
 
     hb.registerHelper('join', function (arr, keyValueGlue, fragmentGlue, wrapper) {
@@ -123,182 +123,182 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
   helpers = this.merge(helpers, Handlebars.helpers);  
 
 
-    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>";
+    return "<div class=\"calculator\">\n    <div class=\"screen\"></div>\n    <div class=\"input\"></div>\n    <div class=\"keyboard\"></div>\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) {
@@ -308,9 +308,9 @@ 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();
@@ -318,9 +318,9 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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;
@@ -334,38 +334,38 @@ 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;
@@ -379,36 +379,36 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         }
 
         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 = {};
@@ -418,11 +418,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;
@@ -434,16 +434,16 @@ 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);
@@ -451,10 +451,10 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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)) {
@@ -465,21 +465,21 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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, {
@@ -487,26 +487,26 @@ 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 = {};
@@ -516,40 +516,40 @@ 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();
@@ -563,9 +563,9 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         }
 
         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));
         }
@@ -594,29 +594,29 @@ 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;
@@ -630,9 +630,9 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         }
 
         if ('undefined' === typeof term) {
-          /**
-           * @event termerror
-           * @param {TypeError} err
+          /**
+           * @event termerror
+           * @param {TypeError} err
            */
           return this.trigger('termerror', new TypeError('Invalid term: ' + name));
         }
@@ -640,13 +640,13 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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) {
@@ -658,18 +658,18 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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));
         }
@@ -682,101 +682,101 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         });
       },
 
-      /**
-       * 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;
@@ -787,17 +787,17 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
           } else {
             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);
         }
@@ -805,11 +805,11 @@ define(['lodash', 'i18n', 'core/collections', 'ui/component', 'ui/maths/calculat
         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 = [];
@@ -823,50 +823,50 @@ 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 () {
@@ -916,8 +916,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) {