math-exercises 3.0.177 → 3.0.178

package/lib/exercises/math/sequences/geometric/situations/geometricFindTermFromSituation.js

@@ -24,7 +24,7 @@ const getInstruction = (identifiers, optsIn) => {
     const situation = situations[situationIndex];
     return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
 
-Que vaut $u_{${rankAsked}}$ ?`;
+Quel calcul permet de trouver $u_{${rankAsked}}$ ?`;
 };
 const getAnswerNode = (identifiers, opts) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;

package/lib/exercises/math/sequences/geometric/sum/geometricComputeSumWithDots.js

@@ -185,7 +185,7 @@ const createRandomIdentifiers = (opts) => {
     const initial = randint(-9, 10, [0]);
     const signReason = coinFlip() ? 1 : -1;
     const reason = signReason * randint(2, 6);
-    const nbTerms = randint(7, 15);
+    const nbTerms = randint(5, 9);
     const minRankDots = firstRank + 2;
     const lastRank = firstRank + nbTerms - 1;
     const lowRankDots = randint(minRankDots, Math.min(minRankDots + randint(1, 3), lastRank));
@@ -225,7 +225,7 @@ const options = [
     generatorOptionFirstTermRankOne,
     {
         id: "isGiveCount",
-        label: "Donner $n$",
+        label: "Donner le nombre de termes de la somme dans la consigne",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.checkbox,
         defaultValue: optsDefault.isGiveCount,

package/lib/exercises/math/sequences/graph/placeFirstSequencePoints.js

@@ -102,12 +102,12 @@ export const placeFirstSequencePoints = {
     isGGBAnswerValid,
     subject: "Mathématiques",
     getHint,
-    getInstruction,
     getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
     getQuestionFromIdentifiers,
     options,
-    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/index.d.ts

@@ -7,5 +7,6 @@ export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
+export * from "./seqArithmGeom/index.js";
 export * from "./variations/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AAEzC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/sequences/index.js

@@ -7,5 +7,6 @@ export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
 export * from "./graph/index.js";
 export * from "./notation/index.js";
+export * from "./seqArithmGeom/index.js";
 // export * from "./limits/index.js";
 export * from "./variations/index.js";

package/lib/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seqArithmGeomRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AA8C3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoMF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE,CAAC;AAkBxE,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"seqArithmGeomRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AA8C3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+LF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE,CAAC;AAkBxE,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CACxD,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/seqArithmGeom/seqArithmGeomRecurrenceFormulaUsage.js

@@ -26,9 +26,11 @@ const getDictSequenceSlice = (coeffs, rank1, value1, rankAsked) => {
         return acc;
     }, { [rank1]: value1.toTree() });
 };
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
     const { rank1, value1, coeffs, rankAsked } = identifiers;
-    return `$(u_n)$ est une suite définie par, pour $n\\geq 1$ :
+    return `$(u_n)$ est une suite définie par, pour $n\\geq ${firstRank}$ :
   
 $$
 u_{n+1} = ${getNodeUNext(coeffs).toTex()}
@@ -38,11 +40,6 @@ et $u_{${rank1}} = ${value1}$.
 
 Calculer le terme $u_{${rankAsked}}$.`;
 };
-const getStartStatement = (identifiers) => {
-    const { rank1 } = identifiers;
-    const askedRank = rank1 + 1;
-    return `u_{${askedRank}}`;
-};
 const getAnswerStuff = (identifiers) => {
     const { rank1, value1, coeffs, rankAsked } = identifiers;
     const dictSequenceSlice = getDictSequenceSlice(coeffs, rank1, value1, rankAsked);
@@ -149,7 +146,7 @@ const getSeqArithmGeomRecurrenceFormulaUsageQuestion = (optsIn) => {
     const distanceOfRankAsked = Number(opts.distanceOfRankAsked);
     const rank1 = randint(firstRank, 20);
     const value1 = randint(-10, 10);
-    const a = randint(-10, 10, [0]);
+    const a = randint(-10, 10, [0, 1]);
     const b = randint(-10, 10, [0]);
     const coeffs = [a, b];
     const rankAsked = rank1 + distanceOfRankAsked;
@@ -159,7 +156,6 @@ const getSeqArithmGeomRecurrenceFormulaUsageQuestion = (optsIn) => {
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers, opts),
-        startStatement: getStartStatement(identifiers, opts),
         answer: getAnswer(identifiers, opts),
         keys: [],
         answerFormat: "tex",

package/lib/exercises/math/spaceGeometry/sphere/sphereLatLonReading.2d.js

@@ -152,7 +152,7 @@ const getKeys = () => {
     return ["degree", "N", "O", "S", "E"];
 };
 const isAnswerValid = (ans, { answer }) => {
-    const ansRefined = ans.replace("^{\\circ}", "°");
+    const ansRefined = ans.replace("^{\\circ}", "°").replace("^\\circ", "°");
     return ansRefined === answer;
 };
 const getSphereLatLonReading2dQuestion = () => {

package/lib/exercises/math/trigonometry/triangle/trigonometryAngleCalcul.js

@@ -21,7 +21,7 @@ const getAnswer = (identifiers) => {
     const { randAngle, triangleIdentifiers } = identifiers;
     const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
     const answer = round(triangle.angles[randAngle].evaluate(), 0);
-    return answer + "^{\\circ}";
+    return answer + "^\\circ";
 };
 const getHint = () => {
     return `On peut utiliser : 
@@ -149,7 +149,7 @@ const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, randint(20, 80) + "^{\\circ}");
+        tryToAddWrongProp(propositions, randint(20, 80) + "^\\circ");
     });
     return shuffle(propositions);
 };

package/lib/exercises/pc/snellDescartes.js

@@ -73,7 +73,7 @@ const getAnswer = (identifiers) => {
     const angleIncidenceRad = (ramdonAngleIncidenceDeg * Math.PI) / 180;
     const angleRefractionRad = Math.asin((n1 / n2) * Math.sin(angleIncidenceRad));
     const angleRefractionDeg = (angleRefractionRad * 180) / Math.PI;
-    const answer = `${frenchify(round(angleRefractionDeg, 1))}^{\\circ}`;
+    const answer = `${frenchify(round(angleRefractionDeg, 1))}^\\circ`;
     return answer;
 };
 const getQuestionFromIdentifiers = (identifiers) => {
@@ -103,7 +103,7 @@ const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, frenchify(round(randint(100, 900) / 10, 1)) + "^{\\circ}");
+        tryToAddWrongProp(propositions, frenchify(round(randint(100, 900) / 10, 1)) + "^\\circ");
     });
     return shuffle(propositions);
 };

package/lib/index.d.ts

@@ -1480,6 +1480,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    affineCoeffs: number[];
+    trinomCoeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     param: string;
     coeffs: number[];
@@ -3252,8 +3255,6 @@ declare const mathExercises: (Exercise<{
     firstValue: number;
     reason: number;
     randValue: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sequences: number[][];
     answerIndex: number;
@@ -3270,13 +3271,6 @@ declare const mathExercises: (Exercise<{
     sequence: number[];
 }, {
     firstTermRankOne?: boolean;
-}> | Exercise<{
-    firstRank: number;
-    firstValue: number;
-    reason: number;
-    nbTerms: number;
-}, {
-    firstTermRank: string;
 }> | Exercise<{
     firstValue: number;
     reason: number;
@@ -3286,12 +3280,6 @@ declare const mathExercises: (Exercise<{
     rank2: number;
     reason: number;
     value1: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    rank1: number;
-    value1: number;
-    rank2: number;
-    value2: number;
-    rankAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     firstRank: number;
     firstTerm: number;
@@ -3305,7 +3293,52 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     n: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    rankAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqArithmeticSituations.js").SituationArithmeticSuperfluousData;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
+}, {
+    firstTermRank: string;
+}> | Exercise<{
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+    isForceWriteSumWithPlusSymbol: boolean;
+}> | Exercise<{
     firstRank: number;
     firstTerm: number;
     reason: number;
@@ -3326,9 +3359,6 @@ declare const mathExercises: (Exercise<{
     value1: number;
     reason: number;
     rank1: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    raison: number;
-    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     reason: number;
     startRank: number;
@@ -3356,6 +3386,42 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sequence: number[];
     reason: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    precisionInitial: number;
+    precisionReason: number;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    raison: number;
+    final: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     firstRank: number;
     firstValue: number;
@@ -3365,9 +3431,30 @@ declare const mathExercises: (Exercise<{
     positiveReason: boolean;
     firstRankOne: boolean;
 }> | Exercise<{
-    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    a: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+}> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: import("./math/utils/sequences/situations/seqGeometricSituations.js").SituationGeometricSuperfluousData;
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsWithSuperfluousData.js").OptionIsWithSuperfluousData> | Exercise<{
     rank: number;
     coeffs: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3402,6 +3489,13 @@ declare const mathExercises: (Exercise<{
     askedTerm: number;
 }, {
     firstRank: string;
+}> | Exercise<{
+    rank1: number;
+    value1: number;
+    coeffs: number[];
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & {
+    distanceOfRankAsked: string;
 }> | Exercise<{
     formulaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, {
@@ -3784,6 +3878,43 @@ declare const mathExercises: (Exercise<{
     m: number;
     p: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    firstValue: number;
+    rankAsked: number;
+    coeffs: number[];
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    coeffs: number[];
+    rankAsked: number;
+    keyIncomplete: string;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isUseFuncRecur: boolean;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne> | Exercise<{
+    firstValue: number;
+    lengthAsked: number;
+    coeffs: number[];
+    isAnswerAlternative: boolean;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef> | Exercise<{
+    firstValue: number;
+    coeffs: number[];
+    rankAsked: number;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef & {
+    typeAsked: string;
+}> | Exercise<{
+    nAsked: number;
+    cyRandModFour?: number;
+    arrRandForStr: number[];
+}, import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef> | Exercise<{
+    valueThreshold: number;
+    valueLimit: number;
+    nodeIdsDistanceMax: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    keyIncomplete: string;
+}, import("./exercises/options/optionFirstTermRankOne.js").OptionFirstTermRankOne & import("./exercises/options/optionIsUsePythonDef.js").OptionIsUsePythonDef & {
+    isUsePythonList: boolean;
+    typeSequence: string;
+}> | Exercise<{
     p: number;
     n: number;
     wordingType: number;

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/latexTester.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YAuLrE,CAAC"}
+{"version":3,"file":"latexTester.d.ts","sourceRoot":"","sources":["../src/latexTester.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,EAAE,6BAA2B,YA+LrE,CAAC"}

package/lib/latexTester.js

@@ -23,8 +23,10 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
             if (inPython || inInlinePython)
                 throw new Error("Dollar in python mode");
             if (nextChar === "$") {
-                if (inDollarMode)
-                    throw new Error("Double dollar instead of single");
+                if (inDollarMode) {
+                    const strAround = `${prevChar}${char}${nextChar}${nextNextChar}`;
+                    throw new Error(`Double dollar instead of single, around ${strAround}, ${latex}`);
+                }
                 inDoubleDollarMode = !inDoubleDollarMode;
                 if (inDoubleDollarMode &&
                     nextNextChar !== undefined &&
@@ -57,7 +59,8 @@ export const latexTester = (latex, isDefaultInMathMode = false) => {
                 char !== "\n" &&
                 char !== "\t") {
                 if (!inDollarMode && !inDoubleDollarMode) {
-                    throw new Error(`Number not in math mode, ${char}, ${latex}`);
+                    const strAround = `${prevChar}${char}${nextChar}${nextNextChar}`;
+                    throw new Error(`Number not in math mode, ${char}, ${strAround}, ${latex}`);
                 }
             }
             //check si charactere spécial
@@ -230,6 +233,8 @@ const validCmds = [
     "\\newline",
     "\\lVert",
     "\\rVert",
+    "\\lvert",
+    "\\rvert",
     "\\hline",
     "\\mathrm",
     "\\overline",
@@ -265,6 +270,4 @@ const validCmds = [
     "\\searrow",
     "\\mapsto",
     "\\color",
-    "\\lvert",
-    "\\rvert",
 ];

package/lib/math/polynomials/affine.d.ts

@@ -4,6 +4,7 @@ import { Polynomial } from "./polynomial.js";
 import { Trinom } from "./trinom.js";
 export declare abstract class AffineConstructor {
     static fromCoeffs(coeffs: number[]): Affine;
+    static randomNiceRoot(): Affine;
     static random(aOpts?: {
         min?: number;
         max?: number;

package/lib/math/polynomials/affine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAcZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAI3B,QAAQ,IAAI,MAAM;IAMlB,aAAa;CAGd"}
+{"version":3,"file":"affine.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/affine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAGlE,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAG9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,8BAAsB,iBAAiB;IACrC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM;IAG3C,MAAM,CAAC,cAAc,IAAI,MAAM;IAK/B,MAAM,CAAC,MAAM,CACX,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM;IAcT,MAAM,CAAC,gBAAgB,CACrB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,EAC3D,KAAK,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;KAAE,GAC1D,MAAM,EAAE;CAcZ;AAED,qBAAa,MAAO,SAAQ,UAAU;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,CAAC;gBAEL,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAY;IAOxD,OAAO,IAAI,MAAM;IAGjB,KAAK,CAAC,CAAC,EAAE,aAAa,GAAG,MAAM;IAG/B,MAAM,IAAI,MAAM;IAMhB,KAAK,CAAC,CAAC,EAAE,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAI3B,QAAQ,IAAI,MAAM;IAMlB,aAAa;CAGd"}

package/lib/math/polynomials/affine.js

@@ -9,6 +9,11 @@ export class AffineConstructor {
     static fromCoeffs(coeffs) {
         return new Affine(coeffs[1], coeffs[0]);
     }
+    static randomNiceRoot() {
+        const root = randint(-10, 10, [0]);
+        const a = randint(-10, 10, [0]);
+        return new Affine(a, -root * a);
+    }
     static random(aOpts, bOpts, variable) {
         const a = randint(aOpts?.min ?? -9, aOpts?.max ?? 10, aOpts?.excludes ?? [0]);
         const b = randint(bOpts?.min ?? -9, bOpts?.max ?? 10, bOpts?.excludes ?? []);

package/lib/math/utils/arithmetic/primeFactors.js

@@ -5,7 +5,7 @@
 export const primeFactors = (n) => {
     // Validate input
     if (!Number.isInteger(n) || n <= 0) {
-        throw new Error("Input must be an integer greater than 1.");
+        // throw new Error("Input must be an integer greater than 1.");
         return [];
     }
     if (n === 1)

package/lib/math/utils/functions/functionComposition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAU3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA6BF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBAsDtC"}
+{"version":3,"file":"functionComposition.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/functions/functionComposition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,eAAe,EAChB,MAAM,mCAAmC,CAAC;AAc3C,OAAO,EAEL,YAAY,EACb,MAAM,4CAA4C,CAAC;AAEpD,eAAO,MAAM,qBAAqB,GAChC,aAAa,aAAa,EAC1B,cAAc,aAAa,EAC3B,eAAc,YAA2C,kBAiB1D,CAAC;AAMF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,QAAQ,EAAE,QAAQ,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,MAAM,aAAa,wBA4ClD,CAAC;AAMF,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,CAAC,WAAW,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC;CAChD,CAAC;AA+CF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,aAAa,EAC1B,IAAI,EAAE,QAAQ,EACd,YAAY,EAAE,aAAa,EAC3B,iBAAiB,GAAE,MAAW,EAC9B,eAAe,GAAE,eAAoB,iBA0DtC"}

package/lib/math/utils/functions/functionComposition.js

@@ -1,3 +1,4 @@
+import { isEqualNode, } from "../../../tree/nodes/equations/equalNode.js";
 import { isFunctionNode, } from "../../../tree/nodes/functions/functionNode.js";
 import { NodeConstructor } from "../../../tree/nodes/nodeConstructor.js";
 import { isOperatorNode, } from "../../../tree/nodes/operators/operatorNode.js";
@@ -11,7 +12,7 @@ export const nodeBySubstitutingVar = (nodeCarrier, nodeInjected, variableNode =
 };
 export const getAllNodePaths = (node) => {
     const arrNodePaths = [];
-    if (isOperatorNode(node)) {
+    if (isOperatorNode(node) || isEqualNode(node)) {
         getAllNodePaths(node.leftChild).forEach((nodePathWithNodes) => {
             arrNodePaths.push({
                 arrNode: [node, ...nodePathWithNodes.arrNode],
@@ -64,6 +65,16 @@ function operatorNodeByReplacingRightChild(opNode, nodeRightChildNew) {
     nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
     return NodeConstructor.fromIdentifiers(nodeIds);
 }
+function equalNodeByReplacingLeftChild(equalNode, nodeLeftChildNew) {
+    const nodeIds = equalNode.toIdentifiers();
+    nodeIds.leftChild = nodeLeftChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
+function equalNodeByReplacingRightChild(equalNode, nodeRightChildNew) {
+    const nodeIds = equalNode.toIdentifiers();
+    nodeIds.rightChild = nodeRightChildNew.toIdentifiers();
+    return NodeConstructor.fromIdentifiers(nodeIds);
+}
 export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simplifyUpToLevel = -1, simplifyOptions = {}) {
     function getNodeForKey(node, key) {
         if (key === "leftChild" || key === "rightChild") {
@@ -83,6 +94,12 @@ export function nodeByReplacingNodeAtPath(nodeCarrier, path, nodeInjected, simpl
         else if (key === "rightChild" && isOperatorNode(node)) {
             return operatorNodeByReplacingRightChild(node, nodeInjected);
         }
+        else if (key === "leftChild" && isEqualNode(node)) {
+            return equalNodeByReplacingLeftChild(node, nodeInjected);
+        }
+        else if (key === "rightChild" && isEqualNode(node)) {
+            return equalNodeByReplacingRightChild(node, nodeInjected);
+        }
         else if (key === "child" && isFunctionNode(node)) {
             return functionNodeByReplacingChild(node, nodeInjected);
         }

package/lib/math/utils/sequences/situations/seqArithmeticSituations.d.ts

@@ -5,6 +5,19 @@ export type SituationArithmeticVariation = {
     getHint: (firstRank: number, ...otherArgs: unknown[]) => string;
     getCorrectionStuff: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => Record<string, unknown>;
 };
+export type RankDecoder = {
+    rankFromTarget: (nodeTarget: AlgebraicNode, firstRank: number) => number;
+    targetFromRank: (rank: number, firstRank: number) => AlgebraicNode;
+};
+export type SituationArithmeticVariationUsingRankDecoder = {
+    getStrQuestion?: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => string;
+    getAnswerStuff: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => {
+        answerNode: AlgebraicNode;
+        rankNode: AlgebraicNode;
+    };
+    getHint: (firstRank: number, ...otherArgs: unknown[]) => string;
+    getCorrectionStuff: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => Record<string, unknown>;
+};
 export type SituationArithmeticSuperfluousData = {
     rand: number;
     values: number[];
@@ -14,12 +27,13 @@ export type SituationArithmetic = {
     randReason: () => number;
     randSuperfluousData: () => SituationArithmeticSuperfluousData;
     randThreshold: (initial: number, reason: number, firstRank: number) => number;
+    rankDecoder: RankDecoder;
     getStrSituation: (initial: number, reason: number, firstRank: number, superfluousData?: SituationArithmeticSuperfluousData) => string;
     variationFindExplicitFormula: SituationArithmeticVariation;
     variationFindRecurrenceFormula: SituationArithmeticVariation;
     variationFindRandomTerm: SituationArithmeticVariation;
-    variationFindRank: SituationArithmeticVariation;
-    variationFindThreshold: SituationArithmeticVariation;
+    variationFindRank: SituationArithmeticVariationUsingRankDecoder;
+    variationFindThreshold: SituationArithmeticVariationUsingRankDecoder;
 };
 export declare const situationsArithmetic: (SituationArithmetic & {
     variationFindExplicitFormula: SituationArithmeticVariation & {
@@ -39,12 +53,12 @@ export declare const situationsArithmetic: (SituationArithmetic & {
             str: string;
         };
     };
-    variationFindRank: SituationArithmeticVariation & {
+    variationFindRank: SituationArithmeticVariationUsingRankDecoder & {
         getCorrectionStuff: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => {
             str: string;
         };
     };
-    variationFindThreshold: SituationArithmeticVariation & {
+    variationFindThreshold: SituationArithmeticVariationUsingRankDecoder & {
         getCorrectionStuff: (initial: number, reason: number, firstRank: number, ...otherArgs: unknown[]) => {
             str: string;
         };

package/lib/math/utils/sequences/situations/seqArithmeticSituations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seqArithmeticSituations.d.ts","sourceRoot":"","sources":["../../../../../src/math/utils/sequences/situations/seqArithmeticSituations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAiBlE,MAAM,MAAM,4BAA4B,GAAG;IACzC,cAAc,CAAC,EAAE,CACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,GAAG,SAAS,EAAE,OAAO,EAAE,KACpB,MAAM,CAAC;IAEZ,aAAa,EAAE,CACb,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,GAAG,SAAS,EAAE,OAAO,EAAE,KACpB,aAAa,CAAC;IACnB,OAAO,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,OAAO,EAAE,KAAK,MAAM,CAAC;IAChE,kBAAkB,EAAE,CAClB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,GAAG,SAAS,EAAE,OAAO,EAAE,KACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,WAAW,EAAE,MAAM,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;IAC9D,aAAa,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MAAM,CAAC;IAE9E,eAAe,EAAE,CACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,eAAe,CAAC,EAAE,kCAAkC,KACjD,MAAM,CAAC;IAEZ,4BAA4B,EAAE,4BAA4B,CAAC;IAC3D,8BAA8B,EAAE,4BAA4B,CAAC;IAC7D,uBAAuB,EAAE,4BAA4B,CAAC;IAEtD,iBAAiB,EAAE,4BAA4B,CAAC;IAChD,sBAAsB,EAAE,4BAA4B,CAAC;CACtD,CAAC;AAw8FF,eAAO,MAAM,oBAAoB;;sCAr7Fd,MAAM,UACP,MAAM,aACH,MAAM,gBACH,OAAO,EAAE;;;;;sCA2Bd,MAAM,UACP,MAAM,aACH,MAAM,gBACH,OAAO,EAAE;;;;;;;sCAiChB,MAAM,UACP,MAAM,aACH,MAAM,gBACH,OAAO,EAAE;;;;;sCAsCd,MAAM,UACP,MAAM,aACH,MAAM,gBACH,OAAO,EAAE;;;;;sCA0Cd,MAAM,UACP,MAAM,aACH,MAAM,gBACH,OAAO,EAAE;;;;IA4xF9B,CAAC"}
+{"version":3,"file":"seqArithmeticSituations.d.ts","sourceRoot":"","sources":["../../../../../src/math/utils/sequences/situations/seqArithmeticSituations.ts"],"names":[],"mappings":"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"}