jsxgraph 1.6.0 → 1.6.1

package/distrib/jsxgraphsrc.js

@@ -59,7 +59,7 @@ return /******/ (function() { // webpackBootstrap
 
 var major = 1,
     minor = 6,
-    patch = 0,
+    patch = 1,
     add = '', //'dev' 'beta'
     version = major + '.' + minor + '.' + patch + (add ? '-' + add : ''),
     constants;
@@ -829,6 +829,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
                 newCoords, newPos,
                 doRound = false,
                 ev_sw,
+                snappedTo, snapValues,
                 slide = this.slideObject,
                 res, cu,
                 slides = [],
@@ -957,20 +958,28 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
                     }
                 }
 
-                // Snap the glider point of the slider into its appropiate position
-                // First, recalculate the new value of this.position
-                // Second, call update(fromParent==true) to make the positioning snappier.
-                ev_sw = _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(this.visProp.snapwidth);
-                if (
-                    _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(ev_sw) > 0.0 &&
-                    Math.abs(this._smax - this._smin) >= _math_math__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z.eps
-                ) {
-                    newPos = Math.max(Math.min(newPos, 1), 0);
-
-                    v = newPos * (this._smax - this._smin) + this._smin;
-                    v = Math.round(v / ev_sw) * ev_sw;
-                    newPos = (v - this._smin) / (this._smax - this._smin);
+                // Snap the glider to snap values.
+                snappedTo = this.findClosestSnapValue(newPos);
+                if(snappedTo !== null) {
+                    snapValues = _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(this.visProp.snapvalues);
+                    newPos = (snapValues[snappedTo] - this._smin) / (this._smax - this._smin);
                     this.update(true);
+                } else {
+                    // Snap the glider point of the slider into its appropiate position
+                    // First, recalculate the new value of this.position
+                    // Second, call update(fromParent==true) to make the positioning snappier.
+                    ev_sw = _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(this.visProp.snapwidth);
+                    if (
+                        _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(ev_sw) > 0.0 &&
+                        Math.abs(this._smax - this._smin) >= _math_math__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z.eps
+                    ) {
+                        newPos = Math.max(Math.min(newPos, 1), 0);
+
+                        v = newPos * (this._smax - this._smin) + this._smin;
+                        v = Math.round(v / ev_sw) * ev_sw;
+                        newPos = (v - this._smin) / (this._smax - this._smin);
+                        this.update(true);
+                    }
                 }
 
                 p1c = slide.point1.coords;
@@ -1117,6 +1126,37 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
             this.position = newPos;
         },
 
+        /**
+         * Find the closest entry in snapValues that is within snapValueDistance of pos.
+         *
+         * @param {Number} pos Value for which snapping is calculated.
+         * @returns {Number} Index of the value to snap to, or null.
+         * @private
+         */
+        findClosestSnapValue: function(pos) {
+            var i, d,
+                snapValues, snapValueDistance,
+                snappedTo = null;
+
+            // Snap the glider to snap values.
+            snapValues = _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(this.visProp.snapvalues);
+            snapValueDistance = _utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.evaluate(this.visProp.snapvaluedistance);
+
+            if (_utils_type__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .Z.isArray(snapValues) &&
+                Math.abs(this._smax - this._smin) >= _math_math__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z.eps &&
+                snapValueDistance > 0.0) {
+                for (i = 0; i < snapValues.length; i++) {
+                    d = Math.abs(pos * (this._smax - this._smin) + this._smin - snapValues[i]);
+                    if (d < snapValueDistance) {
+                        snapValueDistance = d;
+                        snappedTo = i;
+                    }
+                }
+            }
+
+            return snappedTo;
+        },
+
         /**
          * Update of a glider in case a parent element has been updated. That means the
          * relative position of the glider stays the same.
@@ -2502,7 +2542,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
          * @returns {JXG.CoordsElement} Reference to itself.
          */
         _anim: function (direction, stepCount) {
-            var dX, dY, alpha, startPoint, newX, radius, sp1c, sp2c, res, d;
+            var dX, dY, alpha, startPoint, newX, radius, sp1c, sp2c, res;
 
             this.intervalCount += 1;
             if (this.intervalCount > stepCount) {
@@ -5895,7 +5935,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
         },
 
         /**
-         * The update function of the renderert
+         * The update function of the renderer
          * is called.
          * @private
          */
@@ -6365,11 +6405,9 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
          * @param  {Number} h width of the box in pixel
          * @return {Number}   Number of overlapping elements
          */
-        getNumberofConflicts: function (x, y, w, h) {
+        getNumberOfConflicts: function (x, y, w, h) {
             var count = 0,
-                i,
-                obj,
-                le,
+                i, obj, le,
                 savePointPrecision;
 
             // Set the precision of hasPoint to half the max if label isn't too long
@@ -6404,33 +6442,22 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
          * @returns {JXG.Text} Reference to the text object.
          */
         setAutoPosition: function () {
-            var x,
-                y,
-                cx,
-                cy,
+            var x, y, cx, cy,
                 anchorCoords,
                 // anchorX, anchorY,
                 w = this.size[0],
                 h = this.size[1],
-                start_angle,
-                angle,
+                start_angle, angle,
                 optimum = {
                     conflicts: Infinity,
                     angle: 0,
                     r: 0
                 },
-                max_r,
-                delta_r,
-                conflicts,
-                offset,
-                r,
+                max_r, delta_r,
+                conflicts, offset, r,
                 num_positions = 12,
                 step = (2 * Math.PI) / num_positions,
-                j,
-                dx,
-                dy,
-                co,
-                si;
+                j, dx, dy, co, si;
 
             if (
                 this === this.board.infobox ||
@@ -6453,15 +6480,15 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
             dx = offset[0];
             dy = offset[1];
 
-            conflicts = this.getNumberofConflicts(cx + dx, cy - dy, w, h);
+            conflicts = this.getNumberOfConflicts(cx + dx, cy - dy, w, h);
             if (conflicts === 0) {
                 return this;
             }
             // console.log(this.id, conflicts, w, h);
             // r = Geometry.distance([0, 0], offset, 2);
 
-            r = 12;
-            max_r = 28;
+            r = _utils_type__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z.evaluate(this.visProp.autopositionmindistance);
+            max_r = _utils_type__WEBPACK_IMPORTED_MODULE_5__/* ["default"] */ .Z.evaluate(this.visProp.autopositionmaxdistance);
             delta_r = 0.2 * r;
 
             start_angle = Math.atan2(dy, dx);
@@ -6470,7 +6497,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
             optimum.angle = start_angle;
             optimum.r = r;
 
-            while (optimum.conflicts > 0 && r < max_r) {
+            while (optimum.conflicts > 0 && r <= max_r) {
                 for (
                     j = 1, angle = start_angle + step;
                     j < num_positions && optimum.conflicts > 0;
@@ -6482,7 +6509,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
                     x = cx + r * co;
                     y = cy - r * si;
 
-                    conflicts = this.getNumberofConflicts(x, y, w, h);
+                    conflicts = this.getNumberOfConflicts(x, y, w, h);
                     if (conflicts < optimum.conflicts) {
                         optimum.conflicts = conflicts;
                         optimum.angle = angle;
@@ -16357,12 +16384,18 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
     /**
      * Helper function to create curve which displays Riemann sums.
      * Compute coordinates for the rectangles showing the Riemann sum.
+     * <p>
+     * In case of type "simpson" and "trapezoidal", the horizontal line approximating the function value 
+     * is replaced by a parabola or a secant. IN case of "simpson", 
+     * the parabola is approximated visually by a polygonal chain of fixed step width. 
+     * 
      * @param {Function,Array} f Function or array of two functions.
      * If f is a function the integral of this function is approximated by the Riemann sum.
      * If f is an array consisting of two functions the area between the two functions is filled
      * by the Riemann sum bars.
      * @param {Number} n number of rectangles.
      * @param {String} type Type of approximation. Possible values are: 'left', 'right', 'middle', 'lower', 'upper', 'random', 'simpson', or 'trapezoidal'.
+     * "simpson" is Simpson's 1/3 rule.
      * @param {Number} start Left border of the approximation interval
      * @param {Number} end Right border of the approximation interval
      * @returns {Array} An array of two arrays containing the x and y coordinates for the rectangles showing the Riemann sum. This
@@ -16371,18 +16404,14 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      * @memberof JXG.Math.Numerics
      */
     riemann: function (gf, n, type, start, end) {
-        var i,
-            delta,
+        var i, delta,
+            k, a, b, c, f0, f1, f2, xx, h,
+            steps = 30, // Fixed step width for Simpson's rule
             xarr = [],
             yarr = [],
-            j = 0,
             x = start,
-            y,
             sum = 0,
-            f,
-            g,
-            ylow,
-            yup;
+            y, f, g;
 
         if (_utils_type__WEBPACK_IMPORTED_MODULE_1__/* ["default"] */ .Z.isArray(gf)) {
             g = gf[0];
@@ -16399,61 +16428,94 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
 
         delta = (end - start) / n;
 
-        // Upper bar ends
+        // "Upper" horizontal line defined by function
         for (i = 0; i < n; i++) {
-            y = this._riemannValue(x, f, type, delta);
-            xarr[j] = x;
-            yarr[j] = y;
+            if (type === "simpson") {
+                sum += this._riemannValue(x, f, type, delta) * delta;
+
+                h = delta * 0.5;
+                f0 = f(x);
+                f1 = f(x + h);
+                f2 = f(x + 2 * h);
+
+                a = (f2 + f0 - 2 * f1) / (h * h) * 0.5;
+                b = (f2 - f0) / (2 * h);
+                c = f1;
+                for (k = 0; k < steps; k++) {
+                    xx = k * delta / steps - h;
+                    xarr.push(x + xx + h);
+                    yarr.push(a * xx * xx + b * xx + c);
+                }
+                x += delta;
+                y = f2;
+            } else {
+                y = this._riemannValue(x, f, type, delta);
+                xarr.push(x);
+                yarr.push(y);
+
+                x += delta;
+                if (type === "trapezoidal") {
+                    f2 = f(x);
+                    sum += (y + f2) * 0.5 * delta;
+                    y = f2;
+                } else {
+                    sum += y * delta;
+                }
 
-            j += 1;
-            x += delta;
-            if (type === "trapezoidal") {
-                y = f(x);
+                xarr.push(x);
+                yarr.push(y);
             }
-            xarr[j] = x;
-            yarr[j] = y;
-
-            j += 1;
+            xarr.push(x);
+            yarr.push(y);
         }
 
-        // Lower bar ends
+        // "Lower" horizontal line
+        // Go backwards
         for (i = 0; i < n; i++) {
-            if (g) {
-                y = this._riemannValue(x, g, type, -delta);
-            } else {
-                y = 0.0;
-            }
-            xarr[j] = x;
-            yarr[j] = y;
-
-            j += 1;
-            x -= delta;
-            if (type === "trapezoidal" && g) {
-                y = g(x);
-            }
-            xarr[j] = x;
-            yarr[j] = y;
-
-            // Add the area of the bar to 'sum'
-            if (type !== "trapezoidal") {
-                ylow = y;
-                yup = yarr[2 * (n - 1) - 2 * i];
+            if (type === "simpson" && g) {
+                sum -= this._riemannValue(x, g, type, -delta) * delta;
+
+                h = delta * 0.5;
+                f0 = g(x);
+                f1 = g(x - h);
+                f2 = g(x - 2 * h);
+
+                a = (f2 + f0 - 2 * f1) / (h * h) * 0.5;
+                b = (f2 - f0) / (2 * h);
+                c = f1;
+                for (k = 0; k < steps; k++) {
+                    xx = k * delta / steps - h;
+                    xarr.push(x - xx - h);
+                    yarr.push(a * xx * xx + b * xx + c);
+                }
+                x -= delta;
+                y = f2;
             } else {
-                yup = 0.5 * (f(x + delta) + f(x));
                 if (g) {
-                    ylow = 0.5 * (g(x + delta) + g(x));
+                    y = this._riemannValue(x, g, type, -delta);
                 } else {
-                    ylow = 0.0;
+                    y = 0.0;
+                }
+                xarr.push(x);
+                yarr.push(y);
+
+                x -= delta;
+                if (g) {
+                    if (type === "trapezoidal") {
+                        f2 = g(x);
+                        sum -= (y + f2) * 0.5 * delta;
+                        y = f2;
+                    } else {
+                        sum -= y * delta;
+                    }
                 }
             }
-            sum += (yup - ylow) * delta;
+            xarr.push(x);
+            yarr.push(y);
 
             // Draw the vertical lines
-            j += 1;
-            xarr[j] = x;
-            yarr[j] = yarr[2 * (n - 1) - 2 * i];
-
-            j += 1;
+            xarr.push(x);
+            yarr.push(f(x));
         }
 
         return [xarr, yarr, sum];
@@ -16479,12 +16541,12 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      * @memberof JXG.Math.Numerics
      */
     riemannsum: function (f, n, type, start, end) {
-        _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.deprecated("Numerics.riemannsum()", "Numerics.riemann()");
+        _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.deprecated("Numerics.riemannsum()", "Numerics.riemann()[2]");
         return this.riemann(f, n, type, start, end)[2];
     },
 
     /**
-     * Solve initial value problems numerically using Runge-Kutta-methods.
+     * Solve initial value problems numerically using <i>explicit</i> Runge-Kutta methods.
      * See {@link https://en.wikipedia.org/wiki/Runge-Kutta_methods} for more information on the algorithm.
      * @param {object,String} butcher Butcher tableau describing the Runge-Kutta method to use. This can be either a string describing
      * a Runge-Kutta method with a Butcher tableau predefined in JSXGraph like 'euler', 'heun', 'rk4' or an object providing the structure
@@ -16496,18 +16558,20 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      *     c: &lt;Array&gt;
      * }
      * </pre>
-     * which corresponds to the Butcher tableau structure shown here: https://en.wikipedia.org/w/index.php?title=List_of_Runge%E2%80%93Kutta_methods&oldid=357796696
-     * @param {Array} x0 Initial value vector. If the problem is of one-dimensional, the initial value also has to be given in an array.
+     * which corresponds to the Butcher tableau structure
+     * shown here: https://en.wikipedia.org/w/index.php?title=List_of_Runge%E2%80%93Kutta_methods&oldid=357796696 .
+     * <i>Default</i> is 'euler'.
+     * @param {Array} x0 Initial value vector. Even if the problem is one-dimensional, the initial value has to be given in an array.
      * @param {Array} I Interval on which to integrate.
-     * @param {Number} N Number of evaluation points.
+     * @param {Number} N Number of integration intervals, i.e. there are <i>N+1</i> evaluation points.
      * @param {function} f Function describing the right hand side of the first order ordinary differential equation, i.e. if the ode
-     * is given by the equation <pre>dx/dt = f(t, x(t)).</pre> So f has to take two parameters, a number <tt>t</tt> and a
-     * vector <tt>x</tt>, and has to return a vector of the same dimension as <tt>x</tt> has.
+     * is given by the equation <pre>dx/dt = f(t, x(t))</pre>. So, f has to take two parameters, a number <tt>t</tt> and a
+     * vector <tt>x</tt>, and has to return a vector of the same length as <tt>x</tt> has.
      * @returns {Array} An array of vectors describing the solution of the ode on the given interval I.
      * @example
      * // A very simple autonomous system dx(t)/dt = x(t);
-     * function f(t, x) {
-     *     return x;
+     * var f = function(t, x) {
+     *     return [x[0]];
      * }
      *
      * // Solve it with initial value x(0) = 1 on the interval [0, 2]
@@ -16518,7 +16582,8 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      * var dataX = [];
      * var dataY = [];
      * var h = 0.1;        // (I[1] - I[0])/N  = (2-0)/20
-     * for(var i=0; i&lt;data.length; i++) {
+     * var i;
+     * for(i=0; i&lt;data.length; i++) {
      *     dataX[i] = i*h;
      *     dataY[i] = data[i][0];
      * }
@@ -16526,7 +16591,7 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      * </pre><div class="jxgbox" id="JXGd2432d04-4ef7-4159-a90b-a2eb8d38c4f6" style="width: 300px; height: 300px;"></div>
      * <script type="text/javascript">
      * var board = JXG.JSXGraph.initBoard('JXGd2432d04-4ef7-4159-a90b-a2eb8d38c4f6', {boundingbox: [-1, 5, 5, -1], axis: true, showcopyright: false, shownavigation: false});
-     * function f(t, x) {
+     * var f = function(t, x) {
      *     // we have to copy the value.
      *     // return x; would just return the reference.
      *     return [x[0]];
@@ -16545,11 +16610,7 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      */
     rungeKutta: function (butcher, x0, I, N, f) {
         var e,
-            i,
-            j,
-            k,
-            l,
-            s,
+            i, j, k, l, s,
             x = [],
             y = [],
             h = (I[1] - I[0]) / N,
@@ -16564,17 +16625,19 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
         s = butcher.s;
 
         // don't change x0, so copy it
-        for (e = 0; e < dim; e++) {
-            x[e] = x0[e];
-        }
+        // for (e = 0; e < dim; e++) {
+        //     x[e] = x0[e];
+        // }
+        x = x0.slice();
 
-        for (i = 0; i < N; i++) {
+        for (i = 0; i <= N; i++) {
             // Optimization doesn't work for ODEs plotted using time
             //        if((i % quotient == 0) || (i == N-1)) {
-            result[r] = [];
-            for (e = 0; e < dim; e++) {
-                result[r][e] = x[e];
-            }
+            // result[r] = [];
+            // for (e = 0; e < dim; e++) {
+            //     result[r][e] = x[e];
+            // }
+            result[r] = x.slice();
 
             r += 1;
             k = [];
@@ -16647,7 +16710,7 @@ _math__WEBPACK_IMPORTED_MODULE_3__/* ["default"] */ .Z.Numerics = {
      * @param {Function} f Function, whose root is to be found
      * @param {Number} x0 Start value
      * @param {Object} object Parent object in case f is method of it
-     * @returns {Array} [x_0, f(x_0), x_1, f(x_1)] in case that x_0 <= x_1 
+     * @returns {Array} [x_0, f(x_0), x_1, f(x_1)] in case that x_0 <= x_1
      *   or [x_1, f(x_1), x_0, f(x_0)] in case that x_1 < x_0.
      *
      * @see JXG.Math.Numerics.fzero
@@ -19010,7 +19073,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          * Especially, on mobile devices this enhances the user experience.
          * However, it is recommended to allow dragging outside of the JSXGraph board only
          * in certain constructions where users may not "loose" points outside of the board.
-         * Then points may become unreachable.
+         * In such a case, points may become unreachable.
          * <p>
          * A situation where dragging outside of the board is uncritical is for example if
          * only sliders are used to interact with the construction.
@@ -19022,9 +19085,18 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          * <li> document
          * </ul>
          * <p>
+         * Since the introduction of this attribute "moveTarget", the value "document" has become sort of
+         * default on touch devices like smartphones. However, it is no longer the case that the document listens to
+         * move events, but there is the new feature "setPointerCapture", which is also implicitly enabled on certain devices.
+         * In future versions, JSXGraph may adopt this new standard and distinguish only two cases:
+         * <ul>
+         * <li>null: no pointerCapture
+         * <li>document: use pointerCapture
+         * </ul>
+         * <p>
          * This attribute is immutable.
          * It can be changed as follows:
-         * 
+         *
          * @example
          * board.setAttribute({moveTarget: null});
          * board.removeEventHandlers();
@@ -19107,9 +19179,9 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          * Allow user interaction by registering mouse, pointer, keyboard or touch events.
          * Decide if JSXGraph listens to these events. Keyboard events can then turned off
          * separately with the keyboard attribute.
-         * 
+         *
          * <p>This attribute is immutable. Please use
-         * {@link JXG.Board#addEventHandlers()} and 
+         * {@link JXG.Board#addEventHandlers()} and
          * {@link JXG.Board#removeEventHandlers()} directly.
          *
          * @name JXG.Board#registerEvents
@@ -19125,7 +19197,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          * Listen to fullscreen event.
          *
          * <p>This attribute is immutable. Please use
-         * {@link JXG.Board#addFullscreenEventHandlers()} and 
+         * {@link JXG.Board#addFullscreenEventHandlers()} and
          * {@link JXG.Board#removeEventHandlers()} directly.
          *
          * @name JXG.Board#registerFullscreenEvent
@@ -19139,14 +19211,14 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
         /**
          * Listen to resize events, i.e. start "resizeObserver" or handle the resize event with
          * "resizeListener". This is independent from the mouse, touch, pointer events.
-         * 
+         *
          * <p>This attribute is immutable. Please use
-         * {@link JXG.Board#addResizeEventHandlers()} and 
+         * {@link JXG.Board#addResizeEventHandlers()} and
          * {@link JXG.Board#removeEventHandlers()} directly.
          * <p>
          * This attribute just starts a resizeObserver. If the resizeObserver reacts
          * to size changed is controled wuth {@link JXG.Board#resize}.
-         * 
+         *
          * @name JXG.Board#registerResizeEvent
          * @see JXG.Board#resize
          * @see JXG.Board#registerEvents
@@ -19163,7 +19235,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          * <p>
          * In case of 'canvas' it is advisable to call 'board.update()' after all elements have been
          * constructed. This ensures that all elements are drawn with their intended visual appearance.
-         * 
+         *
          * <p>
          * This attribute is immutable.
          *
@@ -22194,11 +22266,11 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
         width: 0.4,
 
         /**
-         * Angle under which comb elements are positioned.
+         * Angle - given in radians - under which comb elements are positioned.
          *
          * @type Number
          * @name Comb#angle
-         * @default 60 degrees
+         * @default Math.PI / 3 (i.e. &pi; /3  or 60^° degrees)
          */
         angle: Math.PI / 3,
 
@@ -23034,7 +23106,37 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          *
          *
          */
-        autoPosition: false
+        autoPosition: false,
+
+        /**
+         * The auto position algorithm tries to put a label to a conflict-free
+         * position around it's anchor element. For this, the algorithm tests 12 positions
+         * around the anchor element starting at a distance from the anchor
+         * defined here (in pixel).
+         *
+         * @name Label#autoPositionMinDistance
+         * @see Label#autoPosition
+         * @see Label#autoPositionMaxDistance
+         * @type Number
+         * @default 12
+         *
+         */
+        autoPositionMinDistance: 12,
+
+        /**
+         * The auto position algorithm tries to put a label to a conflict-free
+         * position around it's anchor element. For this, the algorithm tests 12 positions
+         * around the anchor element up to a distance from the anchor
+         * defined here (in pixel).
+         *
+         * @name Label#autoPositionMaxDistance
+         * @see Label#autoPosition
+         * @see Label#autoPositionMinDistance
+         * @type Number
+         * @default 28
+         *
+         */
+        autoPositionMaxDistance: 28
 
         /**#@-*/
     },
@@ -24336,6 +24438,70 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.Options = {
          */
         snapWidth: -1,      // -1 = deactivated
 
+        /**
+         * List of values to snap to. If the glider is within snapValueDistance
+         * (in user coordinate units) of one of these points,
+         * then the glider snaps to that point.
+         *
+         * @memberOf Slider.prototype
+         * @name snapValues
+         * @type Array
+         * @see Slider#snapValueDistance
+         * @default empty
+         *
+         * @example
+         *         var n = board.create('slider', [[-2, 3], [4, 3], [1, 5, 100]], {
+         *             name: 'n',
+         *             snapWidth: 1,
+         *             snapValues: [1, 22, 77, 100],
+         *             snapValueDistance: 5
+         *         });
+         *
+         *         var k = board.create('slider', [[-2, -1], [4, -1], [-4, 0, 4]], {
+         *             name: 'k',
+         *             snapWidth: 0.1,
+         *             snapValues: [-3, -1, 1, 3],
+         *             snapValueDistance: 0.4
+         *         });
+         *
+         * </pre><div id="JXG9be68014-4e14-479a-82b4-e92d9b8f6eef" class="jxgbox" style="width: 300px; height: 300px;"></div>
+         * <script type="text/javascript">
+         *     (function() {
+         *         var board = JXG.JSXGraph.initBoard('JXG9be68014-4e14-479a-82b4-e92d9b8f6eef',
+         *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+         *             var n = board.create('slider', [[-2, 3], [4, 3], [1, 5, 100]], {
+         *                 name: 'n',
+         *                 snapWidth: 1,
+         *                 snapValues: [1, 22, 77, 100],
+         *                 snapValueDistance: 5
+         *             });
+         *
+         *             var k = board.create('slider', [[-2, -1], [4, -1], [-4, 0, 4]], {
+         *                 name: 'k',
+         *                 snapWidth: 0.1,
+         *                 snapValues: [-3, -1, 1, 3],
+         *                 snapValueDistance: 0.4
+         *             });
+         *
+         *     })();
+         *
+         * </script><pre>
+         *
+         */
+        snapValues: [],
+
+        /**
+         * If the difference between the slider value and one of the elements of snapValues is less
+         * than this number (in user coordinate units), the slider will snap to that value.
+         *
+         * @memberOf Slider.prototype
+         * @name snapValueDistance
+         * @type Number
+         * @see Slider#snapValues
+         * @default 0.0
+         */
+        snapValueDistance: 0.0,
+
         /**
          * The precision of the slider value displayed in the optional text.
          * Replaced by the attribute "digits".
@@ -32044,7 +32210,7 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
         /**
          * Cross browser mouse / pointer / touch coordinates retrieval relative to the documents's top left corner.
          * This method might be a bit outdated today, since pointer events and clientX/Y are omnipresent.
-         * 
+         *
          * @param {Object} [e] The browsers event object. If omitted, <tt>window.event</tt> will be used.
          * @param {Number} [index] If <tt>e</tt> is a touch event, this provides the index of the touch coordinates, i.e. it determines which finger.
          * @param {Object} [doc] The document object.
@@ -32409,10 +32575,16 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
          *
          */
         scaleJSXGraphDiv: function (wrap_id, inner_id, doc, scale) {
-            var len = doc.styleSheets.length, style, rule, w, h, b, wi, hi, bi,
-                scale_l, vshift_l, // scale_p, vshift_p,
+            var len = doc.styleSheets.length, style, rule,
+                w, h, b,
+                wi, hi,
+                wo, ho, inner,
+                scale_l, vshift_l,
                 f = scale,
-                rule_inner_l, // rule_inner_p,
+                ratio,
+                rule_inner_l,
+                title = 'jsxgraph_fullscreen_css',
+                found_css,
                 pseudo_keys = [
                     ":fullscreen",
                     ":-webkit-full-screen",
@@ -32435,45 +32607,80 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
             h = b.height;
             w = b.width;
 
-            bi = doc.getElementById(inner_id).getBoundingClientRect();
-            hi = bi.height;
-            wi = bi.width;
+            inner = doc.getElementById(inner_id);
+            wo = inner._cssFullscreenStore.w;
+            ho = inner._cssFullscreenStore.h;
+            ratio = ho / wo;
 
-            if (wi / hi >= w / h) {
-                scale_l = (f * w) / wi;
+            // Scale the div such that fits into the fullscreen.
+            if (wo > w * f) {
+                wo = w * f;
+                ho = wo * ratio;
+            }
+            if (ho > h * f) {
+                ho = h * f;
+                wo = ho / ratio;
+            }
+
+            wi = wo;
+            hi = ho;
+            // Compare this.setBoundingBox() 
+            if (ratio > 1) {
+                // h > w
+                if (ratio < h / w) {
+                    scale_l =  w * f / wo;
+                } else {
+                    scale_l =  h * f / ho;
+                }
             } else {
-                scale_l = (f * h) / hi;
+                // h <= w
+                if (ratio < h / w) {
+                    scale_l = w * f / wo;
+                } else {
+                    scale_l = h * f / ho;
+                }
             }
             vshift_l = (h - hi) * 0.5;
 
             // CSS rules to center the inner div horizontally and vertically.
             rule_inner_l =
-                "{margin:0 auto;transform:matrix(" +
-                scale_l +
-                ",0,0," +
-                scale_l +
-                ",0," +
-                vshift_l +
-                ");}";
-
-            if (len === 0) {
-                // In case there is not a single CSS rule defined at all.
+                "{" +
+                "width:" + wi + "px !important;" +
+                "height:" + hi + "px !important;" +
+                "margin:0 auto;" +
+                "transform:matrix(" + scale_l + ",0,0," + scale_l + ",0," + vshift_l + ");" +
+                "}";
+
+            found_css = false;
+            // Removing of the CSS here should happen only
+            // in emergency cases.
+            for (i = len - 1; i >= 0; i--) {
+                if (doc.styleSheets[i].title === title) {
+                    found_css = true;
+
+                    if (doc.styleSheets[i].title === title &&
+                        doc.styleSheets[i].cssRules.length > 0 &&
+                        regex.test(doc.styleSheets[i].cssRules[0].cssText) &&
+                        doc.styleSheets[i].deleteRule
+                    ) {
+                        doc.styleSheets[i].deleteRule(0);
+                        break;
+                    }
+                }
+            }
+            if (!found_css) {
+                // In case there is not yet a CSS style sheet for fullscreen
+                // defined, do it now.
                 style = document.createElement("style");
+                style.setAttribute('title', title);
                 // WebKit hack :(
                 style.appendChild(document.createTextNode(""));
-                // Add the <style> element to the page
-                doc.appendChild(style);
-                len = doc.styleSheets.length;
-            }
-
-            // Remove a previously installed CSS rule.
-            if (
-                doc.styleSheets[len - 1].cssRules.length > 0 &&
-                regex.test(doc.styleSheets[len - 1].cssRules[0].cssText) &&
-                doc.styleSheets[len - 1].deleteRule
-            ) {
-                doc.styleSheets[len - 1].deleteRule(0);
+                // Add the <style> element to the page head.
+                // It must be document, not the shadowDOM root.
+                // It seems that the head tag does always exist.
+                document.head.appendChild(style);
             }
+            len = doc.styleSheets.length;
 
             // Install a CSS rule to center the JSXGraph div at the first position of the list.
             for (i = 0; i < len_pseudo; i++) {
@@ -32483,14 +32690,10 @@ _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.extend(
                     doc.styleSheets[len - 1].insertRule(rule, 0);
 
                     break;
-                } catch (err) {
-                    // console.log('JXG.scaleJSXGraphDiv: Could not add CSS rule "' + pseudo_keys[i] + '".');
-                    // console.log('One possible reason could be that the id of the JSXGraph container does not start with a letter.');
-                }
+                } catch (err) {}
             }
             if (i === len_pseudo) {
-                console.log("JXG.scaleJSXGraphDiv: Could not add any CSS rule.");
-                console.log(
+                _jxg__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z.debug("JXG.scaleJSXGraphDiv: Could not add any CSS rule.\n" +
                     "One possible reason could be that the id of the JSXGraph container does not start with a letter."
                 );
             }
@@ -35612,6 +35815,8 @@ math/* default */.Z.Extrapolate = {
 
 /* harmony default export */ var extrapolate = (math/* default */.Z.Extrapolate);
 
+// EXTERNAL MODULE: ./src/math/geometry.js
+var geometry = __webpack_require__(922);
 ;// CONCATENATED MODULE: ./src/math/qdt.js
 /*
     Copyright 2008-2023
@@ -35650,22 +35855,38 @@ math/* default */.Z.Extrapolate = {
 
 
 
+
 /**
  * Instantiate a new quad tree.
  *
  * @name JXG.Math.Quadtree
  * @exports Mat.Quadtree as JXG.Math.Quadtree
  * @param {Array} bbox Bounding box of the new quad (sub)tree.
+ * @param {Object} config Configuration object. Default value: to {capacity: 10}
+ *
  * @constructor
  */
-math/* default */.Z.Quadtree = function (bbox) {
+math/* default */.Z.Quadtree = function (bbox, config, parent) {
+    config = config || {
+        capacity: 10,
+        pointType: 'coords'
+    };
+
     /**
      * The maximum number of points stored in a quad tree node
      * before it is subdivided.
      * @type Number
      * @default 10
      */
-    this.capacity = 10;
+    this.capacity = config.capacity || 10;
+
+    /**
+     * Type of a point object. Possible values are:
+     * 'coords', 'object'.
+     * @type String
+     * @default 'coords'
+     */
+    this.pointType = config.pointType || 'coords';
 
     /**
      * Point storage.
@@ -35678,6 +35899,15 @@ math/* default */.Z.Quadtree = function (bbox) {
     this.ylb = bbox[3];
     this.yub = bbox[1];
 
+    /**
+     * Parent quad tree or null if there is not parent.
+     *
+     * @name JXG.Math.Quadtree#northWest
+     * @type JXG.Math.Quadtree
+     *
+     */
+    this.parent = parent || null;
+
     /**
      * In a subdivided quad tree this represents the top left subtree.
      * @name JXG.Math.Quadtree#northWest
@@ -35705,6 +35935,7 @@ math/* default */.Z.Quadtree = function (bbox) {
      * @type JXG.Math.Quadtree
      */
     this.southWest = null;
+
 };
 
 utils_type/* default */.Z.extend(
@@ -35721,13 +35952,24 @@ utils_type/* default */.Z.extend(
         },
 
         /**
-         * Insert a new point into this quad tree.
+         * Insert a new point into this quad tree. Do this only,
+         * if the point is not yet in the quadtree (test exactly).
+         *
          * @param {JXG.Coords} p
          * @returns {Boolean}
          */
         insert: function (p) {
-            if (!this.contains(p.usrCoords[1], p.usrCoords[2])) {
-                return false;
+            switch (this.pointType) {
+                case 'coords':
+                    if (!this.contains(p.usrCoords[1], p.usrCoords[2])) {
+                        return false;
+                    }
+                    break;
+                case 'object':
+                    if (!this.contains(p.x, p.y)) {
+                        return false;
+                    }
+                    break;
             }
 
             if (this.points.length < this.capacity) {
@@ -35759,21 +36001,22 @@ utils_type/* default */.Z.extend(
          */
         subdivide: function () {
             var i,
-                l = this.points.length,
+                le = this.points.length,
                 mx = this.xlb + (this.xub - this.xlb) / 2,
                 my = this.ylb + (this.yub - this.ylb) / 2;
 
-            this.northWest = new math/* default */.Z.Quadtree([this.xlb, this.yub, mx, my]);
-            this.northEast = new math/* default */.Z.Quadtree([mx, this.yub, this.xub, my]);
-            this.southEast = new math/* default */.Z.Quadtree([this.xlb, my, mx, this.ylb]);
-            this.southWest = new math/* default */.Z.Quadtree([mx, my, this.xub, this.ylb]);
+            this.northWest = new math/* default */.Z.Quadtree([this.xlb, this.yub, mx, my], this.config, this);
+            this.northEast = new math/* default */.Z.Quadtree([mx, this.yub, this.xub, my], this.config, this);
+            this.southEast = new math/* default */.Z.Quadtree([this.xlb, my, mx, this.ylb], this.config, this);
+            this.southWest = new math/* default */.Z.Quadtree([mx, my, this.xub, this.ylb], this.config, this);
 
-            for (i = 0; i < l; i += 1) {
-                this.northWest.insert(this.points[i]);
-                this.northEast.insert(this.points[i]);
-                this.southEast.insert(this.points[i]);
-                this.southWest.insert(this.points[i]);
+            for (i = 0; i < le; i += 1) {
+                this.insert(this.points[i]);
             }
+
+            // We empty this node points
+            this.points.length = 0;
+            this.points = [];
         },
 
         /**
@@ -35819,14 +36062,13 @@ utils_type/* default */.Z.extend(
         },
 
         /**
-         * Retrieve the smallest quad tree that contains the given point.
+         * Retrieve the smallest quad tree that contains the given coordinate pair.
          * @name JXG.Math.Quadtree#_query
          * @param {JXG.Coords|Number} xp
          * @param {Number} y
          * @returns {Boolean|JXG.Quadtree} The quad tree if the point is found, false
          * if none of the quad trees contains the point (i.e. the point is not inside
          * the root tree's AABB).
-         * @private
          */
         query: function (xp, y) {
             var _x, _y;
@@ -35840,7 +36082,94 @@ utils_type/* default */.Z.extend(
             }
 
             return this._query(_x, _y);
+        },
+
+        /**
+         *
+         * @param {*} x
+         * @param {*} y
+         * @param {*} tol
+         * @returns {Boolean}
+         */
+        isIn: function (x, y, tol) {
+            var r, i, le;
+
+            if (this.contains(x, y)) {
+                le = this.points.length;
+
+                switch (this.pointType) {
+                    case 'coords':
+                        for (i = 0; i < le; i++) {
+                            if (geometry/* default */.Z.distance([x, y], this.points[i].usrCoords.slice(1), 2) < tol) {
+                                return true;
+                            }
+                        }
+                        break;
+                    case 'object':
+                        for (i = 0; i < le; i++) {
+                            if (geometry/* default */.Z.distance([x, y], [this.points[i].x, this.points[i].y], 2) < tol) {
+                                return true;
+                            }
+                        }
+                        break;
+               }
+
+
+                if (this.northWest === null) {
+                    return false;
+                }
+
+                r = this.northWest.isIn(x, y, tol);
+                if (r) {
+                    return r;
+                }
+
+                r = this.northEast.isIn(x, y, tol);
+                if (r) {
+                    return r;
+                }
+
+                r = this.southEast.isIn(x, y, tol);
+                if (r) {
+                    return r;
+                }
+
+                r = this.southWest.isIn(x, y, tol);
+                if (r) {
+                    return r;
+                }
+            }
+
+            return false;
+        },
+
+        /**
+         *
+         * @returns {Array}
+         */
+        getAllPoints: function() {
+            var pointsList = [];
+            this.getAllPointsRecursive(pointsList);
+            return pointsList;
+        },
+
+        /**
+         *
+         * @param {Array} pointsList
+         * @private
+         */
+        getAllPointsRecursive(pointsList) {
+            if (this.northWest === null) {
+                Array.prototype.push.apply(pointsList, this.points.slice());
+                return;
+            }
+
+            this.northWest.getAllPointsRecursive(pointsList);
+            this.northEast.getAllPointsRecursive(pointsList);
+            this.southEast.getAllPointsRecursive(pointsList);
+            this.southWest.getAllPointsRecursive(pointsList);
         }
+
     }
 );
 
@@ -37249,8 +37578,6 @@ jxg/* default */.Z.Math.Nlp = {
 var base_coords = __webpack_require__(705);
 // EXTERNAL MODULE: ./src/math/statistics.js
 var statistics = __webpack_require__(309);
-// EXTERNAL MODULE: ./src/math/geometry.js
-var geometry = __webpack_require__(922);
 ;// CONCATENATED MODULE: ./src/math/plot.js
 /*
     Copyright 2008-2023
@@ -46736,20 +47063,21 @@ jxg/* default */.Z.extend(
                                     MathJax.Hub.Queue(["Typeset", MathJax.Hub, el.rendNode]);
                                 }
 
-                                // Restore the transformation necessary for fullscreen mode
-                                // MathJax removes it when handling dynamic content
-                                id = el.board.container;
-                                wrap_id = "fullscreenwrap_" + id;
-                                if (document.getElementById(wrap_id)) {
-                                    scale = el.board.containerObj._cssFullscreenStore.scale;
-                                    vshift = el.board.containerObj._cssFullscreenStore.vshift;
-                                    env/* default */.Z.scaleJSXGraphDiv(
-                                        "#" + wrap_id,
-                                        "#" + id,
-                                        scale,
-                                        vshift
-                                    );
-                                }
+                                // Obsolete:
+                                // // Restore the transformation necessary for fullscreen mode
+                                // // MathJax removes it when handling dynamic content
+                                // id = el.board.container;
+                                // wrap_id = "fullscreenwrap_" + id;
+                                // if (document.getElementById(wrap_id)) {
+                                //     scale = el.board.containerObj._cssFullscreenStore.scale;
+                                //     vshift = el.board.containerObj._cssFullscreenStore.vshift;
+                                //     Env.scaleJSXGraphDiv(
+                                //         "#" + wrap_id,
+                                //         "#" + id,
+                                //         scale,
+                                //         vshift
+                                //     );
+                                // }
                             } catch (e) {
                                 jxg/* default */.Z.debug("MathJax (not yet) loaded");
                             }
@@ -50778,6 +51106,11 @@ jxg/* default */.Z.extend(
                 return false;
             }
 
+            if (utils_type/* default */.Z.evaluate(this.attr.movetarget) === null &&
+                utils_type/* default */.Z.exists(evt.target) && utils_type/* default */.Z.exists(evt.target.releasePointerCapture)) {
+                evt.target.releasePointerCapture(evt.pointerId);
+            }
+
             if (!object && evt.isPrimary) {
                 // First finger down. To be on the safe side this._board_touches is cleared.
                 // this._pointerClearTouches();
@@ -50980,9 +51313,7 @@ jxg/* default */.Z.extend(
          * @returns {Boolean}
          */
         pointerMoveListener: function (evt) {
-            var i,
-                j,
-                pos,
+            var i, j, pos, eps,
                 touchTargets,
                 type = 'mouse'; // in case of no browser
 
@@ -51015,10 +51346,21 @@ jxg/* default */.Z.extend(
             this._inputDevice = this._getPointerInputDevice(evt);
             type = this._inputDevice;
             this.options.precision.hasPoint = this.options.precision[type];
+            eps = this.options.precision.hasPoint * 0.3333;
+
+            pos = this.getMousePosition(evt);
+            // Ignore pointer move event if too close at the border
+            // and setPointerCapture is off
+            if (utils_type/* default */.Z.evaluate(this.attr.movetarget) === null &&
+                pos[0] <= eps || pos[1] <= eps ||
+                pos[0] >= this.canvasWidth - eps ||
+                pos[1] >= this.canvasHeight - eps
+            ) {
+                return this.mode === this.BOARD_MODE_NONE;
+            }
 
             // selection
             if (this.selectingMode) {
-                pos = this.getMousePosition(evt);
                 this._moveSelecting(pos);
                 this.triggerEventHandlers(
                     ['touchmoveselecting', 'moveselecting', 'pointermoveselecting'],
@@ -51026,7 +51368,6 @@ jxg/* default */.Z.extend(
                 );
             } else if (!this.mouseOriginMove(evt)) {
                 if (this.mode === this.BOARD_MODE_DRAG) {
-                    pos = this.getMousePosition(evt);
                     // Run through all jsxgraph elements which are touched by at least one finger.
                     for (i = 0; i < this.touches.length; i++) {
                         touchTargets = this.touches[i].targets;
@@ -51063,7 +51404,6 @@ jxg/* default */.Z.extend(
                     }
 
                     // Move event without dragging an element
-                    pos = this.getMousePosition(evt);
                     this.highlightElements(pos[0], pos[1], evt, -1);
                 }
             }
@@ -52359,7 +52699,7 @@ jxg/* default */.Z.extend(
                 }, options);
                 this.intersectionObserver.observe(that.containerObj);
             } catch (err) {
-                console.log('JSXGraph: IntersectionObserver not available in this browser.');
+                jxg/* default */.Z.debug('JSXGraph: IntersectionObserver not available in this browser.');
             }
         },
 
@@ -54112,10 +54452,10 @@ jxg/* default */.Z.extend(
          * <li> array: ['key', value]
          * </ul>
          * Some board attributes are immutable, like e.g. the renderer type.
-         * 
+         *
          * @param {Object} attributes An object with attributes.
          * @returns {JXG.Board} Reference to the board
-         * 
+         *
          * @example
          * const board = JXG.JSXGraph.initBoard('jxgbox', {
          *     boundingbox: [-5, 5, 5, -5],
@@ -54125,7 +54465,7 @@ jxg/* default */.Z.extend(
          *     showScreenshot: true,
          *     showCopyright: false
          * });
-         * 
+         *
          * board.setAttribute({
          *     animationDelay: 10,
          *     boundingbox: [-10, 5, 10, -5],
@@ -54141,7 +54481,7 @@ jxg/* default */.Z.extend(
          *         locale: 'de-DE'
          *     }
          * });
-         * 
+         *
          * board.setAttribute({
          *     selection: {
          *         enabled: true,
@@ -54159,7 +54499,7 @@ jxg/* default */.Z.extend(
          *     showNavigation: false
          * });
          * board.setAttribute('showCopyright:false');
-         * 
+         *
          * var p = board.create('point', [1, 1], {size: 10,
          *     label: {
          *         fontSize: 24,
@@ -54167,8 +54507,8 @@ jxg/* default */.Z.extend(
          *         offset: [5, 0]
          *     }
          * });
-         * 
-         * 
+         *
+         *
          * </pre><div id="JXGea7b8e09-beac-4d95-9a0c-5fc1c761ffbc" class="jxgbox" style="width: 300px; height: 300px;"></div>
          * <script type="text/javascript">
          *     (function() {
@@ -54180,7 +54520,7 @@ jxg/* default */.Z.extend(
          *         showScreenshot: true,
          *         showCopyright: false
          *     });
-         *     
+         *
          *     board.setAttribute({
          *         animationDelay: 10,
          *         boundingbox: [-10, 5, 10, -5],
@@ -54196,7 +54536,7 @@ jxg/* default */.Z.extend(
          *             locale: 'de-DE'
          *         }
          *     });
-         *     
+         *
          *     board.setAttribute({
          *         selection: {
          *             enabled: true,
@@ -54213,9 +54553,9 @@ jxg/* default */.Z.extend(
          *         showZoom: false,
          *         showNavigation: false
          *     });
-         *     
+         *
          *     board.setAttribute('showCopyright:false');
-         *     
+         *
          *     var p = board.create('point', [1, 1], {size: 10,
          *         label: {
          *             fontSize: 24,
@@ -54223,13 +54563,13 @@ jxg/* default */.Z.extend(
          *             offset: [5, 0]
          *         }
          *     });
-         *     
-         * 
+         *
+         *
          *     })();
-         * 
+         *
          * </script><pre>
-         * 
-         * 
+         *
+         *
          */
         setAttribute: function (attr) {
             var i, arg, pair,
@@ -55345,6 +55685,8 @@ jxg/* default */.Z.extend(
          * Expand the JSXGraph construction to fullscreen.
          * In order to preserve the proportions of the JSXGraph element,
          * a wrapper div is created which is set to fullscreen.
+         * This function is called when fullscreen mode is triggered
+         * <b>and</b> when it is closed.
          * <p>
          * The wrapping div has the CSS class 'jxgbox_wrap_private' which is
          * defined in the file 'jsxgraph.css'
@@ -55417,6 +55759,7 @@ jxg/* default */.Z.extend(
             var wrap_id,
                 wrap_node,
                 inner_node,
+                dim,
                 doc = this.document,
                 fullscreenElement;
 
@@ -55425,7 +55768,17 @@ jxg/* default */.Z.extend(
             inner_node = doc.getElementById(id);
             wrap_id = 'fullscreenwrap_' + id;
 
+            // Store the original data.
+            // This is used to establish the ratio h / w in
+            // fullscreen mode
+            dim = this.containerObj.getBoundingClientRect();
+            inner_node._cssFullscreenStore = {
+                w: dim.width,
+                h: dim.height
+            }
+
             // Wrap a div around the JSXGraph div.
+            // It is removed when fullscreen mode is closed.
             if (doc.getElementById(wrap_id)) {
                 wrap_node = doc.getElementById(wrap_id);
             } else {
@@ -55436,10 +55789,6 @@ jxg/* default */.Z.extend(
                 wrap_node.appendChild(inner_node);
             }
 
-            // Get the real width and height of the JSXGraph div
-            // and determine the scaling and vertical shift amount
-            // this._fullscreen_res = Env._getScaleFactors(inner_node);
-
             // Trigger fullscreen mode
             wrap_node.requestFullscreen =
                 wrap_node.requestFullscreen ||
@@ -55454,12 +55803,15 @@ jxg/* default */.Z.extend(
             } else {
                 fullscreenElement = doc.msFullscreenElement;
             }
+
             if (fullscreenElement === null) {
                 // Start fullscreen mode
                 if (wrap_node.requestFullscreen) {
                     wrap_node.requestFullscreen();
+                    this.startFullscreenResizeObserver(wrap_node);
                 }
             } else {
+                this.stopFullscreenResizeObserver(wrap_node);
                 if (utils_type/* default */.Z.exists(document.exitFullscreen)) {
                     document.exitFullscreen();
                 } else if (utils_type/* default */.Z.exists(document.webkitExitFullscreen)) {
@@ -55480,7 +55832,8 @@ jxg/* default */.Z.extend(
         fullscreenListener: function (evt) {
             var inner_id,
                 inner_node,
-                fullscreenElement, // res,
+                fullscreenElement,
+                i,
                 doc = this.document;
 
             inner_id = this._fullscreen_inner_id;
@@ -55503,30 +55856,22 @@ jxg/* default */.Z.extend(
             if (fullscreenElement) {
                 // Just entered fullscreen mode
 
-                // Get the data computed in board.toFullscreen()
-                // res = this._fullscreen_res;
-
-                // Store the scaling data.
-                // It is used in AbstractRenderer.updateText to restore the scaling matrix
-                // which is removed by MathJax.
+                // Store the original data.
                 // Further, the CSS margin has to be removed when in fullscreen mode,
                 // and must be restored later.
-                inner_node._cssFullscreenStore = {
-                    id: fullscreenElement.id,
-                    isFullscreen: true,
-                    margin: inner_node.style.margin
-                    // width: inner_node.style.width
-                    // scale: res.scale,
-                    // vshift: res.vshift
-                };
-
+                // Obsolete:
+                // It is used in AbstractRenderer.updateText to restore the scaling matrix
+                // which is removed by MathJax.
+                inner_node._cssFullscreenStore.id = fullscreenElement.id;
+                inner_node._cssFullscreenStore.isFullscreen = true;
+                inner_node._cssFullscreenStore.margin = inner_node.style.margin;
                 inner_node.style.margin = '';
-                // inner_node.style.width = res.width + 'px';
 
                 // Do the shifting and scaling via CSS pseudo rules
                 // We do this after fullscreen mode has been established to get the correct size
                 // of the JSXGraph div.
-                env/* default */.Z.scaleJSXGraphDiv(fullscreenElement.id, inner_id, doc, utils_type/* default */.Z.evaluate(this.attr.fullscreen.scale));
+                env/* default */.Z.scaleJSXGraphDiv(fullscreenElement.id, inner_id, doc,
+                    utils_type/* default */.Z.evaluate(this.attr.fullscreen.scale));
 
                 // Clear this.doc.fullscreenElement, because Safari doesn't to it and
                 // when leaving full screen mode it is still set.
@@ -55535,20 +55880,93 @@ jxg/* default */.Z.extend(
                 // Just left the fullscreen mode
 
                 // Remove the CSS rules added in Env.scaleJSXGraphDiv
-                try {
-                    doc.styleSheets[doc.styleSheets.length - 1].deleteRule(0);
-                } catch (err) {
-                    console.log('JSXGraph: Could not remove CSS rules for full screen mode');
+                for (i = doc.styleSheets.length - 1; i >= 0; i--) {
+                    if (doc.styleSheets[i].title === 'jsxgraph_fullscreen_css') {
+                        doc.styleSheets[i].deleteRule(0);
+                        break;
+                    }
                 }
 
                 inner_node._cssFullscreenStore.isFullscreen = false;
                 inner_node.style.margin = inner_node._cssFullscreenStore.margin;
-                // inner_node.style.width = inner_node._cssFullscreenStore.width;
+
+                // Remove the wrapper div
+                inner_node.parentElement.replaceWith(inner_node);
             }
 
             this.updateCSSTransforms();
         },
 
+        /**
+         * Start resize observer in to handle
+         * orientation changes in fullscreen mode.
+         *
+         * @param {Object} node DOM object which is in fullscreen mode. It is the wrapper element
+         * around the JSXGraph div.
+         * @returns {JXG.Board} Reference to the board
+         * @private
+         * @see JXG.Board#toFullscreen
+         *
+         */
+        startFullscreenResizeObserver: function(node) {
+            var that = this;
+
+            if (!env/* default */.Z.isBrowser || !this.attr.resize || !this.attr.resize.enabled) {
+                return this;
+            }
+
+            this.resizeObserver = new ResizeObserver(function (entries) {
+                var inner_id,
+                    fullscreenElement,
+                    doc = that.document;
+
+                if (!that._isResizing) {
+                    that._isResizing = true;
+                    window.setTimeout(function () {
+                        try {
+                            inner_id = that._fullscreen_inner_id;
+                            if (doc.fullscreenElement !== undefined) {
+                                fullscreenElement = doc.fullscreenElement;
+                            } else if (doc.webkitFullscreenElement !== undefined) {
+                                fullscreenElement = doc.webkitFullscreenElement;
+                            } else {
+                                fullscreenElement = doc.msFullscreenElement;
+                            }
+                            if (fullscreenElement !== null) {
+                                env/* default */.Z.scaleJSXGraphDiv(fullscreenElement.id, inner_id, doc,
+                                    utils_type/* default */.Z.evaluate(that.attr.fullscreen.scale));
+                            }
+                        } catch (err) {
+                            that.stopFullscreenResizeObserver(node);
+                        } finally {
+                            that._isResizing = false;
+                        }
+                    }, that.attr.resize.throttle);
+                }
+            });
+            this.resizeObserver.observe(node);
+            return this;
+        },
+
+        /**
+         * Remove resize observer to handle orientation changes in fullscreen mode.
+         * @param {Object} node DOM object which is in fullscreen mode. It is the wrapper element
+         * around the JSXGraph div.
+         * @returns {JXG.Board} Reference to the board
+         * @private
+         * @see JXG.Board#toFullscreen
+         */
+        stopFullscreenResizeObserver: function(node) {
+            if (!env/* default */.Z.isBrowser || !this.attr.resize || !this.attr.resize.enabled) {
+                return this;
+            }
+
+            if (utils_type/* default */.Z.exists(this.resizeObserver)) {
+                this.resizeObserver.unobserve(node);
+            }
+            return this;
+        },
+
         /**
          * Add user activity to the array 'board.userLog'.
          *
@@ -57639,13 +58057,8 @@ jxg/* default */.Z.extend(
 
         // documented in AbstractRenderer
         resize: function (w, h) {
-            // this.svgRoot.style.width  = parseFloat(w) + 'px';
-            // this.svgRoot.style.height = parseFloat(h) + 'px';
-
             this.svgRoot.setAttribute("width", parseFloat(w));
             this.svgRoot.setAttribute("height", parseFloat(h));
-            // this.svgRoot.setAttribute('width',  '100%');
-            // this.svgRoot.setAttribute('height', '100%');
         },
 
         // documented in JXG.AbstractRenderer
@@ -61197,7 +61610,7 @@ jxg/* default */.Z.extend(
             }
             this.context = this.canvasRoot.getContext("2d");
             // The width and height of the canvas is set to twice the CSS values,
-            // followed by an appropiate scaling.
+            // followed by an appropriate scaling.
             // See https://stackoverflow.com/questions/22416462/canvas-element-with-blurred-lines
             this.context.scale(2, 2);
         },
@@ -72663,6 +73076,11 @@ jxg/* default */.Z.registerElement("metapostspline", jxg/* default */.Z.createMe
 /**
  * @class This element is used to provide a constructor for Riemann sums, which is realized as a special curve.
  * The returned element has the method Value() which returns the sum of the areas of the bars.
+ * <p>
+ * In case of type "simpson" and "trapezoidal", the horizontal line approximating the function value 
+ * is replaced by a parabola or a secant. IN case of "simpson", 
+ * the parabola is approximated visually by a polygonal chain of fixed step width. 
+ * 
  * @pseudo
  * @description
  * @name Riemannsum
@@ -72676,7 +73094,7 @@ jxg/* default */.Z.registerElement("metapostspline", jxg/* default */.Z.createMe
  *         n determines the number of bars, it is either a fixed number or a function.
  *         <p>
  *         type is a string or function returning one of the values:  'left', 'right', 'middle', 'lower', 'upper', 'random', 'simpson', or 'trapezoidal'.
- *         Default value is 'left'.
+ *         Default value is 'left'. "simpson" is Simpson's 1/3 rule.
  *         <p>
  *         Further parameters are an optional number or function for the left interval border a,
  *         and an optional number or function for the right interval border b.
@@ -80099,6 +80517,7 @@ jxg/* default */.Z.createSlider = function (board, parents, attributes) {
         ticks, ti, t,
         startx, starty,
         withText, withTicks,
+        snapValues, snapValueDistance,
         snapWidth, sw, s,
         attr;
 
@@ -80106,6 +80525,8 @@ jxg/* default */.Z.createSlider = function (board, parents, attributes) {
     withTicks = attr.withticks;
     withText = attr.withlabel;
     snapWidth = attr.snapwidth;
+    snapValues = attr.snapvalues;
+    snapValueDistance = attr.snapvaluedistance;
 
     // start point
     attr = utils_type/* default */.Z.copyAttributes(attributes, board.options, "slider", "point1");
@@ -80142,7 +80563,7 @@ jxg/* default */.Z.createSlider = function (board, parents, attributes) {
     attr.withLabel = false;
     // gliders set snapwidth=-1 by default (i.e. deactivate them)
     p3 = board.create("glider", [startx, starty, l1], attr);
-    p3.setAttribute({ snapwidth: snapWidth });
+    p3.setAttribute({ snapwidth: snapWidth, snapvalues: snapValues, snapvaluedistance: snapValueDistance });
 
     // Segment from start point to glider point: highline
     attr = utils_type/* default */.Z.copyAttributes(attributes, board.options, "slider", "highline");
@@ -80157,7 +80578,18 @@ jxg/* default */.Z.createSlider = function (board, parents, attributes) {
      */
     p3.Value = function () {
         var sdiff = this._smax - this._smin,
-            ev_sw = utils_type/* default */.Z.evaluate(this.visProp.snapwidth);
+            ev_sw = utils_type/* default */.Z.evaluate(this.visProp.snapwidth),
+            snapValues, i, v;
+
+        snapValues = utils_type/* default */.Z.evaluate(this.visProp.snapvalues);
+        if (utils_type/* default */.Z.isArray(snapValues)) {
+            for (i=0; i < snapValues.length; i++) {
+                v = (snapValues[i] - this._smin) / (this._smax - this._smin);
+                if(this.position === v) {
+                    return snapValues[i];
+                }
+            }
+        }
 
         return ev_sw === -1
             ? this.position * sdiff + this._smin
@@ -88802,36 +89234,36 @@ var checkbox_priv = {
  * }, checkbox);
  * })();
  * </script><pre>
- *
  * @example
- *         var i1 = board.create('input', [-3, 4, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
- *         var c1 = board.create('checkbox', [-3, 2, 'label 1'], {});
- *         var b1 = board.create('button', [-3, -1, 'Change texts', function () {
- *                 i1.setText('g(x)');
+ *     var i1 = board.create('input', [1, 5, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
+ *         var c1 = board.create('checkbox', [1, 3, 'label 1'], {});
+ *         var b1 = board.create('button', [1, 1, 'Change texts', function () {
+ *                 i1.setText('g(x)=');
  *                 i1.set('cos(x)');
  *                 c1.setText('label 2');
  *                 b1.setText('Texts are changed');
  *             }],
- *             {cssStyle: 'width:400px'});
- *
- * </pre><div id="JXG11cac8gg-2354-47e7-9da4-eb298e53de05" class="jxgbox" style="width: 300px; height: 300px;"></div>
+ *             {cssStyle: 'width:200px'});
+ * 
+ * </pre><div id="JXG31c6d070-354b-4f09-aab9-9aaa796f730c" class="jxgbox" style="width: 300px; height: 300px;"></div>
  * <script type="text/javascript">
  *     (function() {
- *         var board = JXG.JSXGraph.initBoard('JXG11cac8gg-2354-47e7-9da4-eb298e53de05',
- *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
- *             var i1 = board.create('input', [-3, 4, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
- *             var c1 = board.create('checkbox', [-3, 2, 'label 1'], {});
- *             var b1 = board.create('button', [-3, -1, 'Change texts', function () {
- *                     i1.setText('g(x)');
+ *         var board = JXG.JSXGraph.initBoard('JXG31c6d070-354b-4f09-aab9-9aaa796f730c',
+ *             {boundingbox: [-1, 7, 7, -1], axis: true, showcopyright: false, shownavigation: false});
+ *         var i1 = board.create('input', [1, 5, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
+ *             var c1 = board.create('checkbox', [1, 3, 'label 1'], {});
+ *             var b1 = board.create('button', [1, 1, 'Change texts', function () {
+ *                     i1.setText('g(x)=');
  *                     i1.set('cos(x)');
  *                     c1.setText('label 2');
  *                     b1.setText('Texts are changed');
  *                 }],
- *                 {cssStyle: 'width:400px'});
- *
+ *                 {cssStyle: 'width:200px'});
+ * 
  *     })();
- *
+ * 
  * </script><pre>
+ * 
  */
 jxg/* default */.Z.createCheckbox = function (board, parents, attributes) {
     var t,
@@ -92084,7 +92516,6 @@ jxg/* default */.Z.createView3D = function (board, parents, attributes) {
             }
             d = utils_type/* default */.Z.evaluate(p.visProp.infoboxdigits);
             infobox = view.board.infobox;
-            console.log(infobox.useLocale())
             if (d === 'auto') {
                 if (infobox.useLocale()) {
                     arr = [pre, '(', infobox.formatNumberLocale(p.X()), ' | ', infobox.formatNumberLocale(p.Y()), ' | ', infobox.formatNumberLocale(p.Z()), ')']