jsxgraph 1.10.0 → 1.10.1

package/distrib/sketch.min.js

@@ -1,5 +1,5 @@
 /*
-    JSXGraph 1.9.1
+    JSXGraph 1.10.0
 
     Copyright 2008-2024
         Matthias Ehmann,

package/package.json

@@ -2,7 +2,7 @@
   "name": "jsxgraph",
   "description": "Interactive geometry, plotting, visualization",
   "homepage": "https://jsxgraph.org",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "exports": {
     "types": "./src/index.d.ts",
     "default": "./src/index.js"

package/src/3d/box3d.js

@@ -113,6 +113,7 @@ JXG.createAxes3D = function (board, parents, attributes) {
             to[i] = front[i];
             // attr[na.toLowerCase()].lastArrow = false;
             axes[na] = view.create("axis3d", [from, to], attr[na.toLowerCase()]);
+            axes[na].view = view;
 
             ticks_attr = attr[na.toLowerCase()].ticks3d;
             len = front[i] - rear[i];
@@ -123,6 +124,7 @@ JXG.createAxes3D = function (board, parents, attributes) {
             } else {
                 axes[na + "Ticks"] = view.create("ticks3d", [from, [0, 0, 1], len, [0, 1, 0]], ticks_attr);
             }
+            axes[na + "Ticks"].view = view;
         }
     }
 

package/src/3d/curve3d.js

@@ -297,23 +297,72 @@ JXG.registerElement("curve3d", JXG.createCurve3D);
  * end value of y. The vector field will contain (number of steps) + 1 vectors in direction of y.
  * @param {Array} zData Array of length 3 containing start value for z, number of steps,
  * end value of z. The vector field will contain (number of steps) + 1 vectors in direction of z.
+ *
+ * @example
+ * const view = board.create('view3d',
+ *     [
+ *         [-6, -3],
+ *         [8, 8],
+ *         [[-3, 3], [-3, 3], [-3, 3]]
+ *     ], {});
+ *
+ * var vf = view.create('vectorfield3d', [
+ *     [(x, y, z) => Math.cos(y), (x, y, z) => Math.sin(x), (x, y, z) => z],
+ *     [-2, 5, 2], // x from -2 to 2 in 5 steps
+ *     [-2, 5, 2], // y
+ *     [-2, 5, 2] // z
+ * ], {
+ *     strokeColor: 'red',
+ *     scale: 0.5
+ * });
+ *
+ * </pre><div id="JXG8e41c67b-3338-4428-bd0f-c69d8f6fb348" class="jxgbox" style="width: 300px; height: 300px;"></div>
+ * <script type="text/javascript">
+ *     (function() {
+ *         var board = JXG.JSXGraph.initBoard('JXG8e41c67b-3338-4428-bd0f-c69d8f6fb348',
+ *             {boundingbox: [-8, 8, 8,-8], axis: false, showcopyright: false, shownavigation: false,
+ *          pan: {
+ *                needTwoFingers: true
+ *           }
+ *          });
+ *     const view = board.create('view3d',
+ *         [
+ *             [-6, -3],
+ *             [8, 8],
+ *             [[-3, 3], [-3, 3], [-3, 3]]
+ *         ], {});
+ *     var vf = view.create('vectorfield3d', [
+ *         [(x, y, z) => Math.cos(y), (x, y, z) => Math.sin(x), (x, y, z) => z],
+ *         [-2, 5, 2], // x from -2 to 2 in 5 steps
+ *         [-2, 5, 2], // y
+ *         [-2, 5, 2] // z
+ *     ], {
+ *         strokeColor: 'red',
+ *         scale: 0.5
+ *     });
+ *
+ *
+ *     })();
+ *
+ * </script><pre>
+ *
  */
 JXG.createVectorfield3D = function (board, parents, attributes) {
     var view = parents[0],
         el, attr;
 
     if (!(parents.length >= 5 &&
-        (Type.isArray(parents[1]) || Type.isFunction(parents[0]) || Type.isString(parents[0])) &&
+        (Type.isArray(parents[1]) || Type.isFunction(parents[1]) || Type.isString(parents[1])) &&
         (Type.isArray(parents[2]) && parents[1].length === 3) &&
         (Type.isArray(parents[3]) && parents[2].length === 3) &&
         (Type.isArray(parents[4]) && parents[3].length === 3)
     )) {
         throw new Error(
             "JSXGraph: Can't create vector field 3D with parent types " +
-            "'" + typeof parents[0] + "', " +
             "'" + typeof parents[1] + "', " +
-            "'" + typeof parents[2] + "'."  +
-            "'" + typeof parents[1] + "', "
+            "'" + typeof parents[2] + "', " +
+            "'" + typeof parents[3] + "'."  +
+            "'" + typeof parents[4] + "', "
         );
     }
 

package/src/3d/linspace3d.js

@@ -602,7 +602,7 @@ JXG.extend(
 
         updateDataArray: function () {
             var s1, e1, s2, e2, c2d, l1, l2,
-                planes = ['xPlaneRear', 'yPlaneRear', 'zPlaneRear'],
+                planes = ['xPlaneRear', 'yPlaneRear', 'zPlaneRear'], // Must be ordered x, y, z
                 points = [],
                 v1 = [0, 0, 0],
                 v2 = [0, 0, 0],
@@ -625,17 +625,20 @@ JXG.extend(
                 Type.evaluate(this.range2[0]) === -Infinity &&
                 Type.evaluate(this.range2[1]) === Infinity
             ) {
+                // Determine the intersections of the new plane with
+                // the view bbox3d.
+                //
                 // Start with the rear plane.
-                // Determine the intersections with the view bbox3d
                 // For each face of the bbox3d we determine two points
-                // which are the ends of the intersection line.
-                // We start with the three rear planes.
+                // which are the end points of the intersecting line
+                // between the plane and a face of bbox3d.
+                // We start with the three rear planes (set in planes[] above)
                 for (j = 0; j < planes.length; j++) {
                     p = view.intersectionPlanePlane(this, view.defaultAxes[planes[j]]);
-
                     if (p[0].length === 3 && p[1].length === 3) {
                         // This test is necessary to filter out intersection lines which are
-                        // identical to intersections of axis planes (they would occur twice).
+                        // identical to intersections of axis planes (they would occur twice),
+                        // i.e. edges of bbox3d.
                         for (i = 0; i < points.length; i++) {
                             if (
                                 (Geometry.distance(p[0], points[i][0], 3) < Mat.eps &&
@@ -651,10 +654,11 @@ JXG.extend(
                         }
                     }
 
-                    // Point on the front plane of the bbox3d
+                    // Take a point on the corresponding front plane of bbox3d.
                     p = [0, 0, 0];
                     p[j] = view.bbox3D[j][1];
 
+                    // Use the Hesse normal form of front plane to intersect it with the plane
                     // d is the rhs of the Hesse normal form of the front plane.
                     d = Mat.innerProduct(p, view.defaultAxes[planes[j]].normal, 3);
                     p = view.intersectionPlanePlane(this, view.defaultAxes[planes[j]], d);
@@ -662,6 +666,7 @@ JXG.extend(
                     if (p[0].length === 3 && p[1].length === 3) {
                         // Do the same test as above
                         for (i = 0; i < points.length; i++) {
+                            // Same test for edges of bbox3d as above
                             if (
                                 (Geometry.distance(p[0], points[i][0], 3) < Mat.eps &&
                                     Geometry.distance(p[1], points[i][1], 3) < Mat.eps) ||
@@ -677,6 +682,11 @@ JXG.extend(
                     }
                 }
 
+                // Handle the case that the plane does not intersect bbox3d at all.
+                if (points.length === 0) {
+                    return { X: this.dataX, Y: this.dataY };
+                }
+
                 // Concatenate the intersection points to a polygon.
                 // If all went well, each intersection should appear
                 // twice in the list.

package/src/3d/point3d.js

@@ -278,13 +278,15 @@ JXG.extend(
         },
 
         update: function (drag) {
-            var c3d, foot;
+            var c3d, foot, res;
 
             // Update is called from board.updateElements
             if (
                 this.element2D.draggable() &&
                 Geometry.distance(this._c2d, this.element2D.coords.usrCoords) !== 0
             ) {
+
+                //
                 if (this.slide) {
                     this.coords = this.slide.projectScreenCoords(
                         [this.element2D.X(), this.element2D.Y()],
@@ -297,17 +299,33 @@ JXG.extend(
                 } else {
                     if (this.view.isVerticalDrag()) {
                         // Drag the point in its vertical to the xy plane
+                        // If the point is outside of bbox3d,
+                        // c3d is already corrected.
                         c3d = this.view.project2DTo3DVertical(this.element2D, this.coords);
                     } else {
                         // Drag the point in its xy plane
                         foot = [1, 0, 0, this.coords[3]];
                         c3d = this.view.project2DTo3DPlane(this.element2D, [1, 0, 0, 1], foot);
                     }
+
                     if (c3d[0] !== 0) {
-                        this.coords = this.view.project3DToCube(c3d);
+                        // Check if c3d is inside of view.bbox3d
+                        // Otherwise, the coords have to be corrected below.
+                        res = this.view.project3DToCube(c3d);
+                        this.coords = res[0];
+
+                        if (res[1]) {
+                            // The 3D coordinates have been corrected, now
+                            // also correct the 2D element.
+                            this.element2D.coords.setCoordinates(
+                                Const.COORDS_BY_USER,
+                                this.view.project3DTo2D(this.coords)
+                            );
+                        }
                     }
                 }
             } else {
+                // Update 2D point from its 3D view
                 this.updateCoords();
                 if (this.slide) {
                     this.coords = this.slide.projectCoords(
@@ -315,7 +333,6 @@ JXG.extend(
                         this._params
                     );
                 }
-                // Update 2D point from its 3D view
                 this.element2D.coords.setCoordinates(
                     Const.COORDS_BY_USER,
                     this.view.project3DTo2D([1, this.X(), this.Y(), this.Z()])

package/src/3d/text3d.js

@@ -278,9 +278,10 @@ JXG.extend(
         },
 
         update: function (drag) {
-            var c3d, foot;
+            var c3d, foot, res;
 
-            // Update is called from board.updateElements
+            // Update is called from board.updateElements.
+            // See Point3D.update() for the logic.
             if (
                 this.element2D.draggable() &&
                 Geometry.distance(this._c2d, this.element2D.coords.usrCoords) !== 0
@@ -296,15 +297,27 @@ JXG.extend(
                     );
                 } else {
                     if (this.view.isVerticalDrag()) {
-                        // Drag the point in its vertical to the xy plane
+                        // Drag the text in its vertical to the xy plane
                         c3d = this.view.project2DTo3DVertical(this.element2D, this.coords);
                     } else {
-                        // Drag the point in its xy plane
+                        // Drag the text in its xy plane
                         foot = [1, 0, 0, this.coords[3]];
                         c3d = this.view.project2DTo3DPlane(this.element2D, [1, 0, 0, 1], foot);
                     }
                     if (c3d[0] !== 0) {
-                        this.coords = this.view.project3DToCube(c3d);
+                        // Check if c3d is inside of view.bbox3d
+                        // Otherwise, the coords have to be corrected below.
+                        res = this.view.project3DToCube(c3d);
+                        this.coords = res[0];
+
+                        if (res[1]) {
+                            // The 3D coordinates have been corrected, now
+                            // also correct the 2D element.
+                            this.element2D.coords.setCoordinates(
+                                Const.COORDS_BY_USER,
+                                this.view.project3DTo2D(this.coords)
+                            );
+                        }
                     }
                 }
             } else {
@@ -315,7 +328,7 @@ JXG.extend(
                         this._params
                     );
                 }
-                // Update 2D point from its 3D view
+                // Update 2D text from its 3D view
                 this.element2D.coords.setCoordinates(
                     Const.COORDS_BY_USER,
                     this.view.project3DTo2D([1, this.X(), this.Y(), this.Z()].slice(1))
@@ -447,8 +460,7 @@ JXG.createText3D = function (board, parents, attributes) {
     el.inherits.push(el.element2D);
     el.element2D.setParents(el);
 
-
-    // if this point is a glider, record that in the update tree
+    // If this point is a glider, record that in the update tree
     if (el.slide) {
         el.slide.addChild(el);
         el.setParents(el.slide);

package/src/3d/view3d.js

@@ -1160,30 +1160,39 @@ JXG.extend(
      * Limit 3D coordinates to the bounding cube.
      *
      * @param {Array} c3d 3D coordinates [x,y,z]
-     * @returns Array with updated 3D coordinates.
+     * @returns Array [Array, Boolean] containing [coords, corrected]. coords contains the updated 3D coordinates,
+     * correct is true if the coords have been changed.
      */
     project3DToCube: function (c3d) {
-        var cube = this.bbox3D;
+        var cube = this.bbox3D,
+            isOut = false;
+
         if (c3d[1] < cube[0][0]) {
             c3d[1] = cube[0][0];
+            isOut = true;
         }
         if (c3d[1] > cube[0][1]) {
             c3d[1] = cube[0][1];
+            isOut = true;
         }
         if (c3d[2] < cube[1][0]) {
             c3d[2] = cube[1][0];
+            isOut = true;
         }
         if (c3d[2] > cube[1][1]) {
             c3d[2] = cube[1][1];
+            isOut = true;
         }
-        if (c3d[3] < cube[2][0]) {
+        if (c3d[3] <= cube[2][0]) {
             c3d[3] = cube[2][0];
+            isOut = true;
         }
-        if (c3d[3] > cube[2][1]) {
+        if (c3d[3] >= cube[2][1]) {
             c3d[3] = cube[2][1];
+            isOut = true;
         }
 
-        return c3d;
+        return [c3d, isOut];
     },
 
     /**
@@ -2295,7 +2304,9 @@ JXG.createView3D = function (board, parents, attributes) {
     view.inherits.push(view.bank_slide);
 
     // Set special infobox attributes of view3d.infobox
-    view.board.infobox.setAttribute(attr.infobox);
+    // Using setAttribute() is not possible here, since we have to
+    // avoid a call of board.update().
+    view.board.infobox.visProp = Type.merge(view.board.infobox.visProp, attr.infobox);
 
     // 3d infobox: drag direction and coordinates
     view.board.highlightInfobox = function (x, y, el) {
@@ -2352,7 +2363,6 @@ JXG.createView3D = function (board, parents, attributes) {
         }
     };
 
-
     // Hack needed to enable addEvent for view3D:
     view.BOARD_MODE_NONE = 0x0000;
 

package/src/base/board.js

@@ -6064,6 +6064,7 @@ JXG.extend(
                     Type.isString(parents[i]) &&
                     !(elementType === 'text' && i === 2) &&
                     !(elementType === 'solidofrevolution3d' && i === 2) &&
+                    !(elementType === 'text3d' && (i === 2 || i === 4)) &&
                     !(
                         (elementType === 'input' ||
                             elementType === 'checkbox' ||

package/src/base/constants.js

@@ -37,7 +37,7 @@ import JXG from "../jxg.js";
 
 var major = 1,
     minor = 10,
-    patch = 0,
+    patch = 1,
     add = '', // 'dev' 'beta'
     version = major + '.' + minor + '.' + patch + (add ? '-' + add : ''),
     constants;

package/src/base/coordselement.js

@@ -1903,13 +1903,58 @@ JXG.extend(
          * @param {Number} [time] Number of milliseconds the animation should last.
          * @param {Object} [options] Optional settings for the animation
          * @param {function} [options.callback] A function that is called as soon as the animation is finished.
-         * @param {String} [options.effect='<>'] animation effects like speed fade in and out. possible values are
-         * '<>' for speed increase on start and slow down at the end (default) and '--' for constant speed during
+         * @param {String} [options.effect='<>'|'>'|'<'] animation effects like speed fade in and out. possible values are
+         * '<>' for speed increase on start and slow down at the end (default), '<' for speed up, '>' for slow down, and '--' for constant speed during
          * the whole animation.
          * @returns {JXG.CoordsElement} Reference to itself.
          * @see JXG.CoordsElement#moveAlong
          * @see JXG.CoordsElement#visit
          * @see JXG.GeometryElement#animate
+         * @example
+         * // moveTo() with different easing options and callback options
+         * let yInit = 3
+         * let [A, B, C, D] = ['==', '<>', '<', '>'].map((s) => board.create('point', [4, yInit--], { name: s, label: { fontSize: 24 } }))
+         * let seg = board.create('segment', [A, [() => A.X(), 0]])  // shows linear
+         *
+         *let isLeftRight = true;
+         *let buttonMove = board.create('button', [-2, 4, 'left',
+         *() => {
+         *    isLeftRight = !isLeftRight;
+         *    buttonMove.rendNodeButton.innerHTML = isLeftRight ? 'left' : 'right'
+         *    let x = isLeftRight ? 4 : -4
+         *    let sym = isLeftRight ? 'triangleleft' : 'triangleright'
+         *
+         *    A.moveTo([x, 3], 1000, { callback: () => A.setAttribute({ face: sym, size: 5 }) })
+         *    B.moveTo([x, 2], 1000, { callback: () => B.setAttribute({ face: sym, size: 5 }), effect: "<>" })
+         *    C.moveTo([x, 1], 1000, { callback: () => C.setAttribute({ face: sym, size: 5 }), effect: "<" })
+         *    D.moveTo([x, 0], 1000, { callback: () => D.setAttribute({ face: sym, size: 5 }), effect: ">" })
+         *
+         *}])
+         *
+          </pre><div id="JXG0f35a50e-e99d-11e8-a1ca-04d3b0c2aad4" class="jxgbox" style="width: 300px; height: 300px;"></div>
+          <script type="text/javascript">
+          {
+*          let board = JXG.JSXGraph.initBoard('JXG0f35a50e-e99d-11e8-a1ca-04d3b0c2aad4')
+          let yInit = 3
+          let [A, B, C, D] = ['==', '<>', '<', '>'].map((s) => board.create('point', [4, yInit--], { name: s, label: { fontSize: 24 } }))
+          let seg = board.create('segment', [A, [() => A.X(), 0]])  // shows linear
+
+         let isLeftRight = true;
+         let buttonMove = board.create('button', [-2, 4, 'left',
+         () => {
+             isLeftRight = !isLeftRight;
+             buttonMove.rendNodeButton.innerHTML = isLeftRight ? 'left' : 'right'
+             let x = isLeftRight ? 4 : -4
+             let sym = isLeftRight ? 'triangleleft' : 'triangleright'
+
+             A.moveTo([x, 3], 1000, { callback: () => A.setAttribute({ face: sym, size: 5 }) })
+             B.moveTo([x, 2], 1000, { callback: () => B.setAttribute({ face: sym, size: 5 }), effect: "<>" })
+             C.moveTo([x, 1], 1000, { callback: () => C.setAttribute({ face: sym, size: 5 }), effect: "<" })
+             D.moveTo([x, 0], 1000, { callback: () => D.setAttribute({ face: sym, size: 5 }), effect: ">" })
+
+         }])
+        }
+        </script><pre>
          */
         moveTo: function (where, time, options) {
             options = options || {};
@@ -1925,10 +1970,24 @@ JXG.extend(
                 dY = where.usrCoords[2] - Y,
                 /** @ignore */
                 stepFun = function (i) {
-                    if (options.effect && options.effect === "<>") {
-                        return Math.pow(Math.sin(((i / steps) * Math.PI) / 2), 2);
+                    let x = i / steps;  // absolute progress of the animatin
+
+                    if (options.effect) {
+                        if (options.effect === "<>") {
+                            return Math.pow(Math.sin((x * Math.PI) / 2), 2);
+                        }
+                        if (options.effect === "<") {   // cubic ease in
+                            return x * x * x;
+                        }
+                        if (options.effect === ">") {   // cubic ease out
+                            return 1 - Math.pow(1 - x, 3);
+                        }
+                        if (options.effect === "==") {
+                            return i / steps;       // linear
+                        }
+                        throw new Error("valid effects are '==', '<>', '>', and '<'.");
                     }
-                    return i / steps;
+                    return i / steps;  // default
                 };
 
             if (
@@ -1972,14 +2031,52 @@ JXG.extend(
          * @param {Number} time Number of milliseconds the animation should last.
          * @param {Object} [options] Optional settings for the animation
          * @param {function} [options.callback] A function that is called as soon as the animation is finished.
-         * @param {String} [options.effect='<>'] animation effects like speed fade in and out. possible values are
-         * '<>' for speed increase on start and slow down at the end (default) and '--' for constant speed during
+         * @param {String} [options.effect='<>'|'>'|'<'] animation effects like speed fade in and out. possible values are
+         * '<>' for speed increase on start and slow down at the end (default), '<' for speed up, '>' for slow down, and '--' for constant speed during
          * the whole animation.
          * @param {Number} [options.repeat=1] How often this animation should be repeated.
          * @returns {JXG.CoordsElement} Reference to itself.
          * @see JXG.CoordsElement#moveAlong
          * @see JXG.CoordsElement#moveTo
          * @see JXG.GeometryElement#animate
+         * @example
+         * // visit() with different easing options
+         * let yInit = 3
+         * let [A, B, C, D] = ['==', '<>', '<', '>'].map((s) => board.create('point', [4, yInit--], { name: s, label: { fontSize: 24 } }))
+         * let seg = board.create('segment', [A, [() => A.X(), 0]])  // shows linear
+         *
+         *let isLeftRight = true;
+         *let buttonVisit = board.create('button', [0, 4, 'visit',
+         *    () => {
+         *        let x = isLeftRight ? 4 : -4
+         *
+         *        A.visit([-x, 3], 4000, { effect: "==", repeat: 2 })  // linear
+         *        B.visit([-x, 2], 4000, { effect: "<>", repeat: 2 })
+         *        C.visit([-x, 1], 4000, { effect: "<", repeat: 2 })
+         *        D.visit([-x, 0], 4000, { effect: ">", repeat: 2 })
+         *    }])
+         *
+          </pre><div id="JXG0f35a50e-e99d-11e8-a1ca-04d3b0c2aad5" class="jxgbox" style="width: 300px; height: 300px;"></div>
+          <script type="text/javascript">
+          {
+*          let board = JXG.JSXGraph.initBoard('JXG0f35a50e-e99d-11e8-a1ca-04d3b0c2aad5')
+          let yInit = 3
+          let [A, B, C, D] = ['==', '<>', '<', '>'].map((s) => board.create('point', [4, yInit--], { name: s, label: { fontSize: 24 } }))
+          let seg = board.create('segment', [A, [() => A.X(), 0]])  // shows linear
+
+         let isLeftRight = true;
+         let buttonVisit = board.create('button', [0, 4, 'visit',
+             () => {
+                 let x = isLeftRight ? 4 : -4
+
+                 A.visit([-x, 3], 4000, { effect: "==", repeat: 2 })  // linear
+                 B.visit([-x, 2], 4000, { effect: "<>", repeat: 2 })
+                 C.visit([-x, 1], 4000, { effect: "<", repeat: 2 })
+                 D.visit([-x, 0], 4000, { effect: ">", repeat: 2 })
+             }])
+            }
+        </script><pre>
+
          */
         visit: function (where, time, options) {
             where = new Coords(Const.COORDS_BY_USER, where, this.board);
@@ -1997,10 +2094,22 @@ JXG.extend(
                 stepFun = function (i) {
                     var x = i < steps / 2 ? (2 * i) / steps : (2 * (steps - i)) / steps;
 
-                    if (options.effect && options.effect === "<>") {
-                        return Math.pow(Math.sin((x * Math.PI) / 2), 2);
-                    }
+                    if (options.effect) {
+                        if (options.effect === "<>") {        // slow at beginning and end
+                            return Math.pow(Math.sin((x * Math.PI) / 2), 2);
+                        }
+                        if (options.effect === "<") {   // cubic ease in
+                            return x * x * x;
+                        }
+                        if (options.effect === ">") {   // cubic ease out
+                            return 1 - Math.pow(1 - x, 3);
+                        }
+                        if (options.effect === "==") {
+                            return x;       // linear
+                        }
+                        throw new Error("valid effects are '==', '<>', '>', and '<'.");
 
+                    }
                     return x;
                 };
 

package/src/element/sector.js

@@ -1233,7 +1233,7 @@ JXG.createAngle = function (board, parents, attributes) {
     attr = Type.copyAttributes(attributes, board.options, "angle");
 
     //  If empty, create a new name
-    if (!Type.exists(attr.name) || attr.name === "") {
+    if (!Type.exists(attr.name) /*|| attr.name === ""*/) {
         attr.name = board.generateName({ type: Const.OBJECT_TYPE_ANGLE });
     }
 

package/src/index.js

@@ -18,7 +18,6 @@ import './math/plot.js';
 import './math/implicitplot.js';
 import './math/metapost.js';
 import './math/statistics.js';
-import './math/symbolic.js';
 import './math/geometry.js';
 import './math/clip.js';
 import './math/poly.js';
@@ -44,7 +43,6 @@ import './element/sector.js';
 import './base/composition.js';
 import './element/composition.js';
 import './element/grid.js';
-import './element/locus.js';
 import './base/text.js';
 import './base/image.js';
 import './element/slider.js';
@@ -58,7 +56,6 @@ import './utils/zip.js';
 import './utils/base64.js';
 import './utils/uuid.js';
 import './utils/encoding.js';
-import './server/server.js';
 import './parser/datasource.js';
 import './parser/jessiecode.js';
 import './parser/prefix.js';