@khanacademy/kmath 0.4.7 → 2.0.0

package/dist/es/index.js

@@ -4,14 +4,18 @@ import { approximateEqual, approximateDeepEqual } from '@khanacademy/perseus-cor
 import $ from 'jquery';
 
 // This file is processed by a Rollup plugin (replace) to inject the production
+// version number during the release build.
+// In dev, you'll never see the version number.
+
 const libName = "@khanacademy/kmath";
-const libVersion = "0.4.7";
+const libVersion = "2.0.0";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
 /**
  * Number Utils
  * A number is a js-number, e.g. 5.12
  */
+
 const DEFAULT_TOLERANCE = 1e-9;
 
 // TODO: Should this just be Number.Epsilon
@@ -101,14 +105,14 @@ var number = /*#__PURE__*/Object.freeze({
     __proto__: null,
     DEFAULT_TOLERANCE: DEFAULT_TOLERANCE,
     EPSILON: EPSILON,
-    is: is$2,
+    ceilTo: ceilTo$2,
     equal: equal$4,
-    sign: sign$1,
+    floorTo: floorTo$2,
+    is: is$2,
     isInteger: isInteger,
     round: round$2,
     roundTo: roundTo$2,
-    floorTo: floorTo$2,
-    ceilTo: ceilTo$2,
+    sign: sign$1,
     toFraction: toFraction
 });
 
@@ -116,6 +120,7 @@ var number = /*#__PURE__*/Object.freeze({
  * Vector Utils
  * A vector is an array of numbers e.g. [0, 3, 4].
  */
+
 function arraySum(array) {
   return array.reduce((memo, arg) => memo + arg, 0);
 }
@@ -301,32 +306,32 @@ function ceilTo$1(vec, increment) {
 
 var vector$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    zip: zip,
-    map: map,
-    is: is$1,
-    normalize: normalize,
-    length: length,
-    dot: dot,
     add: add$1,
-    subtract: subtract,
-    negate: negate,
-    scale: scale,
-    equal: equal$3,
+    angleDeg: angleDeg,
+    angleRad: angleRad,
+    cartFromPolarDeg: cartFromPolarDeg$1,
+    cartFromPolarRad: cartFromPolarRad$1,
+    ceilTo: ceilTo$1,
     codirectional: codirectional,
     collinear: collinear$1,
-    polarRadFromCart: polarRadFromCart$1,
+    dot: dot,
+    equal: equal$3,
+    floorTo: floorTo$1,
+    is: is$1,
+    length: length,
+    map: map,
+    negate: negate,
+    normalize: normalize,
     polarDegFromCart: polarDegFromCart$1,
-    cartFromPolarRad: cartFromPolarRad$1,
-    cartFromPolarDeg: cartFromPolarDeg$1,
-    rotateRad: rotateRad$1,
-    rotateDeg: rotateDeg$1,
-    angleRad: angleRad,
-    angleDeg: angleDeg,
+    polarRadFromCart: polarRadFromCart$1,
     projection: projection,
+    rotateDeg: rotateDeg$1,
+    rotateRad: rotateRad$1,
     round: round$1,
     roundTo: roundTo$1,
-    floorTo: floorTo$1,
-    ceilTo: ceilTo$1
+    scale: scale,
+    subtract: subtract,
+    zip: zip
 });
 
 /**
@@ -334,6 +339,7 @@ var vector$1 = /*#__PURE__*/Object.freeze({
  * A point is an array of two numbers e.g. [0, 0].
  */
 
+
 // A point, in 2D, 3D, or nD space.
 
 // Rotate point (around origin unless a center is specified)
@@ -419,31 +425,32 @@ const ceilTo = ceilTo$1;
 
 var point = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    rotateRad: rotateRad,
-    rotateDeg: rotateDeg,
-    distanceToPoint: distanceToPoint$1,
-    distanceToLine: distanceToLine,
-    reflectOverLine: reflectOverLine,
-    compare: compare,
-    is: is,
     addVector: addVector,
     addVectors: addVectors,
-    subtractVector: subtractVector,
+    cartFromPolarDeg: cartFromPolarDeg,
+    cartFromPolarRad: cartFromPolarRad,
+    ceilTo: ceilTo,
+    compare: compare,
+    distanceToLine: distanceToLine,
+    distanceToPoint: distanceToPoint$1,
     equal: equal$2,
-    polarRadFromCart: polarRadFromCart,
+    floorTo: floorTo,
+    is: is,
     polarDegFromCart: polarDegFromCart,
-    cartFromPolarRad: cartFromPolarRad,
-    cartFromPolarDeg: cartFromPolarDeg,
+    polarRadFromCart: polarRadFromCart,
+    reflectOverLine: reflectOverLine,
+    rotateDeg: rotateDeg,
+    rotateRad: rotateRad,
     round: round,
     roundTo: roundTo,
-    floorTo: floorTo,
-    ceilTo: ceilTo
+    subtractVector: subtractVector
 });
 
 /**
  * Line Utils
  * A line is an array of two points e.g. [[-5, 0], [5, 0]].
  */
+
 function distanceToPoint(line, point$1) {
   return distanceToLine(point$1, line);
 }
@@ -475,9 +482,9 @@ function equal$1(line1, line2, tolerance) {
 var line = /*#__PURE__*/Object.freeze({
     __proto__: null,
     distanceToPoint: distanceToPoint,
-    reflectPoint: reflectPoint,
+    equal: equal$1,
     midpoint: midpoint,
-    equal: equal$1
+    reflectPoint: reflectPoint
 });
 
 /**
@@ -486,6 +493,7 @@ var line = /*#__PURE__*/Object.freeze({
  * For example, [[0, 0], [1, 0]] is the ray starting at the origin and
  * traveling along the positive x-axis.
  */
+
 function equal(ray1, ray2, tolerance) {
   // Compare the directions of the rays
   const v1 = subtract(ray1[1], ray1[0]);
@@ -532,6 +540,8 @@ const KhanMath = {
     let mod;
     a = Math.abs(a);
     b = Math.abs(b);
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     while (b) {
       mod = a % b;
       a = b;
@@ -555,6 +565,7 @@ const KhanMath = {
       return false;
     }
     if (n < 101) {
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
       return !!$.grep(KhanMath.primes, function (p, i) {
         return Math.abs(p - n) <= 0.5;
       }).length;
@@ -718,7 +729,9 @@ const KhanMath = {
       if (format === "mixed") {
         const modulus = numerator % denominator;
         const integer = (numerator - modulus) / denominator;
-        return sign + (integer ? integer + " " : "") + modulus + "/" + denominator;
+        return sign + (
+        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+        integer ? integer + " " : "") + modulus + "/" + denominator;
       } // otherwise proper, improper, or fraction
       return sign + numerator + "/" + denominator;
     }
@@ -738,6 +751,7 @@ function add(a, b) {
  * A collection of geomtry-related utility functions
  */
 
+
 // This should really be a readonly tuple of [number, number]
 
 // Given a number, return whether it is positive (1), negative (-1), or zero (0)
@@ -992,26 +1006,27 @@ function getLineIntersectionString(firstPoints, secondPoints) {
 
 var geometry = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    sign: sign,
+    angleMeasures: angleMeasures,
+    canonicalSineCoefficients: canonicalSineCoefficients,
     ccw: ccw,
+    clockwise: clockwise,
     collinear: collinear,
+    getLineEquation: getLineEquation,
+    getLineIntersection: getLineIntersection,
+    getLineIntersectionString: getLineIntersectionString,
     intersects: intersects,
+    lawOfCosines: lawOfCosines,
+    magnitude: magnitude,
     polygonSidesIntersect: polygonSidesIntersect,
-    vector: vector,
     reverseVector: reverseVector,
-    clockwise: clockwise,
-    magnitude: magnitude,
-    angleMeasures: angleMeasures,
-    similar: similar,
-    lawOfCosines: lawOfCosines,
-    canonicalSineCoefficients: canonicalSineCoefficients,
     rotate: rotate,
-    getLineEquation: getLineEquation,
-    getLineIntersection: getLineIntersection,
-    getLineIntersectionString: getLineIntersectionString
+    sign: sign,
+    similar: similar,
+    vector: vector
 });
 
 // This file contains helper functions for working with angles.
+
 function convertDegreesToRadians(degrees) {
   return degrees / 180 * Math.PI;
 }
@@ -1041,6 +1056,7 @@ function polar(r, th) {
 const getAngleFromVertex = (point, vertex) => {
   const x = point[0] - vertex[0];
   const y = point[1] - vertex[1];
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
   if (!x && !y) {
     return 0;
   }
@@ -1072,12 +1088,12 @@ const getClockwiseAngle = (coords, allowReflexAngles = false) => {
 
 var angles = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    calculateAngleInDegrees: calculateAngleInDegrees,
     convertDegreesToRadians: convertDegreesToRadians,
     convertRadiansToDegrees: convertRadiansToDegrees,
-    calculateAngleInDegrees: calculateAngleInDegrees,
-    polar: polar,
     getAngleFromVertex: getAngleFromVertex,
-    getClockwiseAngle: getClockwiseAngle
+    getClockwiseAngle: getClockwiseAngle,
+    polar: polar
 });
 
 // TODO: there's another, very similar getSinusoidCoefficients function
@@ -1114,8 +1130,8 @@ function getQuadraticCoefficients(coords) {
 
 var coefficients = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    getSinusoidCoefficients: getSinusoidCoefficients,
-    getQuadraticCoefficients: getQuadraticCoefficients
+    getQuadraticCoefficients: getQuadraticCoefficients,
+    getSinusoidCoefficients: getSinusoidCoefficients
 });
 
 export { KhanMath, angles, coefficients, geometry, libVersion, line, number, point, ray, sum, vector$1 as vector };