jsxgraph 1.14.0 → 1.14.1

package/distrib/jsxgraphsrc.js

@@ -60,7 +60,7 @@ return /******/ (function() { // webpackBootstrap
 
 var major = 1,
     minor = 14,
-    patch = 0,
+    patch = 1,
     add = '', // 'dev' 'beta1'
     version = major + '.' + minor + '.' + patch + (add ? '-' + add : ''),
     constants;
@@ -5519,7 +5519,8 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.extend(
             } else if (this.elementClass === _constants_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.OBJECT_CLASS_CIRCLE) {
                 x = this.center.X();
                 y = this.center.Y();
-                bb = [x - this.radius, y + this.radius, x + this.radius, y - this.radius];
+                r = this.Radius(); // this.radius
+                bb = [x - r, y + r, x + r, y - r];
             } else if (this.elementClass === _constants_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.OBJECT_CLASS_CURVE) {
                 le = this.points.length;
                 if (le === 0) {
@@ -7735,8 +7736,8 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.createHTMLSlider = func
     }
 
     // Backwards compatibility
-    attr.anchor = attr.parent || attr.anchor;
-    attr.fixed = attr.fixed || true;
+    attr.anchor = _utils_type_js__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.def(attr.parent, attr.anchor);
+    attr.fixed = _utils_type_js__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .A.def(attr.fixed, true);
 
     par = [
         parents[0][0],
@@ -15697,10 +15698,10 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     }),
 
     /**
-     * Calculates the cosine hyperbolicus of x.
+     * Calculates the hyperbolic cosine of \\(x\\).
      * @function
      * @param {Number} x The number the cosine hyperbolicus will be calculated of.
-     * @returns {Number} Cosine hyperbolicus of the given value.
+     * @returns {Number} Hyperbolic cosine of the given value.
      */
     cosh:
         Math.cosh ||
@@ -15709,10 +15710,10 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         },
 
     /**
-     * Sine hyperbolicus of x.
+     * Hyperbolic sine of \\(x\\).
      * @function
-     * @param {Number} x The number the sine hyperbolicus will be calculated of.
-     * @returns {Number} Sine hyperbolicus of the given value.
+     * @param {Number} x The number the hyperbolic sine will be calculated of.
+     * @returns {Number} Hyperbolic sine of the given value.
      */
     sinh:
         Math.sinh ||
@@ -15721,7 +15722,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         },
 
     /**
-     * Hyperbolic arc-cosine of a number.
+     * Inverse hyperbolic cosine of a number.
      * @function
      * @param {Number} x
      * @returns {Number}
@@ -15733,7 +15734,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         },
 
     /**
-     * Hyperbolic arcsine of a number
+     * Inverse hyperbolic sine of a number
      * @function
      * @param {Number} x
      * @returns {Number}
@@ -15810,7 +15811,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Computes cube root of real number
+     * Computes cube root of real number.
      * Polyfill for Math.cbrt().
      *
      * @function
@@ -15930,7 +15931,11 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         },
 
     /**
-     * A square & multiply algorithm to compute base to the power of exponent.
+     * A square & multiply algorithm to compute `base` to the power of `exponent`.
+     * That is, for base \\(b\\) and integer exponent \\(e\\) it is a fast method to compute
+     * \\[ b^e .\\]
+     * For non-integer values of `exponent`, JavaScript's `Math.pow` is used.
+     *
      * Implementated by Wolfgang Riedl.
      *
      * @param {Number} base
@@ -15965,16 +15970,17 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Greatest common divisor (gcd) of two numbers.
-     * See {@link <a href="https://rosettacode.org/wiki/Greatest_common_divisor#JavaScript">rosettacode.org</a>}.
+     * Greatest common divisor (gcd) of two finite, non-zero integer numbers.
+     * See {@link https://rosettacode.org/wiki/Greatest_common_divisor#JavaScript rosettacode.org}.
      *
-     * @param  {Number} a First number
-     * @param  {Number} b Second number
-     * @returns {Number}   gcd(a, b) if a and b are numbers, NaN else.
+     * @param  {Number} a First number, not zero, Infinity, or NaN
+     * @param  {Number} b Second number, not zero, Infinity, or NaN
+     * @returns {Number} gcd(a, b) if a and b are finite, non-zero numbers, NaN else.
+     * @see JXG.Math#lcm
      */
     gcd: function (a, b) {
         var tmp,
-            endless = true;
+            endless = 100000;
 
         a = Math.abs(a);
         b = Math.abs(b);
@@ -15982,13 +15988,24 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         if (!(_utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(a) && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(b))) {
             return NaN;
         }
+        if (isNaN(a) || isNaN(b) || a === Infinity || b === Infinity) {
+            return NaN;
+        }
+        if (a === 0 || b === 0) {
+            return NaN;
+        }
+        if (!Number.isInteger(a) || !Number.isInteger(b)) {
+            _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.warn('JSXGraph: JXG.Math.gcd requires integer parameters');
+            return NaN;
+        }
+
         if (b > a) {
             tmp = a;
             a = b;
             b = tmp;
         }
 
-        while (endless) {
+        while (endless > 0) {
             a %= b;
             if (a === 0) {
                 return b;
@@ -15997,15 +16014,18 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
             if (b === 0) {
                 return a;
             }
+            endless--;
         }
     },
 
     /**
-     * Least common multiple (lcm) of two numbers.
+     * Least common multiple (lcm) of two finite integer numbers.
+     * lcm(0, a) is defined as 0.
      *
      * @param  {Number} a First number
      * @param  {Number} b Second number
-     * @returns {Number}   lcm(a, b) if a and b are numbers, NaN else.
+     * @returns {Number} lcm(a, b) if a and b are finite integer numbers, NaN else.
+     * @see JXG.Math#gcd
      */
     lcm: function (a, b) {
         var ret;
@@ -16013,6 +16033,16 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
         if (!(_utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(a) && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(b))) {
             return NaN;
         }
+        if (isNaN(a) || isNaN(b) || Math.abs(a) === Infinity || Math.abs(b) === Infinity) {
+            return NaN;
+        }
+        if (a === 0 || b === 0) {
+            return 0;
+        }
+        if (!Number.isInteger(a) || !Number.isInteger(b)) {
+            _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.warn('JSXGraph: JXG.Math.gcd requires integer parameters');
+            return NaN;
+        }
 
         ret = a * b;
         if (ret !== 0) {
@@ -16198,7 +16228,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     /* ********************  Comparisons and logical operators ************** */
 
     /**
-     * Logical test: a < b?
+     * Logical test: `a < b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16209,7 +16239,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical test: a <= b?
+     * Logical test: `a <= b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16220,7 +16250,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical test: a > b?
+     * Logical test: `a > b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16231,7 +16261,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical test: a >= b?
+     * Logical test: `a >= b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16242,7 +16272,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical test: a === b?
+     * Logical test: `a === b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16253,7 +16283,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical test: a !== b?
+     * Logical test: `a !== b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -16264,7 +16294,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical operator: a && b?
+     * Logical operator: `a && b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -16275,7 +16305,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical operator: !a?
+     * Logical operator: `!a`?
      *
      * @param {Boolean} a
      * @returns {Boolean}
@@ -16285,7 +16315,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical operator: a || b?
+     * Logical operator: `a || b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -16296,7 +16326,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Logical operator: either a or b?
+     * Logical operator: either `a` or `b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -16375,7 +16405,7 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     /* *************************** Normalize *************************** */
 
     /**
-     * Normalize the standard form [c, b0, b1, a, k, r, q0, q1].
+     * Normalize the standard form `[c, b0, b1, a, k, r, q0, q1]`.
      * @private
      * @param {Array} stdform The standard form to be normalized.
      * @returns {Array} The normalized standard form.
@@ -16446,13 +16476,13 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.Math = {
     },
 
     /**
-     * Theorem of Vieta: Given a set of simple zeroes x_0, ..., x_n
-     * of a polynomial f, compute the coefficients s_k, (k=0,...,n-1)
-     * of the polynomial of the form. See {@link https://de.wikipedia.org/wiki/Elementarsymmetrisches_Polynom}.
+     * Theorem of Vieta: Given a set of simple zeroes \\(x_0, \ldots, x_n\\)
+     * of a polynomial \\(f\\), compute the coefficients \\(s_k\\), \\(k=0, \ldots, n-1\\),
+     * of the polynomial of the form
+     * \\[ f(x) = (x-x_0)\cdots(x-x_n) = x^n + \sum_{k=1}^{n} (-1)^k s_{k-1} x^{n-k} \\]
+     *
+     * See {@link https://en.wikipedia.org/wiki/Vieta%27s_formulas}
      *
-     *  f(x) = (x-x_0)*...*(x-x_n) =
-     *  x^n + sum_{k=1}^{n} (-1)^(k) s_{k-1} x^(n-k)
-     * </p>
      * @param {Array} x Simple zeroes of the polynomial.
      * @returns {Array} Coefficients of the polynomial.
      *
@@ -17001,22 +17031,20 @@ _math_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.Numerics = {
      * Calculates the integral of function f over interval using Romberg iteration.
      * @param {Array} interval The integration interval, e.g. [0, 3].
      * @param {function} f A function which takes one argument of type number and returns a number.
-     * @param {Object} [config] The algorithm setup. Accepted properties are max_iterations of type number and precision eps.
+     * @param {Object} [config] The algorithm setup. Accepted properties are `max_iterations` of type number and precision `eps`.
      * @param {Number} [config.max_iterations=20]
      * @param {Number} [config.eps=0.0000001]
      * @returns {Number} Integral value of f over interval
      * @example
-     * function f(x) {
-     *   return x*x;
-     * }
+     * var f = (x) => x * x;
      *
-     * // calculates integral of `f` from 0 to 2.
-     * var area1 = JXG.Math.Numerics.Romberg([0, 2], f);
+     * // Calculates integral of `f` from 0 to 3.
+     * var area1 = JXG.Math.Numerics.Romberg([0, 3], f);
      *
-     * // the same with an anonymous function
-     * var area2 = JXG.Math.Numerics.Romberg([0, 2], function (x) { return x*x; });
+     * // The same with an anonymous function
+     * var area2 = JXG.Math.Numerics.Romberg([0, 3], function (x) { return x * x; });
      *
-     * // use trapez rule with maximum of 16 iterations or stop if the precision 0.0001 has been reached.
+     * // Use trapez rule with maximum of 16 iterations or stop if the precision 0.0001 has been reached.
      * var area3 = JXG.Math.Numerics.Romberg([0, 2], f,
      *                                   {max_iterations: 16, eps: 0.0001});
      * @memberof JXG.Math.Numerics
@@ -17033,8 +17061,11 @@ _math_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.Numerics = {
             p = [],
             integral = 0.0,
             last = Infinity,
-            m = config && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(config.max_iterations) ? config.max_iterations : 20,
-            eps = config && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(config.eps) ? config.eps : config.eps || 0.0000001;
+            m, eps;
+
+        config = _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.def(config, {});
+        m = config && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(config.max_iterations) ? config.max_iterations : 20;
+        eps = config && _utils_type_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.isNumber(config.eps) ? config.eps : (config.eps || 0.0000001);
 
         a = interval[0];
         b = interval[1];
@@ -17301,7 +17332,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .A.Numerics = {
         xm = 0.5 * (b - a);
         xp = 0.5 * (b + a);
 
-        if (n & (1 === 1)) {
+        if ((n & 1) === 1) {
             // n odd
             result = w[0] * f(xp);
             for (i = 1; i < m; ++i) {
@@ -22184,12 +22215,12 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
      * The Theil-Sen estimator can be used to determine a more robust linear regression of a set of sample
      * points than least squares regression in {@link JXG.Math.Numerics.regressionPolynomial}.
      *
-     * If the function should be applied to an array a of points, a the coords array can be generated with
-     * JavaScript array.map:
+     * If the function should be applied to an array `a` of *points*, a coords array can be generated with
+     * JavaScript `array.map`:
      *
-     * <pre>
+     * ```
      * JXG.Math.Statistics.TheilSenRegression(a.map(el => el.coords));
-     * </pre>
+     * ```
      *
      * @param {Array} coords Array of {@link JXG.Coords}.
      * @returns {Array} A stdform array of the regression line.
@@ -22197,10 +22228,10 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
      *
      * @example
      * var board = JXG.JSXGraph.initBoard('jxgbox', { boundingbox: [-6,6,6,-6], axis : true });
-     * var a=[];
-     * a[0]=board.create('point', [0,0]);
-     * a[1]=board.create('point', [3,0]);
-     * a[2]=board.create('point', [0,3]);
+     * var a = [];
+     * a[0] = board.create('point', [0, 0]);
+     * a[1] = board.create('point', [3, 0]);
+     * a[2] = board.create('point', [0, 3]);
      *
      * board.create('line', [
      *     () => JXG.Math.Statistics.TheilSenRegression(a.map(el => el.coords))
@@ -22254,7 +22285,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate values of a standard normal random variable with the Marsaglia polar method, see
-     * <a href="https://en.wikipedia.org/wiki/Marsaglia_polar_method">https://en.wikipedia.org/wiki/Marsaglia_polar_method</a>.
+     * {@link https://en.wikipedia.org/wiki/Marsaglia_polar_method}..
      * See also D. E. Knuth, The art of computer programming, vol 2, p. 117.
      *
      * @param {Number} mean mean value of the normal distribution
@@ -22344,7 +22375,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
     },
 
     /**
-     * Generate value of a uniform distributed random variable in the interval [a, b].
+     * Generate value of a uniform distributed random variable in the interval `[a, b]`.
      * @param {Number} a
      * @param {Number} b
      * @returns Number
@@ -22356,7 +22387,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with exponential distribution, i.e.
-     * \\(f(x; \lambda) = \lambda * e^(-\lambda x)\\) if \\(x \geq 0\\) and \\(f(x; \lambda) = 0\\) if \\(x < 0\\).
+     * \\(f(x; \lambda) = \lambda \cdot e^{-\lambda x}\\) if \\(x \geq 0\\) and \\(f(x; \lambda) = 0\\) if \\(x < 0\\).
      * See <a href="https://en.wikipedia.org/wiki/Exponential_distribution">https://en.wikipedia.org/wiki/Exponential_distribution</a>.
      * Algorithm: D.E. Knuth, TAOCP 2, p. 128.
      *
@@ -22425,7 +22456,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with gamma distribution of order alpha.
-     * See <a href="https://en.wikipedia.org/wiki/Gamma_distribution">https://en.wikipedia.org/wiki/Gamma_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Gamma_distribution}.
      * Algorithm: D.E. Knuth, TAOCP 2, p. 129.
 
      * @param {Number} a shape, \\( > 0\\)
@@ -22541,7 +22572,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with beta distribution with shape parameters alpha and beta.
-     * See <a href="https://en.wikipedia.org/wiki/Beta_distribution">https://en.wikipedia.org/wiki/Beta_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Beta_distribution}.
      *
      * @param {Number} alpha \\(< 0\\)
      * @param {Number} beta \\(< 0\\)
@@ -22564,7 +22595,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with chi-square distribution with k degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/Chi-squared_distribution">https://en.wikipedia.org/wiki/Chi-squared_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Chi-squared_distribution}.
      *
      * @param {Number} k \\(>0\\)
      * @returns Number
@@ -22582,7 +22613,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with F-distribution with d<sub>1</sub> and d<sub>2</sub> degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/F-distribution">https://en.wikipedia.org/wiki/F-distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/F-distribution}.
      * @param {Number} d1 \\(>0\\)
      * @param {Number} d2 \\(>0\\)
      * @returns Number
@@ -22604,7 +22635,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate value of a random variable with Students-t-distribution with &nu; degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/Student%27s_t-distribution">https://en.wikipedia.org/wiki/Student%27s_t-distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Student%27s_t-distribution}.
      * @param {Number} nu \\(>0\\)
      * @returns Number
      * @memberof JXG.Math.Statistics
@@ -22625,8 +22656,8 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate values for a random variable in binomial distribution with parameters \\(n\\) and \\(p\\).
-     * See <a href="https://en.wikipedia.org/wiki/Binomial_distribution">https://en.wikipedia.org/wiki/Binomial_distribution</a>.
-     * It uses algorithm BG from <a href="https://dl.acm.org/doi/pdf/10.1145/42372.42381">https://dl.acm.org/doi/pdf/10.1145/42372.42381</a>.
+     * See {@link https://en.wikipedia.org/wiki/Binomial_distribution}.
+     * It uses algorithm BG from {@link https://dl.acm.org/doi/pdf/10.1145/42372.42381}.
      *
      * @param {Number} n Number of trials (n >= 0)
      * @param {Number} p Probability (0 <= p <= 1)
@@ -22750,7 +22781,7 @@ _math_js__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .A.Statistics = {
 
     /**
      * Generate values for a random variable in geometric distribution with probability \\(p\\).
-     * See <a href="https://en.wikipedia.org/wiki/Geometric_distribution">https://en.wikipedia.org/wiki/Geometric_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Geometric_distribution}.
      *
      * @param {Number} p (0 <= p <= 1)
      * @returns Number
@@ -38527,7 +38558,7 @@ upcomingInput:function () {
 showPosition:function () {
         var pre = this.pastInput();
         var c = new Array(pre.length + 1).join("-");
-        return pre + this.upcomingInput() + "\n" + c+"^";
+        return _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.escapeHTML(pre + this.upcomingInput() + "\n" + c+"^");
     },
 next:function () {
         if (this.done) {
@@ -42757,8 +42788,10 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.extend(
         mergeAttr: function (attr, special, toLower, ignoreUndefinedSpecials) {
             var e, e2, o;
 
-            toLower = toLower || true;
-            ignoreUndefinedSpecials = ignoreUndefinedSpecials || false;
+            // toLower = toLower || true;
+            // ignoreUndefinedSpecials || false;
+            toLower = this.def(toLower, true);
+            ignoreUndefinedSpecials = this.def(ignoreUndefinedSpecials, false);
 
             for (e in special) {
                 if (special.hasOwnProperty(e)) {
@@ -43231,8 +43264,13 @@ _jxg_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .A.extend(
          * @returns {String}
          */
         trimNumber: function (str) {
-            str = str.replace(/^0+/, "");
-            str = str.replace(/0+$/, "");
+            if (str !== '0') {
+                str = str.replace(/^0+/, "");
+            }
+
+            if (str.indexOf('.') >= 0 || str.indexOf(',') >= 0) {
+                str = str.replace(/0+$/, "");
+            }
 
             if (str[str.length - 1] === "." || str[str.length - 1] === ",") {
                 str = str.slice(0, -1);
@@ -54352,11 +54390,11 @@ jxg/* default */.A.Complex.C = jxg/* default */.A.C;
 math/* default */.A.Tiling = {
     /**
      * Triangulate (partition it into triangles) a given two dimensional domain.
-     * The number of triangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
-     * If the optional parameter stepsV is not given or is equal to 0, the rectangle is partitioned into
+     * The number of triangles the original rectangle is divided into depends on the parameters` `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
+     * If the optional parameter `stepsV` is not given or is equal to 0, the rectangle is partitioned into
      * nearly equilateral triangles.
-     * Otherwise, the shape of the triangles depends on the ratio of stepsU / stepsV.
+     * Otherwise, the shape of the triangles depends on the ratio of `stepsU / stepsV`.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -54512,8 +54550,8 @@ math/* default */.A.Tiling = {
 
     /**
      * Rectangulate (partition it into rectangles) a given two dimensional domain.
-     * The number of rectangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
+     * The number of rectangles the original rectangle is divided into depends on the parameters `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -54637,288 +54675,6 @@ math/* default */.A.Tiling = {
         }
         return [vertices, faces];
     }
-
-    // triangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         width, height,
-    //         wSide, hSide,
-    //         triangleWidth, triangleHeight,
-    //         s1, s2,
-    //         i, j,
-    //         numRows,
-    //         widthX, widthY, heightX, heightY,
-    //         oddPoints,
-    //         evenPoints;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error(" the board created is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     if (s1 <= s2) {
-    //         width = s1;
-    //         height = s2;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         width = s2;
-    //         height = s1;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-    //     // Calculate height and width of the triangles and number of rows
-    //     triangleWidth = width / stepsU;
-
-    //     if (stepsV === undefined || stepsV === 0) {
-    //         // Equilateral triangles, depending on parameter "stepsU"
-    //         triangleHeight = (triangleWidth * Math.sqrt(3)) / 2;
-    //         numRows = Math.round(height / triangleHeight);
-    //     } else {
-    //         // Two parameters stepsU, stepsV
-    //         numRows = stepsV;
-    //         triangleHeight = height / numRows;
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsU;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsU;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / numRows;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / numRows;
-
-    //     oddPoints = [];
-    //     evenPoints = [];
-
-    //     // Push coordinates of the base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     evenPoints.push(coords.length - 1);
-
-    //     // Calculate point coordinates of layer 0 and store indices in evenPoints
-    //     for (i = 1; i <= stepsU; i++) {
-    //         coords.push([p1[0] + i * widthX, p1[1] + i * widthY]); // Points first line
-    //         evenPoints.push(coords.length - 1);
-    //     }
-
-    //     for (i = 1; i <= numRows; i++) {
-    //         if (i % 2 === 0) {
-    //             // Points and faces of layers with an even index
-
-    //             evenPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // evenPoints stores index of the first point of the layer
-    //             evenPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[evenPoints[0]][0] + j * widthX,
-    //                     coords[evenPoints[0]][1] + j * widthY
-    //                 ]);
-    //                 //evenPoints stores index of the most recently calculated point of the layer
-    //                 evenPoints.push(coords.length - 1);
-    //             }
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([evenPoints[0], oddPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([evenPoints[j - 1], oddPoints[j], evenPoints[j]]);
-    //                 faces.push([evenPoints[j], oddPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         } else {
-    //             // Points and faces of layers with an odd index
-
-    //             oddPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // oddPoints stores index of the first point of the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer except for the last point
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[oddPoints[0]][0] + j * widthX - widthX / 2,
-    //                     coords[oddPoints[0]][1] + j * widthY - widthY / 2
-    //                 ]);
-    //                 // oddPoints stores index of the most recently calculated point of the layer
-    //                 oddPoints.push(coords.length - 1);
-    //             }
-    //             // Calculate last point coordinates within the layer
-    //             coords.push([
-    //                 coords[oddPoints[0]][0] + stepsU * widthX,
-    //                 coords[oddPoints[0]][1] + stepsU * widthY
-    //             ]);
-    //             // oddPoints stores index of last point within the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([oddPoints[0], evenPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([oddPoints[j], evenPoints[j - 1], evenPoints[j]]);
-    //                 faces.push([oddPoints[j], evenPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // rectangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         wSide, hSide,
-    //         s1, s2,
-    //         i, j,
-    //         widthX, widthY,
-    //         heightX, heightY,
-    //         startPointLayer;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error("rectangulation_old: area is not rectangle  ");
-    //         // console.log("rectangulation_old: area is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     // s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     // s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     s1 = Mat.hypot(vec1[0], vec1[1]);
-    //     s2 = Mat.hypot(vec2[0], vec2[1]);
-
-    //     if (s1 <= s2) {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsV;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsV;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / stepsU;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / stepsU;
-
-    //     // Initialize startPointLayer that stores coordinates of the first point of the current layer
-    //     startPointLayer = [];
-
-    //     // Push coordinates of base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     startPointLayer = coords[0];
-
-    //     // Calculate point coordinates of layer 0
-    //     for (j = 1; j <= stepsV; j++) {
-    //         coords.push([startPointLayer[0] + j * widthX, startPointLayer[1] + j * widthY]);
-    //     }
-
-    //     for (i = 1; i <= stepsU; i++) {
-    //         startPointLayer = [];
-
-    //         // Calculate point coordinates of first point of layer
-    //         coords.push([
-    //             p1[0] + i * heightX,
-    //             p1[1] + i * heightY
-    //         ]);
-    //         startPointLayer = coords[coords.length - 1];
-
-    //         // Calculating remaining point coordinates of layer
-    //         for (j = 1; j <= stepsV; j++) {
-    //             coords.push([
-    //                 startPointLayer[0] + j * widthX,
-    //                 startPointLayer[1] + j * widthY
-    //             ]);
-    //         }
-
-    //         // Connect rectangles by grouping indices of points
-    //         for (
-    //             j = coords.length - stepsV - 1;
-    //             j < coords.length - 1;
-    //             j++
-    //         ) {
-    //             faces.push([j, j - stepsV - 1, j - stepsV, j + 1]);
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // /**
-    //  * This function creates an array of dynamic 3-dimensional points
-    //  * based on an array of pairs of two coordinates.
-    //  * It uses a mathematical function to assign a third coordinate (the z-coordinate)
-    //  * to each pair of two coordinates.
-    //  * The 3-dimensional points are not stored directly.
-    //  * Instead the array stores JavaScript functions that utilize the mentioned mathematical function
-    //  * to return an array of three coordinates.
-    //  * This allows the recognition and proper visualization of changes to the underlying
-    //  * mathematical function.
-    //  * @name mapMeshTo3D
-    //  * @param {Array} surface
-    //  * @param {Parametricsurface3d} el
-    //  * @returns {Array} dynamicPoints array of [x, y, z] coordinates
-    //  *
-    //  * @private
-    //  * @memberof JXG.Math.Tiling
-    //  */
-    // mapMeshTo3D: function (surface, el) {
-    //     var dynamicPoints = [], i;
-
-    //     for (i = 0; i < surface[0].length; i++) {
-    //         dynamicPoints.push(
-    //             (function (u, v) {
-    //                 return function(x, y) { return el.F(u, v); };
-    //             })(surface[0][i][0], surface[0][i][1])
-    //         ); // Capture values explicitly
-    //         // dynamicPoints.push(
-    //         //     (function (u, v) {
-    //         //         return function(x, y) { return el.F(Type.evaluate(u), Type.evaluate(v)); };
-    //         //     })(surface[0][i][0], surface[0][i][1])
-    //         // ); // Capture values explicitly
-    //     }
-
-    //     return dynamicPoints;
-    // }
 };
 
 /* harmony default export */ var math_tiling = (math/* default */.A.Tiling);
@@ -58236,9 +57992,9 @@ jxg/* default */.A.extend(
     /** @lends JXG.Composition.prototype */ {
         /**
          * Adds an element to the composition container.
-         * @param {String} what Descriptive name for the element, e.g. <em>startpoint</em> or <em>area</em>. This is used to
-         * access the element later on. There are some reserved names: <em>elements, add, remove, update, prepareUpdate,
-         * updateRenderer, highlight, noHighlight</em>, and all names that would form invalid object property names in
+         * @param {String} what Descriptive name for the element, e.g. `startpoint` or `area`. This is used to
+         * access the element later on. There are some reserved names: `elements`, `add`, `remove`, `update`, `prepareUpdate`,
+         * `updateRenderer`, `highlight`, `noHighlight`, and all names that would form invalid object property names in
          * JavaScript.
          * @param {JXG.GeometryElement|JXG.Composition} element A reference to the element that is to be added. This can be
          * another composition, too.
@@ -62762,6 +62518,9 @@ jxg/* default */.A.extend(
             var w = width,
                 h = height,
                 // bb,
+                bbox,
+                offX = 0,
+                offY = 0,
                 css,
                 width_adjustment, height_adjustment;
 
@@ -62798,7 +62557,38 @@ jxg/* default */.A.extend(
 
             // If bounding box is not yet initialized, do it now.
             if (isNaN(this.getBoundingBox()[0])) {
-                this.setBoundingBox(this.attr.boundingbox, this.keepaspectratio, 'keep');
+                // This is not enough
+                // this.setBoundingBox(this.attr.boundingbox, this.keepaspectratio, 'keep');
+                // Instead, we do the same as in JXG.JSXGraphinitBoard():
+                bbox = this.attr.boundingbox;
+                if (utils_type/* default */.A.exists(bbox) && this.keepaspectratio) {
+                    /*
+                     * If the boundingbox attribute is given and the ratio of height and width of the
+                     * sides defined by the bounding box and the ratio of the dimensions of the div tag
+                     * which contains the board do not coincide, then the smaller side is chosen.
+                     */
+                    this.unitX = w / (bbox[2] - bbox[0]);
+                    this.unitY = h / (bbox[1] - bbox[3]);
+
+                    if (Math.abs(this.unitX) < Math.abs(this.unitY)) {
+                        this.unitY = (Math.abs(this.unitX) * this.unitY) / Math.abs(this.unitY);
+                        // Add the additional units in equal portions above and below
+                        offY = (h / this.unitY - (bbox[1] - bbox[3])) * 0.5;
+                    } else {
+                        this.unitX = (Math.abs(this.unitY) * this.unitX) / Math.abs(this.unitX);
+                        // Add the additional units in equal portions left and right
+                        offX = (w / this.unitX - (bbox[2] - bbox[0])) * 0.5;
+                    }
+                } else {
+                    this.unitX = w / (bbox[2] - bbox[0]);
+                    this.unitY = h / (bbox[1] - bbox[3]);
+                }
+                this.origin.scrCoords = [1,
+                    -this.unitX * (bbox[0] - offX),
+                    this.unitY * (bbox[1] + offY)
+                ];
+                this.canvasWidth = w;
+                this.canvasHeight = h;
             }
 
             // Do nothing if the dimension did not change since being visible
@@ -62839,16 +62629,21 @@ jxg/* default */.A.extend(
             }
 
             this.resizeObserver = new ResizeObserver(function (entries) {
-                var bb;
+                // var bb;
+
+                // Take the last observed size
+                that._lastContentRect = entries[entries.length - 1].contentRect;
                 if (!that._isResizing) {
                     that._isResizing = true;
-                    bb = entries[0].contentRect;
+                    // bb = entries[0].contentRect;
                     window.setTimeout(function () {
+                        var bb = that._lastContentRect;
                         try {
                             that.updateContainerDims(bb.width, bb.height);
                         } catch (e) {
-                            jxg/* default */.A.debug(e);   // Used to log errors during board.update()
-                            that.stopResizeObserver();
+                            // JXG.debug(e);   // Used to log errors during board.update()
+                            console.error(e);
+                            // that.stopResizeObserver();
                         } finally {
                             that._isResizing = false;
                         }
@@ -63881,7 +63676,7 @@ jxg/* default */.A.extend(
          * @private
          */
         _removeObj: function (object, saveMethod) {
-            var el, o, i;
+            var el, i, pos;
 
             if (utils_type/* default */.A.isArray(object)) {
                 for (i = 0; i < object.length; i++) {
@@ -63899,6 +63694,16 @@ jxg/* default */.A.extend(
                 return this;
             }
 
+            // Already removed (e.g. reached again through a parent's childElements
+            // or View3D.removeObject). Removing it twice used to splice a live element.
+            if (object._pos === -1 && this.objects[object.id] !== object) {
+                return this;
+            }
+
+            if (object.is3D && utils_type/* default */.A.exists(object.view.objects[object.id])) {
+                jxg/* default */.A.warn("board.removeObject() of 3D object " + object.id + ". Use view3d.removeObject() instead.");
+            }
+
             try {
                 // remove all children.
                 for (el in object.childElements) {
@@ -63948,15 +63753,16 @@ jxg/* default */.A.extend(
                 }
 
                 // remove the object itself from our control structures
-                if (object._pos > -1) {
-                    this.objectsList.splice(object._pos, 1);
+                // Trust _pos only if it still points at the object, and reset it
+                // afterwards, so a stale index can never splice another element.
+                pos = this.objectsList[object._pos] === object ? object._pos : this.objectsList.indexOf(object);
+                if (pos > -1) {
+                    this.objectsList.splice(pos, 1);
                     // Quadratic complexity for reindexing the positions:
-                    for (i = object._pos; i < this.objectsList.length; i++) {
-                        o = this.objectsList[i];
-                        if (o._pos > -1) {
-                            o._pos--;
-                        }
+                    for (i = pos; i < this.objectsList.length; i++) {
+                        this.objectsList[i]._pos = i;
                     }
+                    object._pos = -1;
                 } else if (object.type !== constants/* default */.A.OBJECT_TYPE_TURTLE) {
                     jxg/* default */.A.debug(
                         'Board.removeObject: object ' + object.id + ' not found in list.'
@@ -67102,7 +66908,7 @@ jxg/* default */.A.SVGRenderer = function (container, dim) {
         var id = this.uniqName('ClipFull'),
             node1 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'clipPath'),
             node2 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'rect'),
-            style, rx, ry;
+            style, r;
         node1.setAttributeNS(null, 'id', id);
 
         node2.setAttributeNS(null, 'x', 0);
@@ -67112,10 +66918,9 @@ jxg/* default */.A.SVGRenderer = function (container, dim) {
 
         // Inherit border-radius
         style = getComputedStyle(this.container);
-        rx = utils_type/* default */.A.exists(style['border-radius']) ? parseFloat(style['border-radius']) : 0;
-        ry = rx;
-        node2.setAttributeNS(null, 'rx', rx);
-        node2.setAttributeNS(null, 'ry', ry);
+        r = (utils_type/* default */.A.exists(style['border-radius']) && style['border-radius'] !== '') ? parseFloat(style['border-radius']) : 0;
+        node2.setAttributeNS(null, 'rx', r);
+        node2.setAttributeNS(null, 'ry', r);
 
         node1.appendChild(node2);
         return node1;
@@ -67803,7 +67608,7 @@ jxg/* default */.A.extend(
 
         // Already documented in JXG.AbstractRenderer
         setLayer: function (el, level) {
-            var node;
+            var node, elNode;
             if (!utils_type/* default */.A.exists(level)) {
                 level = 0;
             } else if (level >= src_options/* default */.A.layer.numlayers) {
@@ -67811,8 +67616,16 @@ jxg/* default */.A.extend(
             }
 
             node = this.layer[level];
+            // if ('moveBefore' in Element.prototype) {
             if (utils_type/* default */.A.exists(node.moveBefore)) {
-                node.moveBefore(el.rendNode, null);
+                // node.moveBefore(el.rendNode, null);
+                elNode = el.rendNode;
+                if (elNode.isConnected && node.isConnected &&
+                    (elNode.ownerDocument === node.ownerDocument)) {
+                    node.moveBefore(elNode, null);
+                } else {
+                    node.insertBefore(elNode, null);
+                }
             } else {
                 node.appendChild(el.rendNode);
             }
@@ -68099,6 +67912,7 @@ jxg/* default */.A.extend(
                 i = 0;
                 while (i < len) {
                     if (el.points[i] === undefined) {
+                        i++;
                         continue;
                     }
                     scr = el.points[i].scrCoords;
@@ -70932,7 +70746,7 @@ jxg/* default */.A.extend(
          * Set the gradient angle for linear color gradients.
          *
          * @private
-         * @param {JXG.GeometryElement} node An arbitrary JSXGraph element, preferably one with an area.
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} radians angle value in radians. 0 is horizontal from left to right, Pi/4 is vertical from top to bottom.
          */
         updateGradientAngle: function (el, radians) {
@@ -70988,7 +70802,7 @@ jxg/* default */.A.extend(
          * Set circles for radial color gradients.
          *
          * @private
-         * @param {SVGnode} node SVG gradient node
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} cx Canvas value x1 (but value between 0 and 1)
          * @param {Number} cy  Canvas value y1 (but value between 0 and 1)
          * @param {Number} r  Canvas value r1 (but value between 0 and 1)
@@ -71001,19 +70815,20 @@ jxg/* default */.A.extend(
                 c1, c2,
                 cxs, cys, rs,
                 fxs, fys, frs,
-                dx, dy;
+                dx, dy, d;
 
             c1 = new base_coords/* default */.A(constants/* default */.A.COORDS_BY_USER, [bb[0], bb[1]], el.board);
             c2 = new base_coords/* default */.A(constants/* default */.A.COORDS_BY_USER, [bb[2], bb[3]], el.board);
             dx = c2.scrCoords[1] - c1.scrCoords[1];
             dy = c1.scrCoords[2] - c2.scrCoords[2];
-
             cxs = c1.scrCoords[1] + dx * cx;
             cys = c2.scrCoords[2] + dy * cy;
             fxs = c1.scrCoords[1] + dx * fx;
             fys = c2.scrCoords[2] + dy * fy;
-            rs = r * (dx + dy) * 0.5;
-            frs = fr * (dx + dy) * 0.5;
+
+            d = Math.abs(dx) + Math.abs(dy);
+            rs = Math.max(r * d * 0.5, 0);
+            frs = Math.max(fr * d * 0.5, 0);
 
             return this.context.createRadialGradient(fxs, fys, frs, cxs, cys, rs);
         },
@@ -80354,13 +80169,30 @@ jxg/* default */.A.registerElement("circle", jxg/* default */.A.createCircle);
  * @jsxgraphsignature Ellipse
  * Parent elements can be two elements either of type {@link JXG.Point} or array of
  * numbers describing the coordinates of a point.
- * The third parameter is a number/function which defines the length of the major axis
+ * The third parameter is a number/function which defines the length of the major axis.
  * @param {PointLike} point1
  * @param {PointLike} point2
  * @param {NumberLike} number
  * @param {Number} [start=0] parameter of the curve start, default: 0.
  * @param {Number} [end=2π] parameter for the curve end, default: 2&pi;.
  *
+ * @example
+ * var A = board.create('point', [1,0]);
+ * var B = board.create('point', [-1,0]);
+ * var el = board.create('ellipse',[A, B, 4]);
+ *
+ * </pre><div id="JXG7898d447-94dc-4dce-9ad3-60e3387be9f3" class="jxgbox" style="width: 300px; height: 300px;"></div>
+ * <script type="text/javascript">
+ *     (function() {
+ *         var board = JXG.JSXGraph.initBoard('JXG7898d447-94dc-4dce-9ad3-60e3387be9f3',
+ *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+ *     var A = board.create('point', [1,0]);
+ *     var B = board.create('point', [-1,0]);
+ *     var el = board.create('ellipse',[A,B, 4]);
+ *     })();
+ *
+ * </script><pre>
+ *
  */
 jxg/* default */.A.createEllipse = function (board, parents, attributes) {
     var polarForm,
@@ -80632,6 +80464,23 @@ jxg/* default */.A.createEllipse = function (board, parents, attributes) {
  * @param {NumberLike} number
  * @param {Number} [start=-π] parameter of the curve start, default: -&pi;.
  * @param {Number} [end=π] parameter for the curve end, default: &pi;.
+ * @example
+ * var A = board.create('point', [1,0]);
+ * var B = board.create('point', [-1,0]);
+ * var el = board.create('hyperbola',[A, B, 1]);
+ *
+ * </pre><div id="JXGa4c0068b-41bc-4be4-b485-d0d0c7f2e10b" class="jxgbox" style="width: 300px; height: 300px;"></div>
+ * <script type="text/javascript">
+ *     (function() {
+ *         var board = JXG.JSXGraph.initBoard('JXGa4c0068b-41bc-4be4-b485-d0d0c7f2e10b',
+ *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+ *     var A = board.create('point', [1,0]);
+ *     var B = board.create('point', [-1,0]);
+ *     var el = board.create('hyperbola',[A,B, 1]);
+ *
+ *     })();
+ *
+ * </script><pre>
  */
 jxg/* default */.A.createHyperbola = function (board, parents, attributes) {
     var polarForm,
@@ -87856,11 +87705,11 @@ jxg/* default */.A.createSector = function (board, parents, attributes) {
                 s = el.line1.point1.coords;
             } else if (
                 el.line1.point2.Dist(el.line2.point1) < eps ||
-                el.line1.point2.Dist(el.line2.point1) < eps
+                el.line1.point2.Dist(el.line2.point2) < eps
             ) {
                 s = el.line1.point2.coords;
             } else {
-                console.log(
+                jxg/* default */.A.warn(
                     "JSXGraph warning: Can't create Sector from parallel lines with no common defining point."
                 );
             }
@@ -87941,10 +87790,13 @@ jxg/* default */.A.createSector = function (board, parents, attributes) {
                     B = l1.point1.coords.usrCoords;
                 } else if (
                     l1.point2.Dist(l2.point1) < eps ||
-                    l1.point2.Dist(l2.point1) < eps
+                    l1.point2.Dist(l2.point2) < eps
                 ) {
                     B = l1.point2.coords.usrCoords;
                 } else {
+                    jxg/* default */.A.warn(
+                        "JSXGraph warning: sector from parallel lines with no common defining point."
+                    );
                 }
             }
 
@@ -111916,7 +111768,7 @@ jxg/* default */.A.extend(
     },
 
     removeObject: function (object, saveMethod) {
-        var i, el, le, o, fst, face;
+        var i, el, le, o, fst, face, gone, list;
 
         // this.board.removeObject(object, saveMethod);
         if (utils_type/* default */.A.isArray(object)) {
@@ -111928,8 +111780,8 @@ jxg/* default */.A.extend(
 
         object = this.select(object);
 
-        // // If the object which is about to be removed unknown or a string, do nothing.
-        // // it is a string if a string was given and could not be resolved to an element.
+        // If the object which is about to be removed unknown or a string, do nothing.
+        // it is a string if a string was given and could not be resolved to an element.
         if (!utils_type/* default */.A.exists(object) || utils_type/* default */.A.isString(object)) {
             return this;
         }
@@ -111938,38 +111790,46 @@ jxg/* default */.A.extend(
             // Remove all children.
             for (el in object.childElements) {
                 if (object.childElements.hasOwnProperty(el)) {
-                    this.removeObject(object.childElements[el]);
+                    o = object.childElements[el];
+                    if (!(object.is3D && object.element2D === o)) {
+                        this.removeObject(o);
+                    }
                 }
             }
             if (object.type === constants/* default */.A.OBJECT_TYPE_POLYHEDRON3D) {
                 // Special treatment for polyhedron3d.
                 // With this we can avoid the time consuming addChild() calls.
+                // Mark faces and their 2D elements, then compact objectsList once.
+                // Splicing face by face with stale _pos removed unrelated elements.
+                gone = {};
                 le = object.faces.length;
-                if (le > 0) {
-                    fst = object.faces[0]._pos;
-                    fst = (object.faces[0].element2D._pos < fst) ? object.faces[0].element2D._pos : fst;
-                }
                 for (i = 0; i < le; i++) {
                     face = object.faces[i];
                     delete this.objects[face.id];
 
-                    // this.board.removeObject(face.element2D, saveMethod);
                     delete this.board.objects[face.element2D.id];
                     delete this.board.elementsByName[face.element2D.name];
                     face.element2D.remove();
-                    this.board.objectsList.splice(face.element2D._pos, 1);
+                    gone[face.element2D.id] = true;
+                    face.element2D._pos = -1;
 
                     delete this.board.objects[face.id];
                     delete this.board.elementsByName[face.name];
                     face.remove();
-                    this.board.objectsList.splice(face._pos, 1);
+                    gone[face.id] = true;
+                    face._pos = -1;
                 }
-                le = this.board.objectsList.length;
-                // Reindex the positions
-                for (i = fst; i < this.board.objectsList.length; i++) {
-                    o = this.board.objectsList[i];
-                    if (o._pos > -1) { o._pos = i; }
+                list = this.board.objectsList;
+                fst = 0;
+                for (i = 0; i < list.length; i++) {
+                    o = list[i];
+                    if (!gone.hasOwnProperty(o.id)) {
+                        o._pos = fst;
+                        list[fst] = o;
+                        fst++;
+                    }
                 }
+                list.length = fst;
                 object.faces = [];
             }
 
@@ -115638,8 +115498,6 @@ jxg/* default */.A.extend(
             }
         },
 
-
-
         /**
         * Starts an animated point movement towards the given coordinates `where`.
         * The animation is done after `time` milliseconds.
@@ -115861,9 +115719,6 @@ jxg/* default */.A.extend(
             });
         },
 
-
-
-
         // Not yet working
         __evt__update3D: function (oc) { }
     }
@@ -117481,8 +117336,8 @@ jxg/* default */.A.createLine3D = function (board, parents, attributes) {
          * @private
          */
         el.endpoints = endpoints;
-        el.addChild(endpoints[0]);
-        el.addChild(endpoints[1]);
+        // el.addChild(endpoints[0]); // Is done below
+        // el.addChild(endpoints[1]);
         // el.setParents(endpoints);
         el.addParents([point1, point2]);
 
@@ -118829,18 +118684,24 @@ jxg/* default */.A.createIntersectionLine3D = function (board, parents, attribut
     var view = parents[0],
         el1 = parents[1],
         el2 = parents[2],
-        ixnLine, i,// func,
+        ixnLine, i,// f,
         attr = utils_type/* default */.A.copyAttributes(attributes, board.options, 'intersectionline3d'),
         pts = [];
 
-    // func = Geometry.intersectionFunction3D(view, el1, el2);
+    // var func = Geometry.intersectionFunction3D(view, el1, el2);
     for (i = 0; i < 2; i++) {
-        pts[i] = view.create('point3d', [
-            // Use closures
-            (function(ii) {
-                return function() { return geometry/* default */.A.intersectionFunction3D(view, el1, el2)[ii]; };
-            })(i)
-        ], attr['point' + (i + 1)]);
+        try {
+            pts[i] = view.create('point3d', [
+                // Use closures
+                (function (ii) {
+                    return function () { return geometry/* default */.A.intersectionFunction3D(view, el1, el2)[ii]; };
+                })(i)
+            ], attr['point' + (i + 1)]);
+        } catch (err) {
+            throw new Error(
+                "JSXGraph: Can't create IntersectionLine3D from the intersection of these types. Please check the intersecting elements."
+            );
+        }
     }
     ixnLine = view.create('line3d', pts, attr);
 
@@ -121200,28 +121061,52 @@ jxg/* default */.A.extend(
     jxg/* default */.A.Sphere3D.prototype,
     /** @lends JXG.Sphere3D.prototype */ {
 
+        /**
+         * Returns the x-coordinate of the sphere given as parametric surface for parameters `u` and `v`.
+         * @param {Number} u
+         * @param {Number} v
+         * @returns {Number} x-coordinate
+         */
         X: function(u, v) {
             var r = this.Radius();
             return r * Math.sin(u) * Math.cos(v);
         },
 
+        /**
+         * Returns the y-coordinate of the sphere given as parametric surface for parameters `u` and `v`.
+         * @param {Number} u
+         * @param {Number} v
+         * @returns {Number} y-coordinate
+         */
         Y: function(u, v) {
             var r = this.Radius();
             return r * Math.sin(u) * Math.sin(v);
         },
 
+        /**
+         * Returns the z-coordinate of the sphere given as parametric surface for parameters `u` and `v`.
+         * @param {Number} u
+         * @param {Number} v
+         * @returns {Number} z-coordinate
+         */
         Z: function(u, v) {
             var r = this.Radius();
             return r * Math.cos(u);
         },
 
+        /**
+         * The parameter range of `u`
+         * @type {Array}
+         */
         range_u: [0, 2 * Math.PI],
+
+        /**
+         * The parameter range of `v`
+         * @type {Array}
+         */
         range_v: [0, Math.PI],
 
         update: function () {
-            if (this.projectionType !== this.view.projectionType) {
-                this.rebuildProjection();
-            }
             return this;
         },
 
@@ -121269,34 +121154,55 @@ jxg/* default */.A.extend(
             return NaN;
         },
 
-        // The central projection of a sphere is an ellipse. The front and back
-        // points of the sphere---that is, the points closest to and furthest
-        // from the screen---project to the foci of the ellipse.
-        //
-        // To see this, look at the cone tangent to the sphere whose tip is at
-        // the camera. The image of the sphere is the ellipse where this cone
-        // intersects the screen. By acting on the sphere with scalings centered
-        // on the camera, you can send it to either of the Dandelin spheres that
-        // touch the screen at the foci of the image ellipse.
-        //
-        // This factory method produces two functions, `focusFn(-1)` and
-        // `focusFn(1)`, that evaluate to the projections of the front and back
-        // points of the sphere, respectively.
+        /**
+         * The central projection of a sphere is an ellipse. The front and back
+         * points of the sphere -- that is, the points closest to and furthest
+         * from the screen -- project to the foci of the ellipse.
+         *
+         * To see this, look at the cone tangent to the sphere whose tip is at
+         * the camera. The image of the sphere is the ellipse where this cone
+         * intersects the screen. By acting on the sphere with scalings centered
+         * on the camera, you can send it to either of the Dandelin spheres that
+         * touch the screen at the foci of the image ellipse.
+         *
+         * This factory method produces two functions, `focusFn(-1)` and
+         * `focusFn(1)`, that evaluate to the projections of the front and back
+         * points of the sphere, respectively.
+         *
+         * The parallel projection of a sphere is a cicle. We use an ellipse curve
+         * for this projection, too. The two focii now coincide with the center of
+         * the sphere. The 2D radius point is defined by the projection of the center
+         * and the projected radius.
+         * @param {Number} sgn Expecst -1 or 1 for the two focus points
+         * @returns {Array} 2D coordinates of the projected focus point
+         *
+         */
         focusFn: function (sgn) {
             var that = this;
 
             return function () {
-                var camDir = that.view.boxToCam[3],
+                var camDir,
+                    v = (that.view.projectionType === 'central') ? 1 : 0,
                     r = that.Radius();
 
+                // Parallel projection: v === 0, the two focii coincide with the center
+                // Central projection: v === 1
+                camDir = (v === 0) ? [0, 0, 0, 0] : that.view.boxToCam[3];
+
                 return that.view.project3DTo2D([
-                    that.center.X() + sgn * r * camDir[1],
-                    that.center.Y() + sgn * r * camDir[2],
-                    that.center.Z() + sgn * r * camDir[3]
+                    that.center.X() + v * sgn * r * camDir[1],
+                    that.center.Y() + v * sgn * r * camDir[2],
+                    that.center.Z() + v * sgn * r * camDir[3]
                 ]).slice(1, 3);
             };
         },
 
+        // Replace our 2D representation with a new one that's consistent with
+        // the view's current projection type
+        /**
+         *
+         * @returns {Array} 2D coordinates of the projected 3rd point that is on the ellipse.
+         */
         innerVertexFn: function () {
             var that = this;
 
@@ -121306,6 +121212,7 @@ jxg/* default */.A.extend(
                     distOffAxis = math/* default */.A.hypot(p[0], p[1]),
                     cam = view.boxToCam,
                     r = that.Radius(),
+                    c, bs,
                     angleOffAxis = Math.atan(-distOffAxis / p[2]),
                     steepness = Math.acos(r / math/* default */.A.norm(p)),
                     lean = angleOffAxis + steepness,
@@ -121313,6 +121220,22 @@ jxg/* default */.A.extend(
                     sin_lean = Math.sin(lean),
                     inward;
 
+                // Do parallel projection
+                if (that.view.projectionType !== 'central') {
+                    bs = view.bbox3D[0][1] - view.bbox3D[0][0];
+                    r *= view.size[0] / bs;
+
+                    c = view.project3DTo2D([
+                            that.center.X(),
+                            that.center.Y(),
+                            that.center.Z()
+                        ]);
+                    c[1] += r;
+
+                    return c;
+                }
+
+                // Do central projection
                 if (distOffAxis > 1e-8) {
                     // if the center of the sphere isn't too close to the camera
                     // axis, find the direction in plane of the screen that
@@ -121337,7 +121260,15 @@ jxg/* default */.A.extend(
             };
         },
 
-        buildCentralProjection: function (attr) {
+        /**
+         * Create 2D helper points and an ellipse to visualize the `sphere3d`.
+         * Handles central and parallel projection simultaneously.
+         *
+         * This is done only once at creation time.
+         *
+         * @param {object} attr Attributes for the sphere objects
+         */
+        buildProjection: function (attr) {
             var view = this.view,
                 auxStyle = { visible: false, withLabel: false },
                 frontFocus = view.create('point', this.focusFn(-1), auxStyle),
@@ -121346,53 +121277,6 @@ jxg/* default */.A.extend(
 
             this.aux2D = [frontFocus, backFocus, innerVertex];
             this.element2D = view.create('ellipse', this.aux2D, attr === undefined ? this.visProp : attr);
-        },
-
-        buildParallelProjection: function (attr) {
-            // The parallel projection of a sphere is a circle
-            var that = this,
-                // center2d = function () {
-                //     var c3d = [1, that.center.X(), that.center.Y(), that.center.Z()];
-                //     return that.view.project3DTo2D(c3d);
-                // },
-                radius2d = function () {
-                    var boxSize = that.view.bbox3D[0][1] - that.view.bbox3D[0][0];
-                    return that.Radius() * that.view.size[0] / boxSize;
-                };
-
-            this.aux2D = [];
-            this.element2D = this.view.create(
-                'circle',
-                // [center2d, radius2d],
-                [that.center.element2D, radius2d],
-                attr === undefined ? this.visProp : attr
-            );
-        },
-
-        // replace our 2D representation with a new one that's consistent with
-        // the view's current projection type
-        rebuildProjection: function (attr) {
-            var i;
-
-            // remove the old 2D representation from the scene tree
-            if (this.element2D) {
-                this.view.board.removeObject(this.element2D);
-                for (i in this.aux2D) {
-                    if (this.aux2D.hasOwnProperty(i)) {
-                        this.view.board.removeObject(this.aux2D[i]);
-                    }
-                }
-            }
-
-            // build a new 2D representation. the representation is stored in
-            // `this.element2D`, and any auxiliary elements are stored in
-            // `this.aux2D`
-            this.projectionType = this.view.projectionType;
-            if (this.projectionType === 'central') {
-                this.buildCentralProjection(attr);
-            } else {
-                this.buildParallelProjection(attr);
-            }
 
             // attach the new 2D representation to the scene tree
             this.addChild(this.element2D);
@@ -121686,7 +121570,7 @@ jxg/* default */.A.createSphere3D = function (board, parents, attributes) {
     // to the correct initial state
     // Here, element2D is created.
     attr = el.setAttr2D(attr);
-    el.rebuildProjection(attr);
+    el.buildProjection(attr);
 
     el.element2D.prepareUpdate().update();
     if (!board.isSuspendedUpdate) {