Docs

8 files changed, 3314 insertions, 0 deletions

diff --git a/node_modules/fraction.js/LICENSE b/node_modules/fraction.js/LICENSE
new file mode 100644
index 0000000..6dd5328
--- /dev/null
+++ b/node_modules/fraction.js/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Robert Eisele
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/node_modules/fraction.js/README.md b/node_modules/fraction.js/README.md
new file mode 100644
index 0000000..7d3f31a
--- /dev/null
+++ b/node_modules/fraction.js/README.md
@@ -0,0 +1,466 @@
+# Fraction.js - ℚ in JavaScript
+
+[![NPM Package](https://img.shields.io/npm/v/fraction.js.svg?style=flat)](https://npmjs.org/package/fraction.js "View this project on npm")
+[![MIT license](http://img.shields.io/badge/license-MIT-brightgreen.svg)](http://opensource.org/licenses/MIT)
+
+
+Tired of inprecise numbers represented by doubles, which have to store rational and irrational numbers like PI or sqrt(2) the same way? Obviously the following problem is preventable:
+
+```javascript
+1 / 98 * 98 // = 0.9999999999999999
+```
+
+If you need more precision or just want a fraction as a result, just include *Fraction.js*:
+
+```javascript
+var Fraction = require('fraction.js');
+// or
+import Fraction from 'fraction.js';
+```
+
+and give it a trial:
+
+```javascript
+Fraction(1).div(98).mul(98) // = 1
+```
+
+Internally, numbers are represented as *numerator / denominator*, which adds just a little overhead. However, the library is written with performance and accuracy in mind, which makes it the perfect basis for [Polynomial.js](https://github.com/infusion/Polynomial.js) and [Math.js](https://github.com/josdejong/mathjs).
+
+Convert decimal to fraction
+===
+The simplest job for fraction.js is to get a fraction out of a decimal:
+```javascript
+var x = new Fraction(1.88);
+var res = x.toFraction(true); // String "1 22/25"
+```
+
+Examples / Motivation
+===
+A simple example might be
+
+```javascript
+var f = new Fraction("9.4'31'"); // 9.4313131313131...
+f.mul([-4, 3]).mod("4.'8'"); // 4.88888888888888...
+```
+The result is
+
+```javascript
+console.log(f.toFraction()); // -4154 / 1485
+```
+You could of course also access the sign (s), numerator (n) and denominator (d) on your own:
+```javascript
+f.s * f.n / f.d = -1 * 4154 / 1485 = -2.797306...
+```
+
+If you would try to calculate it yourself, you would come up with something like:
+
+```javascript
+(9.4313131 * (-4 / 3)) % 4.888888 = -2.797308133...
+```
+
+Quite okay, but yea - not as accurate as it could be.
+
+
+Laplace Probability
+===
+Simple example. What's the probability of throwing a 3, and 1 or 4, and 2 or 4 or 6 with a fair dice?
+
+P({3}):
+```javascript
+var p = new Fraction([3].length, 6).toString(); // 0.1(6)
+```
+
+P({1, 4}):
+```javascript
+var p = new Fraction([1, 4].length, 6).toString(); // 0.(3)
+```
+
+P({2, 4, 6}):
+```javascript
+var p = new Fraction([2, 4, 6].length, 6).toString(); // 0.5
+```
+
+Convert degrees/minutes/seconds to precise rational representation:
+===
+
+57+45/60+17/3600
+```javascript
+var deg = 57; // 57°
+var min = 45; // 45 Minutes
+var sec = 17; // 17 Seconds
+
+new Fraction(deg).add(min, 60).add(sec, 3600).toString() // -> 57.7547(2)
+```
+
+
+Rational approximation of irrational numbers
+===
+
+Now it's getting messy ;d To approximate a number like *sqrt(5) - 2* with a numerator and denominator, you can reformat the equation as follows: *pow(n / d + 2, 2) = 5*.
+
+Then the following algorithm will generate the rational number besides the binary representation.
+
+```javascript
+var x = "/", s = "";
+
+var a = new Fraction(0),
+    b = new Fraction(1);
+for (var n = 0; n <= 10; n++) {
+
+  var c = a.add(b).div(2);
+
+  console.log(n + "\t" + a + "\t" + b + "\t" + c + "\t" + x);
+
+  if (c.add(2).pow(2) < 5) {
+    a = c;
+    x = "1";
+  } else {
+    b = c;
+    x = "0";
+  }
+  s+= x;
+}
+console.log(s)
+```
+
+The result is
+
+```
+n   a[n]        b[n]        c[n]            x[n]
+0   0/1         1/1         1/2             /
+1   0/1         1/2         1/4             0
+2   0/1         1/4         1/8             0
+3   1/8         1/4         3/16            1
+4   3/16        1/4         7/32            1
+5   7/32        1/4         15/64           1
+6   15/64       1/4         31/128          1
+7   15/64       31/128      61/256          0
+8   15/64       61/256      121/512         0
+9   15/64       121/512     241/1024        0
+10  241/1024    121/512     483/2048        1
+```
+Thus the approximation after 11 iterations of the bisection method is *483 / 2048* and the binary representation is 0.00111100011 (see [WolframAlpha](http://www.wolframalpha.com/input/?i=sqrt%285%29-2+binary))
+
+
+I published another example on how to approximate PI with fraction.js on my [blog](http://www.xarg.org/2014/03/precise-calculations-in-javascript/) (Still not the best idea to approximate irrational numbers, but it illustrates the capabilities of Fraction.js perfectly).
+
+
+Get the exact fractional part of a number
+---
+```javascript
+var f = new Fraction("-6.(3416)");
+console.log("" + f.mod(1).abs()); // 0.(3416)
+```
+
+Mathematical correct modulo
+---
+The behaviour on negative congruences is different to most modulo implementations in computer science. Even the *mod()* function of Fraction.js behaves in the typical way. To solve the problem of having the mathematical correct modulo with Fraction.js you could come up with this:
+
+```javascript
+var a = -1;
+var b = 10.99;
+
+console.log(new Fraction(a)
+  .mod(b)); // Not correct, usual Modulo
+
+console.log(new Fraction(a)
+  .mod(b).add(b).mod(b)); // Correct! Mathematical Modulo
+```
+
+fmod() impreciseness circumvented
+---
+It turns out that Fraction.js outperforms almost any fmod() implementation, including JavaScript itself, [php.js](http://phpjs.org/functions/fmod/), C++, Python, Java and even Wolframalpha due to the fact that numbers like 0.05, 0.1, ... are infinite decimal in base 2.
+
+The equation *fmod(4.55, 0.05)* gives *0.04999999999999957*, wolframalpha says *1/20*. The correct answer should be **zero**, as 0.05 divides 4.55 without any remainder.
+
+
+Parser
+===
+
+Any function (see below) as well as the constructor of the *Fraction* class parses its input and reduce it to the smallest term.
+
+You can pass either Arrays, Objects, Integers, Doubles or Strings.
+
+Arrays / Objects
+---
+```javascript
+new Fraction(numerator, denominator);
+new Fraction([numerator, denominator]);
+new Fraction({n: numerator, d: denominator});
+```
+
+Integers
+---
+```javascript
+new Fraction(123);
+```
+
+Doubles
+---
+```javascript
+new Fraction(55.4);
+```
+
+**Note:** If you pass a double as it is, Fraction.js will perform a number analysis based on Farey Sequences. If you concern performance, cache Fraction.js objects and pass arrays/objects.
+
+The method is really precise, but too large exact numbers, like 1234567.9991829 will result in a wrong approximation. If you want to keep the number as it is, convert it to a string, as the string parser will not perform any further observations. If you have problems with the approximation, in the file `examples/approx.js` is a different approximation algorithm, which might work better in some more specific use-cases.
+
+
+Strings
+---
+```javascript
+new Fraction("123.45");
+new Fraction("123/45"); // A rational number represented as two decimals, separated by a slash
+new Fraction("123:45"); // A rational number represented as two decimals, separated by a colon
+new Fraction("4 123/45"); // A rational number represented as a whole number and a fraction
+new Fraction("123.'456'"); // Note the quotes, see below!
+new Fraction("123.(456)"); // Note the brackets, see below!
+new Fraction("123.45'6'"); // Note the quotes, see below!
+new Fraction("123.45(6)"); // Note the brackets, see below!
+```
+
+Two arguments
+---
+```javascript
+new Fraction(3, 2); // 3/2 = 1.5
+```
+
+Repeating decimal places
+---
+*Fraction.js* can easily handle repeating decimal places. For example *1/3* is *0.3333...*. There is only one repeating digit. As you can see in the examples above, you can pass a number like *1/3* as "0.'3'" or "0.(3)", which are synonym. There are no tests to parse something like 0.166666666 to 1/6! If you really want to handle this number, wrap around brackets on your own with the function below for example: 0.1(66666666)
+
+Assume you want to divide 123.32 / 33.6(567). [WolframAlpha](http://www.wolframalpha.com/input/?i=123.32+%2F+%2812453%2F370%29) states that you'll get a period of 1776 digits. *Fraction.js* comes to the same result. Give it a try:
+
+```javascript
+var f = new Fraction("123.32");
+console.log("Bam: " + f.div("33.6(567)"));
+```
+
+To automatically make a number like "0.123123123" to something more Fraction.js friendly like "0.(123)", I hacked this little brute force algorithm in a 10 minutes. Improvements are welcome...
+
+```javascript
+function formatDecimal(str) {
+
+  var comma, pre, offset, pad, times, repeat;
+
+  if (-1 === (comma = str.indexOf(".")))
+    return str;
+
+  pre = str.substr(0, comma + 1);
+  str = str.substr(comma + 1);
+
+  for (var i = 0; i < str.length; i++) {
+
+    offset = str.substr(0, i);
+
+    for (var j = 0; j < 5; j++) {
+
+      pad = str.substr(i, j + 1);
+
+      times = Math.ceil((str.length - offset.length) / pad.length);
+
+      repeat = new Array(times + 1).join(pad); // Silly String.repeat hack
+
+      if (0 === (offset + repeat).indexOf(str)) {
+        return pre + offset + "(" + pad + ")";
+      }
+    }
+  }
+  return null;
+}
+
+var f, x = formatDecimal("13.0123123123"); // = 13.0(123)
+if (x !== null) {
+  f = new Fraction(x);
+}
+```
+
+Attributes
+===
+
+The Fraction object allows direct access to the numerator, denominator and sign attributes. It is ensured that only the sign-attribute holds sign information so that a sign comparison is only necessary against this attribute.
+
+```javascript
+var f = new Fraction('-1/2');
+console.log(f.n); // Numerator: 1
+console.log(f.d); // Denominator: 2
+console.log(f.s); // Sign: -1
+```
+
+
+Functions
+===
+
+Fraction abs()
+---
+Returns the actual number without any sign information
+
+Fraction neg()
+---
+Returns the actual number with flipped sign in order to get the additive inverse
+
+Fraction add(n)
+---
+Returns the sum of the actual number and the parameter n
+
+Fraction sub(n)
+---
+Returns the difference of the actual number and the parameter n
+
+Fraction mul(n)
+---
+Returns the product of the actual number and the parameter n
+
+Fraction div(n)
+---
+Returns the quotient of the actual number and the parameter n
+
+Fraction pow(exp)
+---
+Returns the power of the actual number, raised to an possible rational exponent. If the result becomes non-rational the function returns `null`.
+
+Fraction mod(n)
+---
+Returns the modulus (rest of the division) of the actual object and n (this % n). It's a much more precise [fmod()](#fmod-impreciseness-circumvented) if you like. Please note that *mod()* is just like the modulo operator of most programming languages. If you want a mathematical correct modulo, see [here](#mathematical-correct-modulo).
+
+Fraction mod()
+---
+Returns the modulus (rest of the division) of the actual object (numerator mod denominator)
+
+Fraction gcd(n)
+---
+Returns the fractional greatest common divisor
+
+Fraction lcm(n)
+---
+Returns the fractional least common multiple
+
+Fraction ceil([places=0-16])
+---
+Returns the ceiling of a rational number with Math.ceil
+
+Fraction floor([places=0-16])
+---
+Returns the floor of a rational number with Math.floor
+
+Fraction round([places=0-16])
+---
+Returns the rational number rounded with Math.round
+
+Fraction roundTo(multiple)
+---
+Rounds a fraction to the closest multiple of another fraction. 
+
+Fraction inverse()
+---
+Returns the multiplicative inverse of the actual number (n / d becomes d / n) in order to get the reciprocal
+
+Fraction simplify([eps=0.001])
+---
+Simplifies the rational number under a certain error threshold. Ex. `0.333` will be `1/3` with `eps=0.001`
+
+boolean equals(n)
+---
+Check if two numbers are equal
+
+int compare(n)
+---
+Compare two numbers.
+```
+result < 0: n is greater than actual number
+result > 0: n is smaller than actual number
+result = 0: n is equal to the actual number
+```
+
+boolean divisible(n)
+---
+Check if two numbers are divisible (n divides this)
+
+double valueOf()
+---
+Returns a decimal representation of the fraction
+
+String toString([decimalPlaces=15])
+---
+Generates an exact string representation of the actual object. For repeated decimal places all digits are collected within brackets, like `1/3 = "0.(3)"`. For all other numbers, up to `decimalPlaces` significant digits are collected - which includes trailing zeros if the number is getting truncated. However, `1/2 = "0.5"` without trailing zeros of course.
+
+**Note:** As `valueOf()` and `toString()` are provided, `toString()` is only called implicitly in a real string context. Using the plus-operator like `"123" + new Fraction` will call valueOf(), because JavaScript tries to combine two primitives first and concatenates them later, as string will be the more dominant type. `alert(new Fraction)` or `String(new Fraction)` on the other hand will do what you expect. If you really want to have control, you should call `toString()` or `valueOf()` explicitly!
+
+String toLatex(excludeWhole=false)
+---
+Generates an exact LaTeX representation of the actual object. You can see a [live demo](http://www.xarg.org/2014/03/precise-calculations-in-javascript/) on my blog.
+
+The optional boolean parameter indicates if you want to exclude the whole part. "1 1/3" instead of "4/3"
+
+String toFraction(excludeWhole=false)
+---
+Gets a string representation of the fraction
+
+The optional boolean parameter indicates if you want to exclude the whole part. "1 1/3" instead of "4/3"
+
+Array toContinued()
+---
+Gets an array of the fraction represented as a continued fraction. The first element always contains the whole part.
+
+```javascript
+var f = new Fraction('88/33');
+var c = f.toContinued(); // [2, 1, 2]
+```
+
+Fraction clone()
+---
+Creates a copy of the actual Fraction object
+
+
+Exceptions
+===
+If a really hard error occurs (parsing error, division by zero), *fraction.js* throws exceptions! Please make sure you handle them correctly.
+
+
+
+Installation
+===
+Installing fraction.js is as easy as cloning this repo or use the following command:
+
+```
+npm install fraction.js
+```
+
+Using Fraction.js with the browser
+===
+```html
+<script src="fraction.js"></script>
+<script>
+    console.log(Fraction("123/456"));
+</script>
+```
+
+Using Fraction.js with TypeScript
+===
+```js
+import Fraction from "fraction.js";
+console.log(Fraction("123/456"));
+```
+
+Coding Style
+===
+As every library I publish, fraction.js is also built to be as small as possible after compressing it with Google Closure Compiler in advanced mode. Thus the coding style orientates a little on maxing-out the compression rate. Please make sure you keep this style if you plan to extend the library.
+
+
+Precision
+===
+Fraction.js tries to circumvent floating point errors, by having an internal representation of numerator and denominator. As it relies on JavaScript, there is also a limit. The biggest number representable is `Number.MAX_SAFE_INTEGER / 1` and the smallest is `-1 / Number.MAX_SAFE_INTEGER`, with `Number.MAX_SAFE_INTEGER=9007199254740991`. If this is not enough, there is `bigfraction.js` shipped experimentally, which relies on `BigInt` and should become the new Fraction.js eventually. 
+
+Testing
+===
+If you plan to enhance the library, make sure you add test cases and all the previous tests are passing. You can test the library with
+
+```
+npm test
+```
+
+
+Copyright and licensing
+===
+Copyright (c) 2023, [Robert Eisele](https://raw.org/)
+Licensed under the MIT license.
diff --git a/node_modules/fraction.js/bigfraction.js b/node_modules/fraction.js/bigfraction.js
new file mode 100644
index 0000000..038ca05
--- /dev/null
+++ b/node_modules/fraction.js/bigfraction.js
@@ -0,0 +1,899 @@
+/**
+ * @license Fraction.js v4.2.1 20/08/2023
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2023, Robert Eisele (robert@raw.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+
+/**
+ *
+ * This class offers the possibility to calculate fractions.
+ * You can pass a fraction in different formats. Either as array, as double, as string or as an integer.
+ *
+ * Array/Object form
+ * [ 0 => <numerator>, 1 => <denominator> ]
+ * [ n => <numerator>, d => <denominator> ]
+ *
+ * Integer form
+ * - Single integer value
+ *
+ * Double form
+ * - Single double value
+ *
+ * String form
+ * 123.456 - a simple double
+ * 123/456 - a string fraction
+ * 123.'456' - a double with repeating decimal places
+ * 123.(456) - synonym
+ * 123.45'6' - a double with repeating last place
+ * 123.45(6) - synonym
+ *
+ * Example:
+ *
+ * let f = new Fraction("9.4'31'");
+ * f.mul([-4, 3]).div(4.9);
+ *
+ */
+
+(function(root) {
+
+  "use strict";
+
+  // Set Identity function to downgrade BigInt to Number if needed
+  if (typeof BigInt === 'undefined') BigInt = function(n) { if (isNaN(n)) throw new Error(""); return n; };
+
+  const C_ONE = BigInt(1);
+  const C_ZERO = BigInt(0);
+  const C_TEN = BigInt(10);
+  const C_TWO = BigInt(2);
+  const C_FIVE = BigInt(5);
+
+  // Maximum search depth for cyclic rational numbers. 2000 should be more than enough.
+  // Example: 1/7 = 0.(142857) has 6 repeating decimal places.
+  // If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits
+  const MAX_CYCLE_LEN = 2000;
+
+  // Parsed data to avoid calling "new" all the time
+  const P = {
+    "s": C_ONE,
+    "n": C_ZERO,
+    "d": C_ONE
+  };
+
+  function assign(n, s) {
+
+    try {
+      n = BigInt(n);
+    } catch (e) {
+      throw InvalidParameter();
+    }
+    return n * s;
+  }
+
+  // Creates a new Fraction internally without the need of the bulky constructor
+  function newFraction(n, d) {
+
+    if (d === C_ZERO) {
+      throw DivisionByZero();
+    }
+
+    const f = Object.create(Fraction.prototype);
+    f["s"] = n < C_ZERO ? -C_ONE : C_ONE;
+
+    n = n < C_ZERO ? -n : n;
+
+    const a = gcd(n, d);
+
+    f["n"] = n / a;
+    f["d"] = d / a;
+    return f;
+  }
+
+  function factorize(num) {
+
+    const factors = {};
+
+    let n = num;
+    let i = C_TWO;
+    let s = C_FIVE - C_ONE;
+
+    while (s <= n) {
+
+      while (n % i === C_ZERO) {
+        n/= i;
+        factors[i] = (factors[i] || C_ZERO) + C_ONE;
+      }
+      s+= C_ONE + C_TWO * i++;
+    }
+
+    if (n !== num) {
+      if (n > 1)
+        factors[n] = (factors[n] || C_ZERO) + C_ONE;
+    } else {
+      factors[num] = (factors[num] || C_ZERO) + C_ONE;
+    }
+    return factors;
+  }
+
+  const parse = function(p1, p2) {
+
+    let n = C_ZERO, d = C_ONE, s = C_ONE;
+
+    if (p1 === undefined || p1 === null) {
+      /* void */
+    } else if (p2 !== undefined) {
+      n = BigInt(p1);
+      d = BigInt(p2);
+      s = n * d;
+
+      if (n % C_ONE !== C_ZERO || d % C_ONE !== C_ZERO) {
+        throw NonIntegerParameter();
+      }
+
+    } else if (typeof p1 === "object") {
+      if ("d" in p1 && "n" in p1) {
+        n = BigInt(p1["n"]);
+        d = BigInt(p1["d"]);
+        if ("s" in p1)
+          n*= BigInt(p1["s"]);
+      } else if (0 in p1) {
+        n = BigInt(p1[0]);
+        if (1 in p1)
+          d = BigInt(p1[1]);
+      } else if (p1 instanceof BigInt) {
+        n = BigInt(p1);
+      } else {
+        throw InvalidParameter();
+      }
+      s = n * d;
+    } else if (typeof p1 === "bigint") {
+      n = p1;
+      s = p1;
+      d = C_ONE;
+    } else if (typeof p1 === "number") {
+
+      if (isNaN(p1)) {
+        throw InvalidParameter();
+      }
+
+      if (p1 < 0) {
+        s = -C_ONE;
+        p1 = -p1;
+      }
+
+      if (p1 % 1 === 0) {
+        n = BigInt(p1);
+      } else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow
+
+        let z = 1;
+
+        let A = 0, B = 1;
+        let C = 1, D = 1;
+
+        let N = 10000000;
+
+        if (p1 >= 1) {
+          z = 10 ** Math.floor(1 + Math.log10(p1));
+          p1/= z;
+        }
+
+        // Using Farey Sequences
+
+        while (B <= N && D <= N) {
+          let M = (A + C) / (B + D);
+
+          if (p1 === M) {
+            if (B + D <= N) {
+              n = A + C;
+              d = B + D;
+            } else if (D > B) {
+              n = C;
+              d = D;
+            } else {
+              n = A;
+              d = B;
+            }
+            break;
+
+          } else {
+
+            if (p1 > M) {
+              A+= C;
+              B+= D;
+            } else {
+              C+= A;
+              D+= B;
+            }
+
+            if (B > N) {
+              n = C;
+              d = D;
+            } else {
+              n = A;
+              d = B;
+            }
+          }
+        }
+        n = BigInt(n) * BigInt(z);
+        d = BigInt(d);
+
+      }
+
+    } else if (typeof p1 === "string") {
+
+      let ndx = 0;
+
+      let v = C_ZERO, w = C_ZERO, x = C_ZERO, y = C_ONE, z = C_ONE;
+
+      let match = p1.match(/\d+|./g);
+
+      if (match === null)
+        throw InvalidParameter();
+
+      if (match[ndx] === '-') {// Check for minus sign at the beginning
+        s = -C_ONE;
+        ndx++;
+      } else if (match[ndx] === '+') {// Check for plus sign at the beginning
+        ndx++;
+      }
+
+      if (match.length === ndx + 1) { // Check if it's just a simple number "1234"
+        w = assign(match[ndx++], s);
+      } else if (match[ndx + 1] === '.' || match[ndx] === '.') { // Check if it's a decimal number
+
+        if (match[ndx] !== '.') { // Handle 0.5 and .5
+          v = assign(match[ndx++], s);
+        }
+        ndx++;
+
+        // Check for decimal places
+        if (ndx + 1 === match.length || match[ndx + 1] === '(' && match[ndx + 3] === ')' || match[ndx + 1] === "'" && match[ndx + 3] === "'") {
+          w = assign(match[ndx], s);
+          y = C_TEN ** BigInt(match[ndx].length);
+          ndx++;
+        }
+
+        // Check for repeating places
+        if (match[ndx] === '(' && match[ndx + 2] === ')' || match[ndx] === "'" && match[ndx + 2] === "'") {
+          x = assign(match[ndx + 1], s);
+          z = C_TEN ** BigInt(match[ndx + 1].length) - C_ONE;
+          ndx+= 3;
+        }
+
+      } else if (match[ndx + 1] === '/' || match[ndx + 1] === ':') { // Check for a simple fraction "123/456" or "123:456"
+        w = assign(match[ndx], s);
+        y = assign(match[ndx + 2], C_ONE);
+        ndx+= 3;
+      } else if (match[ndx + 3] === '/' && match[ndx + 1] === ' ') { // Check for a complex fraction "123 1/2"
+        v = assign(match[ndx], s);
+        w = assign(match[ndx + 2], s);
+        y = assign(match[ndx + 4], C_ONE);
+        ndx+= 5;
+      }
+
+      if (match.length <= ndx) { // Check for more tokens on the stack
+        d = y * z;
+        s = /* void */
+        n = x + d * v + z * w;
+      } else {
+        throw InvalidParameter();
+      }
+
+    } else {
+      throw InvalidParameter();
+    }
+
+    if (d === C_ZERO) {
+      throw DivisionByZero();
+    }
+
+    P["s"] = s < C_ZERO ? -C_ONE : C_ONE;
+    P["n"] = n < C_ZERO ? -n : n;
+    P["d"] = d < C_ZERO ? -d : d;
+  };
+
+  function modpow(b, e, m) {
+
+    let r = C_ONE;
+    for (; e > C_ZERO; b = (b * b) % m, e >>= C_ONE) {
+
+      if (e & C_ONE) {
+        r = (r * b) % m;
+      }
+    }
+    return r;
+  }
+
+  function cycleLen(n, d) {
+
+    for (; d % C_TWO === C_ZERO;
+      d/= C_TWO) {
+    }
+
+    for (; d % C_FIVE === C_ZERO;
+      d/= C_FIVE) {
+    }
+
+    if (d === C_ONE) // Catch non-cyclic numbers
+      return C_ZERO;
+
+    // If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem:
+    // 10^(d-1) % d == 1
+    // However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone,
+    // as we want to translate the numbers to strings.
+
+    let rem = C_TEN % d;
+    let t = 1;
+
+    for (; rem !== C_ONE; t++) {
+      rem = rem * C_TEN % d;
+
+      if (t > MAX_CYCLE_LEN)
+        return C_ZERO; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1`
+    }
+    return BigInt(t);
+  }
+
+  function cycleStart(n, d, len) {
+
+    let rem1 = C_ONE;
+    let rem2 = modpow(C_TEN, len, d);
+
+    for (let t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE)
+      // Solve 10^s == 10^(s+t) (mod d)
+
+      if (rem1 === rem2)
+        return BigInt(t);
+
+      rem1 = rem1 * C_TEN % d;
+      rem2 = rem2 * C_TEN % d;
+    }
+    return 0;
+  }
+
+  function gcd(a, b) {
+
+    if (!a)
+      return b;
+    if (!b)
+      return a;
+
+    while (1) {
+      a%= b;
+      if (!a)
+        return b;
+      b%= a;
+      if (!b)
+        return a;
+    }
+  }
+
+  /**
+   * Module constructor
+   *
+   * @constructor
+   * @param {number|Fraction=} a
+   * @param {number=} b
+   */
+  function Fraction(a, b) {
+
+    parse(a, b);
+
+    if (this instanceof Fraction) {
+      a = gcd(P["d"], P["n"]); // Abuse a
+      this["s"] = P["s"];
+      this["n"] = P["n"] / a;
+      this["d"] = P["d"] / a;
+    } else {
+      return newFraction(P['s'] * P['n'], P['d']);
+    }
+  }
+
+  var DivisionByZero = function() {return new Error("Division by Zero");};
+  var InvalidParameter = function() {return new Error("Invalid argument");};
+  var NonIntegerParameter = function() {return new Error("Parameters must be integer");};
+
+  Fraction.prototype = {
+
+    "s": C_ONE,
+    "n": C_ZERO,
+    "d": C_ONE,
+
+    /**
+     * Calculates the absolute value
+     *
+     * Ex: new Fraction(-4).abs() => 4
+     **/
+    "abs": function() {
+
+      return newFraction(this["n"], this["d"]);
+    },
+
+    /**
+     * Inverts the sign of the current fraction
+     *
+     * Ex: new Fraction(-4).neg() => 4
+     **/
+    "neg": function() {
+
+      return newFraction(-this["s"] * this["n"], this["d"]);
+    },
+
+    /**
+     * Adds two rational numbers
+     *
+     * Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
+     **/
+    "add": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Subtracts two rational numbers
+     *
+     * Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
+     **/
+    "sub": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Multiplies two rational numbers
+     *
+     * Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
+     **/
+    "mul": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * P["s"] * this["n"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Divides two rational numbers
+     *
+     * Ex: new Fraction("-17.(345)").inverse().div(3)
+     **/
+    "div": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * P["s"] * this["n"] * P["d"],
+        this["d"] * P["n"]
+      );
+    },
+
+    /**
+     * Clones the actual object
+     *
+     * Ex: new Fraction("-17.(345)").clone()
+     **/
+    "clone": function() {
+      return newFraction(this['s'] * this['n'], this['d']);
+    },
+
+    /**
+     * Calculates the modulo of two rational numbers - a more precise fmod
+     *
+     * Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
+     **/
+    "mod": function(a, b) {
+
+      if (a === undefined) {
+        return newFraction(this["s"] * this["n"] % this["d"], C_ONE);
+      }
+
+      parse(a, b);
+      if (0 === P["n"] && 0 === this["d"]) {
+        throw DivisionByZero();
+      }
+
+      /*
+       * First silly attempt, kinda slow
+       *
+       return that["sub"]({
+       "n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)),
+       "d": num["d"],
+       "s": this["s"]
+       });*/
+
+      /*
+       * New attempt: a1 / b1 = a2 / b2 * q + r
+       * => b2 * a1 = a2 * b1 * q + b1 * b2 * r
+       * => (b2 * a1 % a2 * b1) / (b1 * b2)
+       */
+      return newFraction(
+        this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
+        P["d"] * this["d"]
+      );
+    },
+
+    /**
+     * Calculates the fractional gcd of two rational numbers
+     *
+     * Ex: new Fraction(5,8).gcd(3,7) => 1/56
+     */
+    "gcd": function(a, b) {
+
+      parse(a, b);
+
+      // gcd(a / b, c / d) = gcd(a, c) / lcm(b, d)
+
+      return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
+    },
+
+    /**
+     * Calculates the fractional lcm of two rational numbers
+     *
+     * Ex: new Fraction(5,8).lcm(3,7) => 15
+     */
+    "lcm": function(a, b) {
+
+      parse(a, b);
+
+      // lcm(a / b, c / d) = lcm(a, c) / gcd(b, d)
+
+      if (P["n"] === C_ZERO && this["n"] === C_ZERO) {
+        return newFraction(C_ZERO, C_ONE);
+      }
+      return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
+    },
+
+    /**
+     * Gets the inverse of the fraction, means numerator and denominator are exchanged
+     *
+     * Ex: new Fraction([-3, 4]).inverse() => -4 / 3
+     **/
+    "inverse": function() {
+      return newFraction(this["s"] * this["d"], this["n"]);
+    },
+
+    /**
+     * Calculates the fraction to some integer exponent
+     *
+     * Ex: new Fraction(-1,2).pow(-3) => -8
+     */
+    "pow": function(a, b) {
+
+      parse(a, b);
+
+      // Trivial case when exp is an integer
+
+      if (P['d'] === C_ONE) {
+
+        if (P['s'] < C_ZERO) {
+          return newFraction((this['s'] * this["d"]) ** P['n'], this["n"] ** P['n']);
+        } else {
+          return newFraction((this['s'] * this["n"]) ** P['n'], this["d"] ** P['n']);
+        }
+      }
+
+      // Negative roots become complex
+      //     (-a/b)^(c/d) = x
+      // <=> (-1)^(c/d) * (a/b)^(c/d) = x
+      // <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x
+      // <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x       # DeMoivre's formula
+      // From which follows that only for c=0 the root is non-complex
+      if (this['s'] < C_ZERO) return null;
+
+      // Now prime factor n and d
+      let N = factorize(this['n']);
+      let D = factorize(this['d']);
+
+      // Exponentiate and take root for n and d individually
+      let n = C_ONE;
+      let d = C_ONE;
+      for (let k in N) {
+        if (k === '1') continue;
+        if (k === '0') {
+          n = C_ZERO;
+          break;
+        }
+        N[k]*= P['n'];
+
+        if (N[k] % P['d'] === C_ZERO) {
+          N[k]/= P['d'];
+        } else return null;
+        n*= BigInt(k) ** N[k];
+      }
+
+      for (let k in D) {
+        if (k === '1') continue;
+        D[k]*= P['n'];
+
+        if (D[k] % P['d'] === C_ZERO) {
+          D[k]/= P['d'];
+        } else return null;
+        d*= BigInt(k) ** D[k];
+      }
+
+      if (P['s'] < C_ZERO) {
+        return newFraction(d, n);
+      }
+      return newFraction(n, d);
+    },
+
+    /**
+     * Check if two rational numbers are the same
+     *
+     * Ex: new Fraction(19.6).equals([98, 5]);
+     **/
+    "equals": function(a, b) {
+
+      parse(a, b);
+      return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0
+    },
+
+    /**
+     * Check if two rational numbers are the same
+     *
+     * Ex: new Fraction(19.6).equals([98, 5]);
+     **/
+    "compare": function(a, b) {
+
+      parse(a, b);
+      let t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]);
+
+      return (C_ZERO < t) - (t < C_ZERO);
+    },
+
+    /**
+     * Calculates the ceil of a rational number
+     *
+     * Ex: new Fraction('4.(3)').ceil() => (5 / 1)
+     **/
+    "ceil": function(places) {
+
+      places = C_TEN ** BigInt(places || 0);
+
+      return newFraction(this["s"] * places * this["n"] / this["d"] +
+        (places * this["n"] % this["d"] > C_ZERO && this["s"] >= C_ZERO ? C_ONE : C_ZERO),
+        places);
+    },
+
+    /**
+     * Calculates the floor of a rational number
+     *
+     * Ex: new Fraction('4.(3)').floor() => (4 / 1)
+     **/
+    "floor": function(places) {
+
+      places = C_TEN ** BigInt(places || 0);
+
+      return newFraction(this["s"] * places * this["n"] / this["d"] -
+        (places * this["n"] % this["d"] > C_ZERO && this["s"] < C_ZERO ? C_ONE : C_ZERO),
+        places);
+    },
+
+    /**
+     * Rounds a rational numbers
+     *
+     * Ex: new Fraction('4.(3)').round() => (4 / 1)
+     **/
+    "round": function(places) {
+
+      places = C_TEN ** BigInt(places || 0);
+
+      /* Derivation:
+
+      s >= 0:
+        round(n / d) = trunc(n / d) + (n % d) / d >= 0.5 ? 1 : 0
+                     = trunc(n / d) + 2(n % d) >= d ? 1 : 0
+      s < 0:
+        round(n / d) =-trunc(n / d) - (n % d) / d > 0.5 ? 1 : 0
+                     =-trunc(n / d) - 2(n % d) > d ? 1 : 0
+
+      =>:
+
+      round(s * n / d) = s * trunc(n / d) + s * (C + 2(n % d) > d ? 1 : 0)
+          where C = s >= 0 ? 1 : 0, to fix the >= for the positve case.
+      */
+
+      return newFraction(this["s"] * places * this["n"] / this["d"] +
+        this["s"] * ((this["s"] >= C_ZERO ? C_ONE : C_ZERO) + C_TWO * (places * this["n"] % this["d"]) > this["d"] ? C_ONE : C_ZERO),
+        places);
+    },
+
+    /**
+     * Check if two rational numbers are divisible
+     *
+     * Ex: new Fraction(19.6).divisible(1.5);
+     */
+    "divisible": function(a, b) {
+
+      parse(a, b);
+      return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"])));
+    },
+
+    /**
+     * Returns a decimal representation of the fraction
+     *
+     * Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
+     **/
+    'valueOf': function() {
+      // Best we can do so far
+      return Number(this["s"] * this["n"]) / Number(this["d"]);
+    },
+
+    /**
+     * Creates a string representation of a fraction with all digits
+     *
+     * Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
+     **/
+    'toString': function(dec) {
+
+      let N = this["n"];
+      let D = this["d"];
+
+      function trunc(x) {
+          return typeof x === 'bigint' ? x : Math.floor(x);
+      }
+
+      dec = dec || 15; // 15 = decimal places when no repetition
+
+      let cycLen = cycleLen(N, D); // Cycle length
+      let cycOff = cycleStart(N, D, cycLen); // Cycle start
+
+      let str = this['s'] < C_ZERO ? "-" : "";
+
+      // Append integer part
+      str+= trunc(N / D);
+
+      N%= D;
+      N*= C_TEN;
+
+      if (N)
+        str+= ".";
+
+      if (cycLen) {
+
+        for (let i = cycOff; i--;) {
+          str+= trunc(N / D);
+          N%= D;
+          N*= C_TEN;
+        }
+        str+= "(";
+        for (let i = cycLen; i--;) {
+          str+= trunc(N / D);
+          N%= D;
+          N*= C_TEN;
+        }
+        str+= ")";
+      } else {
+        for (let i = dec; N && i--;) {
+          str+= trunc(N / D);
+          N%= D;
+          N*= C_TEN;
+        }
+      }
+      return str;
+    },
+
+    /**
+     * Returns a string-fraction representation of a Fraction object
+     *
+     * Ex: new Fraction("1.'3'").toFraction() => "4 1/3"
+     **/
+    'toFraction': function(excludeWhole) {
+
+      let n = this["n"];
+      let d = this["d"];
+      let str = this['s'] < C_ZERO ? "-" : "";
+
+      if (d === C_ONE) {
+        str+= n;
+      } else {
+        let whole = n / d;
+        if (excludeWhole && whole > C_ZERO) {
+          str+= whole;
+          str+= " ";
+          n%= d;
+        }
+
+        str+= n;
+        str+= '/';
+        str+= d;
+      }
+      return str;
+    },
+
+    /**
+     * Returns a latex representation of a Fraction object
+     *
+     * Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
+     **/
+    'toLatex': function(excludeWhole) {
+
+      let n = this["n"];
+      let d = this["d"];
+      let str = this['s'] < C_ZERO ? "-" : "";
+
+      if (d === C_ONE) {
+        str+= n;
+      } else {
+        let whole = n / d;
+        if (excludeWhole && whole > C_ZERO) {
+          str+= whole;
+          n%= d;
+        }
+
+        str+= "\\frac{";
+        str+= n;
+        str+= '}{';
+        str+= d;
+        str+= '}';
+      }
+      return str;
+    },
+
+    /**
+     * Returns an array of continued fraction elements
+     *
+     * Ex: new Fraction("7/8").toContinued() => [0,1,7]
+     */
+    'toContinued': function() {
+
+      let a = this['n'];
+      let b = this['d'];
+      let res = [];
+
+      do {
+        res.push(a / b);
+        let t = a % b;
+        a = b;
+        b = t;
+      } while (a !== C_ONE);
+
+      return res;
+    },
+
+    "simplify": function(eps) {
+
+      eps = eps || 0.001;
+
+      const thisABS = this['abs']();
+      const cont = thisABS['toContinued']();
+
+      for (let i = 1; i < cont.length; i++) {
+
+        let s = newFraction(cont[i - 1], C_ONE);
+        for (let k = i - 2; k >= 0; k--) {
+          s = s['inverse']()['add'](cont[k]);
+        }
+
+        if (Math.abs(s['sub'](thisABS).valueOf()) < eps) {
+          return s['mul'](this['s']);
+        }
+      }
+      return this;
+    }
+  };
+
+  if (typeof define === "function" && define["amd"]) {
+    define([], function() {
+      return Fraction;
+    });
+  } else if (typeof exports === "object") {
+    Object.defineProperty(exports, "__esModule", { 'value': true });
+    Fraction['default'] = Fraction;
+    Fraction['Fraction'] = Fraction;
+    module['exports'] = Fraction;
+  } else {
+    root['Fraction'] = Fraction;
+  }
+
+})(this);
diff --git a/node_modules/fraction.js/fraction.cjs b/node_modules/fraction.js/fraction.cjs
new file mode 100644
index 0000000..0a10d8c
--- /dev/null
+++ b/node_modules/fraction.js/fraction.cjs
@@ -0,0 +1,904 @@
+/**
+ * @license Fraction.js v4.3.7 31/08/2023
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2023, Robert Eisele (robert@raw.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+
+/**
+ *
+ * This class offers the possibility to calculate fractions.
+ * You can pass a fraction in different formats. Either as array, as double, as string or as an integer.
+ *
+ * Array/Object form
+ * [ 0 => <numerator>, 1 => <denominator> ]
+ * [ n => <numerator>, d => <denominator> ]
+ *
+ * Integer form
+ * - Single integer value
+ *
+ * Double form
+ * - Single double value
+ *
+ * String form
+ * 123.456 - a simple double
+ * 123/456 - a string fraction
+ * 123.'456' - a double with repeating decimal places
+ * 123.(456) - synonym
+ * 123.45'6' - a double with repeating last place
+ * 123.45(6) - synonym
+ *
+ * Example:
+ *
+ * var f = new Fraction("9.4'31'");
+ * f.mul([-4, 3]).div(4.9);
+ *
+ */
+
+(function(root) {
+
+  "use strict";
+
+  // Maximum search depth for cyclic rational numbers. 2000 should be more than enough.
+  // Example: 1/7 = 0.(142857) has 6 repeating decimal places.
+  // If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits
+  var MAX_CYCLE_LEN = 2000;
+
+  // Parsed data to avoid calling "new" all the time
+  var P = {
+    "s": 1,
+    "n": 0,
+    "d": 1
+  };
+
+  function assign(n, s) {
+
+    if (isNaN(n = parseInt(n, 10))) {
+      throw InvalidParameter();
+    }
+    return n * s;
+  }
+
+  // Creates a new Fraction internally without the need of the bulky constructor
+  function newFraction(n, d) {
+
+    if (d === 0) {
+      throw DivisionByZero();
+    }
+
+    var f = Object.create(Fraction.prototype);
+    f["s"] = n < 0 ? -1 : 1;
+
+    n = n < 0 ? -n : n;
+
+    var a = gcd(n, d);
+
+    f["n"] = n / a;
+    f["d"] = d / a;
+    return f;
+  }
+
+  function factorize(num) {
+
+    var factors = {};
+
+    var n = num;
+    var i = 2;
+    var s = 4;
+
+    while (s <= n) {
+
+      while (n % i === 0) {
+        n/= i;
+        factors[i] = (factors[i] || 0) + 1;
+      }
+      s+= 1 + 2 * i++;
+    }
+
+    if (n !== num) {
+      if (n > 1)
+        factors[n] = (factors[n] || 0) + 1;
+    } else {
+      factors[num] = (factors[num] || 0) + 1;
+    }
+    return factors;
+  }
+
+  var parse = function(p1, p2) {
+
+    var n = 0, d = 1, s = 1;
+    var v = 0, w = 0, x = 0, y = 1, z = 1;
+
+    var A = 0, B = 1;
+    var C = 1, D = 1;
+
+    var N = 10000000;
+    var M;
+
+    if (p1 === undefined || p1 === null) {
+      /* void */
+    } else if (p2 !== undefined) {
+      n = p1;
+      d = p2;
+      s = n * d;
+
+      if (n % 1 !== 0 || d % 1 !== 0) {
+        throw NonIntegerParameter();
+      }
+
+    } else
+      switch (typeof p1) {
+
+        case "object":
+          {
+            if ("d" in p1 && "n" in p1) {
+              n = p1["n"];
+              d = p1["d"];
+              if ("s" in p1)
+                n*= p1["s"];
+            } else if (0 in p1) {
+              n = p1[0];
+              if (1 in p1)
+                d = p1[1];
+            } else {
+              throw InvalidParameter();
+            }
+            s = n * d;
+            break;
+          }
+        case "number":
+          {
+            if (p1 < 0) {
+              s = p1;
+              p1 = -p1;
+            }
+
+            if (p1 % 1 === 0) {
+              n = p1;
+            } else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow
+
+              if (p1 >= 1) {
+                z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10));
+                p1/= z;
+              }
+
+              // Using Farey Sequences
+              // http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/
+
+              while (B <= N && D <= N) {
+                M = (A + C) / (B + D);
+
+                if (p1 === M) {
+                  if (B + D <= N) {
+                    n = A + C;
+                    d = B + D;
+                  } else if (D > B) {
+                    n = C;
+                    d = D;
+                  } else {
+                    n = A;
+                    d = B;
+                  }
+                  break;
+
+                } else {
+
+                  if (p1 > M) {
+                    A+= C;
+                    B+= D;
+                  } else {
+                    C+= A;
+                    D+= B;
+                  }
+
+                  if (B > N) {
+                    n = C;
+                    d = D;
+                  } else {
+                    n = A;
+                    d = B;
+                  }
+                }
+              }
+              n*= z;
+            } else if (isNaN(p1) || isNaN(p2)) {
+              d = n = NaN;
+            }
+            break;
+          }
+        case "string":
+          {
+            B = p1.match(/\d+|./g);
+
+            if (B === null)
+              throw InvalidParameter();
+
+            if (B[A] === '-') {// Check for minus sign at the beginning
+              s = -1;
+              A++;
+            } else if (B[A] === '+') {// Check for plus sign at the beginning
+              A++;
+            }
+
+            if (B.length === A + 1) { // Check if it's just a simple number "1234"
+              w = assign(B[A++], s);
+            } else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number
+
+              if (B[A] !== '.') { // Handle 0.5 and .5
+                v = assign(B[A++], s);
+              }
+              A++;
+
+              // Check for decimal places
+              if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") {
+                w = assign(B[A], s);
+                y = Math.pow(10, B[A].length);
+                A++;
+              }
+
+              // Check for repeating places
+              if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") {
+                x = assign(B[A + 1], s);
+                z = Math.pow(10, B[A + 1].length) - 1;
+                A+= 3;
+              }
+
+            } else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456"
+              w = assign(B[A], s);
+              y = assign(B[A + 2], 1);
+              A+= 3;
+            } else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2"
+              v = assign(B[A], s);
+              w = assign(B[A + 2], s);
+              y = assign(B[A + 4], 1);
+              A+= 5;
+            }
+
+            if (B.length <= A) { // Check for more tokens on the stack
+              d = y * z;
+              s = /* void */
+              n = x + d * v + z * w;
+              break;
+            }
+
+            /* Fall through on error */
+          }
+        default:
+          throw InvalidParameter();
+      }
+
+    if (d === 0) {
+      throw DivisionByZero();
+    }
+
+    P["s"] = s < 0 ? -1 : 1;
+    P["n"] = Math.abs(n);
+    P["d"] = Math.abs(d);
+  };
+
+  function modpow(b, e, m) {
+
+    var r = 1;
+    for (; e > 0; b = (b * b) % m, e >>= 1) {
+
+      if (e & 1) {
+        r = (r * b) % m;
+      }
+    }
+    return r;
+  }
+
+
+  function cycleLen(n, d) {
+
+    for (; d % 2 === 0;
+      d/= 2) {
+    }
+
+    for (; d % 5 === 0;
+      d/= 5) {
+    }
+
+    if (d === 1) // Catch non-cyclic numbers
+      return 0;
+
+    // If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem:
+    // 10^(d-1) % d == 1
+    // However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone,
+    // as we want to translate the numbers to strings.
+
+    var rem = 10 % d;
+    var t = 1;
+
+    for (; rem !== 1; t++) {
+      rem = rem * 10 % d;
+
+      if (t > MAX_CYCLE_LEN)
+        return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1`
+    }
+    return t;
+  }
+
+
+  function cycleStart(n, d, len) {
+
+    var rem1 = 1;
+    var rem2 = modpow(10, len, d);
+
+    for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE)
+      // Solve 10^s == 10^(s+t) (mod d)
+
+      if (rem1 === rem2)
+        return t;
+
+      rem1 = rem1 * 10 % d;
+      rem2 = rem2 * 10 % d;
+    }
+    return 0;
+  }
+
+  function gcd(a, b) {
+
+    if (!a)
+      return b;
+    if (!b)
+      return a;
+
+    while (1) {
+      a%= b;
+      if (!a)
+        return b;
+      b%= a;
+      if (!b)
+        return a;
+    }
+  };
+
+  /**
+   * Module constructor
+   *
+   * @constructor
+   * @param {number|Fraction=} a
+   * @param {number=} b
+   */
+  function Fraction(a, b) {
+
+    parse(a, b);
+
+    if (this instanceof Fraction) {
+      a = gcd(P["d"], P["n"]); // Abuse variable a
+      this["s"] = P["s"];
+      this["n"] = P["n"] / a;
+      this["d"] = P["d"] / a;
+    } else {
+      return newFraction(P['s'] * P['n'], P['d']);
+    }
+  }
+
+  var DivisionByZero = function() { return new Error("Division by Zero"); };
+  var InvalidParameter = function() { return new Error("Invalid argument"); };
+  var NonIntegerParameter = function() { return new Error("Parameters must be integer"); };
+
+  Fraction.prototype = {
+
+    "s": 1,
+    "n": 0,
+    "d": 1,
+
+    /**
+     * Calculates the absolute value
+     *
+     * Ex: new Fraction(-4).abs() => 4
+     **/
+    "abs": function() {
+
+      return newFraction(this["n"], this["d"]);
+    },
+
+    /**
+     * Inverts the sign of the current fraction
+     *
+     * Ex: new Fraction(-4).neg() => 4
+     **/
+    "neg": function() {
+
+      return newFraction(-this["s"] * this["n"], this["d"]);
+    },
+
+    /**
+     * Adds two rational numbers
+     *
+     * Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
+     **/
+    "add": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Subtracts two rational numbers
+     *
+     * Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
+     **/
+    "sub": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Multiplies two rational numbers
+     *
+     * Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
+     **/
+    "mul": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * P["s"] * this["n"] * P["n"],
+        this["d"] * P["d"]
+      );
+    },
+
+    /**
+     * Divides two rational numbers
+     *
+     * Ex: new Fraction("-17.(345)").inverse().div(3)
+     **/
+    "div": function(a, b) {
+
+      parse(a, b);
+      return newFraction(
+        this["s"] * P["s"] * this["n"] * P["d"],
+        this["d"] * P["n"]
+      );
+    },
+
+    /**
+     * Clones the actual object
+     *
+     * Ex: new Fraction("-17.(345)").clone()
+     **/
+    "clone": function() {
+      return newFraction(this['s'] * this['n'], this['d']);
+    },
+
+    /**
+     * Calculates the modulo of two rational numbers - a more precise fmod
+     *
+     * Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
+     **/
+    "mod": function(a, b) {
+
+      if (isNaN(this['n']) || isNaN(this['d'])) {
+        return new Fraction(NaN);
+      }
+
+      if (a === undefined) {
+        return newFraction(this["s"] * this["n"] % this["d"], 1);
+      }
+
+      parse(a, b);
+      if (0 === P["n"] && 0 === this["d"]) {
+        throw DivisionByZero();
+      }
+
+      /*
+       * First silly attempt, kinda slow
+       *
+       return that["sub"]({
+       "n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)),
+       "d": num["d"],
+       "s": this["s"]
+       });*/
+
+      /*
+       * New attempt: a1 / b1 = a2 / b2 * q + r
+       * => b2 * a1 = a2 * b1 * q + b1 * b2 * r
+       * => (b2 * a1 % a2 * b1) / (b1 * b2)
+       */
+      return newFraction(
+        this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
+        P["d"] * this["d"]
+      );
+    },
+
+    /**
+     * Calculates the fractional gcd of two rational numbers
+     *
+     * Ex: new Fraction(5,8).gcd(3,7) => 1/56
+     */
+    "gcd": function(a, b) {
+
+      parse(a, b);
+
+      // gcd(a / b, c / d) = gcd(a, c) / lcm(b, d)
+
+      return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
+    },
+
+    /**
+     * Calculates the fractional lcm of two rational numbers
+     *
+     * Ex: new Fraction(5,8).lcm(3,7) => 15
+     */
+    "lcm": function(a, b) {
+
+      parse(a, b);
+
+      // lcm(a / b, c / d) = lcm(a, c) / gcd(b, d)
+
+      if (P["n"] === 0 && this["n"] === 0) {
+        return newFraction(0, 1);
+      }
+      return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
+    },
+
+    /**
+     * Calculates the ceil of a rational number
+     *
+     * Ex: new Fraction('4.(3)').ceil() => (5 / 1)
+     **/
+    "ceil": function(places) {
+
+      places = Math.pow(10, places || 0);
+
+      if (isNaN(this["n"]) || isNaN(this["d"])) {
+        return new Fraction(NaN);
+      }
+      return newFraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places);
+    },
+
+    /**
+     * Calculates the floor of a rational number
+     *
+     * Ex: new Fraction('4.(3)').floor() => (4 / 1)
+     **/
+    "floor": function(places) {
+
+      places = Math.pow(10, places || 0);
+
+      if (isNaN(this["n"]) || isNaN(this["d"])) {
+        return new Fraction(NaN);
+      }
+      return newFraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places);
+    },
+
+    /**
+     * Rounds a rational numbers
+     *
+     * Ex: new Fraction('4.(3)').round() => (4 / 1)
+     **/
+    "round": function(places) {
+
+      places = Math.pow(10, places || 0);
+
+      if (isNaN(this["n"]) || isNaN(this["d"])) {
+        return new Fraction(NaN);
+      }
+      return newFraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
+    },
+
+    /**
+     * Rounds a rational number to a multiple of another rational number
+     *
+     * Ex: new Fraction('0.9').roundTo("1/8") => 7 / 8
+     **/
+    "roundTo": function(a, b) {
+
+      /*
+      k * x/y ≤ a/b < (k+1) * x/y
+      ⇔ k ≤ a/b / (x/y) < (k+1)
+      ⇔ k = floor(a/b * y/x)
+      */
+
+      parse(a, b);
+
+      return newFraction(this['s'] * Math.round(this['n'] * P['d'] / (this['d'] * P['n'])) * P['n'], P['d']);
+    },
+
+    /**
+     * Gets the inverse of the fraction, means numerator and denominator are exchanged
+     *
+     * Ex: new Fraction([-3, 4]).inverse() => -4 / 3
+     **/
+    "inverse": function() {
+
+      return newFraction(this["s"] * this["d"], this["n"]);
+    },
+
+    /**
+     * Calculates the fraction to some rational exponent, if possible
+     *
+     * Ex: new Fraction(-1,2).pow(-3) => -8
+     */
+    "pow": function(a, b) {
+
+      parse(a, b);
+
+      // Trivial case when exp is an integer
+
+      if (P['d'] === 1) {
+
+        if (P['s'] < 0) {
+          return newFraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n']));
+        } else {
+          return newFraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n']));
+        }
+      }
+
+      // Negative roots become complex
+      //     (-a/b)^(c/d) = x
+      // <=> (-1)^(c/d) * (a/b)^(c/d) = x
+      // <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x         # rotate 1 by 180°
+      // <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x       # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index )
+      // From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case.
+      if (this['s'] < 0) return null;
+
+      // Now prime factor n and d
+      var N = factorize(this['n']);
+      var D = factorize(this['d']);
+
+      // Exponentiate and take root for n and d individually
+      var n = 1;
+      var d = 1;
+      for (var k in N) {
+        if (k === '1') continue;
+        if (k === '0') {
+          n = 0;
+          break;
+        }
+        N[k]*= P['n'];
+
+        if (N[k] % P['d'] === 0) {
+          N[k]/= P['d'];
+        } else return null;
+        n*= Math.pow(k, N[k]);
+      }
+
+      for (var k in D) {
+        if (k === '1') continue;
+        D[k]*= P['n'];
+
+        if (D[k] % P['d'] === 0) {
+          D[k]/= P['d'];
+        } else return null;
+        d*= Math.pow(k, D[k]);
+      }
+
+      if (P['s'] < 0) {
+        return newFraction(d, n);
+      }
+      return newFraction(n, d);
+    },
+
+    /**
+     * Check if two rational numbers are the same
+     *
+     * Ex: new Fraction(19.6).equals([98, 5]);
+     **/
+    "equals": function(a, b) {
+
+      parse(a, b);
+      return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0
+    },
+
+    /**
+     * Check if two rational numbers are the same
+     *
+     * Ex: new Fraction(19.6).equals([98, 5]);
+     **/
+    "compare": function(a, b) {
+
+      parse(a, b);
+      var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]);
+      return (0 < t) - (t < 0);
+    },
+
+    "simplify": function(eps) {
+
+      if (isNaN(this['n']) || isNaN(this['d'])) {
+        return this;
+      }
+
+      eps = eps || 0.001;
+
+      var thisABS = this['abs']();
+      var cont = thisABS['toContinued']();
+
+      for (var i = 1; i < cont.length; i++) {
+
+        var s = newFraction(cont[i - 1], 1);
+        for (var k = i - 2; k >= 0; k--) {
+          s = s['inverse']()['add'](cont[k]);
+        }
+
+        if (Math.abs(s['sub'](thisABS).valueOf()) < eps) {
+          return s['mul'](this['s']);
+        }
+      }
+      return this;
+    },
+
+    /**
+     * Check if two rational numbers are divisible
+     *
+     * Ex: new Fraction(19.6).divisible(1.5);
+     */
+    "divisible": function(a, b) {
+
+      parse(a, b);
+      return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"])));
+    },
+
+    /**
+     * Returns a decimal representation of the fraction
+     *
+     * Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
+     **/
+    'valueOf': function() {
+
+      return this["s"] * this["n"] / this["d"];
+    },
+
+    /**
+     * Returns a string-fraction representation of a Fraction object
+     *
+     * Ex: new Fraction("1.'3'").toFraction(true) => "4 1/3"
+     **/
+    'toFraction': function(excludeWhole) {
+
+      var whole, str = "";
+      var n = this["n"];
+      var d = this["d"];
+      if (this["s"] < 0) {
+        str+= '-';
+      }
+
+      if (d === 1) {
+        str+= n;
+      } else {
+
+        if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
+          str+= whole;
+          str+= " ";
+          n%= d;
+        }
+
+        str+= n;
+        str+= '/';
+        str+= d;
+      }
+      return str;
+    },
+
+    /**
+     * Returns a latex representation of a Fraction object
+     *
+     * Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
+     **/
+    'toLatex': function(excludeWhole) {
+
+      var whole, str = "";
+      var n = this["n"];
+      var d = this["d"];
+      if (this["s"] < 0) {
+        str+= '-';
+      }
+
+      if (d === 1) {
+        str+= n;
+      } else {
+
+        if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
+          str+= whole;
+          n%= d;
+        }
+
+        str+= "\\frac{";
+        str+= n;
+        str+= '}{';
+        str+= d;
+        str+= '}';
+      }
+      return str;
+    },
+
+    /**
+     * Returns an array of continued fraction elements
+     *
+     * Ex: new Fraction("7/8").toContinued() => [0,1,7]
+     */
+    'toContinued': function() {
+
+      var t;
+      var a = this['n'];
+      var b = this['d'];
+      var res = [];
+
+      if (isNaN(a) || isNaN(b)) {
+        return res;
+      }
+
+      do {
+        res.push(Math.floor(a / b));
+        t = a % b;
+        a = b;
+        b = t;
+      } while (a !== 1);
+
+      return res;
+    },
+
+    /**
+     * Creates a string representation of a fraction with all digits
+     *
+     * Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
+     **/
+    'toString': function(dec) {
+
+      var N = this["n"];
+      var D = this["d"];
+
+      if (isNaN(N) || isNaN(D)) {
+        return "NaN";
+      }
+
+      dec = dec || 15; // 15 = decimal places when no repetation
+
+      var cycLen = cycleLen(N, D); // Cycle length
+      var cycOff = cycleStart(N, D, cycLen); // Cycle start
+
+      var str = this['s'] < 0 ? "-" : "";
+
+      str+= N / D | 0;
+
+      N%= D;
+      N*= 10;
+
+      if (N)
+        str+= ".";
+
+      if (cycLen) {
+
+        for (var i = cycOff; i--;) {
+          str+= N / D | 0;
+          N%= D;
+          N*= 10;
+        }
+        str+= "(";
+        for (var i = cycLen; i--;) {
+          str+= N / D | 0;
+          N%= D;
+          N*= 10;
+        }
+        str+= ")";
+      } else {
+        for (var i = dec; N && i--;) {
+          str+= N / D | 0;
+          N%= D;
+          N*= 10;
+        }
+      }
+      return str;
+    }
+  };
+
+  if (typeof exports === "object") {
+    Object.defineProperty(exports, "__esModule", { 'value': true });
+    exports['default'] = Fraction;
+    module['exports'] = Fraction;
+  } else {
+    root['Fraction'] = Fraction;
+  }
+
+})(this);
diff --git a/node_modules/fraction.js/fraction.d.ts b/node_modules/fraction.js/fraction.d.ts
new file mode 100644
index 0000000..e62cfe1
--- /dev/null
+++ b/node_modules/fraction.js/fraction.d.ts
@@ -0,0 +1,60 @@
+declare module 'Fraction';

+

+export interface NumeratorDenominator {

+  n: number;

+  d: number;

+}

+

+type FractionConstructor = {

+  (fraction: Fraction): Fraction;

+  (num: number | string): Fraction;

+  (numerator: number, denominator: number): Fraction;

+  (numbers: [number | string, number | string]): Fraction;

+  (fraction: NumeratorDenominator): Fraction;

+  (firstValue: Fraction | number | string | [number | string, number | string] | NumeratorDenominator, secondValue?: number): Fraction;

+};

+

+export default class Fraction {

+  constructor (fraction: Fraction);

+  constructor (num: number | string);

+  constructor (numerator: number, denominator: number);

+  constructor (numbers: [number | string, number | string]);

+  constructor (fraction: NumeratorDenominator);

+  constructor (firstValue: Fraction | number | string | [number | string, number | string] | NumeratorDenominator, secondValue?: number);

+

+  s: number;

+  n: number;

+  d: number;

+

+  abs(): Fraction;

+  neg(): Fraction;

+

+  add: FractionConstructor;

+  sub: FractionConstructor;

+  mul: FractionConstructor;

+  div: FractionConstructor;

+  pow: FractionConstructor;

+  gcd: FractionConstructor;

+  lcm: FractionConstructor;

+  

+  mod(n?: number | string | Fraction): Fraction;

+

+  ceil(places?: number): Fraction;

+  floor(places?: number): Fraction;

+  round(places?: number): Fraction;

+

+  inverse(): Fraction;

+  

+  simplify(eps?: number): Fraction;

+  

+  equals(n: number | string | Fraction): boolean;

+  compare(n: number | string | Fraction): number;

+  divisible(n: number | string | Fraction): boolean;

+  

+  valueOf(): number;

+  toString(decimalPlaces?: number): string;

+  toLatex(excludeWhole?: boolean): string;

+  toFraction(excludeWhole?: boolean): string;

+  toContinued(): number[];

+  clone(): Fraction;

+}

diff --git a/node_modules/fraction.js/fraction.js b/node_modules/fraction.js/fraction.js
new file mode 100644
index 0000000..b9780e0
--- /dev/null
+++ b/node_modules/fraction.js/fraction.js
@@ -0,0 +1,891 @@
+/**
+ * @license Fraction.js v4.3.7 31/08/2023
+ * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+ *
+ * Copyright (c) 2023, Robert Eisele (robert@raw.org)
+ * Dual licensed under the MIT or GPL Version 2 licenses.
+ **/
+
+
+/**
+ *
+ * This class offers the possibility to calculate fractions.
+ * You can pass a fraction in different formats. Either as array, as double, as string or as an integer.
+ *
+ * Array/Object form
+ * [ 0 => <numerator>, 1 => <denominator> ]
+ * [ n => <numerator>, d => <denominator> ]
+ *
+ * Integer form
+ * - Single integer value
+ *
+ * Double form
+ * - Single double value
+ *
+ * String form
+ * 123.456 - a simple double
+ * 123/456 - a string fraction
+ * 123.'456' - a double with repeating decimal places
+ * 123.(456) - synonym
+ * 123.45'6' - a double with repeating last place
+ * 123.45(6) - synonym
+ *
+ * Example:
+ *
+ * var f = new Fraction("9.4'31'");
+ * f.mul([-4, 3]).div(4.9);
+ *
+ */
+
+
+// Maximum search depth for cyclic rational numbers. 2000 should be more than enough.
+// Example: 1/7 = 0.(142857) has 6 repeating decimal places.
+// If MAX_CYCLE_LEN gets reduced, long cycles will not be detected and toString() only gets the first 10 digits
+var MAX_CYCLE_LEN = 2000;
+
+// Parsed data to avoid calling "new" all the time
+var P = {
+  "s": 1,
+  "n": 0,
+  "d": 1
+};
+
+function assign(n, s) {
+
+  if (isNaN(n = parseInt(n, 10))) {
+    throw InvalidParameter();
+  }
+  return n * s;
+}
+
+// Creates a new Fraction internally without the need of the bulky constructor
+function newFraction(n, d) {
+
+  if (d === 0) {
+    throw DivisionByZero();
+  }
+
+  var f = Object.create(Fraction.prototype);
+  f["s"] = n < 0 ? -1 : 1;
+
+  n = n < 0 ? -n : n;
+
+  var a = gcd(n, d);
+
+  f["n"] = n / a;
+  f["d"] = d / a;
+  return f;
+}
+
+function factorize(num) {
+
+  var factors = {};
+
+  var n = num;
+  var i = 2;
+  var s = 4;
+
+  while (s <= n) {
+
+    while (n % i === 0) {
+      n/= i;
+      factors[i] = (factors[i] || 0) + 1;
+    }
+    s+= 1 + 2 * i++;
+  }
+
+  if (n !== num) {
+    if (n > 1)
+      factors[n] = (factors[n] || 0) + 1;
+  } else {
+    factors[num] = (factors[num] || 0) + 1;
+  }
+  return factors;
+}
+
+var parse = function(p1, p2) {
+
+  var n = 0, d = 1, s = 1;
+  var v = 0, w = 0, x = 0, y = 1, z = 1;
+
+  var A = 0, B = 1;
+  var C = 1, D = 1;
+
+  var N = 10000000;
+  var M;
+
+  if (p1 === undefined || p1 === null) {
+    /* void */
+  } else if (p2 !== undefined) {
+    n = p1;
+    d = p2;
+    s = n * d;
+
+    if (n % 1 !== 0 || d % 1 !== 0) {
+      throw NonIntegerParameter();
+    }
+
+  } else
+    switch (typeof p1) {
+
+      case "object":
+        {
+          if ("d" in p1 && "n" in p1) {
+            n = p1["n"];
+            d = p1["d"];
+            if ("s" in p1)
+              n*= p1["s"];
+          } else if (0 in p1) {
+            n = p1[0];
+            if (1 in p1)
+              d = p1[1];
+          } else {
+            throw InvalidParameter();
+          }
+          s = n * d;
+          break;
+        }
+      case "number":
+        {
+          if (p1 < 0) {
+            s = p1;
+            p1 = -p1;
+          }
+
+          if (p1 % 1 === 0) {
+            n = p1;
+          } else if (p1 > 0) { // check for != 0, scale would become NaN (log(0)), which converges really slow
+
+            if (p1 >= 1) {
+              z = Math.pow(10, Math.floor(1 + Math.log(p1) / Math.LN10));
+              p1/= z;
+            }
+
+            // Using Farey Sequences
+            // http://www.johndcook.com/blog/2010/10/20/best-rational-approximation/
+
+            while (B <= N && D <= N) {
+              M = (A + C) / (B + D);
+
+              if (p1 === M) {
+                if (B + D <= N) {
+                  n = A + C;
+                  d = B + D;
+                } else if (D > B) {
+                  n = C;
+                  d = D;
+                } else {
+                  n = A;
+                  d = B;
+                }
+                break;
+
+              } else {
+
+                if (p1 > M) {
+                  A+= C;
+                  B+= D;
+                } else {
+                  C+= A;
+                  D+= B;
+                }
+
+                if (B > N) {
+                  n = C;
+                  d = D;
+                } else {
+                  n = A;
+                  d = B;
+                }
+              }
+            }
+            n*= z;
+          } else if (isNaN(p1) || isNaN(p2)) {
+            d = n = NaN;
+          }
+          break;
+        }
+      case "string":
+        {
+          B = p1.match(/\d+|./g);
+
+          if (B === null)
+            throw InvalidParameter();
+
+          if (B[A] === '-') {// Check for minus sign at the beginning
+            s = -1;
+            A++;
+          } else if (B[A] === '+') {// Check for plus sign at the beginning
+            A++;
+          }
+
+          if (B.length === A + 1) { // Check if it's just a simple number "1234"
+            w = assign(B[A++], s);
+          } else if (B[A + 1] === '.' || B[A] === '.') { // Check if it's a decimal number
+
+            if (B[A] !== '.') { // Handle 0.5 and .5
+              v = assign(B[A++], s);
+            }
+            A++;
+
+            // Check for decimal places
+            if (A + 1 === B.length || B[A + 1] === '(' && B[A + 3] === ')' || B[A + 1] === "'" && B[A + 3] === "'") {
+              w = assign(B[A], s);
+              y = Math.pow(10, B[A].length);
+              A++;
+            }
+
+            // Check for repeating places
+            if (B[A] === '(' && B[A + 2] === ')' || B[A] === "'" && B[A + 2] === "'") {
+              x = assign(B[A + 1], s);
+              z = Math.pow(10, B[A + 1].length) - 1;
+              A+= 3;
+            }
+
+          } else if (B[A + 1] === '/' || B[A + 1] === ':') { // Check for a simple fraction "123/456" or "123:456"
+            w = assign(B[A], s);
+            y = assign(B[A + 2], 1);
+            A+= 3;
+          } else if (B[A + 3] === '/' && B[A + 1] === ' ') { // Check for a complex fraction "123 1/2"
+            v = assign(B[A], s);
+            w = assign(B[A + 2], s);
+            y = assign(B[A + 4], 1);
+            A+= 5;
+          }
+
+          if (B.length <= A) { // Check for more tokens on the stack
+            d = y * z;
+            s = /* void */
+            n = x + d * v + z * w;
+            break;
+          }
+
+          /* Fall through on error */
+        }
+      default:
+        throw InvalidParameter();
+    }
+
+  if (d === 0) {
+    throw DivisionByZero();
+  }
+
+  P["s"] = s < 0 ? -1 : 1;
+  P["n"] = Math.abs(n);
+  P["d"] = Math.abs(d);
+};
+
+function modpow(b, e, m) {
+
+  var r = 1;
+  for (; e > 0; b = (b * b) % m, e >>= 1) {
+
+    if (e & 1) {
+      r = (r * b) % m;
+    }
+  }
+  return r;
+}
+
+
+function cycleLen(n, d) {
+
+  for (; d % 2 === 0;
+    d/= 2) {
+  }
+
+  for (; d % 5 === 0;
+    d/= 5) {
+  }
+
+  if (d === 1) // Catch non-cyclic numbers
+    return 0;
+
+  // If we would like to compute really large numbers quicker, we could make use of Fermat's little theorem:
+  // 10^(d-1) % d == 1
+  // However, we don't need such large numbers and MAX_CYCLE_LEN should be the capstone,
+  // as we want to translate the numbers to strings.
+
+  var rem = 10 % d;
+  var t = 1;
+
+  for (; rem !== 1; t++) {
+    rem = rem * 10 % d;
+
+    if (t > MAX_CYCLE_LEN)
+      return 0; // Returning 0 here means that we don't print it as a cyclic number. It's likely that the answer is `d-1`
+  }
+  return t;
+}
+
+
+function cycleStart(n, d, len) {
+
+  var rem1 = 1;
+  var rem2 = modpow(10, len, d);
+
+  for (var t = 0; t < 300; t++) { // s < ~log10(Number.MAX_VALUE)
+    // Solve 10^s == 10^(s+t) (mod d)
+
+    if (rem1 === rem2)
+      return t;
+
+    rem1 = rem1 * 10 % d;
+    rem2 = rem2 * 10 % d;
+  }
+  return 0;
+}
+
+function gcd(a, b) {
+
+  if (!a)
+    return b;
+  if (!b)
+    return a;
+
+  while (1) {
+    a%= b;
+    if (!a)
+      return b;
+    b%= a;
+    if (!b)
+      return a;
+  }
+};
+
+/**
+ * Module constructor
+ *
+ * @constructor
+ * @param {number|Fraction=} a
+ * @param {number=} b
+ */
+export default function Fraction(a, b) {
+
+  parse(a, b);
+
+  if (this instanceof Fraction) {
+    a = gcd(P["d"], P["n"]); // Abuse variable a
+    this["s"] = P["s"];
+    this["n"] = P["n"] / a;
+    this["d"] = P["d"] / a;
+  } else {
+    return newFraction(P['s'] * P['n'], P['d']);
+  }
+}
+
+var DivisionByZero = function() { return new Error("Division by Zero"); };
+var InvalidParameter = function() { return new Error("Invalid argument"); };
+var NonIntegerParameter = function() { return new Error("Parameters must be integer"); };
+
+Fraction.prototype = {
+
+  "s": 1,
+  "n": 0,
+  "d": 1,
+
+  /**
+   * Calculates the absolute value
+   *
+   * Ex: new Fraction(-4).abs() => 4
+   **/
+  "abs": function() {
+
+    return newFraction(this["n"], this["d"]);
+  },
+
+  /**
+   * Inverts the sign of the current fraction
+   *
+   * Ex: new Fraction(-4).neg() => 4
+   **/
+  "neg": function() {
+
+    return newFraction(-this["s"] * this["n"], this["d"]);
+  },
+
+  /**
+   * Adds two rational numbers
+   *
+   * Ex: new Fraction({n: 2, d: 3}).add("14.9") => 467 / 30
+   **/
+  "add": function(a, b) {
+
+    parse(a, b);
+    return newFraction(
+      this["s"] * this["n"] * P["d"] + P["s"] * this["d"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+
+  /**
+   * Subtracts two rational numbers
+   *
+   * Ex: new Fraction({n: 2, d: 3}).add("14.9") => -427 / 30
+   **/
+  "sub": function(a, b) {
+
+    parse(a, b);
+    return newFraction(
+      this["s"] * this["n"] * P["d"] - P["s"] * this["d"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+
+  /**
+   * Multiplies two rational numbers
+   *
+   * Ex: new Fraction("-17.(345)").mul(3) => 5776 / 111
+   **/
+  "mul": function(a, b) {
+
+    parse(a, b);
+    return newFraction(
+      this["s"] * P["s"] * this["n"] * P["n"],
+      this["d"] * P["d"]
+    );
+  },
+
+  /**
+   * Divides two rational numbers
+   *
+   * Ex: new Fraction("-17.(345)").inverse().div(3)
+   **/
+  "div": function(a, b) {
+
+    parse(a, b);
+    return newFraction(
+      this["s"] * P["s"] * this["n"] * P["d"],
+      this["d"] * P["n"]
+    );
+  },
+
+  /**
+   * Clones the actual object
+   *
+   * Ex: new Fraction("-17.(345)").clone()
+   **/
+  "clone": function() {
+    return newFraction(this['s'] * this['n'], this['d']);
+  },
+
+  /**
+   * Calculates the modulo of two rational numbers - a more precise fmod
+   *
+   * Ex: new Fraction('4.(3)').mod([7, 8]) => (13/3) % (7/8) = (5/6)
+   **/
+  "mod": function(a, b) {
+
+    if (isNaN(this['n']) || isNaN(this['d'])) {
+      return new Fraction(NaN);
+    }
+
+    if (a === undefined) {
+      return newFraction(this["s"] * this["n"] % this["d"], 1);
+    }
+
+    parse(a, b);
+    if (0 === P["n"] && 0 === this["d"]) {
+      throw DivisionByZero();
+    }
+
+    /*
+     * First silly attempt, kinda slow
+     *
+     return that["sub"]({
+     "n": num["n"] * Math.floor((this.n / this.d) / (num.n / num.d)),
+     "d": num["d"],
+     "s": this["s"]
+     });*/
+
+    /*
+     * New attempt: a1 / b1 = a2 / b2 * q + r
+     * => b2 * a1 = a2 * b1 * q + b1 * b2 * r
+     * => (b2 * a1 % a2 * b1) / (b1 * b2)
+     */
+    return newFraction(
+      this["s"] * (P["d"] * this["n"]) % (P["n"] * this["d"]),
+      P["d"] * this["d"]
+    );
+  },
+
+  /**
+   * Calculates the fractional gcd of two rational numbers
+   *
+   * Ex: new Fraction(5,8).gcd(3,7) => 1/56
+   */
+  "gcd": function(a, b) {
+
+    parse(a, b);
+
+    // gcd(a / b, c / d) = gcd(a, c) / lcm(b, d)
+
+    return newFraction(gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]), P["d"] * this["d"]);
+  },
+
+  /**
+   * Calculates the fractional lcm of two rational numbers
+   *
+   * Ex: new Fraction(5,8).lcm(3,7) => 15
+   */
+  "lcm": function(a, b) {
+
+    parse(a, b);
+
+    // lcm(a / b, c / d) = lcm(a, c) / gcd(b, d)
+
+    if (P["n"] === 0 && this["n"] === 0) {
+      return newFraction(0, 1);
+    }
+    return newFraction(P["n"] * this["n"], gcd(P["n"], this["n"]) * gcd(P["d"], this["d"]));
+  },
+
+  /**
+   * Calculates the ceil of a rational number
+   *
+   * Ex: new Fraction('4.(3)').ceil() => (5 / 1)
+   **/
+  "ceil": function(places) {
+
+    places = Math.pow(10, places || 0);
+
+    if (isNaN(this["n"]) || isNaN(this["d"])) {
+      return new Fraction(NaN);
+    }
+    return newFraction(Math.ceil(places * this["s"] * this["n"] / this["d"]), places);
+  },
+
+  /**
+   * Calculates the floor of a rational number
+   *
+   * Ex: new Fraction('4.(3)').floor() => (4 / 1)
+   **/
+  "floor": function(places) {
+
+    places = Math.pow(10, places || 0);
+
+    if (isNaN(this["n"]) || isNaN(this["d"])) {
+      return new Fraction(NaN);
+    }
+    return newFraction(Math.floor(places * this["s"] * this["n"] / this["d"]), places);
+  },
+
+  /**
+   * Rounds a rational number
+   *
+   * Ex: new Fraction('4.(3)').round() => (4 / 1)
+   **/
+  "round": function(places) {
+
+    places = Math.pow(10, places || 0);
+
+    if (isNaN(this["n"]) || isNaN(this["d"])) {
+      return new Fraction(NaN);
+    }
+    return newFraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
+  },
+
+  /**
+   * Rounds a rational number to a multiple of another rational number
+   *
+   * Ex: new Fraction('0.9').roundTo("1/8") => 7 / 8
+   **/
+  "roundTo": function(a, b) {
+
+    /*
+    k * x/y ≤ a/b < (k+1) * x/y
+    ⇔ k ≤ a/b / (x/y) < (k+1)
+    ⇔ k = floor(a/b * y/x)
+    */
+
+    parse(a, b);
+
+    return newFraction(this['s'] * Math.round(this['n'] * P['d'] / (this['d'] * P['n'])) * P['n'], P['d']);
+  },
+
+  /**
+   * Gets the inverse of the fraction, means numerator and denominator are exchanged
+   *
+   * Ex: new Fraction([-3, 4]).inverse() => -4 / 3
+   **/
+  "inverse": function() {
+
+    return newFraction(this["s"] * this["d"], this["n"]);
+  },
+
+  /**
+   * Calculates the fraction to some rational exponent, if possible
+   *
+   * Ex: new Fraction(-1,2).pow(-3) => -8
+   */
+  "pow": function(a, b) {
+
+    parse(a, b);
+
+    // Trivial case when exp is an integer
+
+    if (P['d'] === 1) {
+
+      if (P['s'] < 0) {
+        return newFraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n']));
+      } else {
+        return newFraction(Math.pow(this['s'] * this["n"], P['n']), Math.pow(this["d"], P['n']));
+      }
+    }
+
+    // Negative roots become complex
+    //     (-a/b)^(c/d) = x
+    // <=> (-1)^(c/d) * (a/b)^(c/d) = x
+    // <=> (cos(pi) + i*sin(pi))^(c/d) * (a/b)^(c/d) = x         # rotate 1 by 180°
+    // <=> (cos(c*pi/d) + i*sin(c*pi/d)) * (a/b)^(c/d) = x       # DeMoivre's formula in Q ( https://proofwiki.org/wiki/De_Moivre%27s_Formula/Rational_Index )
+    // From which follows that only for c=0 the root is non-complex. c/d is a reduced fraction, so that sin(c/dpi)=0 occurs for d=1, which is handled by our trivial case.
+    if (this['s'] < 0) return null;
+
+    // Now prime factor n and d
+    var N = factorize(this['n']);
+    var D = factorize(this['d']);
+
+    // Exponentiate and take root for n and d individually
+    var n = 1;
+    var d = 1;
+    for (var k in N) {
+      if (k === '1') continue;
+      if (k === '0') {
+        n = 0;
+        break;
+      }
+      N[k]*= P['n'];
+
+      if (N[k] % P['d'] === 0) {
+        N[k]/= P['d'];
+      } else return null;
+      n*= Math.pow(k, N[k]);
+    }
+
+    for (var k in D) {
+      if (k === '1') continue;
+      D[k]*= P['n'];
+
+      if (D[k] % P['d'] === 0) {
+        D[k]/= P['d'];
+      } else return null;
+      d*= Math.pow(k, D[k]);
+    }
+
+    if (P['s'] < 0) {
+      return newFraction(d, n);
+    }
+    return newFraction(n, d);
+  },
+
+  /**
+   * Check if two rational numbers are the same
+   *
+   * Ex: new Fraction(19.6).equals([98, 5]);
+   **/
+  "equals": function(a, b) {
+
+    parse(a, b);
+    return this["s"] * this["n"] * P["d"] === P["s"] * P["n"] * this["d"]; // Same as compare() === 0
+  },
+
+  /**
+   * Check if two rational numbers are the same
+   *
+   * Ex: new Fraction(19.6).equals([98, 5]);
+   **/
+  "compare": function(a, b) {
+
+    parse(a, b);
+    var t = (this["s"] * this["n"] * P["d"] - P["s"] * P["n"] * this["d"]);
+    return (0 < t) - (t < 0);
+  },
+
+  "simplify": function(eps) {
+
+    if (isNaN(this['n']) || isNaN(this['d'])) {
+      return this;
+    }
+
+    eps = eps || 0.001;
+
+    var thisABS = this['abs']();
+    var cont = thisABS['toContinued']();
+
+    for (var i = 1; i < cont.length; i++) {
+
+      var s = newFraction(cont[i - 1], 1);
+      for (var k = i - 2; k >= 0; k--) {
+        s = s['inverse']()['add'](cont[k]);
+      }
+
+      if (Math.abs(s['sub'](thisABS).valueOf()) < eps) {
+        return s['mul'](this['s']);
+      }
+    }
+    return this;
+  },
+
+  /**
+   * Check if two rational numbers are divisible
+   *
+   * Ex: new Fraction(19.6).divisible(1.5);
+   */
+  "divisible": function(a, b) {
+
+    parse(a, b);
+    return !(!(P["n"] * this["d"]) || ((this["n"] * P["d"]) % (P["n"] * this["d"])));
+  },
+
+  /**
+   * Returns a decimal representation of the fraction
+   *
+   * Ex: new Fraction("100.'91823'").valueOf() => 100.91823918239183
+   **/
+  'valueOf': function() {
+
+    return this["s"] * this["n"] / this["d"];
+  },
+
+  /**
+   * Returns a string-fraction representation of a Fraction object
+   *
+   * Ex: new Fraction("1.'3'").toFraction(true) => "4 1/3"
+   **/
+  'toFraction': function(excludeWhole) {
+
+    var whole, str = "";
+    var n = this["n"];
+    var d = this["d"];
+    if (this["s"] < 0) {
+      str+= '-';
+    }
+
+    if (d === 1) {
+      str+= n;
+    } else {
+
+      if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
+        str+= whole;
+        str+= " ";
+        n%= d;
+      }
+
+      str+= n;
+      str+= '/';
+      str+= d;
+    }
+    return str;
+  },
+
+  /**
+   * Returns a latex representation of a Fraction object
+   *
+   * Ex: new Fraction("1.'3'").toLatex() => "\frac{4}{3}"
+   **/
+  'toLatex': function(excludeWhole) {
+
+    var whole, str = "";
+    var n = this["n"];
+    var d = this["d"];
+    if (this["s"] < 0) {
+      str+= '-';
+    }
+
+    if (d === 1) {
+      str+= n;
+    } else {
+
+      if (excludeWhole && (whole = Math.floor(n / d)) > 0) {
+        str+= whole;
+        n%= d;
+      }
+
+      str+= "\\frac{";
+      str+= n;
+      str+= '}{';
+      str+= d;
+      str+= '}';
+    }
+    return str;
+  },
+
+  /**
+   * Returns an array of continued fraction elements
+   *
+   * Ex: new Fraction("7/8").toContinued() => [0,1,7]
+   */
+  'toContinued': function() {
+
+    var t;
+    var a = this['n'];
+    var b = this['d'];
+    var res = [];
+
+    if (isNaN(a) || isNaN(b)) {
+      return res;
+    }
+
+    do {
+      res.push(Math.floor(a / b));
+      t = a % b;
+      a = b;
+      b = t;
+    } while (a !== 1);
+
+    return res;
+  },
+
+  /**
+   * Creates a string representation of a fraction with all digits
+   *
+   * Ex: new Fraction("100.'91823'").toString() => "100.(91823)"
+   **/
+  'toString': function(dec) {
+
+    var N = this["n"];
+    var D = this["d"];
+
+    if (isNaN(N) || isNaN(D)) {
+      return "NaN";
+    }
+
+    dec = dec || 15; // 15 = decimal places when no repetation
+
+    var cycLen = cycleLen(N, D); // Cycle length
+    var cycOff = cycleStart(N, D, cycLen); // Cycle start
+
+    var str = this['s'] < 0 ? "-" : "";
+
+    str+= N / D | 0;
+
+    N%= D;
+    N*= 10;
+
+    if (N)
+      str+= ".";
+
+    if (cycLen) {
+
+      for (var i = cycOff; i--;) {
+        str+= N / D | 0;
+        N%= D;
+        N*= 10;
+      }
+      str+= "(";
+      for (var i = cycLen; i--;) {
+        str+= N / D | 0;
+        N%= D;
+        N*= 10;
+      }
+      str+= ")";
+    } else {
+      for (var i = dec; N && i--;) {
+        str+= N / D | 0;
+        N%= D;
+        N*= 10;
+      }
+    }
+    return str;
+  }
+};
diff --git a/node_modules/fraction.js/fraction.min.js b/node_modules/fraction.js/fraction.min.js
new file mode 100644
index 0000000..1cfa151
--- /dev/null
+++ b/node_modules/fraction.js/fraction.min.js
@@ -0,0 +1,18 @@
+/*
+Fraction.js v4.3.7 31/08/2023
+https://www.xarg.org/2014/03/rational-numbers-in-javascript/
+
+Copyright (c) 2023, Robert Eisele (robert@raw.org)
+Dual licensed under the MIT or GPL Version 2 licenses.
+*/
+(function(B){function x(){return Error("Invalid argument")}function z(){return Error("Division by Zero")}function n(a,c){var b=0,d=1,f=1,l=0,k=0,t=0,y=1,u=1,g=0,h=1,v=1,q=1;if(void 0!==a&&null!==a)if(void 0!==c){if(b=a,d=c,f=b*d,0!==b%1||0!==d%1)throw Error("Parameters must be integer");}else switch(typeof a){case "object":if("d"in a&&"n"in a)b=a.n,d=a.d,"s"in a&&(b*=a.s);else if(0 in a)b=a[0],1 in a&&(d=a[1]);else throw x();f=b*d;break;case "number":0>a&&(f=a,a=-a);if(0===a%1)b=a;else if(0<a){1<=
+a&&(u=Math.pow(10,Math.floor(1+Math.log(a)/Math.LN10)),a/=u);for(;1E7>=h&&1E7>=q;)if(b=(g+v)/(h+q),a===b){1E7>=h+q?(b=g+v,d=h+q):q>h?(b=v,d=q):(b=g,d=h);break}else a>b?(g+=v,h+=q):(v+=g,q+=h),1E7<h?(b=v,d=q):(b=g,d=h);b*=u}else if(isNaN(a)||isNaN(c))d=b=NaN;break;case "string":h=a.match(/\d+|./g);if(null===h)throw x();"-"===h[g]?(f=-1,g++):"+"===h[g]&&g++;if(h.length===g+1)k=r(h[g++],f);else if("."===h[g+1]||"."===h[g]){"."!==h[g]&&(l=r(h[g++],f));g++;if(g+1===h.length||"("===h[g+1]&&")"===h[g+3]||
+"'"===h[g+1]&&"'"===h[g+3])k=r(h[g],f),y=Math.pow(10,h[g].length),g++;if("("===h[g]&&")"===h[g+2]||"'"===h[g]&&"'"===h[g+2])t=r(h[g+1],f),u=Math.pow(10,h[g+1].length)-1,g+=3}else"/"===h[g+1]||":"===h[g+1]?(k=r(h[g],f),y=r(h[g+2],1),g+=3):"/"===h[g+3]&&" "===h[g+1]&&(l=r(h[g],f),k=r(h[g+2],f),y=r(h[g+4],1),g+=5);if(h.length<=g){d=y*u;f=b=t+d*l+u*k;break}default:throw x();}if(0===d)throw z();e.s=0>f?-1:1;e.n=Math.abs(b);e.d=Math.abs(d)}function r(a,c){if(isNaN(a=parseInt(a,10)))throw x();return a*c}
+function m(a,c){if(0===c)throw z();var b=Object.create(p.prototype);b.s=0>a?-1:1;a=0>a?-a:a;var d=w(a,c);b.n=a/d;b.d=c/d;return b}function A(a){for(var c={},b=a,d=2,f=4;f<=b;){for(;0===b%d;)b/=d,c[d]=(c[d]||0)+1;f+=1+2*d++}b!==a?1<b&&(c[b]=(c[b]||0)+1):c[a]=(c[a]||0)+1;return c}function w(a,c){if(!a)return c;if(!c)return a;for(;;){a%=c;if(!a)return c;c%=a;if(!c)return a}}function p(a,c){n(a,c);if(this instanceof p)a=w(e.d,e.n),this.s=e.s,this.n=e.n/a,this.d=e.d/a;else return m(e.s*e.n,e.d)}var e=
+{s:1,n:0,d:1};p.prototype={s:1,n:0,d:1,abs:function(){return m(this.n,this.d)},neg:function(){return m(-this.s*this.n,this.d)},add:function(a,c){n(a,c);return m(this.s*this.n*e.d+e.s*this.d*e.n,this.d*e.d)},sub:function(a,c){n(a,c);return m(this.s*this.n*e.d-e.s*this.d*e.n,this.d*e.d)},mul:function(a,c){n(a,c);return m(this.s*e.s*this.n*e.n,this.d*e.d)},div:function(a,c){n(a,c);return m(this.s*e.s*this.n*e.d,this.d*e.n)},clone:function(){return m(this.s*this.n,this.d)},mod:function(a,c){if(isNaN(this.n)||
+isNaN(this.d))return new p(NaN);if(void 0===a)return m(this.s*this.n%this.d,1);n(a,c);if(0===e.n&&0===this.d)throw z();return m(this.s*e.d*this.n%(e.n*this.d),e.d*this.d)},gcd:function(a,c){n(a,c);return m(w(e.n,this.n)*w(e.d,this.d),e.d*this.d)},lcm:function(a,c){n(a,c);return 0===e.n&&0===this.n?m(0,1):m(e.n*this.n,w(e.n,this.n)*w(e.d,this.d))},ceil:function(a){a=Math.pow(10,a||0);return isNaN(this.n)||isNaN(this.d)?new p(NaN):m(Math.ceil(a*this.s*this.n/this.d),a)},floor:function(a){a=Math.pow(10,
+a||0);return isNaN(this.n)||isNaN(this.d)?new p(NaN):m(Math.floor(a*this.s*this.n/this.d),a)},round:function(a){a=Math.pow(10,a||0);return isNaN(this.n)||isNaN(this.d)?new p(NaN):m(Math.round(a*this.s*this.n/this.d),a)},roundTo:function(a,c){n(a,c);return m(this.s*Math.round(this.n*e.d/(this.d*e.n))*e.n,e.d)},inverse:function(){return m(this.s*this.d,this.n)},pow:function(a,c){n(a,c);if(1===e.d)return 0>e.s?m(Math.pow(this.s*this.d,e.n),Math.pow(this.n,e.n)):m(Math.pow(this.s*this.n,e.n),Math.pow(this.d,
+e.n));if(0>this.s)return null;var b=A(this.n),d=A(this.d),f=1,l=1,k;for(k in b)if("1"!==k){if("0"===k){f=0;break}b[k]*=e.n;if(0===b[k]%e.d)b[k]/=e.d;else return null;f*=Math.pow(k,b[k])}for(k in d)if("1"!==k){d[k]*=e.n;if(0===d[k]%e.d)d[k]/=e.d;else return null;l*=Math.pow(k,d[k])}return 0>e.s?m(l,f):m(f,l)},equals:function(a,c){n(a,c);return this.s*this.n*e.d===e.s*e.n*this.d},compare:function(a,c){n(a,c);var b=this.s*this.n*e.d-e.s*e.n*this.d;return(0<b)-(0>b)},simplify:function(a){if(isNaN(this.n)||
+isNaN(this.d))return this;a=a||.001;for(var c=this.abs(),b=c.toContinued(),d=1;d<b.length;d++){for(var f=m(b[d-1],1),l=d-2;0<=l;l--)f=f.inverse().add(b[l]);if(Math.abs(f.sub(c).valueOf())<a)return f.mul(this.s)}return this},divisible:function(a,c){n(a,c);return!(!(e.n*this.d)||this.n*e.d%(e.n*this.d))},valueOf:function(){return this.s*this.n/this.d},toFraction:function(a){var c,b="",d=this.n,f=this.d;0>this.s&&(b+="-");1===f?b+=d:(a&&0<(c=Math.floor(d/f))&&(b=b+c+" ",d%=f),b=b+d+"/",b+=f);return b},
+toLatex:function(a){var c,b="",d=this.n,f=this.d;0>this.s&&(b+="-");1===f?b+=d:(a&&0<(c=Math.floor(d/f))&&(b+=c,d%=f),b=b+"\\frac{"+d+"}{"+f,b+="}");return b},toContinued:function(){var a=this.n,c=this.d,b=[];if(isNaN(a)||isNaN(c))return b;do{b.push(Math.floor(a/c));var d=a%c;a=c;c=d}while(1!==a);return b},toString:function(a){var c=this.n,b=this.d;if(isNaN(c)||isNaN(b))return"NaN";var d;a:{for(d=b;0===d%2;d/=2);for(;0===d%5;d/=5);if(1===d)d=0;else{for(var f=10%d,l=1;1!==f;l++)if(f=10*f%d,2E3<l){d=
+0;break a}d=l}}a:{f=1;l=10;for(var k=d,t=1;0<k;l=l*l%b,k>>=1)k&1&&(t=t*l%b);l=t;for(k=0;300>k;k++){if(f===l){l=k;break a}f=10*f%b;l=10*l%b}l=0}f=0>this.s?"-":"";f+=c/b|0;(c=c%b*10)&&(f+=".");if(d){for(a=l;a--;)f+=c/b|0,c%=b,c*=10;f+="(";for(a=d;a--;)f+=c/b|0,c%=b,c*=10;f+=")"}else for(a=a||15;c&&a--;)f+=c/b|0,c%=b,c*=10;return f}};"object"===typeof exports?(Object.defineProperty(exports,"__esModule",{value:!0}),exports["default"]=p,module.exports=p):B.Fraction=p})(this);
\ No newline at end of file
diff --git a/node_modules/fraction.js/package.json b/node_modules/fraction.js/package.json
new file mode 100644
index 0000000..085d287
--- /dev/null
+++ b/node_modules/fraction.js/package.json
@@ -0,0 +1,55 @@
+{
+  "name": "fraction.js",
+  "title": "fraction.js",
+  "version": "4.3.7",
+  "homepage": "https://www.xarg.org/2014/03/rational-numbers-in-javascript/",
+  "bugs": "https://github.com/rawify/Fraction.js/issues",
+  "description": "A rational number library",
+  "keywords": [
+    "math",
+    "fraction",
+    "rational",
+    "rationals",
+    "number",
+    "parser",
+    "rational numbers"
+  ],
+  "author": {
+    "name": "Robert Eisele",
+    "email": "robert@raw.org",
+    "url": "https://raw.org/"
+  },
+  "type": "module",
+  "main": "fraction.cjs",
+  "exports": {
+    ".": {
+      "import": "./fraction.js",
+      "require": "./fraction.cjs",
+      "types": "./fraction.d.ts"
+    }
+  },
+  "types": "./fraction.d.ts",
+  "private": false,
+  "readmeFilename": "README.md",
+  "directories": {
+    "example": "examples"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/rawify/Fraction.js.git"
+  },
+  "funding": {
+    "type": "patreon",
+    "url": "https://github.com/sponsors/rawify"
+  },
+  "engines": {
+    "node": "*"
+  },
+  "scripts": {
+    "test": "mocha tests/*.js"
+  },
+  "devDependencies": {
+    "mocha": "*"
+  }
+}