math-exercises 1.3.52 → 1.3.53

package/lib/tree/nodes/operators/substractNode.js

@@ -1,28 +1,28 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SubstractNode = void 0;
-const mathjs_1 = require("mathjs");
-const node_1 = require("../node");
-const operatorNode_1 = require("./operatorNode");
-class SubstractNode extends operatorNode_1.OperatorNode {
-    constructor(leftChild, rightChild) {
-        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
-    }
-    toMathString() {
-        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
-    }
-    toTex() {
-        let rightTex = this.rightChild.toTex();
-        let leftTex = this.leftChild.toTex();
-        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
-            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
-            rightTex[0] === '-';
-        if (needBrackets)
-            rightTex = `(${rightTex})`;
-        return `${leftTex} - ${rightTex}`;
-    }
-    toMathjs() {
-        return (0, mathjs_1.subtract)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
-    }
-}
-exports.SubstractNode = SubstractNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubstractNode = void 0;
+const mathjs_1 = require("mathjs");
+const node_1 = require("../node");
+const operatorNode_1 = require("./operatorNode");
+class SubstractNode extends operatorNode_1.OperatorNode {
+    constructor(leftChild, rightChild) {
+        super(operatorNode_1.OperatorIds.substract, leftChild, rightChild, false, '-');
+    }
+    toMathString() {
+        return `${this.leftChild.toMathString()}-(${this.rightChild.toMathString()})`;
+    }
+    toTex() {
+        let rightTex = this.rightChild.toTex();
+        let leftTex = this.leftChild.toTex();
+        const needBrackets = (this.rightChild.type === node_1.NodeType.operator &&
+            [operatorNode_1.OperatorIds.add, operatorNode_1.OperatorIds.substract].includes(this.rightChild.id)) ||
+            rightTex[0] === '-';
+        if (needBrackets)
+            rightTex = `(${rightTex})`;
+        return `${leftTex} - ${rightTex}`;
+    }
+    toMathjs() {
+        return (0, mathjs_1.subtract)(this.leftChild.toMathjs(), this.rightChild.toMathjs());
+    }
+}
+exports.SubstractNode = SubstractNode;

package/lib/tree/nodes/variables/variableNode.d.ts

@@ -1,10 +1,10 @@
-import { Node, NodeType } from '../node';
-export declare class VariableNode implements Node {
-    name: string;
-    type: NodeType;
-    constructor(name: string);
-    toTex(): string;
-    toMathString(): string;
-    toMathjs(): string;
-}
+import { Node, NodeType } from '../node';
+export declare class VariableNode implements Node {
+    name: string;
+    type: NodeType;
+    constructor(name: string);
+    toTex(): string;
+    toMathString(): string;
+    toMathjs(): string;
+}
 //# sourceMappingURL=variableNode.d.ts.map

package/lib/tree/nodes/variables/variableNode.js

@@ -1,20 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariableNode = void 0;
-const node_1 = require("../node");
-class VariableNode {
-    constructor(name) {
-        this.type = node_1.NodeType.variable;
-        this.name = name;
-    }
-    toTex() {
-        return `${this.name}`;
-    }
-    toMathString() {
-        return `${this.name}`;
-    }
-    toMathjs() {
-        return this.name;
-    }
-}
-exports.VariableNode = VariableNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableNode = void 0;
+const node_1 = require("../node");
+class VariableNode {
+    constructor(name) {
+        this.type = node_1.NodeType.variable;
+        this.name = name;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toMathString() {
+        return `${this.name}`;
+    }
+    toMathjs() {
+        return this.name;
+    }
+}
+exports.VariableNode = VariableNode;

package/lib/tree/parsers/derivateParser.js

@@ -1,62 +1,62 @@
-"use strict";
-// import { Node, NodeType } from "../nodes/node";
-// import { NumberNode } from "../nodes/numbers/numberNode";
-// import { PowerNode } from "../nodes/operators/powerNode";
-// import { AddNode } from "../nodes/operators/addNode";
-// import { FractionNode } from "../nodes/operators/fractionNode";
-// import { MultiplyNode } from "../nodes/operators/multiplyNode";
-// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
-// import { SubstractNode } from "../nodes/operators/substractNode";
-// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
-// import { SqrtNode } from "../nodes/functions/sqrtNode";
-// import { OppositeNode } from "../nodes/functions/oppositeNode";
-// export function derivateParser(node: Node): Node {
-//   if (!node) throw Error("encountered a null node ??");
-//   switch (node.type) {
-//     case NodeType.variable:
-//       return new NumberNode(1);
-//     case NodeType.number:
-//       return new NumberNode(0);
-//     case NodeType.operator:
-//       const operatorNode = node as OperatorNode;
-//       const u = operatorNode.leftChild;
-//       const v = operatorNode.rightChild;
-//       switch (operatorNode.id) {
-//         case OperatorIds.add:
-//           return new AddNode(derivateParser(u), derivateParser(v));
-//         case OperatorIds.substract: {
-//           return new SubstractNode(derivateParser(u), derivateParser(v));
-//         }
-//         case OperatorIds.multiply: {
-//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
-//         }
-//         case OperatorIds.divide:
-//         case OperatorIds.fraction:
-//           return new FractionNode(
-//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
-//             new PowerNode(v, new NumberNode(2))
-//           );
-//         case OperatorIds.power: {
-//           const operatorNode = node as OperatorNode;
-//           const n = operatorNode.rightChild as NumberNode;
-//           const u = operatorNode.leftChild;
-//           return new MultiplyNode(
-//             n,
-//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
-//           );
-//         }
-//       }
-//     case NodeType.function: {
-//       const functionNode = node as FunctionNode;
-//       const child = functionNode.child;
-//       switch (functionNode.id) {
-//         case FunctionsIds.sqrt: {
-//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
-//         }
-//         case FunctionsIds.opposite: {
-//           return new OppositeNode(derivateParser(child));
-//         }
-//       }
-//     }
-//   }
-// }
+"use strict";
+// import { Node, NodeType } from "../nodes/node";
+// import { NumberNode } from "../nodes/numbers/numberNode";
+// import { PowerNode } from "../nodes/operators/powerNode";
+// import { AddNode } from "../nodes/operators/addNode";
+// import { FractionNode } from "../nodes/operators/fractionNode";
+// import { MultiplyNode } from "../nodes/operators/multiplyNode";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// import { SubstractNode } from "../nodes/operators/substractNode";
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { SqrtNode } from "../nodes/functions/sqrtNode";
+// import { OppositeNode } from "../nodes/functions/oppositeNode";
+// export function derivateParser(node: Node): Node {
+//   if (!node) throw Error("encountered a null node ??");
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return new NumberNode(1);
+//     case NodeType.number:
+//       return new NumberNode(0);
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       const u = operatorNode.leftChild;
+//       const v = operatorNode.rightChild;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return new AddNode(derivateParser(u), derivateParser(v));
+//         case OperatorIds.substract: {
+//           return new SubstractNode(derivateParser(u), derivateParser(v));
+//         }
+//         case OperatorIds.multiply: {
+//           return new AddNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v)));
+//         }
+//         case OperatorIds.divide:
+//         case OperatorIds.fraction:
+//           return new FractionNode(
+//             new SubstractNode(new MultiplyNode(derivateParser(u), v), new MultiplyNode(u, derivateParser(v))),
+//             new PowerNode(v, new NumberNode(2))
+//           );
+//         case OperatorIds.power: {
+//           const operatorNode = node as OperatorNode;
+//           const n = operatorNode.rightChild as NumberNode;
+//           const u = operatorNode.leftChild;
+//           return new MultiplyNode(
+//             n,
+//             new MultiplyNode(derivateParser(u), new PowerNode(u, new NumberNode(n.value - 1)))
+//           );
+//         }
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return new FractionNode(derivateParser(child), new MultiplyNode(new NumberNode(2), new SqrtNode(child)));
+//         }
+//         case FunctionsIds.opposite: {
+//           return new OppositeNode(derivateParser(child));
+//         }
+//       }
+//     }
+//   }
+// }

package/lib/tree/parsers/latexParser.js

@@ -0,0 +1,110 @@
+"use strict";
+// import { FunctionNode, FunctionsIds } from "../nodes/functions/functionNode";
+// import { Node, NodeType } from "../nodes/node";
+// import { OperatorIds, OperatorNode } from "../nodes/operators/operatorNode";
+// export function latexParser(node: Node): string {
+//   if (!node) {
+//     console.log("parsing a null node ???");
+//     return "";
+//   }
+//   switch (node.type) {
+//     case NodeType.variable:
+//       return node.tex;
+//     case NodeType.number:
+//       return node.tex;
+//     case NodeType.operator:
+//       const operatorNode = node as OperatorNode;
+//       let rightTex = latexParser(operatorNode.rightChild);
+//       let leftTex = latexParser(operatorNode.leftChild);
+//       const { leftChild, rightChild } = operatorNode;
+//       switch (operatorNode.id) {
+//         case OperatorIds.add:
+//           return `${leftTex} ${rightTex[0] === "-" ? "" : "+ "}${rightTex}`;
+//         case OperatorIds.substract: {
+//           const needBrackets =
+//             (rightChild.type === NodeType.operator &&
+//               [OperatorIds.add, OperatorIds.substract].includes((rightChild as OperatorNode).id)) ||
+//             rightTex[0] === "-";
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} - ${rightTex}`;
+//         }
+//         case OperatorIds.multiply: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.divide].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           //  permet de gérer le cas 3*2^x
+//           let showTimesSign = !isNaN(+rightTex[0]) || rightChild.type === NodeType.number;
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             showTimesSign ||= [OperatorIds.fraction].includes(operatorRightChild.id);
+//           }
+//           return `${leftTex}${showTimesSign ? "\\times " : ""}${rightTex}`;
+//         }
+//         case OperatorIds.divide: {
+//           if (leftChild.type === NodeType.operator) {
+//             if ([OperatorIds.add, OperatorIds.substract, OperatorIds.multiply].includes((leftChild as OperatorNode).id))
+//               leftTex = `(${leftTex})`;
+//           }
+//           let needBrackets = rightTex[0] === "-";
+//           if (rightChild.type === NodeType.operator) {
+//             const operatorRightChild = rightChild as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorRightChild.id);
+//           }
+//           if (needBrackets) rightTex = `(${rightTex})`;
+//           return `${leftTex} \\div ${rightTex}`;
+//         }
+//         case OperatorIds.fraction: {
+//           return `\\frac{${leftTex}}{${rightTex}}`;
+//         }
+//         case OperatorIds.power: {
+//           let needBrackets = leftTex[0] === "-";
+//           if (leftChild.type === NodeType.operator) {
+//             const childOperator = leftChild as OperatorNode;
+//             needBrackets ||= [
+//               OperatorIds.add,
+//               OperatorIds.substract,
+//               OperatorIds.multiply,
+//               OperatorIds.divide,
+//               OperatorIds.fraction,
+//               OperatorIds.power,
+//             ].includes(childOperator.id);
+//           }
+//           if (needBrackets) leftTex = `(${leftTex})`;
+//           return `${leftTex}^{${rightTex}}`;
+//         }
+//         case OperatorIds.equal: {
+//           return `${leftTex} = ${rightTex}`;
+//         }
+//         default:
+//           return node.tex;
+//       }
+//     case NodeType.function: {
+//       const functionNode = node as FunctionNode;
+//       const child = functionNode.child;
+//       let childTex = latexParser(functionNode.child);
+//       switch (functionNode.id) {
+//         case FunctionsIds.sqrt: {
+//           return `\\sqrt{${childTex}}`;
+//         }
+//         case FunctionsIds.opposite: {
+//           let needBrackets = childTex[0] === "-";
+//           if (child.type === NodeType.operator) {
+//             const operatorChild = child as OperatorNode;
+//             needBrackets ||= [OperatorIds.add, OperatorIds.substract].includes(operatorChild.id);
+//           }
+//           if (needBrackets) childTex = `(${childTex})`;
+//           return `-${childTex}`;
+//         }
+//       }
+//     }
+//     default:
+//       return "";
+//   }
+// }

package/lib/tree/parsers/simplify.d.ts

@@ -1,4 +1,4 @@
-import { Node } from '../nodes/node';
-export declare const simplifyComplex: (node: Node) => Node;
-export declare const simplifyNode: (node: Node) => Node;
+import { Node } from '../nodes/node';
+export declare const simplifyComplex: (node: Node) => Node;
+export declare const simplifyNode: (node: Node) => Node;
 //# sourceMappingURL=simplify.d.ts.map

package/lib/tree/parsers/simplify.js

@@ -1,73 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.simplifyNode = exports.simplifyComplex = void 0;
-const mathjs_1 = require("mathjs");
-const oppositeNode_1 = require("../nodes/functions/oppositeNode");
-const sqrtNode_1 = require("../nodes/functions/sqrtNode");
-const numberNode_1 = require("../nodes/numbers/numberNode");
-const piNode_1 = require("../nodes/numbers/piNode");
-const addNode_1 = require("../nodes/operators/addNode");
-const fractionNode_1 = require("../nodes/operators/fractionNode");
-const multiplyNode_1 = require("../nodes/operators/multiplyNode");
-const powerNode_1 = require("../nodes/operators/powerNode");
-const substractNode_1 = require("../nodes/operators/substractNode");
-const variableNode_1 = require("../nodes/variables/variableNode");
-const logNode_1 = require("../nodes/functions/logNode");
-const expNode_1 = require("../nodes/functions/expNode");
-const cosNode_1 = require("../../tree/nodes/functions/cosNode");
-const sinNode_1 = require("../../tree/nodes/functions/sinNode");
-const complexNode_1 = require("../nodes/complex/complexNode");
-const simplifyComplex = (node) => {
-    return mathjsComplexToNode((0, mathjs_1.complex)(node.toMathjs()));
-};
-exports.simplifyComplex = simplifyComplex;
-const mathjsComplexToNode = (complex) => {
-    return new complexNode_1.ComplexNode(complex.re, complex.im);
-};
-const simplifyNode = (node) => {
-    return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
-};
-exports.simplifyNode = simplifyNode;
-const mathjsNodeToNode = (mathjsNode) => {
-    if (mathjsNode.isSymbolNode) {
-        if (mathjsNode.name === 'pi')
-            return piNode_1.PiNode;
-        return new variableNode_1.VariableNode(mathjsNode.name);
-    }
-    else if (mathjsNode.isConstantNode) {
-        return new numberNode_1.NumberNode(mathjsNode.value);
-    }
-    else if (mathjsNode.isOperatorNode) {
-        switch (mathjsNode.fn) {
-            case 'add':
-                return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'subtract':
-                return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'unaryMinus':
-                return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'divide':
-                return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'multiply':
-                return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-            case 'pow':
-                return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
-        }
-    }
-    else if (mathjsNode.isFunctionNode) {
-        const fn = mathjsNode.fn;
-        switch (fn.name) {
-            case 'sqrt':
-                return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'log':
-                return new logNode_1.LogNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'exp':
-                return new expNode_1.ExpNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'cos':
-                return new cosNode_1.CosNode(mathjsNodeToNode(mathjsNode.args[0]));
-            case 'sin':
-                return new sinNode_1.SinNode(mathjsNodeToNode(mathjsNode.args[0]));
-        }
-    }
-    console.log(mathjsNode);
-    throw Error('unrecognized mathjs node');
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifyNode = exports.simplifyComplex = void 0;
+const mathjs_1 = require("mathjs");
+const oppositeNode_1 = require("../nodes/functions/oppositeNode");
+const sqrtNode_1 = require("../nodes/functions/sqrtNode");
+const numberNode_1 = require("../nodes/numbers/numberNode");
+const piNode_1 = require("../nodes/numbers/piNode");
+const addNode_1 = require("../nodes/operators/addNode");
+const fractionNode_1 = require("../nodes/operators/fractionNode");
+const multiplyNode_1 = require("../nodes/operators/multiplyNode");
+const powerNode_1 = require("../nodes/operators/powerNode");
+const substractNode_1 = require("../nodes/operators/substractNode");
+const variableNode_1 = require("../nodes/variables/variableNode");
+const logNode_1 = require("../nodes/functions/logNode");
+const expNode_1 = require("../nodes/functions/expNode");
+const cosNode_1 = require("../../tree/nodes/functions/cosNode");
+const sinNode_1 = require("../../tree/nodes/functions/sinNode");
+const complexNode_1 = require("../nodes/complex/complexNode");
+const simplifyComplex = (node) => {
+    return mathjsComplexToNode((0, mathjs_1.complex)(node.toMathjs()));
+};
+exports.simplifyComplex = simplifyComplex;
+const mathjsComplexToNode = (complex) => {
+    return new complexNode_1.ComplexNode(complex.re, complex.im);
+};
+const simplifyNode = (node) => {
+    return mathjsNodeToNode((0, mathjs_1.simplify)(node.toMathString()));
+};
+exports.simplifyNode = simplifyNode;
+const mathjsNodeToNode = (mathjsNode) => {
+    if (mathjsNode.isSymbolNode) {
+        if (mathjsNode.name === 'pi')
+            return piNode_1.PiNode;
+        return new variableNode_1.VariableNode(mathjsNode.name);
+    }
+    else if (mathjsNode.isConstantNode) {
+        return new numberNode_1.NumberNode(mathjsNode.value);
+    }
+    else if (mathjsNode.isOperatorNode) {
+        switch (mathjsNode.fn) {
+            case 'add':
+                return new addNode_1.AddNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'subtract':
+                return new substractNode_1.SubstractNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'unaryMinus':
+                return new oppositeNode_1.OppositeNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'divide':
+                return new fractionNode_1.FractionNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'multiply':
+                return new multiplyNode_1.MultiplyNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+            case 'pow':
+                return new powerNode_1.PowerNode(mathjsNodeToNode(mathjsNode.args[0]), mathjsNodeToNode(mathjsNode.args[1]));
+        }
+    }
+    else if (mathjsNode.isFunctionNode) {
+        const fn = mathjsNode.fn;
+        switch (fn.name) {
+            case 'sqrt':
+                return new sqrtNode_1.SqrtNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'log':
+                return new logNode_1.LogNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'exp':
+                return new expNode_1.ExpNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'cos':
+                return new cosNode_1.CosNode(mathjsNodeToNode(mathjsNode.args[0]));
+            case 'sin':
+                return new sinNode_1.SinNode(mathjsNodeToNode(mathjsNode.args[0]));
+        }
+    }
+    console.log(mathjsNode);
+    throw Error('unrecognized mathjs node');
+};

package/lib/utils/arrayEqual.d.ts

@@ -1,2 +1,2 @@
-export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
+export declare function arrayEqual<T>(arr1: T[], arr2: T[]): boolean;
 //# sourceMappingURL=arrayEqual.d.ts.map

package/lib/utils/arrayEqual.js

@@ -1,13 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayEqual = void 0;
-function arrayEqual(arr1, arr2) {
-    if (arr1.length !== arr2.length)
-        return false;
-    for (let i = 0; i < arr1.length; i++) {
-        if (arr1[i] !== arr2[i])
-            return false;
-    }
-    return true;
-}
-exports.arrayEqual = arrayEqual;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayEqual = void 0;
+function arrayEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length)
+        return false;
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i])
+            return false;
+    }
+    return true;
+}
+exports.arrayEqual = arrayEqual;

package/lib/utils/coin.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coin = void 0;
+const coin = () => {
+    return Math.random() < 0.5;
+};
+exports.coin = coin;

package/lib/utils/coinFlip.d.ts

@@ -1,2 +1,2 @@
-export declare const coinFlip: () => Boolean;
+export declare const coinFlip: () => Boolean;
 //# sourceMappingURL=coinFlip.d.ts.map

package/lib/utils/coinFlip.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.coinFlip = void 0;
-const coinFlip = () => {
-    return Math.random() < 0.5;
-};
-exports.coinFlip = coinFlip;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coinFlip = void 0;
+const coinFlip = () => {
+    return Math.random() < 0.5;
+};
+exports.coinFlip = coinFlip;

package/lib/utils/diceFlip.d.ts

@@ -1,2 +1,2 @@
-export declare const diceFlip: (faces: number) => number;
+export declare const diceFlip: (faces: number) => number;
 //# sourceMappingURL=diceFlip.d.ts.map

package/lib/utils/diceFlip.js

@@ -1,12 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.diceFlip = void 0;
-const random_1 = require("./random");
-const diceFlip = (faces) => {
-    const arr = [];
-    for (let i = 0; i < faces; i++) {
-        arr.push(i);
-    }
-    return (0, random_1.random)(arr);
-};
-exports.diceFlip = diceFlip;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diceFlip = void 0;
+const random_1 = require("./random");
+const diceFlip = (faces) => {
+    const arr = [];
+    for (let i = 0; i < faces; i++) {
+        arr.push(i);
+    }
+    return (0, random_1.random)(arr);
+};
+exports.diceFlip = diceFlip;

package/lib/utils/random.d.ts

@@ -1,2 +1,2 @@
-export declare function random<t>(array: t[]): t;
+export declare function random<t>(array: t[]): t;
 //# sourceMappingURL=random.d.ts.map

package/lib/utils/random.js

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.random = void 0;
-function random(array) {
-    return array[Math.floor(Math.random() * array.length)];
-}
-exports.random = random;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.random = void 0;
+function random(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+exports.random = random;

package/lib/utils/shuffle.d.ts

@@ -1,2 +1,2 @@
-export declare function shuffle<T>(array: T[]): T[];
+export declare function shuffle<T>(array: T[]): T[];
 //# sourceMappingURL=shuffle.d.ts.map