summaryrefslogtreecommitdiff
path: root/node_modules/fraction.js
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/fraction.js')
-rw-r--r--node_modules/fraction.js/LICENSE21
-rw-r--r--node_modules/fraction.js/README.md466
-rw-r--r--node_modules/fraction.js/bigfraction.js899
-rw-r--r--node_modules/fraction.js/fraction.cjs904
-rw-r--r--node_modules/fraction.js/fraction.d.ts60
-rw-r--r--node_modules/fraction.js/fraction.js891
-rw-r--r--node_modules/fraction.js/fraction.min.js18
-rw-r--r--node_modules/fraction.js/package.json55
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": "*"
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-06 08:38:39 +0000