math-exercises 3.0.216 → 3.0.218

package/lib/exercises/math/squareRoots/squareRootEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"squareRootEquation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootEquation.js

@@ -1,11 +1,10 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { equationVEA } from "../../../exercises/vea/equationVEA.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { EquationSolutionNode } from "../../../tree/nodes/equations/equationSolutionNode.js";
-import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { square } from "../../../tree/nodes/operators/powerNode.js";
-import { DiscreteSetNode, EmptySet, } from "../../../tree/nodes/sets/discreteSetNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { k } = identifiers;
     return `Résoudre l'équation suivante : 
@@ -69,11 +68,13 @@ const getPropositions = (n, { answer, k }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { k }) => {
-    const solution = k < 0 ? EmptySet : new DiscreteSetNode([new NumberNode(k ** 2)]);
-    const answerTree = new EquationSolutionNode(solution);
-    const validLatexs = answerTree.toAllValidTexs();
-    return validLatexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return equationVEA(ans, answer.replace("S=", ""));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const squareRootEquation = {
     id: "squareRootEquation",

package/lib/exercises/math/squareRoots/squareRootIdentities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAyUF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"squareRootIdentities.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootIdentities.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA6UF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/math/squareRoots/squareRootIdentities.js

@@ -8,6 +8,7 @@ import { add, AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { multiply, MultiplyNode, } from "../../../tree/nodes/operators/multiplyNode.js";
 import { square, SquareNode } from "../../../tree/nodes/operators/powerNode.js";
 import { substract, SubstractNode, } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { probaFlip } from "../../../utils/alea/probaFlip.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
@@ -234,10 +235,12 @@ const getPropositions = (n, { answer, a, b, type, x, y }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
-    const validAnswer = getAnswerNode(identifiers);
-    const texs = validAnswer.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return (parseAlgebraic(ans)
+        .simplify({
+        forbidFactorize: true,
+    })
+        .toTex() === answer);
 };
 export const squareRootIdentities = {
     id: "squareRootIdentities",

package/lib/exercises/math/squareRoots/squareRootsDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"squareRootsDistributivity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/squareRoots/squareRootsDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+GF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

package/lib/exercises/math/squareRoots/squareRootsDistributivity.js

@@ -6,6 +6,7 @@ import { sqrt, SqrtNode } from "../../../tree/nodes/functions/sqrtNode.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { add, AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { multiply, MultiplyNode, } from "../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
 /**
  * a sqrt(b) (c + d sqrt(b))
@@ -84,14 +85,12 @@ const getPropositions = (n, { answer, b }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { a, b, c, d }) => {
-    const aNode = new NumberNode(a);
-    const cNode = new NumberNode(c);
-    const dNode = new NumberNode(d);
-    const bTree = new SqrtNode(new NumberNode(b));
-    const answer = new AddNode(new MultiplyNode(new MultiplyNode(aNode, cNode), bTree), new MultiplyNode(new MultiplyNode(aNode, dNode), new NumberNode(b))).simplify({ forbidFactorize: true });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return (parseAlgebraic(ans)
+        .simplify({
+        forbidFactorize: true,
+    })
+        .toTex() === answer);
 };
 export const squareRootsDistributivity = {
     id: "squareRootsDistributivity",

package/lib/exercises/math/trigonometry/arcLength.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arcLength.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,EAAE,eAAe,GAAG,SAAS,CAAC;IAC/C,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA4GF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}
+{"version":3,"file":"arcLength.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcLength.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,iBAAiB,EAAE,eAAe,GAAG,SAAS,CAAC;IAC/C,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAmGF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

package/lib/exercises/math/trigonometry/arcLength.js

@@ -6,6 +6,7 @@ import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
 import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 const getPropositions = (n, { answer, isThetaInDegree, radius }) => {
     const propositions = [];
@@ -41,14 +42,8 @@ const getInstruction = (identifiers) => {
 const getKeys = () => {
     return ["pi"];
 };
-const isAnswerValid = (ans, { isThetaInDegree, radius, thetaInDegree, thetaInRadNodeIds }) => {
-    const node = getAnswerNode({
-        isThetaInDegree,
-        radius,
-        thetaInDegree,
-        thetaInRadNodeIds,
-    });
-    return node.toAllValidTexs().includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return parseAlgebraic(ans).simplify().toTex() === answer;
 };
 const getArcLengthQuestion = () => {
     const radius = randint(1, 6);

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findAtomEntitiesNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAMnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgGF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAYhE,CAAC"}
+{"version":3,"file":"findAtomEntitiesNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAMnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAYhE,CAAC"}

package/lib/exercises/pc/chemicalElements/findAtomEntitiesNumberFromMass.js

@@ -65,12 +65,6 @@ const getPropositions = (n, { answer, atomSymbol, sampleMass }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    // const atom = atomes.find(a => a.symbole === atomSymbol)!
-    // const sampleMassMeasure = new Measure(sampleMass, 0);
-    // const atomMass = nucleonMass.value.times(atom.masseAtomique).toSignificant(2);
-    // const entitiesNumber = sampleMassMeasure.divide(atomMass).toSignificant(2);
-    // const texs = entitiesNumber.toAllValidTexs();
-    // return texs.includes(ans);
     return ans === answer;
 };
 export const findAtomEntitiesNumberFromMass = {

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAoOF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}
+{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAiOF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -6,6 +6,7 @@ import { random } from "../../../utils/alea/random.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { molecules } from "../../../pc/constants/molecularChemistry/molecule.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const getInstruction = (identifiers) => {
     const { moleculeName, concentration, molarAbsorptivity, pathLength, absorbance, targetVariableName, } = identifiers;
     const variables = [
@@ -165,10 +166,8 @@ const getPropositions = (n, { answer, concentration, molarAbsorptivity, pathLeng
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
-    const validAnswer = getAnswer(identifiers).unfrenchify();
-    const latexs = validAnswer.toTree().toAllValidTexs();
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const BeerLambertRandomValueExercise = {
     id: "beerLambertRandomValue",

package/lib/exercises/pc/dosage/concentrationFromMassCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concentrationFromMassCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationFromMassCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AAkLF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}
+{"version":3,"file":"concentrationFromMassCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationFromMassCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AA6JF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

package/lib/exercises/pc/dosage/concentrationFromMassCalculation.js

@@ -4,6 +4,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { round } from "../../../math/utils/round.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const getInstruction = (identifiers) => {
     const { concentration, mass, molarMass, variable } = identifiers;
     switch (variable) {
@@ -118,24 +119,8 @@ const getPropositions = (n, { answer, concentration, mass, molarMass, variable }
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { variable, mass, molarMass, concentration }) => {
-    let validanswer;
-    switch (variable) {
-        case "C":
-            validanswer = round(mass / molarMass, 2);
-            break;
-        case "t":
-            validanswer = round(concentration * molarMass, 2);
-            break;
-        case "M":
-            validanswer = round(mass / concentration, 2);
-            break;
-    }
-    const latexs = [
-        ...validanswer.toTree().toAllValidTexs(),
-        validanswer.toScientific(2).toTex(),
-    ];
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const concentrationFromMassCalculation = {
     id: "concentrationFromMassCalculation",

package/lib/exercises/pc/energy/energyTransfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"energyTransfer.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/energyTransfer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAmFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}
+{"version":3,"file":"energyTransfer.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/energyTransfer.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA2EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}

package/lib/exercises/pc/energy/energyTransfer.js

@@ -4,6 +4,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round } from "../../../math/utils/round.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const substances = [
     { name: "eau", latentHeat: 334 }, // kJ/kg for melting ice
     { name: "fer", latentHeat: 276 }, // kJ/kg for melting iron
@@ -56,14 +57,8 @@ const getPropositions = (n, { answer, substance, mass }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { substance, mass }) => {
-    const subst = substances.find((s) => s.name === substance);
-    const energy = round(mass * subst.latentHeat, 2);
-    const validanswer1 = `${energy}\\kJ`;
-    const validanswer2 = energy.toTree().toAllValidTexs();
-    const latexs = [];
-    latexs.push(validanswer1, ...validanswer2);
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const energyTransfer = {
     id: "energyTransfer",

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thermalEnergyTransferCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/thermalEnergyTransferCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC;CACzC,CAAC;AAwRF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"thermalEnergyTransferCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/thermalEnergyTransferCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,GAAG,QAAQ,CAAC;CACzC,CAAC;AAuPF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/pc/energy/thermalEnergyTransferCalculation.js

@@ -4,6 +4,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { round } from "../../../math/utils/round.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 const getInstruction = (identifiers) => {
     const { mass, specificHeat, initialTemp, finalTemp, variable } = identifiers;
     const deltaT = finalTemp - initialTemp;
@@ -148,30 +149,8 @@ const getPropositions = (n, { answer, mass, specificHeat, initialTemp, finalTemp
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { mass, specificHeat, initialTemp, finalTemp, variable }) => {
-    let validanswer;
-    const deltaT = finalTemp - initialTemp;
-    switch (variable) {
-        case "E_th":
-            validanswer = round(mass * specificHeat * deltaT, 2);
-            break;
-        case "m":
-            validanswer = round((mass * specificHeat * deltaT) / (specificHeat * deltaT), 2);
-            break;
-        case "c":
-            validanswer = round((mass * specificHeat * deltaT) / (mass * deltaT), 2);
-            break;
-        case "deltaT":
-            validanswer = round((mass * specificHeat * deltaT) / (mass * specificHeat), 2);
-            break;
-    }
-    const latexs = [
-        ...validanswer.toTree().toAllValidTexs(),
-        validanswer.toScientific(2).toTex(),
-        validanswer.toScientific(1).toTex(),
-        validanswer.toScientific(3).toTex(),
-    ];
-    return latexs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const thermalEnergyTransferCalculation = {
     id: "thermalEnergyTransferCalculation",

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}
+{"version":3,"file":"proportionnalityCoeffFromLine.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/math/proportionnalityCoeffFromLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA0FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

package/lib/exercises/pc/math/proportionnalityCoeffFromLine.js

@@ -1,5 +1,6 @@
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
 import { randomColor } from "../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { Integer } from "../../../math/numbers/integer/integer.js";
@@ -7,6 +8,7 @@ import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 const getInstruction = () => {
     return "Déterminer le coefficient de proportionnalité entre $y$ et $x$ : ";
 };
@@ -71,12 +73,13 @@ const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { xA, xB, yA, yB }) => {
-    const leadingCoeff = new Rational(yB - yA, xB - xA)
-        .simplify()
-        .toTree({ allowFractionToDecimal: true });
-    const texs = leadingCoeff.toAllValidTexs();
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 export const proportionnalityCoeffFromLine = {
     id: "proportionnalityCoeffFromLine",

package/lib/exercises/vea/equationVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/equationVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,aAAa,MAAM,YAa3D,CAAC"}
+{"version":3,"file":"equationVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/equationVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,EAAE,aAAa,MAAM,YAgB3D,CAAC"}

package/lib/exercises/vea/equationVEA.js

@@ -4,6 +4,8 @@ import { handleVEAError } from "../../utils/errors/handleVEAError.js";
 import { rationalVEA } from "./rationalVEA.js";
 export const equationVEA = (ans, solutionTex) => {
     try {
+        if (solutionTex === "\\varnothing")
+            return ans === "\\varnothing" || ans === "S=\\varnothing";
         const parsed = equationSolutionParser(ans);
         if (parsed) {
             return rationalVEA(parsed.toTex(), solutionTex);

package/lib/exercises/vea/rationalVEA.d.ts

@@ -1,8 +1,9 @@
 type Opts = {
     allowNonIrreductible?: boolean;
     allowDecimal?: boolean;
+    allowDecimalApprox?: boolean;
     decimalPrecision?: number;
 };
-export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal }?: Opts) => boolean;
+export declare const rationalVEA: (studentAns: string, answer: string, { allowNonIrreductible, decimalPrecision, allowDecimal, allowDecimalApprox, }?: Opts) => boolean;
 export {};
 //# sourceMappingURL=rationalVEA.d.ts.map

package/lib/exercises/vea/rationalVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAOA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,2DAA0D,IAIzD,YAkCF,CAAC"}
+{"version":3,"file":"rationalVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/rationalVEA.ts"],"names":[],"mappings":"AAeA,KAAK,IAAI,GAAG;IACV,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AACF,eAAO,MAAM,WAAW,GACtB,YAAY,MAAM,EAClB,QAAQ,MAAM,EACd,gFAKG,IAKF,YAsEF,CAAC"}

package/lib/exercises/vea/rationalVEA.js

@@ -1,14 +1,18 @@
 import { round } from "../../math/utils/round.js";
-import { isNumberNode } from "../../tree/nodes/numbers/numberNode.js";
+import { isOppositeNode } from "../../tree/nodes/functions/oppositeNode.js";
+import { isNumberNode, } from "../../tree/nodes/numbers/numberNode.js";
+import { isFractionNode, } from "../../tree/nodes/operators/fractionNode.js";
 import { parseAlgebraic } from "../../tree/parsers/latexParser.js";
 import { rationalParser } from "../../tree/parsers/rationalParser.js";
 import { handleVEAError } from "../../utils/errors/handleVEAError.js";
-export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal } = {
+export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalPrecision, allowDecimal, allowDecimalApprox, } = {
     allowNonIrreductible: true,
     decimalPrecision: 2,
     allowDecimal: true,
+    allowDecimalApprox: true,
 }) => {
     allowDecimal = allowDecimal ?? true;
+    allowDecimalApprox = allowDecimalApprox ?? true;
     allowNonIrreductible = allowNonIrreductible ?? true;
     decimalPrecision = decimalPrecision ?? undefined;
     const parsed = rationalParser(studentAns);
@@ -19,6 +23,20 @@ export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalP
         if (isNumberNode(parsed)) {
             if (!allowDecimal)
                 return false;
+            if (!allowDecimalApprox) {
+                //si l'answer n'est pas décimable et que c'est un nbNode on renvoit faux dans tous les cas
+                const answerFraced = isFractionNode(parsedAnswer)
+                    ? parsedAnswer
+                    : isOppositeNode(parsedAnswer) && isFractionNode(parsedAnswer.child)
+                        ? parsedAnswer.child
+                        : isNumberNode(parsedAnswer)
+                            ? parsedAnswer.toFrac()
+                            : null;
+                if (!!answerFraced &&
+                    !isNumberNode(answerFraced) &&
+                    !answerFraced.isDecimal())
+                    return false;
+            }
             if (decimalPrecision === undefined)
                 return (Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001);
             else {
@@ -32,6 +50,22 @@ export const rationalVEA = (studentAns, answer, { allowNonIrreductible, decimalP
             }
         }
         else if (allowNonIrreductible) {
+            if (!allowDecimalApprox) {
+                if (isNumberNode(parsed)) {
+                    //si l'answer n'est pas décimable et que c'est un nbNode on renvoit faux dans tous les cas
+                    const answerFraced = isFractionNode(parsedAnswer)
+                        ? parsedAnswer
+                        : isOppositeNode(parsedAnswer) && isFractionNode(parsedAnswer.child)
+                            ? parsedAnswer.child
+                            : isNumberNode(parsedAnswer)
+                                ? parsedAnswer.toFrac()
+                                : null;
+                    if (!!answerFraced &&
+                        !isNumberNode(answerFraced) &&
+                        !answerFraced.isDecimal())
+                        return false;
+                }
+            }
             return Math.abs(parsed.evaluate() - parsedAnswer.evaluate()) < 0.0000001;
         }
         else {

package/lib/exercises/vea/treeTableVEA.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAgB5B,CAAC"}
+{"version":3,"file":"treeTableVEA.d.ts","sourceRoot":"","sources":["../../../src/exercises/vea/treeTableVEA.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,GACvB,KAAK,MAAM,EAAE,EAAE,EAAE,EAAE,EACnB,aAAa,MAAM,EAAE,EAAE,EAAE,EAAE,YAiB5B,CAAC"}

package/lib/exercises/vea/treeTableVEA.js

@@ -1,3 +1,4 @@
+import { percentVEA } from "./percentVEA.js";
 import { rationalVEA } from "./rationalVEA.js";
 // type Options = {
 // }
@@ -6,5 +7,6 @@ export const treeTableVEA = (ans, answerTable) => {
     //les branches peuvent commuter au sein d'un block
     //les blocks peuvent commuter au sein d'un step
     return ans.every((step, i) => step.every((block, j) => block.every((branch, k) => branch.every((value, l) => value === answerTable[i][j][k][l] ||
+        percentVEA(value, answerTable[i][j][k][l]) ||
         rationalVEA(value, answerTable[i][j][k][l])))));
 };

package/lib/index.d.ts

@@ -119,7 +119,9 @@ declare const mathExercises: (Exercise<{
     denom: number;
     num1: number;
     num2: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    allowNonIrreductible?: boolean;
+}> | Exercise<{
     num1: number;
     num2: number;
     denom1: number;
@@ -681,11 +683,6 @@ declare const mathExercises: (Exercise<{
     d: number;
     k: number;
     isSubstract: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    a: number;
-    k1: number;
-    b: number;
-    k2: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     b: number;
     c: number;
@@ -5943,10 +5940,8 @@ declare const mathExercises: (Exercise<{
     graphIds2: import("./math/graphs/graph.js").GraphIdentifiers;
     graphNodes1: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
     graphEdges1: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
-    scale1: number;
     graphNodes2: import("./math/utils/graphs/graphRenderer.js").GraphNode[];
     graphEdges2: import("./math/utils/graphs/graphRenderer.js").GraphEdge[];
-    scale2: number;
 }, {
     graphType: string;
 }> | Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/math/graphs/graph.d.ts

@@ -26,7 +26,7 @@ export declare class Graph {
     densifyUpTo(minDensity: number): Graph;
     undirectedGraph(): Graph;
     isWeaklyConnected(): boolean;
-    getWeaklyConnectedSubgraphChainsAsArrIndex(): number[][];
+    getWeaklyConnectedSubgraphCoveringChainsAsArrIndex(): number[][];
     getSomePathsWithNbEdges(nbEdges: number, nbToFindIfPossible: number): number[][];
     /**
      *

package/lib/math/graphs/graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/math/graphs/graph.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EAEN,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EAEzB,cAAc,GAAE,MAAM,EAA8B;IA6EtD,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EACzB,cAAc,GAAE,MAAM,EAA8B,EACpD,WAAW,GAAE,OAAc;IAkC7B,MAAM,CAAC,WAAW,CAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,YAA4B,EACpD,UAAU,EAAE,OAAO;IAuErB,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,KAAK,EAAE;IAgCnD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IA0BnD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAKrD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,qBAAa,KAAK;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;gBACR,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO;IAMpE,aAAa;IASb,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmB1D,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAc5C,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,UAAU,EAAE,MAAM;IAc9B,eAAe,IAAI,KAAK;IASxB,iBAAiB,IAAI,OAAO;IAoC5B,0CAA0C,IAAI,MAAM,EAAE,EAAE;IA8CxD,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,EAAE;IAmCb;;;;OAIG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBxD,wBAAwB,CAAC,gBAAgB,EAAE,MAAM;IAUjD,+BAA+B,CAC7B,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,OAAO;IAmB7B,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,eAAe;IAWf,MAAM,CAAC,MAAM,EAAE,KAAK;CAQrB"}
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../../../src/math/graphs/graph.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,MAAM,EAEN,iBAAiB,EAClB,MAAM,uBAAuB,CAAC;AAE/B,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CACpB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EAEzB,cAAc,GAAE,MAAM,EAA8B;IA6EtD,MAAM,CAAC,MAAM,CACX,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,OAAc,EAAE,yBAAyB;IACnD,UAAU,GAAE,OAAe,EAC3B,UAAU,GAAE,MAAa,EACzB,cAAc,GAAE,MAAM,EAA8B,EACpD,WAAW,GAAE,OAAc;IAkC7B,MAAM,CAAC,WAAW,CAChB,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,YAA4B,EACpD,UAAU,EAAE,OAAO;IAuErB,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,KAAK,EAAE;IAgCnD,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IA0BnD,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAKrD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;IAC1B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,qBAAa,KAAK;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,OAAO,CAAC;gBACR,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO;IAMpE,aAAa;IASb,eAAe,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAmB1D,aAAa,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAc5C,OAAO,IAAI,MAAM;IAIjB,WAAW,CAAC,UAAU,EAAE,MAAM;IAc9B,eAAe,IAAI,KAAK;IASxB,iBAAiB,IAAI,OAAO;IAoC5B,kDAAkD,IAAI,MAAM,EAAE,EAAE;IAuGhE,uBAAuB,CACrB,OAAO,EAAE,MAAM,EACf,kBAAkB,EAAE,MAAM,GACzB,MAAM,EAAE,EAAE;IAmCb;;;;OAIG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE;IAqBxD,wBAAwB,CAAC,gBAAgB,EAAE,MAAM;IAUjD,+BAA+B,CAC7B,gBAAgB,EAAE,MAAM,EACxB,kBAAkB,EAAE,OAAO;IAmB7B,WAAW,CAAC,aAAa,EAAE,MAAM,EAAE,GAAG,OAAO;IAQ7C,eAAe;IAWf,MAAM,CAAC,MAAM,EAAE,KAAK;CAQrB"}