@tachybase/plugin-evaluator-mathjs 1.3.20

package/dist/node_modules/mathjs/lib/cjs/function/geometry/distance.js

@@ -0,0 +1,360 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDistance = void 0;
+
+var _is = require("../../utils/is.js");
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'distance';
+var dependencies = ['typed', 'addScalar', 'subtract', 'divideScalar', 'multiplyScalar', 'unaryMinus', 'sqrt', 'abs'];
+var createDistance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      addScalar = _ref.addScalar,
+      subtract = _ref.subtract,
+      multiplyScalar = _ref.multiplyScalar,
+      divideScalar = _ref.divideScalar,
+      unaryMinus = _ref.unaryMinus,
+      sqrt = _ref.sqrt,
+      abs = _ref.abs;
+
+  /**
+    * Calculates:
+    *    The eucledian distance between two points in N-dimensional spaces.
+    *    Distance between point and a line in 2 and 3 dimensional spaces.
+    *    Pairwise distance between a set of 2D or 3D points
+    * NOTE:
+    *    When substituting coefficients of a line(a, b and c), use ax + by + c = 0 instead of ax + by = c
+    *    For parametric equation of a 3D line, x0, y0, z0, a, b, c are from: (x−x0, y−y0, z−z0) = t(a, b, c)
+    *
+    * Syntax:
+    *    math.distance([x1, y1], [x2, y2])
+    *-   math.distance({pointOneX: 4, pointOneY: 5}, {pointTwoX: 2, pointTwoY: 7})
+    *    math.distance([x1, y1, z1], [x2, y2, z2])
+    *    math.distance({pointOneX: 4, pointOneY: 5, pointOneZ: 8}, {pointTwoX: 2, pointTwoY: 7, pointTwoZ: 9})
+    *    math.distance([x1, y1, ... , N1], [x2, y2, ... , N2])
+    *    math.distance([[A], [B], [C]...])
+    *    math.distance([x1, y1], [LinePtX1, LinePtY1], [LinePtX2, LinePtY2])
+    *    math.distance({pointX: 1, pointY: 4}, {lineOnePtX: 6, lineOnePtY: 3}, {lineTwoPtX: 2, lineTwoPtY: 8})
+    *    math.distance([x1, y1, z1], [LinePtX1, LinePtY1, LinePtZ1], [LinePtX2, LinePtY2, LinePtZ2])
+    *    math.distance({pointX: 1, pointY: 4, pointZ: 7}, {lineOnePtX: 6, lineOnePtY: 3, lineOnePtZ: 4}, {lineTwoPtX: 2, lineTwoPtY: 8, lineTwoPtZ: 5})
+    *    math.distance([x1, y1], [xCoeffLine, yCoeffLine, constant])
+    *    math.distance({pointX: 10, pointY: 10}, {xCoeffLine: 8, yCoeffLine: 1, constant: 3})
+    *    math.distance([x1, y1, z1], [x0, y0, z0, a-tCoeff, b-tCoeff, c-tCoeff]) point and parametric equation of 3D line
+    *    math.distance([x, y, z], [x0, y0, z0, a, b, c])
+    *    math.distance({pointX: 2, pointY: 5, pointZ: 9}, {x0: 4, y0: 6, z0: 3, a: 4, b: 2, c: 0})
+    *
+    * Examples:
+    *    math.distance([0,0], [4,4])                     // Returns 5.6569
+    *    math.distance(
+    *     {pointOneX: 0, pointOneY: 0},
+    *     {pointTwoX: 10, pointTwoY: 10})                // Returns 14.142135623730951
+    *    math.distance([1, 0, 1], [4, -2, 2])            // Returns 3.74166
+    *    math.distance(
+    *     {pointOneX: 4, pointOneY: 5, pointOneZ: 8},
+    *     {pointTwoX: 2, pointTwoY: 7, pointTwoZ: 9})    // Returns 3
+    *    math.distance([1, 0, 1, 0], [0, -1, 0, -1])     // Returns 2
+    *    math.distance([[1, 2], [1, 2], [1, 3]])         // Returns [0, 1, 1]
+    *    math.distance([[1,2,4], [1,2,6], [8,1,3]])      // Returns [2, 7.14142842854285, 7.681145747868608]
+    *    math.distance([10, 10], [8, 1, 3])              // Returns 11.535230316796387
+    *    math.distance([10, 10], [2, 3], [-8, 0])        // Returns 8.759953130362847
+    *    math.distance(
+    *     {pointX: 1, pointY: 4},
+    *     {lineOnePtX: 6, lineOnePtY: 3},
+    *     {lineTwoPtX: 2, lineTwoPtY: 8})                // Returns 2.720549372624744
+    *    math.distance([2, 3, 1], [1, 1, 2, 5, 0, 1])    // Returns 2.3204774044612857
+    *    math.distance(
+    *     {pointX: 2, pointY: 3, pointZ: 1},
+    *     {x0: 1, y0: 1, z0: 2, a: 5, b: 0, c: 1}        // Returns 2.3204774044612857
+    *
+    * @param {Array | Matrix | Object} x    Co-ordinates of first point
+    * @param {Array | Matrix | Object} y    Co-ordinates of second point
+    * @return {Number | BigNumber} Returns the distance from two/three points
+  */
+  return typed(name, {
+    'Array, Array, Array': function ArrayArrayArray(x, y, z) {
+      // Point to Line 2D (x=Point, y=LinePoint1, z=LinePoint2)
+      if (x.length === 2 && y.length === 2 && z.length === 2) {
+        if (!_2d(x)) {
+          throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
+        }
+
+        if (!_2d(y)) {
+          throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
+        }
+
+        if (!_2d(z)) {
+          throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
+        }
+
+        var m = divideScalar(subtract(z[1], z[0]), subtract(y[1], y[0]));
+        var xCoeff = multiplyScalar(multiplyScalar(m, m), y[0]);
+        var yCoeff = unaryMinus(multiplyScalar(m, y[0]));
+        var constant = x[1];
+        return _distancePointLine2D(x[0], x[1], xCoeff, yCoeff, constant);
+      } else {
+        throw new TypeError('Invalid Arguments: Try again');
+      }
+    },
+    'Object, Object, Object': function ObjectObjectObject(x, y, z) {
+      if (Object.keys(x).length === 2 && Object.keys(y).length === 2 && Object.keys(z).length === 2) {
+        if (!_2d(x)) {
+          throw new TypeError('Values of pointX and pointY should be numbers or BigNumbers');
+        }
+
+        if (!_2d(y)) {
+          throw new TypeError('Values of lineOnePtX and lineOnePtY should be numbers or BigNumbers');
+        }
+
+        if (!_2d(z)) {
+          throw new TypeError('Values of lineTwoPtX and lineTwoPtY should be numbers or BigNumbers');
+        }
+
+        if ('pointX' in x && 'pointY' in x && 'lineOnePtX' in y && 'lineOnePtY' in y && 'lineTwoPtX' in z && 'lineTwoPtY' in z) {
+          var m = divideScalar(subtract(z.lineTwoPtY, z.lineTwoPtX), subtract(y.lineOnePtY, y.lineOnePtX));
+          var xCoeff = multiplyScalar(multiplyScalar(m, m), y.lineOnePtX);
+          var yCoeff = unaryMinus(multiplyScalar(m, y.lineOnePtX));
+          var constant = x.pointX;
+          return _distancePointLine2D(x.pointX, x.pointY, xCoeff, yCoeff, constant);
+        } else {
+          throw new TypeError('Key names do not match');
+        }
+      } else {
+        throw new TypeError('Invalid Arguments: Try again');
+      }
+    },
+    'Array, Array': function ArrayArray(x, y) {
+      // Point to Line 2D (x=[pointX, pointY], y=[x-coeff, y-coeff, const])
+      if (x.length === 2 && y.length === 3) {
+        if (!_2d(x)) {
+          throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
+        }
+
+        if (!_3d(y)) {
+          throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
+        }
+
+        return _distancePointLine2D(x[0], x[1], y[0], y[1], y[2]);
+      } else if (x.length === 3 && y.length === 6) {
+        // Point to Line 3D
+        if (!_3d(x)) {
+          throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
+        }
+
+        if (!_parametricLine(y)) {
+          throw new TypeError('Array with 6 numbers or BigNumbers expected for second argument');
+        }
+
+        return _distancePointLine3D(x[0], x[1], x[2], y[0], y[1], y[2], y[3], y[4], y[5]);
+      } else if (x.length === y.length && x.length > 0) {
+        // Point to Point N-dimensions
+        if (!_containsOnlyNumbers(x)) {
+          throw new TypeError('All values of an array should be numbers or BigNumbers');
+        }
+
+        if (!_containsOnlyNumbers(y)) {
+          throw new TypeError('All values of an array should be numbers or BigNumbers');
+        }
+
+        return _euclideanDistance(x, y);
+      } else {
+        throw new TypeError('Invalid Arguments: Try again');
+      }
+    },
+    'Object, Object': function ObjectObject(x, y) {
+      if (Object.keys(x).length === 2 && Object.keys(y).length === 3) {
+        if (!_2d(x)) {
+          throw new TypeError('Values of pointX and pointY should be numbers or BigNumbers');
+        }
+
+        if (!_3d(y)) {
+          throw new TypeError('Values of xCoeffLine, yCoeffLine and constant should be numbers or BigNumbers');
+        }
+
+        if ('pointX' in x && 'pointY' in x && 'xCoeffLine' in y && 'yCoeffLine' in y && 'constant' in y) {
+          return _distancePointLine2D(x.pointX, x.pointY, y.xCoeffLine, y.yCoeffLine, y.constant);
+        } else {
+          throw new TypeError('Key names do not match');
+        }
+      } else if (Object.keys(x).length === 3 && Object.keys(y).length === 6) {
+        // Point to Line 3D
+        if (!_3d(x)) {
+          throw new TypeError('Values of pointX, pointY and pointZ should be numbers or BigNumbers');
+        }
+
+        if (!_parametricLine(y)) {
+          throw new TypeError('Values of x0, y0, z0, a, b and c should be numbers or BigNumbers');
+        }
+
+        if ('pointX' in x && 'pointY' in x && 'x0' in y && 'y0' in y && 'z0' in y && 'a' in y && 'b' in y && 'c' in y) {
+          return _distancePointLine3D(x.pointX, x.pointY, x.pointZ, y.x0, y.y0, y.z0, y.a, y.b, y.c);
+        } else {
+          throw new TypeError('Key names do not match');
+        }
+      } else if (Object.keys(x).length === 2 && Object.keys(y).length === 2) {
+        // Point to Point 2D
+        if (!_2d(x)) {
+          throw new TypeError('Values of pointOneX and pointOneY should be numbers or BigNumbers');
+        }
+
+        if (!_2d(y)) {
+          throw new TypeError('Values of pointTwoX and pointTwoY should be numbers or BigNumbers');
+        }
+
+        if ('pointOneX' in x && 'pointOneY' in x && 'pointTwoX' in y && 'pointTwoY' in y) {
+          return _euclideanDistance([x.pointOneX, x.pointOneY], [y.pointTwoX, y.pointTwoY]);
+        } else {
+          throw new TypeError('Key names do not match');
+        }
+      } else if (Object.keys(x).length === 3 && Object.keys(y).length === 3) {
+        // Point to Point 3D
+        if (!_3d(x)) {
+          throw new TypeError('Values of pointOneX, pointOneY and pointOneZ should be numbers or BigNumbers');
+        }
+
+        if (!_3d(y)) {
+          throw new TypeError('Values of pointTwoX, pointTwoY and pointTwoZ should be numbers or BigNumbers');
+        }
+
+        if ('pointOneX' in x && 'pointOneY' in x && 'pointOneZ' in x && 'pointTwoX' in y && 'pointTwoY' in y && 'pointTwoZ' in y) {
+          return _euclideanDistance([x.pointOneX, x.pointOneY, x.pointOneZ], [y.pointTwoX, y.pointTwoY, y.pointTwoZ]);
+        } else {
+          throw new TypeError('Key names do not match');
+        }
+      } else {
+        throw new TypeError('Invalid Arguments: Try again');
+      }
+    },
+    Array: function Array(arr) {
+      if (!_pairwise(arr)) {
+        throw new TypeError('Incorrect array format entered for pairwise distance calculation');
+      }
+
+      return _distancePairwise(arr);
+    }
+  });
+
+  function _isNumber(a) {
+    // distance supports numbers and bignumbers
+    return typeof a === 'number' || (0, _is.isBigNumber)(a);
+  }
+
+  function _2d(a) {
+    // checks if the number of arguments are correct in count and are valid (should be numbers)
+    if (a.constructor !== Array) {
+      a = _objectToArray(a);
+    }
+
+    return _isNumber(a[0]) && _isNumber(a[1]);
+  }
+
+  function _3d(a) {
+    // checks if the number of arguments are correct in count and are valid (should be numbers)
+    if (a.constructor !== Array) {
+      a = _objectToArray(a);
+    }
+
+    return _isNumber(a[0]) && _isNumber(a[1]) && _isNumber(a[2]);
+  }
+
+  function _containsOnlyNumbers(a) {
+    // checks if the number of arguments are correct in count and are valid (should be numbers)
+    if (!Array.isArray(a)) {
+      a = _objectToArray(a);
+    }
+
+    return a.every(_isNumber);
+  }
+
+  function _parametricLine(a) {
+    if (a.constructor !== Array) {
+      a = _objectToArray(a);
+    }
+
+    return _isNumber(a[0]) && _isNumber(a[1]) && _isNumber(a[2]) && _isNumber(a[3]) && _isNumber(a[4]) && _isNumber(a[5]);
+  }
+
+  function _objectToArray(o) {
+    var keys = Object.keys(o);
+    var a = [];
+
+    for (var i = 0; i < keys.length; i++) {
+      a.push(o[keys[i]]);
+    }
+
+    return a;
+  }
+
+  function _pairwise(a) {
+    // checks for valid arguments passed to _distancePairwise(Array)
+    if (a[0].length === 2 && _isNumber(a[0][0]) && _isNumber(a[0][1])) {
+      if (a.some(function (aI) {
+        return aI.length !== 2 || !_isNumber(aI[0]) || !_isNumber(aI[1]);
+      })) {
+        return false;
+      }
+    } else if (a[0].length === 3 && _isNumber(a[0][0]) && _isNumber(a[0][1]) && _isNumber(a[0][2])) {
+      if (a.some(function (aI) {
+        return aI.length !== 3 || !_isNumber(aI[0]) || !_isNumber(aI[1]) || !_isNumber(aI[2]);
+      })) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+
+    return true;
+  }
+
+  function _distancePointLine2D(x, y, a, b, c) {
+    var num = abs(addScalar(addScalar(multiplyScalar(a, x), multiplyScalar(b, y)), c));
+    var den = sqrt(addScalar(multiplyScalar(a, a), multiplyScalar(b, b)));
+    return divideScalar(num, den);
+  }
+
+  function _distancePointLine3D(x, y, z, x0, y0, z0, a, b, c) {
+    var num = [subtract(multiplyScalar(subtract(y0, y), c), multiplyScalar(subtract(z0, z), b)), subtract(multiplyScalar(subtract(z0, z), a), multiplyScalar(subtract(x0, x), c)), subtract(multiplyScalar(subtract(x0, x), b), multiplyScalar(subtract(y0, y), a))];
+    num = sqrt(addScalar(addScalar(multiplyScalar(num[0], num[0]), multiplyScalar(num[1], num[1])), multiplyScalar(num[2], num[2])));
+    var den = sqrt(addScalar(addScalar(multiplyScalar(a, a), multiplyScalar(b, b)), multiplyScalar(c, c)));
+    return divideScalar(num, den);
+  }
+
+  function _euclideanDistance(x, y) {
+    var vectorSize = x.length;
+    var result = 0;
+    var diff = 0;
+
+    for (var i = 0; i < vectorSize; i++) {
+      diff = subtract(x[i], y[i]);
+      result = addScalar(multiplyScalar(diff, diff), result);
+    }
+
+    return sqrt(result);
+  }
+
+  function _distancePairwise(a) {
+    var result = [];
+    var pointA = [];
+    var pointB = [];
+
+    for (var i = 0; i < a.length - 1; i++) {
+      for (var j = i + 1; j < a.length; j++) {
+        if (a[0].length === 2) {
+          pointA = [a[i][0], a[i][1]];
+          pointB = [a[j][0], a[j][1]];
+        } else if (a[0].length === 3) {
+          pointA = [a[i][0], a[i][1], a[i][2]];
+          pointB = [a[j][0], a[j][1], a[j][2]];
+        }
+
+        result.push(_euclideanDistance(pointA, pointB));
+      }
+    }
+
+    return result;
+  }
+});
+exports.createDistance = createDistance;

package/dist/node_modules/mathjs/lib/cjs/function/geometry/intersect.js

@@ -0,0 +1,242 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIntersect = void 0;
+
+var _factory = require("../../utils/factory.js");
+
+var name = 'intersect';
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten', 'isZero', 'isNumeric'];
+var createIntersect = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      config = _ref.config,
+      abs = _ref.abs,
+      add = _ref.add,
+      addScalar = _ref.addScalar,
+      matrix = _ref.matrix,
+      multiply = _ref.multiply,
+      multiplyScalar = _ref.multiplyScalar,
+      divideScalar = _ref.divideScalar,
+      subtract = _ref.subtract,
+      smaller = _ref.smaller,
+      equalScalar = _ref.equalScalar,
+      flatten = _ref.flatten,
+      isZero = _ref.isZero,
+      isNumeric = _ref.isNumeric;
+
+  /**
+   * Calculates the point of intersection of two lines in two or three dimensions
+   * and of a line and a plane in three dimensions. The inputs are in the form of
+   * arrays or 1 dimensional matrices. The line intersection functions return null
+   * if the lines do not meet.
+   *
+   * Note: Fill the plane coefficients as `x + y + z = c` and not as `x + y + z + c = 0`.
+   *
+   * Syntax:
+   *
+   *    math.intersect(endPoint1Line1, endPoint2Line1, endPoint1Line2, endPoint2Line2)
+   *    math.intersect(endPoint1, endPoint2, planeCoefficients)
+   *
+   * Examples:
+   *
+   *    math.intersect([0, 0], [10, 10], [10, 0], [0, 10])              // Returns [5, 5]
+   *    math.intersect([0, 0, 0], [10, 10, 0], [10, 0, 0], [0, 10, 0])  // Returns [5, 5, 0]
+   *    math.intersect([1, 0, 1],  [4, -2, 2], [1, 1, 1, 6])            // Returns [7, -4, 3]
+   *
+   * @param  {Array | Matrix} w   Co-ordinates of first end-point of first line
+   * @param  {Array | Matrix} x   Co-ordinates of second end-point of first line
+   * @param  {Array | Matrix} y   Co-ordinates of first end-point of second line
+   *                              OR Co-efficients of the plane's equation
+   * @param  {Array | Matrix} z   Co-ordinates of second end-point of second line
+   *                              OR undefined if the calculation is for line and plane
+   * @return {Array}              Returns the point of intersection of lines/lines-planes
+   */
+  return typed('intersect', {
+    'Array, Array, Array': _AAA,
+    'Array, Array, Array, Array': _AAAA,
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
+      var arr = _AAA(x.valueOf(), y.valueOf(), plane.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    },
+    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
+      // TODO: output matrix type should match input matrix type
+      var arr = _AAAA(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    }
+  });
+
+  function _AAA(x, y, plane) {
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    plane = _coerceArr(plane);
+
+    if (!_3d(x)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
+    }
+
+    if (!_3d(y)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
+    }
+
+    if (!_4d(plane)) {
+      throw new TypeError('Array with 4 numbers expected as third argument');
+    }
+
+    return _intersectLinePlane(x[0], x[1], x[2], y[0], y[1], y[2], plane[0], plane[1], plane[2], plane[3]);
+  }
+
+  function _AAAA(w, x, y, z) {
+    w = _coerceArr(w);
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    z = _coerceArr(z);
+
+    if (w.length === 2) {
+      if (!_2d(w)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
+      }
+
+      if (!_2d(x)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
+      }
+
+      if (!_2d(y)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
+      }
+
+      if (!_2d(z)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for fourth argument');
+      }
+
+      return _intersect2d(w, x, y, z);
+    } else if (w.length === 3) {
+      if (!_3d(w)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
+      }
+
+      if (!_3d(x)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
+      }
+
+      if (!_3d(y)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for third argument');
+      }
+
+      if (!_3d(z)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for fourth argument');
+      }
+
+      return _intersect3d(w[0], w[1], w[2], x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
+    } else {
+      throw new TypeError('Arrays with two or thee dimensional points expected');
+    }
+  }
+  /** Coerce row and column 2-dim arrays to 1-dim array */
+
+
+  function _coerceArr(arr) {
+    // row matrix
+    if (arr.length === 1) return arr[0]; // column matrix
+
+    if (arr.length > 1 && Array.isArray(arr[0])) {
+      if (arr.every(function (el) {
+        return Array.isArray(el) && el.length === 1;
+      })) return flatten(arr);
+    }
+
+    return arr;
+  }
+
+  function _2d(x) {
+    return x.length === 2 && isNumeric(x[0]) && isNumeric(x[1]);
+  }
+
+  function _3d(x) {
+    return x.length === 3 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]);
+  }
+
+  function _4d(x) {
+    return x.length === 4 && isNumeric(x[0]) && isNumeric(x[1]) && isNumeric(x[2]) && isNumeric(x[3]);
+  }
+
+  function _intersect2d(p1a, p1b, p2a, p2b) {
+    var o1 = p1a;
+    var o2 = p2a;
+    var d1 = subtract(o1, p1b);
+    var d2 = subtract(o2, p2b);
+    var det = subtract(multiplyScalar(d1[0], d2[1]), multiplyScalar(d2[0], d1[1]));
+    if (isZero(det)) return null;
+
+    if (smaller(abs(det), config.epsilon)) {
+      return null;
+    }
+
+    var d20o11 = multiplyScalar(d2[0], o1[1]);
+    var d21o10 = multiplyScalar(d2[1], o1[0]);
+    var d20o21 = multiplyScalar(d2[0], o2[1]);
+    var d21o20 = multiplyScalar(d2[1], o2[0]);
+    var t = divideScalar(addScalar(subtract(subtract(d20o11, d21o10), d20o21), d21o20), det);
+    return add(multiply(d1, t), o1);
+  }
+
+  function _intersect3dHelper(a, b, c, d, e, f, g, h, i, j, k, l) {
+    // (a - b)*(c - d) + (e - f)*(g - h) + (i - j)*(k - l)
+    var add1 = multiplyScalar(subtract(a, b), subtract(c, d));
+    var add2 = multiplyScalar(subtract(e, f), subtract(g, h));
+    var add3 = multiplyScalar(subtract(i, j), subtract(k, l));
+    return addScalar(addScalar(add1, add2), add3);
+  }
+
+  function _intersect3d(x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4) {
+    var d1343 = _intersect3dHelper(x1, x3, x4, x3, y1, y3, y4, y3, z1, z3, z4, z3);
+
+    var d4321 = _intersect3dHelper(x4, x3, x2, x1, y4, y3, y2, y1, z4, z3, z2, z1);
+
+    var d1321 = _intersect3dHelper(x1, x3, x2, x1, y1, y3, y2, y1, z1, z3, z2, z1);
+
+    var d4343 = _intersect3dHelper(x4, x3, x4, x3, y4, y3, y4, y3, z4, z3, z4, z3);
+
+    var d2121 = _intersect3dHelper(x2, x1, x2, x1, y2, y1, y2, y1, z2, z1, z2, z1);
+
+    var numerator = subtract(multiplyScalar(d1343, d4321), multiplyScalar(d1321, d4343));
+    var denominator = subtract(multiplyScalar(d2121, d4343), multiplyScalar(d4321, d4321));
+    if (isZero(denominator)) return null;
+    var ta = divideScalar(numerator, denominator);
+    var tb = divideScalar(addScalar(d1343, multiplyScalar(ta, d4321)), d4343);
+    var pax = addScalar(x1, multiplyScalar(ta, subtract(x2, x1)));
+    var pay = addScalar(y1, multiplyScalar(ta, subtract(y2, y1)));
+    var paz = addScalar(z1, multiplyScalar(ta, subtract(z2, z1)));
+    var pbx = addScalar(x3, multiplyScalar(tb, subtract(x4, x3)));
+    var pby = addScalar(y3, multiplyScalar(tb, subtract(y4, y3)));
+    var pbz = addScalar(z3, multiplyScalar(tb, subtract(z4, z3)));
+
+    if (equalScalar(pax, pbx) && equalScalar(pay, pby) && equalScalar(paz, pbz)) {
+      return [pax, pay, paz];
+    } else {
+      return null;
+    }
+  }
+
+  function _intersectLinePlane(x1, y1, z1, x2, y2, z2, x, y, z, c) {
+    var x1x = multiplyScalar(x1, x);
+    var x2x = multiplyScalar(x2, x);
+    var y1y = multiplyScalar(y1, y);
+    var y2y = multiplyScalar(y2, y);
+    var z1z = multiplyScalar(z1, z);
+    var z2z = multiplyScalar(z2, z);
+    var numerator = subtract(subtract(subtract(c, x1x), y1y), z1z);
+    var denominator = subtract(subtract(subtract(addScalar(addScalar(x2x, y2y), z2z), x1x), y1y), z1z);
+    var t = divideScalar(numerator, denominator);
+    var px = addScalar(x1, multiplyScalar(t, subtract(x2, x1)));
+    var py = addScalar(y1, multiplyScalar(t, subtract(y2, y1)));
+    var pz = addScalar(z1, multiplyScalar(t, subtract(z2, z1)));
+    return [px, py, pz]; // TODO: Add cases when line is parallel to the plane:
+    //       (a) no intersection,
+    //       (b) line contained in plane
+  }
+});
+exports.createIntersect = createIntersect;