diff --git a/fraction.js b/fraction.js
deleted file mode 100644
index fec06120..00000000
--- a/fraction.js
+++ /dev/null
@@ -1,908 +0,0 @@
-/**
- * @license Fraction.js v4.1.2 23/05/2021
- * https://www.xarg.org/2014/03/rational-numbers-in-javascript/
- *
- * Copyright (c) 2021, Robert Eisele (robert@xarg.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 => <nominator>, 1 => <denominator> ]
- * [ n => <nominator>, 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);
- *
- */
-
- const memo = {};
-
- let 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 createError(name) {
- 
-     function errorConstructor() {
-       var temp = Error.apply(this, arguments);
-       temp['name'] = this['name'] = name;
-       this['stack'] = temp['stack'];
-       this['message'] = temp['message'];
-     }
- 
-     /**
-      * Error constructor
-      *
-      * @constructor
-      */
-     function IntermediateInheritor() { }
-     IntermediateInheritor.prototype = Error.prototype;
-     errorConstructor.prototype = new IntermediateInheritor();
- 
-     return errorConstructor;
-   }
- 
-   var DivisionByZero = Fraction['DivisionByZero'] = createError('DivisionByZero');
-   var InvalidParameter = Fraction['InvalidParameter'] = createError('InvalidParameter');
- 
-   function assign(n, s) {
- 
-     if (isNaN(n = parseInt(n, 10))) {
-       throwInvalidParam();
-     }
-     return n * s;
-   }
- 
-   function throwInvalidParam() {
-     throw new InvalidParameter();
-   }
- 
-   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;
-     } 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 {
-               throwInvalidParam();
-             }
-             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;
-               }
-
-               const key = p1+'#'+p2
-              const memoized = memo[key]
-              if(memoized) {
-                s = memoized.s;
-                n = memoized.n;
-                d = memoized.d;
-                break;
-              }
- 
-               // 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)
-               throwInvalidParam();
- 
-             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:
-           throwInvalidParam();
-       }
- 
-     if (d === 0) {
-       throw new DivisionByZero();
-     }
- 
-     P["s"] = s < 0 ? -1 : 1;
-     P["n"] = Math.abs(n);
-     P["d"] = Math.abs(d);
-     memo[p1+'#'+p2] = {s:P["s"],n:P["n"],d:P["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) {
- 
-     if (!(this instanceof Fraction)) {
-       return new Fraction(a, b);
-     }
- 
-     parse(a, b);
- 
-     a = gcd(P["d"], P["n"]); // Abuse variable a
- 
-     this["s"] = P["s"];
-     this["n"] = P["n"] / a;
-     this["d"] = P["d"] / a;
-   }
- 
-   Fraction.prototype = {
- 
-     "s": 1,
-     "n": 0,
-     "d": 1,
- 
-     /**
-      * Calculates the absolute value
-      *
-      * Ex: new Fraction(-4).abs() => 4
-      **/
-     "abs": function() {
- 
-       return new Fraction(this["n"], this["d"]);
-     },
- 
-     /**
-      * Inverts the sign of the current fraction
-      *
-      * Ex: new Fraction(-4).neg() => 4
-      **/
-     "neg": function() {
- 
-       return new Fraction(-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 new Fraction(
-         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 new Fraction(
-         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 new Fraction(
-         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 new Fraction(
-         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 new Fraction(this);
-     },
- 
-     /**
-      * 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 new Fraction(this["s"] * this["n"] % this["d"], 1);
-       }
- 
-       parse(a, b);
-       if (0 === P["n"] && 0 === this["d"]) {
-         Fraction(0, 0); // 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 new Fraction(
-         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 new Fraction(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 new Fraction;
-       }
-       return new Fraction(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 new Fraction(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 new Fraction(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 new Fraction(Math.round(places * this["s"] * this["n"] / this["d"]), places);
-     },
- 
-     /**
-      * Gets the inverse of the fraction, means numerator and denominator are exchanged
-      *
-      * Ex: new Fraction([-3, 4]).inverse() => -4 / 3
-      **/
-     "inverse": function() {
- 
-       return new Fraction(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 new Fraction(Math.pow(this['s'] * this["d"], P['n']), Math.pow(this["n"], P['n']));
-         } else {
-           return new Fraction(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 new Fraction(d, n);
-       }
-       return new Fraction(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) {
- 
-       // First naive implementation, needs improvement
- 
-       if (isNaN(this['n']) || isNaN(this['d'])) {
-         return this;
-       }
- 
-       var cont = this['abs']()['toContinued']();
- 
-       eps = eps || 0.001;
- 
-       function rec(a) {
-         if (a.length === 1)
-           return new Fraction(a[0]);
-         return rec(a.slice(1))['inverse']()['add'](a[0]);
-       }
- 
-       for (var i = 0; i < cont.length; i++) {
-         var tmp = rec(cont.slice(0, i + 1));
-         if (tmp['sub'](this['abs']())['abs']().valueOf() < eps) {
-           return tmp['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() => "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 g;
-       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'] === -1 ? "-" : "";
- 
-       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 define === "function" && define["amd"]) {
-     define([], function() {
-       return Fraction;
-     });
-   } else if (typeof exports === "object") {
-     Object.defineProperty(Fraction, "__esModule", { 'value': true });
-     Fraction['default'] = Fraction;
-     Fraction['Fraction'] = Fraction;
-     module['exports'] = Fraction;
-   } else {
-     root['Fraction'] = Fraction;
-   }
- 
- 
-  export default Fraction;
\ No newline at end of file
diff --git a/fraction.mjs b/fraction.mjs
new file mode 100644
index 00000000..f95ee90a
--- /dev/null
+++ b/fraction.mjs
@@ -0,0 +1,84 @@
+import Fraction from 'fraction.js';
+import { TimeSpan } from './strudel.mjs';
+
+// Returns the start of the cycle.
+Fraction.prototype.sam = function () {
+  return this.floor();
+};
+
+// Returns the start of the next cycle.
+Fraction.prototype.nextSam = function () {
+  return this.sam().add(1);
+};
+
+// Returns a TimeSpan representing the begin and end of the Time value's cycle
+Fraction.prototype.wholeCycle = function () {
+  return new TimeSpan(this.sam(), this.nextSam());
+};
+
+Fraction.prototype.lt = function (other) {
+  return this.compare(other) < 0;
+};
+
+Fraction.prototype.gt = function (other) {
+  return this.compare(other) > 0;
+};
+
+Fraction.prototype.lte = function (other) {
+  return this.compare(other) <= 0;
+};
+
+Fraction.prototype.gte = function (other) {
+  return this.compare(other) >= 0;
+};
+
+Fraction.prototype.eq = function (other) {
+  return this.compare(other) == 0;
+};
+
+Fraction.prototype.max = function (other) {
+  return this.gt(other) ? this : other;
+};
+
+Fraction.prototype.min = function (other) {
+  return this.lt(other) ? this : other;
+};
+
+Fraction.prototype.show = function () {
+  return this.s * this.n + '/' + this.d;
+};
+
+Fraction.prototype.or = function (other) {
+  return this.eq(0) ? other : this;
+};
+
+const fraction = (n) => {
+  if (typeof n === 'number') {
+    /*
+    https://github.com/infusion/Fraction.js/#doubles
+    „If you pass a double as it is, Fraction.js will perform a number analysis based on Farey Sequences."
+    „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“
+    
+    -> those farey sequences turn out to make pattern querying ~20 times slower! always use strings!
+    -> still, some optimizations could be done: .mul .div .add .sub calls still use numbers
+    */
+    n = String(n);
+  }
+  return Fraction(n);
+};
+
+export default fraction;
+
+// "If you concern performance, cache Fraction.js objects and pass arrays/objects.“
+// -> tested memoized version, but it's slower than unmemoized, even with repeated evaluation
+/* const memo = {};
+const memoizedFraction = (n) => {
+  if (typeof n === 'number') {
+    n = String(n);
+  }
+  if (memo[n] !== undefined) {
+    return memo[n];
+  }
+  memo[n] = Fraction(n);
+  return memo[n];
+}; */
diff --git a/repl/src/euclid.mjs b/repl/src/euclid.mjs
index a395d42d..208254d9 100644
--- a/repl/src/euclid.mjs
+++ b/repl/src/euclid.mjs
@@ -1,7 +1,7 @@
 import { Pattern, timeCat } from '../../strudel.mjs';
 import bjork from 'bjork';
 import { rotate } from '../../util.mjs';
-import Fraction from 'fraction.js';
+import Fraction from '../../fraction.js';
 
 const euclid = (pulses, steps, rotation = 0) => {
   const b = bjork(steps, pulses);
diff --git a/repl/src/parse.ts b/repl/src/parse.ts
index 87cf6edd..215c5a3c 100644
--- a/repl/src/parse.ts
+++ b/repl/src/parse.ts
@@ -12,7 +12,7 @@ const applyOptions = (parent: any) => (pat: any, i: number) => {
   if (operator) {
     switch (operator.type_) {
       case 'stretch':
-        const speed = new Fraction(operator.arguments_.amount).inverse();
+        const speed = Fraction(operator.arguments_.amount).inverse();
         return reify(pat).fast(speed);
       case 'bjorklund':
         return pat.euclid(operator.arguments_.pulse, operator.arguments_.step, operator.arguments_.rotation);
@@ -56,7 +56,7 @@ function resolveReplications(ast) {
               options_: {
                 operator: {
                   type_: 'stretch',
-                  arguments_: { amount: new Fraction(replicate).inverse().toString() },
+                  arguments_: { amount: Fraction(replicate).inverse().toString() },
                 },
               },
             },
diff --git a/strudel.mjs b/strudel.mjs
index 9500102a..8efc8c69 100644
--- a/strudel.mjs
+++ b/strudel.mjs
@@ -1,4 +1,4 @@
-import Fraction from './fraction.js'
+import Fraction from './fraction.mjs'
 import { compose } from 'ramda'; // will remove this as soon as compose is implemented here
 import { isNote, toMidi } from './util.mjs';
 
@@ -30,57 +30,6 @@ export function curry(func, overload) {
     return fn;
 }
 
-// Returns the start of the cycle.
-Fraction.prototype.sam = function() {
-    return this.floor();
-}
-
-// Returns the start of the next cycle.
-Fraction.prototype.nextSam = function() {
-    return this.sam().add(1)
-}
-
-// Returns a TimeSpan representing the begin and end of the Time value's cycle
-Fraction.prototype.wholeCycle = function() {
-    return new TimeSpan(this.sam(), this.nextSam())
-}
-
-Fraction.prototype.lt = function(other) {
-    return this.compare(other) < 0
-}
-
-Fraction.prototype.gt = function(other) {
-    return this.compare(other) > 0
-}
-
-Fraction.prototype.lte = function(other) {
-    return this.compare(other) <= 0
-}
-
-Fraction.prototype.gte = function(other) {
-    return this.compare(other) >= 0
-}
-
-Fraction.prototype.eq = function(other) {
-    return this.compare(other) == 0
-}
-
-Fraction.prototype.max = function(other) {
-    return this.gt(other) ? this : other
-}
-
-Fraction.prototype.min = function(other) {
-    return this.lt(other) ? this : other
-}
-
-Fraction.prototype.show = function () {
-    return (this.s * this.n) + "/" + this.d
-}
-
-Fraction.prototype.or = function(other) {
-    return this.eq(0) ? other : this
-}
-
 class TimeSpan {
     constructor(begin, end) {
         this.begin = Fraction(begin)