jsxgraph 1.14.0 → 1.14.1

package/src/math/tiling.js

@@ -46,11 +46,11 @@ import Mat from "./math.js";
 Mat.Tiling = {
     /**
      * Triangulate (partition it into triangles) a given two dimensional domain.
-     * The number of triangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
-     * If the optional parameter stepsV is not given or is equal to 0, the rectangle is partitioned into
+     * The number of triangles the original rectangle is divided into depends on the parameters` `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
+     * If the optional parameter `stepsV` is not given or is equal to 0, the rectangle is partitioned into
      * nearly equilateral triangles.
-     * Otherwise, the shape of the triangles depends on the ratio of stepsU / stepsV.
+     * Otherwise, the shape of the triangles depends on the ratio of `stepsU / stepsV`.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -206,8 +206,8 @@ Mat.Tiling = {
 
     /**
      * Rectangulate (partition it into rectangles) a given two dimensional domain.
-     * The number of rectangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
+     * The number of rectangles the original rectangle is divided into depends on the parameters `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -331,288 +331,6 @@ Mat.Tiling = {
         }
         return [vertices, faces];
     }
-
-    // triangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         width, height,
-    //         wSide, hSide,
-    //         triangleWidth, triangleHeight,
-    //         s1, s2,
-    //         i, j,
-    //         numRows,
-    //         widthX, widthY, heightX, heightY,
-    //         oddPoints,
-    //         evenPoints;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error(" the board created is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     if (s1 <= s2) {
-    //         width = s1;
-    //         height = s2;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         width = s2;
-    //         height = s1;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-    //     // Calculate height and width of the triangles and number of rows
-    //     triangleWidth = width / stepsU;
-
-    //     if (stepsV === undefined || stepsV === 0) {
-    //         // Equilateral triangles, depending on parameter "stepsU"
-    //         triangleHeight = (triangleWidth * Math.sqrt(3)) / 2;
-    //         numRows = Math.round(height / triangleHeight);
-    //     } else {
-    //         // Two parameters stepsU, stepsV
-    //         numRows = stepsV;
-    //         triangleHeight = height / numRows;
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsU;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsU;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / numRows;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / numRows;
-
-    //     oddPoints = [];
-    //     evenPoints = [];
-
-    //     // Push coordinates of the base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     evenPoints.push(coords.length - 1);
-
-    //     // Calculate point coordinates of layer 0 and store indices in evenPoints
-    //     for (i = 1; i <= stepsU; i++) {
-    //         coords.push([p1[0] + i * widthX, p1[1] + i * widthY]); // Points first line
-    //         evenPoints.push(coords.length - 1);
-    //     }
-
-    //     for (i = 1; i <= numRows; i++) {
-    //         if (i % 2 === 0) {
-    //             // Points and faces of layers with an even index
-
-    //             evenPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // evenPoints stores index of the first point of the layer
-    //             evenPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[evenPoints[0]][0] + j * widthX,
-    //                     coords[evenPoints[0]][1] + j * widthY
-    //                 ]);
-    //                 //evenPoints stores index of the most recently calculated point of the layer
-    //                 evenPoints.push(coords.length - 1);
-    //             }
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([evenPoints[0], oddPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([evenPoints[j - 1], oddPoints[j], evenPoints[j]]);
-    //                 faces.push([evenPoints[j], oddPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         } else {
-    //             // Points and faces of layers with an odd index
-
-    //             oddPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // oddPoints stores index of the first point of the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer except for the last point
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[oddPoints[0]][0] + j * widthX - widthX / 2,
-    //                     coords[oddPoints[0]][1] + j * widthY - widthY / 2
-    //                 ]);
-    //                 // oddPoints stores index of the most recently calculated point of the layer
-    //                 oddPoints.push(coords.length - 1);
-    //             }
-    //             // Calculate last point coordinates within the layer
-    //             coords.push([
-    //                 coords[oddPoints[0]][0] + stepsU * widthX,
-    //                 coords[oddPoints[0]][1] + stepsU * widthY
-    //             ]);
-    //             // oddPoints stores index of last point within the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([oddPoints[0], evenPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([oddPoints[j], evenPoints[j - 1], evenPoints[j]]);
-    //                 faces.push([oddPoints[j], evenPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // rectangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         wSide, hSide,
-    //         s1, s2,
-    //         i, j,
-    //         widthX, widthY,
-    //         heightX, heightY,
-    //         startPointLayer;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error("rectangulation_old: area is not rectangle  ");
-    //         // console.log("rectangulation_old: area is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     // s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     // s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     s1 = Mat.hypot(vec1[0], vec1[1]);
-    //     s2 = Mat.hypot(vec2[0], vec2[1]);
-
-    //     if (s1 <= s2) {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsV;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsV;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / stepsU;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / stepsU;
-
-    //     // Initialize startPointLayer that stores coordinates of the first point of the current layer
-    //     startPointLayer = [];
-
-    //     // Push coordinates of base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     startPointLayer = coords[0];
-
-    //     // Calculate point coordinates of layer 0
-    //     for (j = 1; j <= stepsV; j++) {
-    //         coords.push([startPointLayer[0] + j * widthX, startPointLayer[1] + j * widthY]);
-    //     }
-
-    //     for (i = 1; i <= stepsU; i++) {
-    //         startPointLayer = [];
-
-    //         // Calculate point coordinates of first point of layer
-    //         coords.push([
-    //             p1[0] + i * heightX,
-    //             p1[1] + i * heightY
-    //         ]);
-    //         startPointLayer = coords[coords.length - 1];
-
-    //         // Calculating remaining point coordinates of layer
-    //         for (j = 1; j <= stepsV; j++) {
-    //             coords.push([
-    //                 startPointLayer[0] + j * widthX,
-    //                 startPointLayer[1] + j * widthY
-    //             ]);
-    //         }
-
-    //         // Connect rectangles by grouping indices of points
-    //         for (
-    //             j = coords.length - stepsV - 1;
-    //             j < coords.length - 1;
-    //             j++
-    //         ) {
-    //             faces.push([j, j - stepsV - 1, j - stepsV, j + 1]);
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // /**
-    //  * This function creates an array of dynamic 3-dimensional points
-    //  * based on an array of pairs of two coordinates.
-    //  * It uses a mathematical function to assign a third coordinate (the z-coordinate)
-    //  * to each pair of two coordinates.
-    //  * The 3-dimensional points are not stored directly.
-    //  * Instead the array stores JavaScript functions that utilize the mentioned mathematical function
-    //  * to return an array of three coordinates.
-    //  * This allows the recognition and proper visualization of changes to the underlying
-    //  * mathematical function.
-    //  * @name mapMeshTo3D
-    //  * @param {Array} surface
-    //  * @param {Parametricsurface3d} el
-    //  * @returns {Array} dynamicPoints array of [x, y, z] coordinates
-    //  *
-    //  * @private
-    //  * @memberof JXG.Math.Tiling
-    //  */
-    // mapMeshTo3D: function (surface, el) {
-    //     var dynamicPoints = [], i;
-
-    //     for (i = 0; i < surface[0].length; i++) {
-    //         dynamicPoints.push(
-    //             (function (u, v) {
-    //                 return function(x, y) { return el.F(u, v); };
-    //             })(surface[0][i][0], surface[0][i][1])
-    //         ); // Capture values explicitly
-    //         // dynamicPoints.push(
-    //         //     (function (u, v) {
-    //         //         return function(x, y) { return el.F(Type.evaluate(u), Type.evaluate(v)); };
-    //         //     })(surface[0][i][0], surface[0][i][1])
-    //         // ); // Capture values explicitly
-    //     }
-
-    //     return dynamicPoints;
-    // }
 };
 
 export default Mat.Tiling;

package/src/parser/jessiecode.js

@@ -3473,7 +3473,7 @@ upcomingInput:function () {
 showPosition:function () {
         var pre = this.pastInput();
         var c = new Array(pre.length + 1).join("-");
-        return pre + this.upcomingInput() + "\n" + c+"^";
+        return JXG.escapeHTML(pre + this.upcomingInput() + "\n" + c+"^");
     },
 next:function () {
         if (this.done) {

package/src/renderer/canvas.js

@@ -206,7 +206,7 @@ JXG.extend(
          * Set the gradient angle for linear color gradients.
          *
          * @private
-         * @param {JXG.GeometryElement} node An arbitrary JSXGraph element, preferably one with an area.
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} radians angle value in radians. 0 is horizontal from left to right, Pi/4 is vertical from top to bottom.
          */
         updateGradientAngle: function (el, radians) {
@@ -262,7 +262,7 @@ JXG.extend(
          * Set circles for radial color gradients.
          *
          * @private
-         * @param {SVGnode} node SVG gradient node
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} cx Canvas value x1 (but value between 0 and 1)
          * @param {Number} cy  Canvas value y1 (but value between 0 and 1)
          * @param {Number} r  Canvas value r1 (but value between 0 and 1)
@@ -275,19 +275,20 @@ JXG.extend(
                 c1, c2,
                 cxs, cys, rs,
                 fxs, fys, frs,
-                dx, dy;
+                dx, dy, d;
 
             c1 = new Coords(Const.COORDS_BY_USER, [bb[0], bb[1]], el.board);
             c2 = new Coords(Const.COORDS_BY_USER, [bb[2], bb[3]], el.board);
             dx = c2.scrCoords[1] - c1.scrCoords[1];
             dy = c1.scrCoords[2] - c2.scrCoords[2];
-
             cxs = c1.scrCoords[1] + dx * cx;
             cys = c2.scrCoords[2] + dy * cy;
             fxs = c1.scrCoords[1] + dx * fx;
             fys = c2.scrCoords[2] + dy * fy;
-            rs = r * (dx + dy) * 0.5;
-            frs = fr * (dx + dy) * 0.5;
+
+            d = Math.abs(dx) + Math.abs(dy);
+            rs = Math.max(r * d * 0.5, 0);
+            frs = Math.max(fr * d * 0.5, 0);
 
             return this.context.createRadialGradient(fxs, fys, frs, cxs, cys, rs);
         },

package/src/renderer/svg.js

@@ -253,7 +253,7 @@ JXG.SVGRenderer = function (container, dim) {
         var id = this.uniqName('ClipFull'),
             node1 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'clipPath'),
             node2 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'rect'),
-            style, rx, ry;
+            style, r;
         node1.setAttributeNS(null, 'id', id);
 
         node2.setAttributeNS(null, 'x', 0);
@@ -263,10 +263,9 @@ JXG.SVGRenderer = function (container, dim) {
 
         // Inherit border-radius
         style = getComputedStyle(this.container);
-        rx = Type.exists(style['border-radius']) ? parseFloat(style['border-radius']) : 0;
-        ry = rx;
-        node2.setAttributeNS(null, 'rx', rx);
-        node2.setAttributeNS(null, 'ry', ry);
+        r = (Type.exists(style['border-radius']) && style['border-radius'] !== '') ? parseFloat(style['border-radius']) : 0;
+        node2.setAttributeNS(null, 'rx', r);
+        node2.setAttributeNS(null, 'ry', r);
 
         node1.appendChild(node2);
         return node1;
@@ -954,7 +953,7 @@ JXG.extend(
 
         // Already documented in JXG.AbstractRenderer
         setLayer: function (el, level) {
-            var node;
+            var node, elNode;
             if (!Type.exists(level)) {
                 level = 0;
             } else if (level >= Options.layer.numlayers) {
@@ -962,8 +961,16 @@ JXG.extend(
             }
 
             node = this.layer[level];
+            // if ('moveBefore' in Element.prototype) {
             if (Type.exists(node.moveBefore)) {
-                node.moveBefore(el.rendNode, null);
+                // node.moveBefore(el.rendNode, null);
+                elNode = el.rendNode;
+                if (elNode.isConnected && node.isConnected &&
+                    (elNode.ownerDocument === node.ownerDocument)) {
+                    node.moveBefore(elNode, null);
+                } else {
+                    node.insertBefore(elNode, null);
+                }
             } else {
                 node.appendChild(el.rendNode);
             }
@@ -1250,6 +1257,7 @@ JXG.extend(
                 i = 0;
                 while (i < len) {
                     if (el.points[i] === undefined) {
+                        i++;
                         continue;
                     }
                     scr = el.points[i].scrCoords;

package/src/utils/type.js

@@ -1404,8 +1404,10 @@ JXG.extend(
         mergeAttr: function (attr, special, toLower, ignoreUndefinedSpecials) {
             var e, e2, o;
 
-            toLower = toLower || true;
-            ignoreUndefinedSpecials = ignoreUndefinedSpecials || false;
+            // toLower = toLower || true;
+            // ignoreUndefinedSpecials || false;
+            toLower = this.def(toLower, true);
+            ignoreUndefinedSpecials = this.def(ignoreUndefinedSpecials, false);
 
             for (e in special) {
                 if (special.hasOwnProperty(e)) {
@@ -1878,8 +1880,13 @@ JXG.extend(
          * @returns {String}
          */
         trimNumber: function (str) {
-            str = str.replace(/^0+/, "");
-            str = str.replace(/0+$/, "");
+            if (str !== '0') {
+                str = str.replace(/^0+/, "");
+            }
+
+            if (str.indexOf('.') >= 0 || str.indexOf(',') >= 0) {
+                str = str.replace(/0+$/, "");
+            }
 
             if (str[str.length - 1] === "." || str[str.length - 1] === ",") {
                 str = str.slice(0, -1);