jsxgraph 1.4.0 → 1.4.1

package/src/math/complex.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/extrapolate.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/geometry.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -1084,7 +1084,7 @@ define([
                 };
 
             } else if ((
-                        el1.elementClass === Const.OBJECT_CLASS_CURVE && 
+                        el1.elementClass === Const.OBJECT_CLASS_CURVE &&
                         !el1_isArcType &&
                         el2.elementClass === Const.OBJECT_CLASS_LINE
                        ) ||
@@ -1729,7 +1729,7 @@ define([
          * @param {Array} q1 First point of segment 2 using normalized homogeneous coordinates [1,x,y]
          * @param {Array} q2 Second point or direction of segment 2 using normalized homogeneous coordinates [1,x,y] or point at infinity [0,x,y], respectively
          * @returns {Array} [Intersection point, t, u] The first entry contains the homogeneous coordinates
-         * of the intersection point. The second and third entry give the position of the intersection with respect 
+         * of the intersection point. The second and third entry give the position of the intersection with respect
          * to the definiting parameters. For example, the second entry t is defined by: intersection point = p1 + t * deltaP, where
          * deltaP = (p2 - p1) when both parameters are coordinates, and deltaP = p2 if p2 is a point at infinity.
          * If the two segments are collinear, [[0,0,0], Infinity, Infinity] is returned.
@@ -1749,8 +1749,8 @@ define([
             c[2] /= c[0];
             c[0] /= c[0];
 
-            // Now compute in principle: 
-            //    t = dist(c - p1) / dist(p2 - p1) and 
+            // Now compute in principle:
+            //    t = dist(c - p1) / dist(p2 - p1) and
             //    u = dist(c - q1) / dist(q2 - q1)
             // However: the points q1, q2, p1, p2 might be ideal points - or in general - the
             // coordinates might be not normalized.

package/src/math/ia.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -299,9 +299,9 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Addition
-         * 
-         * @param {JXG.Math.Interval|Number} x 
-         * @param {JXG.Math.Interval|Number} y 
+         *
+         * @param {JXG.Math.Interval|Number} x
+         * @param {JXG.Math.Interval|Number} y
          * @returns JXG.Math.Interval
          */
         add: function(x, y) {
@@ -316,9 +316,9 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Subtraction
-         * 
-         * @param {JXG.Math.Interval|Number} x 
-         * @param {JXG.Math.Interval|Number} y 
+         *
+         * @param {JXG.Math.Interval|Number} x
+         * @param {JXG.Math.Interval|Number} y
          * @returns JXG.Math.Interval
          */
          sub: function(x, y) {
@@ -333,9 +333,9 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Multiplication
-         * 
-         * @param {JXG.Math.Interval|Number} x 
-         * @param {JXG.Math.Interval|Number} y 
+         *
+         * @param {JXG.Math.Interval|Number} x
+         * @param {JXG.Math.Interval|Number} y
          * @returns JXG.Math.Interval
          */
          mul: function(x, y) {
@@ -437,9 +437,9 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Division
-         * 
-         * @param {JXG.Math.Interval|Number} x 
-         * @param {JXG.Math.Interval|Number} y 
+         *
+         * @param {JXG.Math.Interval|Number} x
+         * @param {JXG.Math.Interval|Number} y
          * @returns JXG.Math.Interval
          */
          div: function(x, y) {
@@ -470,8 +470,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Return +x (i.e. identity)
-         * 
-         * @param {JXG.Math.Interval} x 
+         *
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
          positive: function(x) {
@@ -480,8 +480,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Return -x
-         * 
-         * @param {JXG.Math.Interval} x 
+         *
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
          negative: function(x) {
@@ -497,37 +497,37 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Test if interval is empty set.
-         * @param {JXG.Math.Interval} i 
+         * @param {JXG.Math.Interval} i
          * @returns Boolean
-         */        
+         */
         isEmpty: function(i) {
             return i.lo > i.hi;
         },
 
         /**
          * Test if interval is (-Infinity, Infinity).
-         * @param {JXG.Math.Interval} i 
+         * @param {JXG.Math.Interval} i
          * @returns Boolean
-         */        
+         */
         isWhole: function(i){
             return i.lo === -Infinity && i.hi === Infinity;
         },
 
         /**
          * Test if interval contains 0.
-         * @param {JXG.Math.Interval} i 
+         * @param {JXG.Math.Interval} i
          * @returns Boolean
-         */        
+         */
          zeroIn: function(i) {
             return this.hasValue(i, 0);
         },
 
         /**
          * Test if interval contains a specific value.
-         * @param {JXG.Math.Interval} i 
+         * @param {JXG.Math.Interval} i
          * @param {Number} value
          * @returns Boolean
-         */        
+         */
          hasValue: function(i, value) {
             if (this.isEmpty(i)) {
                 return false;
@@ -540,7 +540,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
-         */        
+         */
          hasInterval: function(x, y) {
             if (this.isEmpty(x)) {
                 return true;
@@ -553,7 +553,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
-         */        
+         */
          intervalsOverlap: function(x, y) {
             if (this.isEmpty(x) || this.isEmpty(y)) {
                 return false;
@@ -566,8 +566,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          */
         /**
          * @private
-         * @param {JXG.Math.Interval} x 
-         * @param {JXG.Math.Interval} y 
+         * @param {JXG.Math.Interval} x
+         * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
         divNonZero: function(x, y) {
@@ -607,8 +607,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * @private
-         * @param {JXG.Math.Interval} x 
-         * @param {JXG.Math.Interval} y 
+         * @param {JXG.Math.Interval} x
+         * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
          divPositive: function(x, v) {
@@ -631,8 +631,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * @private
-         * @param {JXG.Math.Interval} x 
-         * @param {JXG.Math.Interval} y 
+         * @param {JXG.Math.Interval} x
+         * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
          divNegative: function(x, v) {
@@ -655,7 +655,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * @private
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
          divZero: function(x) {
@@ -670,8 +670,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          */
         /**
          * x mod y:  x - n * y
-         * @param {JXG.Math.Interval|Number} x 
-         * @param {JXG.Math.Interval|Number} y 
+         * @param {JXG.Math.Interval|Number} x
+         * @param {JXG.Math.Interval|Number} y
          * @returns JXG.Math.Interval
          */
         fmod: function(x, y) {
@@ -698,7 +698,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * 1 / x
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         multiplicativeInverse: function(x) {
@@ -730,7 +730,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * x<sup>power</sup>
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @param {JXG.Math.Interval|Number} power
          * @returns JXG.Math.Interval
          */
@@ -797,7 +797,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * sqrt(x)
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
          sqrt: function(x) {
@@ -809,7 +809,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * x<sup>1/n</sup>
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @param {Number} n
          * @returns JXG.Math.Interval
          */
@@ -865,8 +865,8 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          * Misc
          */
         /**
-         * 
-         * @param {JXG.Math.Interval|Number} x 
+         *
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         exp: function(x) {
@@ -881,7 +881,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Natural log
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         log: function(x) {
@@ -898,7 +898,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Natural log, alias for {@link JXG.Math.IntervalArithmetic#log}.
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         ln: function(x) {
@@ -909,7 +909,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         // export const LOG_EXP_2 = log(new MatInterval(2, 2))
         /**
          * Logarithm to base 10.
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         log10: function(x) {
@@ -921,7 +921,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Logarithm to base 2.
-         * @param {JXG.Math.Interval|Number} x 
+         * @param {JXG.Math.Interval|Number} x
          * @returns JXG.Math.Interval
          */
         log2: function(x) {
@@ -933,7 +933,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Hull of intervals x and y
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -954,7 +954,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Intersection of intervals x and y
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -973,7 +973,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Union of overlapping intervals x and y
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -986,7 +986,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
 
         /**
          * Difference of overlapping intervals x and y
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -1022,7 +1022,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         width: function(x) {
@@ -1033,7 +1033,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         abs: function(x) {
@@ -1053,7 +1053,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -1073,7 +1073,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns JXG.Math.Interval
          */
@@ -1115,7 +1115,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         cos: function(x) {
@@ -1163,7 +1163,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         sin: function(x) {
@@ -1174,7 +1174,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         tan: function(x) {
@@ -1199,7 +1199,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         asin: function(x) {
@@ -1213,7 +1213,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         acos: function(x) {
@@ -1227,7 +1227,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         atan: function(x) {
@@ -1238,7 +1238,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         sinh: function(x) {
@@ -1249,7 +1249,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         cosh: function(x) {
@@ -1266,7 +1266,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @returns JXG.Math.Interval
          */
         tanh: function(x) {
@@ -1281,7 +1281,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          */
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */
@@ -1300,7 +1300,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         // },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */
@@ -1312,7 +1312,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */
@@ -1330,7 +1330,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */
@@ -1348,7 +1348,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */
@@ -1366,7 +1366,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
         },
 
         /**
-         * @param {JXG.Math.Interval} x 
+         * @param {JXG.Math.Interval} x
          * @param {JXG.Math.Interval} y
          * @returns Boolean
          */

package/src/math/math.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/metapost.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/nlp.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Carsten Miller,
         Reinhard Oldenburg,
@@ -145,7 +145,7 @@ define(['jxg'], function (JXG) {
          * @returns {Number} Exit status of the COBYLA2 optimization.
          */
         FindMinimum: function(calcfc, n,  m, x, rhobeg, rhoend,  iprint,  maxfun) {
-    	    // CobylaExitStatus FindMinimum(final Calcfc calcfc, int n, int m, double[] x, double rhobeg, double rhoend, int iprint, int maxfun)
+            // CobylaExitStatus FindMinimum(final Calcfc calcfc, int n, int m, double[] x, double rhobeg, double rhoend, int iprint, int maxfun)
             //     This subroutine minimizes an objective function F(X) subject to M
             //     inequality constraints on X, where X is a vector of variables that has
             //     N components.  The algorithm employs linear approximations to the
@@ -241,7 +241,7 @@ define(['jxg'], function (JXG) {
          * @returns {Number} Exit status of the COBYLA2 optimization
          */
         cobylb: function (calcfc, n,  m,  mpp,  x, rhobeg,  rhoend,  iprint,  maxfun) {
-    		// calcf ist funktion die aufgerufen wird wie calcfc(n, m, ix, ocon)
+            // calcf ist funktion die aufgerufen wird wie calcfc(n, m, ix, ocon)
             // N.B. Arguments CON, SIM, SIMI, DATMAT, A, VSIG, VETA, SIGBAR, DX, W & IACT
             //      have been removed.
 
@@ -314,7 +314,7 @@ define(['jxg'], function (JXG) {
             //     Make the next call of the user-supplied subroutine CALCFC. These
             //     instructions are also used for calling CALCFC during the iterations of
             //     the algorithm.
-		    //alert("Iteration "+nfvals+" x="+x);
+            //alert("Iteration "+nfvals+" x="+x);
             L_40:
             do {
                 if (nfvals >= maxfun && nfvals > 0) {

package/src/math/numerics.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -31,6 +31,7 @@
 
 /*global JXG: true, define: true*/
 /*jslint nomen: true, plusplus: true*/
+/*eslint no-loss-of-precision: off */
 
 /* depends:
  utils/type

package/src/math/plot.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -457,7 +457,7 @@ define(['jxg', 'base/constants', 'base/coords', 'math/math', 'math/extrapolate',
                 vy = curve.Y(t_real, true) ;
                 vy2 = curve.Y(t_real2, true) ;
                 dy = (vy - vy2) / (t_real - t_real2);
-               
+
                 if (p_good !== null) {
                     this._insertPoint_v2(curve, new Coords(Const.COORDS_BY_USER, p_good, curve.board, false));
                     return true;
@@ -1016,7 +1016,7 @@ define(['jxg', 'base/constants', 'base/coords', 'math/math', 'math/extrapolate',
         },
 
         /**
-         * 
+         *
          * @param {JXG.Curve} curve JSXGraph curve element
          * @param {Number} ta
          * @param {Number} tb
@@ -1959,7 +1959,7 @@ console.log("Polynomial of degree", level);
                 dx, dy;
 
             //console.log("Level", level)
-            if (level == 0) {
+            if (level === 0) {
                 this._insertPoint_v4(curve, [1, NaN, NaN], t);
                 return;
             }

package/src/math/poly.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/probfuncs.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Carsten Miller,
         Andreas Walter,
@@ -30,6 +30,7 @@
 
 /*global JXG: true, define: true*/
 /*jslint nomen: true, plusplus: true*/
+/*eslint no-loss-of-precision: off */
 
 /* depends:
  jxg