math-exercises 2.2.4 → 2.2.6

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

@@ -1 +1 @@
-{"version":3,"file":"efficiencyCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/efficiencyCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,CAAC;CAClC,CAAC;AA8IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"efficiencyCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/efficiencyCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,CAAC;CAClC,CAAC;AA8IF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

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

@@ -118,4 +118,5 @@ exports.efficiencyCalculation = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"kineticEnergyOrMassOrSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/kineticEnergyOrMassOrSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"kineticEnergyOrMassOrSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/energy/kineticEnergyOrMassOrSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAelC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAuNF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}

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

@@ -164,4 +164,5 @@ exports.kineticEnergyOrMassOrSpeed = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    hasHintAndCorrection: true,
 };

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,EAST,MAAM,0BAA0B,CAAC;AAMlC,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;AA4NF,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,EAST,MAAM,0BAA0B,CAAC;AAMlC,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;AA4NF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

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

@@ -139,4 +139,5 @@ exports.thermalEnergyTransferCalculation = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/forces/calculateNormalOrFrictionForce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateNormalOrFrictionForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/calculateNormalOrFrictionForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA8FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAehE,CAAC"}
+{"version":3,"file":"calculateNormalOrFrictionForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/calculateNormalOrFrictionForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA8FF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAgBhE,CAAC"}

package/lib/exercises/pc/forces/calculateNormalOrFrictionForce.js

@@ -98,4 +98,5 @@ exports.calculateNormalOrFrictionForce = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/forces/electroStaticForce.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"electroStaticForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/electroStaticForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,iBAAiB,CAAC;IACtB,EAAE,EAAE,iBAAiB,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoJF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"electroStaticForce.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/electroStaticForce.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,iBAAiB,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,iBAAiB,CAAC;IACtB,EAAE,EAAE,iBAAiB,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAoJF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/pc/forces/electroStaticForce.js

@@ -113,4 +113,5 @@ exports.electroStaticForce = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/forces/gravitationalAttractionObjectHeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gravitationalAttractionObjectHeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionObjectHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAcrE,CAAC"}
+{"version":3,"file":"gravitationalAttractionObjectHeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalAttractionObjectHeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiIF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAerE,CAAC"}

package/lib/exercises/pc/forces/gravitationalAttractionObjectHeight.js

@@ -128,4 +128,5 @@ exports.gravitationalAttractionObjectHeight = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/forces/gravitationalForcePlanets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gravitationalForcePlanets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalForcePlanets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAiJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"gravitationalForcePlanets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/gravitationalForcePlanets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAOnD,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAiJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAgB3D,CAAC"}

package/lib/exercises/pc/forces/gravitationalForcePlanets.js

@@ -114,4 +114,5 @@ exports.gravitationalForcePlanets = {
     isAnswerValid,
     subject: "Physique",
     maxAllowedQuestions: 8,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/forces/massWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"massWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/massWeight.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACjC,CAAC;AAmEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}
+{"version":3,"file":"massWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/massWeight.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,UAAU,GAAG,UAAU,CAAC;CACjC,CAAC;AAmEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/pc/forces/massWeight.js

@@ -64,4 +64,5 @@ exports.MassWeightExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/motion/averageSpeed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,KAAK,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAoJpD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}
+{"version":3,"file":"averageSpeed.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeed.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAEF,KAAK,OAAO,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAoJpD,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/pc/motion/averageSpeed.js

@@ -118,4 +118,5 @@ exports.averageSpeed = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/motion/averageSpeedCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA4MF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA4MF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/pc/motion/averageSpeedCalculation.js

@@ -142,4 +142,5 @@ exports.AverageSpeedCalculationExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/motion/motionReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,CAAC;AA0LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,CAAC;AA0LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}

package/lib/exercises/pc/motion/motionReference.js

@@ -164,4 +164,5 @@ exports.MotionReferenceExercise = {
     isAnswerValid,
     subject: "Physique",
     maxAllowedQuestions: 10,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/pH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAcpC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -58,4 +58,5 @@ exports.pH = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/power/calculatePowerOfLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculatePowerOfLight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/calculatePowerOfLight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"calculatePowerOfLight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/power/calculatePowerOfLight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/pc/power/calculatePowerOfLight.js

@@ -82,4 +82,5 @@ exports.calculatePowerOfLight = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/spectral/spectralEnergy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spectralEnergy.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/spectral/spectralEnergy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACzC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAwJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"spectralEnergy.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/spectral/spectralEnergy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACzC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAwJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/pc/spectral/spectralEnergy.js

@@ -126,4 +126,5 @@ exports.SpectralEnergyExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/waves/lightDistanceConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lightDistanceConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/lightDistanceConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAqKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"lightDistanceConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/lightDistanceConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAGnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AAqKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/pc/waves/lightDistanceConversion.js

@@ -157,4 +157,5 @@ exports.lightDistanceConversion = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/waves/periodicWaveCelerity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"periodicWaveCelerity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/periodicWaveCelerity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"periodicWaveCelerity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/periodicWaveCelerity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}

package/lib/exercises/pc/waves/periodicWaveCelerity.js

@@ -82,4 +82,5 @@ exports.periodicWaveCelerity = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/weight/calculateWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/pc/weight/calculateWeight.js

@@ -69,4 +69,5 @@ exports.calculateWeight = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/weight/weightOnTheMoon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -78,4 +78,5 @@ exports.weightOnTheMoon = {
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -5,6 +5,9 @@ declare global {
         frenchify: () => string;
         toScientific: (decimals?: number) => AlgebraicNode;
     }
+    interface String {
+        toTree: () => AlgebraicNode;
+    }
 }
 /**
  * TODO
@@ -142,6 +145,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     nb: string;
     rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
+}> | import("./exercises/exercise").Exercise<{
+    nb: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
@@ -235,6 +244,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     affinesCoeffs: number[][];
     operation: string;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    bOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     b: number;
     c: number;
@@ -254,38 +269,6 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     a: number;
     b: number;
     c: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     d: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
@@ -617,6 +600,8 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     xValues: number[];
     imageValues: number[];
+    isAskingImage: boolean;
+    value: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
@@ -692,6 +677,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     quadrinomial: number[];
     leftbound: number;
     rightbound: number;
+}> | import("./exercises/exercise").Exercise<{
+    a: number;
+    b: number;
+    type: number;
+}> | import("./exercises/exercise").Exercise<{
+    coeffs: number[];
 }> | import("./exercises/exercise").Exercise<{
     a: number;
     k: number;
@@ -1209,6 +1200,12 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     rank2: number;
     reason: number;
     value1: number;
+}> | import("./exercises/exercise").Exercise<{
+    rank1: number;
+    value1: number;
+    rank2: number;
+    value2: number;
+    rankAsked: number;
 }> | import("./exercises/exercise").Exercise<{
     firstValue: number;
     reason: number;
@@ -1267,43 +1264,15 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     type: number;
     nb: string;
 }> | import("./exercises/exercise").Exercise<{
+    x: number;
+    y: number;
+    z: number;
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     sqrtOperand: number;
 }> | import("./exercises/exercise").Exercise<{
     k: number;
 }> | import("./exercises/exercise").Exercise<{
     type: number;
-    /**
-     * TODO
-     * Décimal : permettre facilement -0.xxx
-     * Tree shaking export
-     *
-     * VEA:
-     *  -> -3x est bien transofmré en -3*x, x*(-3) mais pas en -x*3
-     *      ->> faire le meme delire que pour les power mais pour les opposite ?
-     *          c'est à dire créer toutes les permuts en déplacant le moins qquepart
-     *  -> faire des nodes pour les Ensembles de nombre
-     *
-     * !-> choses pour lesquelles la v1 ne marchera pas :
-     *  !-- fractions non réduites
-     *  !-- nbs décimaux avec des 0
-     *  !-- nb quelconque de moins, genre -3*-4 ou -x/-y
-     * !-> pour ces choses là il faut obligatoirement parser la rpéonse élève ?
-     *
-     * Passer les sqrtNode en tree-iable
-     *
-     *
-     *
-     * !!!à fix :
-     * ! fraction réductible
-     * ! 0,20 au lieu de 0,2
-     * ! moins partout dans fraction
-     * !puissances négatives vers inverse fraction
-     * ! simplification du ln
-     * ! meileure gestion des [] : le clavier devriat pouvoir produire des left/right ;
-     *      !aussi en tapant [ puis diviser, le crochet passe en numérateur
-     * ! espace tous les 3 chiffres dans un nb (le clavier doit le fournir aussi!)
-    
-    */
     a: number;
     x: number;
     b: number | undefined;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -30,6 +30,10 @@ const MathExercises = __importStar(require("./exercises/math"));
 const PCExercises = __importStar(require("./exercises/pc"));
 const infiniteNode_1 = require("./tree/nodes/numbers/infiniteNode");
 const toScientific_1 = require("./utils/numberPrototype/toScientific");
+const variableNode_1 = require("./tree/nodes/variables/variableNode");
+String.prototype.toTree = function () {
+    return new variableNode_1.VariableNode(this.valueOf());
+};
 Number.prototype.toTree = function () {
     const value = this.valueOf();
     if (value === Infinity)

package/lib/math/geometry/spacePoint.d.ts

@@ -0,0 +1,27 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+type AleaBound = {
+    min?: number;
+    max?: number;
+    excludes?: number[];
+};
+export declare abstract class SpacePointConstructor {
+    static random(name: string, xOpts?: AleaBound, yOpts?: AleaBound, zOpts?: AleaBound): SpacePoint;
+    static randomDifferent(names: string[]): SpacePoint[];
+}
+export declare class SpacePoint {
+    name: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toTexWithCoords(): string;
+    toCoords(): string;
+    midpoint(B: SpacePoint, name?: string): SpacePoint;
+    distanceTo(B: SpacePoint): number;
+    equals(B: SpacePoint): boolean;
+    isAligned(B: SpacePoint, C: SpacePoint): void;
+    toGGBCommand(): string;
+}
+export {};
+//# sourceMappingURL=spacePoint.d.ts.map

package/lib/math/geometry/spacePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spacePoint.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spacePoint.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAI/D,KAAK,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC;AACrE,8BAAsB,qBAAqB;IACzC,MAAM,CAAC,MAAM,CACX,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,EACjB,KAAK,CAAC,EAAE,SAAS,GAChB,UAAU;IAyBb,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE;CA4BvC;AAED,qBAAa,UAAU;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IAQlB,KAAK,IAAI,MAAM;IAIf,eAAe,IAAI,MAAM;IAKzB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,CAAC,CAAC,EAAE,UAAU,EAAE,IAAI,SAAM,GAAG,UAAU;IAkB/C,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIjC,MAAM,CAAC,CAAC,EAAE,UAAU,GAAG,OAAO;IAG9B,SAAS,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU;IAOtC,YAAY;CAKb"}

package/lib/math/geometry/spacePoint.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpacePoint = exports.SpacePointConstructor = void 0;
+const numberNode_1 = require("../../tree/nodes/numbers/numberNode");
+const randint_1 = require("../utils/random/randint");
+class SpacePointConstructor {
+    static random(name, xOpts, yOpts, zOpts) {
+        const x = (0, randint_1.randint)(xOpts?.min ?? -9, xOpts?.max ?? 10, xOpts?.excludes ?? []);
+        const y = (0, randint_1.randint)(yOpts?.min ?? -9, yOpts?.max ?? 10, yOpts?.excludes ?? []);
+        const z = (0, randint_1.randint)(zOpts?.min ?? -9, zOpts?.max ?? 10, zOpts?.excludes ?? []);
+        return new SpacePoint(name, new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z));
+    }
+    static randomDifferent(names) {
+        const res = [];
+        const points = [];
+        for (let i = 0; i < names.length; i++) {
+            let x;
+            let y;
+            let z;
+            do {
+                x = (0, randint_1.randint)(-10, 11);
+                y = (0, randint_1.randint)(-10, 11);
+                z = (0, randint_1.randint)(-10, 11);
+            } while (points.some((point) => point[0] === x && point[1] === y && point[2] === z));
+            points.push([x, y, z]);
+            res.push(new SpacePoint(names[i], new numberNode_1.NumberNode(x), new numberNode_1.NumberNode(y), new numberNode_1.NumberNode(z)));
+        }
+        return res;
+    }
+}
+exports.SpacePointConstructor = SpacePointConstructor;
+class SpacePoint {
+    constructor(name, x, y, z) {
+        this.name = name;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    toTex() {
+        return `${this.name}`;
+    }
+    toTexWithCoords() {
+        return `${this.name}\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    toCoords() {
+        return `\\left(${this.x.toTex()};${this.y.toTex()};${this.z.toTex()}\\right)`;
+    }
+    midpoint(B, name = "I") {
+        // const types = [this.x.type, this.y.type, B.x.type, B.y.type];
+        // if (types.some((type) => type !== NodeType.number)) {
+        //   throw Error("general midpoint not implemented yet");
+        // }
+        // return new Point(
+        //   name,
+        //   new Rational((this.x as NumberNode).value + (B.x as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        //   new Rational((this.y as NumberNode).value + (B.y as NumberNode).value, 2)
+        //     .simplify()
+        //     .toTree(),
+        // );
+        throw Error("unimplemented");
+    }
+    distanceTo(B) {
+        throw Error("unimplemented");
+    }
+    equals(B) {
+        return this.x.equals(B.x) && this.y.equals(B.y) && this.z.equals(B.z);
+    }
+    isAligned(B, C) {
+        // const AB = VectorConstructor.fromPoints(this, B);
+        // const AC = VectorConstructor.fromPoints(this, C);
+        // return AB.isColinear(AC);
+        throw Error("unimplemented");
+    }
+    toGGBCommand() {
+        return `${this.name} = (${this.x.toMathString()}, ${this.y.toMathString()}, ${this.z.toMathString()}})`;
+    }
+}
+exports.SpacePoint = SpacePoint;

package/lib/math/geometry/spaceVector.d.ts

@@ -0,0 +1,28 @@
+import { AlgebraicNode } from "../../tree/nodes/algebraicNode";
+import { Node } from "../../tree/nodes/node";
+import { SpacePoint } from "./spacePoint";
+export declare abstract class SpaceVectorConstructor {
+    static fromPoints(origin: SpacePoint, end: SpacePoint): SpaceVector;
+    static random(name: string, allowNull?: boolean): SpaceVector;
+    static randomDifferents(names: string[], allowNull?: boolean): SpaceVector[];
+}
+export declare class SpaceVector {
+    name: string;
+    tex: string;
+    x: AlgebraicNode;
+    y: AlgebraicNode;
+    z: AlgebraicNode;
+    constructor(name: string, x: AlgebraicNode, y: AlgebraicNode, z: AlgebraicNode);
+    toTex(): string;
+    toInlineCoordsTex(): string;
+    toTexWithCoords(): string;
+    isColinear(v: SpaceVector): boolean;
+    determinant(v: SpaceVector): AlgebraicNode;
+    times(k: AlgebraicNode, name?: string): SpaceVector;
+    scalarProduct(v: SpaceVector): Node;
+    add(v: SpaceVector): SpaceVector;
+    getNorm(): AlgebraicNode;
+    getEndPoint(startPoint: SpacePoint, name?: string): SpacePoint;
+    equals(v: SpaceVector): boolean;
+}
+//# sourceMappingURL=spaceVector.d.ts.map

package/lib/math/geometry/spaceVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spaceVector.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/spaceVector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,EAAE,IAAI,EAAY,MAAM,uBAAuB,CAAC;AAQvD,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,8BAAsB,sBAAsB;IAC1C,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,UAAU,GAAG,WAAW;IAQnE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,WAAW;IAY1D,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,UAAO,GAAG,WAAW,EAAE;CAW1E;AAED,qBAAa,WAAW;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;IACjB,CAAC,EAAE,aAAa,CAAC;gBAEf,IAAI,EAAE,MAAM,EACZ,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa,EAChB,CAAC,EAAE,aAAa;IASlB,KAAK,IAAI,MAAM;IAIf,iBAAiB,IAAI,MAAM;IAK3B,eAAe,IAAI,MAAM;IAMzB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO;IAGnC,WAAW,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa;IAI1C,KAAK,CAAC,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,EAAE,MAAM;IAQrC,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,IAAI;IAInC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW;IAShC,OAAO,IAAI,aAAa;IAYxB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,MAAM;IAQjD,MAAM,CAAC,CAAC,EAAE,WAAW;CAGtB"}