math-exercises 3.0.213 → 3.0.215

package/lib/index.d.ts

@@ -165,6 +165,15 @@ declare const mathExercises: (Exercise<{
     denum1: number;
     denum2: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    denomSrc: number;
+    denom: number;
+    numOperand: number;
+    numSum: number;
+    indexBlank: number;
+}, {
+    allowNonIrreductible: boolean;
+    denom: string;
+}> | Exercise<{
     numbers: number[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     rand: number;
@@ -204,6 +213,19 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    numbers: number[];
+}, {
+    number1Pool: string[];
+    number2Pool: string[];
+}> | Exercise<{
+    numbers: number[];
+}, {
+    factorPool: string[];
+}> | Exercise<{
+    numbers: number[];
+}, {
+    factorPool: string[];
+}> | Exercise<{
     type: number;
     a: number;
     b: number;
@@ -402,12 +424,27 @@ declare const mathExercises: (Exercise<{
     indexPart: number;
 }, {
     ratioTypes: string[];
+}> | Exercise<{
+    ratioType: string;
+    situationIndex: number;
+    total: number;
+    ratio: number[];
+}, {
+    ratioTypes: string[];
 }> | Exercise<{
     num: number;
     denum: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
+    opType: string;
+    explicitWriting: boolean;
+}, {
+    explicitWriting: string;
+    opType: string;
+}> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -644,6 +681,11 @@ 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;
@@ -819,6 +861,94 @@ declare const mathExercises: (Exercise<{
 }, {
     statementFormulaType: string;
 }> | Exercise<{
+    arg: number;
+    zTex: string;
+    reIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    imIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    rIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    thetaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    reIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    imIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    z1ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z1ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z2ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z2ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    z1ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z1ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z2ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z2ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsX: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsY: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aReIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    aImIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bReIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bImIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    re: number;
+    im: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsModule: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsArgument: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isAngleInDegrees: boolean;
+}, {
+    isAngleInDegrees: boolean;
+}> | Exercise<{
+    pointIdsA: import("./math/geometry/point.js").PointIdentifiers;
+    nodeIdsModule: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsArgument: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    isCosAsked: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    moduleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    argIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nodeIdsModule: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsArgument: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsAngleBase: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    texAngleBase: string;
+    isShouldDisplayAngleBase: boolean;
+}> | Exercise<{
+    nodeIdsModule: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    nodeIdsArgument: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nbSides: number;
+    vFactor: number;
+    nodeIdsModule: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    nbSides: number;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+    indexTarget: number;
+    exponent: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    typeSituation: string;
+    nodeIdsAffixExp: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    indexesOfPoints: number[];
+    letters: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, {
+    allowPositiveA: boolean;
+}> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    aIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z1ReIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+    z1ImIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    n: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    n: number;
+    a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     z1Re: number;
     z1Im: number;
     z2Re: number;
@@ -853,27 +983,6 @@ declare const mathExercises: (Exercise<{
     re: number;
     im: number;
     isRe: boolean;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    arg: number;
-    zTex: string;
-    reIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    imIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    rIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    thetaIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    reIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    imIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    z1ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z1ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z2ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z2ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    z1ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z1ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z2ModuleIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
-    z2ArgIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     randomUnitIndex: number;
     randomUnitInstructionIndex: number;
@@ -928,6 +1037,24 @@ declare const mathExercises: (Exercise<{
     prefixPool: string[];
     isToPow10: boolean;
     isFromSymbol: boolean;
+}> | Exercise<{
+    hours: number;
+    minutes: number;
+}, {
+    amPmType: string;
+}> | Exercise<{
+    dateTimeStart: {
+        day: number;
+        hours: number;
+        minutes: number;
+    };
+    dateTimeDuration: {
+        day: number;
+        hours: number;
+        minutes: number;
+    };
+}, {
+    hoursMinutesType: string;
 }> | Exercise<{
     point: import("./math/geometry/point.js").PointIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -2678,6 +2805,8 @@ declare const mathExercises: (Exercise<{
     secondVectorPointsIndexes: number[];
     a: number;
     b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     points: string[][];
     pointAskedIndex: number[];
@@ -2720,6 +2849,9 @@ declare const mathExercises: (Exercise<{
     width: number;
     height: number;
     depth: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    height: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     A: number[];
     B: number[];
@@ -2909,6 +3041,14 @@ declare const mathExercises: (Exercise<{
     angleTypes: ("alternes-internes" | "correspondants" | "alternes-externes" | "autres")[];
     isFakeDisplay: boolean;
     nbDigits: "0" | "1" | "2";
+}> | Exercise<{
+    measure: number;
+}, {
+    availableAngleNature: string;
+}> | Exercise<{
+    angleIds: import("./math/geometry/angle.js").AngleIdentifiers;
+}, {
+    availableAngleNature: string;
 }> | Exercise<{
     lines: {
         pointA: number[];
@@ -2995,6 +3135,17 @@ declare const mathExercises: (Exercise<{
 }, {
     withoutPerp: boolean;
 }> | Exercise<{
+    lineIds: import("./math/geometry/line.js").LineIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+    indexPoint: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    lineIds: import("./math/geometry/line.js").LineIdentifiers;
+    pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+    indexPoint: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    strNameTriangle: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     type: number;
     useAngles: boolean;
@@ -3019,6 +3170,11 @@ declare const mathExercises: (Exercise<{
     triangleIds2: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     factor: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    triangleIds: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
+    strNameTriangle: string;
+}, {
+    heightType: string;
+}> | Exercise<{
     perimeter: number;
     askingX: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -3053,6 +3209,10 @@ declare const mathExercises: (Exercise<{
     bIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     cIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     isAskingRadius: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    radius: number;
+    isGivenDiameter: boolean;
+    randPositionRadius: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -3368,12 +3528,12 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     kind: "factor";
     a: number;
-    operator: "multiplication" | "division" | "soustraction" | "addition";
+    operator: "addition" | "soustraction" | "multiplication" | "division";
     factor: number;
 } | {
     kind: "series";
     series: number[];
-    operator: "multiplication" | "division" | "soustraction" | "addition";
+    operator: "addition" | "soustraction" | "multiplication" | "division";
     factor: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValues: number[];
@@ -4415,6 +4575,16 @@ declare const mathExercises: (Exercise<{
     spacePointIdsBaseVecsEndPoint: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
     spacePointIdsWrtBaseVecs: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    rectangularPrismOrigin: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
+    L: number;
+    l: number;
+    h: number;
+    arrSegmentSpacePointIds: import("./math/geometry/spacePoint.js").SpacePointIdentifiers[];
+    acceptedInputType: string;
+}, {
+    acceptedInputType: string;
+    nbComponents: string;
+}> | Exercise<{
     spacePointIds: import("./math/geometry/spacePoint.js").SpacePointIdentifiers;
     nodeIdsPlaneEquation: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -5759,6 +5929,26 @@ declare const mathExercises: (Exercise<{
     p: number;
     a: number;
     pow: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    currentDay: number;
+    step: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    numbers: number[];
+    missingIndex: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    mod: number;
+    a: number;
+    n: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    p: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    a: number;
+    b: number;
 }, Record<string, string | boolean | string[]>>)[];
 declare const pcExercises: (Exercise<{
     numbers: 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.js

@@ -273,4 +273,6 @@ const validCmds = [
     "\\color",
     "\\wedge",
     "\\equiv",
+    "\\pmod",
+    "\\arg",
 ];

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

@@ -1 +1 @@
-{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAuCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAkBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAKP,QAAQ,CAAC,QAAQ,UAAQ;IAczB,KAAK;IAGL,SAAS;IAIT,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA2BF"}
+{"version":3,"file":"angle.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/angle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAI7C,8BAAsB,gBAAgB;IACpC,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,gBAAgB;CAUrD;AACD,KAAK,UAAU,GAAG;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;CACjC,CAAC;AAEF,KAAK,qBAAqB,GAAG;IAC3B,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC,CAAC;AACF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,KAAK,CAAC,EAAE,qBAAqB,CAAC;CAC/B,CAAC;AACF,qBAAa,KAAK;IAChB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,eAAe,CAAC,EAAE,aAAa,CAAC;IAChC,KAAK,CAAC,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;gBACS,MAAM,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU;IAmB/C,aAAa,IAAI,gBAAgB;IASjC,WAAW,CAAC,CAAC,EAAE,KAAK;IAIpB,MAAM,CAAC,CAAC,EAAE,KAAK;IAqBf,SAAS,CAAC,CAAC,EAAE,KAAK;IASlB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAuCzB,MAAM;IAMN,eAAe,CAAC,CAAC,EAAE,KAAK;IAsCxB,gBAAgB,CAAC,CAAC,EAAE,KAAK;IAoBzB,QAAQ,CAAC,QAAQ,UAAQ;IAkBzB,YAAY,CAAC,QAAQ,UAAQ;IAW7B,OAAO;IAKP,QAAQ,CAAC,QAAQ,UAAQ;IAczB,KAAK;IAGL,SAAS;IAIT,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAgBN,UAAU,CAAC,IAAI,CAAC,EAAE;QAChB,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB;CA+BF"}

package/lib/math/geometry/angle.js

@@ -242,6 +242,9 @@ export class Angle {
         if (opts?.thickness !== undefined) {
             cmds.push(`SetLineThickness(${this.name}, ${opts?.thickness})`);
         }
+        if (opts?.decoration !== undefined) {
+            cmds.push(`SetDecoration(${this.name}, ${opts?.decoration})`);
+        }
         return cmds;
     }
 }

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

@@ -39,7 +39,7 @@ export declare class Segment {
         color?: string;
         size?: "scriptsize" | "tiny" | "small" | "large";
     }): string[];
-    toGGBCommands(shouldBuildPoints: boolean, { isFixed, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, }?: ToGGBCommandsProps): string[];
+    toGGBCommands(shouldBuildPoints: boolean, { isFixed, isSelectionnable, showLabel, showUnderlyingPointsLabel, showLength, style, thickness, color, }?: ToGGBCommandsProps): string[];
     includes(point: Point): boolean;
     toVector(): import("./vector.js").Vector;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,GACV,GAAE,kBAAuB;IAkC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../src/math/geometry/segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sDAAsD,CAAC;AAE1F,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAElE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,OAAO,EAAE,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAGvE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,gBAAgB,CAAC;IACzB,MAAM,EAAE,gBAAgB,CAAC;IACzB,KAAK,CAAC,EAAE,uBAAuB,CAAC;CACjC,CAAC;AACF,8BAAsB,kBAAkB;IACtC,MAAM,CAAC,MAAM;IAOb,MAAM,CAAC,eAAe,CAAC,WAAW,EAAE,kBAAkB;CAYvD;AAED,KAAK,uBAAuB,GAAG;IAC7B,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,YAAY,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAC3E,qBAAa,OAAO;IAClB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,aAAa,CAAC;IAC3B,KAAK,CAAC,EAAE,YAAY,CAAC;gBACT,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,YAAY;IAS9D,aAAa,IAAI,kBAAkB;IAUnC,WAAW;IAGX,SAAS;IAST,aAAa;IAYb,KAAK;IAGL,YAAY;IAGZ,WAAW;IAGX,qBAAqB,CAAC,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,GACL,GAAE;QACD,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;KAC7C;IAiBN,aAAa,CACX,iBAAiB,EAAE,OAAO,EAC1B,EACE,OAAc,EACd,gBAAuB,EACvB,SAAiB,EACjB,yBAAgC,EAChC,UAAkB,EAClB,KAAK,EACL,SAAS,EACT,KAAK,GACN,GAAE,kBAAuB;IAqC5B,QAAQ,CAAC,KAAK,EAAE,KAAK;IAOrB,QAAQ;CAGT"}

package/lib/math/geometry/segment.js

@@ -89,12 +89,15 @@ export class Segment {
         }
         return cmds;
     }
-    toGGBCommands(shouldBuildPoints, { isFixed = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, } = {}) {
+    toGGBCommands(shouldBuildPoints, { isFixed = true, isSelectionnable = true, showLabel = false, showUnderlyingPointsLabel = true, showLength = false, style, thickness, color, } = {}) {
         const commands = [
             `${this.ggbName}=Segment(${this.pointA.name},${this.pointB.name})`,
-            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"},${isFixed ? "false" : "true"})`,
+            `SetFixed(${this.ggbName},${isFixed ? "true" : "false"},${isSelectionnable ? "true" : "false"})`,
             `ShowLabel(${this.ggbName},${showLabel ? "true" : "false"})`,
         ];
+        if (color !== undefined) {
+            commands.push(`SetColor(${this.ggbName}, ${color})`);
+        }
         if (style !== undefined) {
             commands.push(`SetLineStyle(${this.ggbName}, ${style})`);
         }

package/lib/math/utils/geometry/angleBetweenPoints.d.ts

@@ -0,0 +1,4 @@
+import { Point } from "../../../math/geometry/point.js";
+export declare const valueAngleBetweenPoints: (point1: Point, pointCenter: Point, point2: Point) => number;
+export declare const exactAngleCandidate: (valueAngle: number) => import("../../../tree/nodes/numbers/constantNode.js").ConstantNode | import("../../../tree/nodes/numbers/numberNode.js").NumberNode | import("../../../tree/nodes/operators/multiplyNode.js").MultiplyNode;
+//# sourceMappingURL=angleBetweenPoints.d.ts.map

package/lib/math/utils/geometry/angleBetweenPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleBetweenPoints.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/geometry/angleBetweenPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AASrD,eAAO,MAAM,uBAAuB,GAClC,QAAQ,KAAK,EACb,aAAa,KAAK,EAClB,QAAQ,KAAK,WAoCd,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,4MAoCrD,CAAC"}

package/lib/math/utils/geometry/angleBetweenPoints.js

@@ -0,0 +1,58 @@
+import { SpaceVector } from "../../../math/geometry/spaceVector.js";
+import { VectorConstructor } from "../../../math/geometry/vector.js";
+import { opposite } from "../../../tree/nodes/functions/oppositeNode.js";
+import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+export const valueAngleBetweenPoints = (point1, pointCenter, point2) => {
+    const vec1 = VectorConstructor.fromPoints(pointCenter, point1);
+    const vec2 = VectorConstructor.fromPoints(pointCenter, point2);
+    const [nodeNorm1, nodeNorm2] = [vec1, vec2].map((vec) => vec.getNorm());
+    const nodeScalarProduct = vec1.scalarProduct(vec2);
+    const nodeCosAngle = frac(nodeScalarProduct, multiply(nodeNorm1, nodeNorm2));
+    const valueCosAngle = Math.min(1, Math.max(-1, nodeCosAngle.evaluate()));
+    const valueAngle = (() => {
+        const valueAngleRaw = Math.acos(valueCosAngle);
+        const nodeVectorialProduct = (() => {
+            const spaceVec1 = new SpaceVector(vec1.name, vec1.x, vec1.y, (0).toTree());
+            const spaceVec2 = new SpaceVector(vec2.name, vec2.x, vec2.y, (0).toTree());
+            return spaceVec1.vetorialProduct(spaceVec2);
+        })();
+        if (nodeVectorialProduct.z.evaluate() > 0) {
+            return valueAngleRaw;
+        }
+        else {
+            return -valueAngleRaw;
+        }
+    })();
+    return valueAngle;
+};
+export const exactAngleCandidate = (valueAngle) => {
+    const nodeAngleExactCandidate = (() => {
+        if (Math.abs(valueAngle - 0) < 0.05) {
+            return (0).toTree();
+        }
+        else {
+            const sign = valueAngle >= 0 ? +1 : -1;
+            const nMax = 8; //Pi/8 is the limit
+            const [nodeAngleCandidate] = [...Array(nMax).keys()]
+                .map((i) => i + 1)
+                .flatMap((n) => {
+                const nodeAngleBase = frac(PiNode, n);
+                const arrNodeAngle = [...Array(n + 1).keys()].map((i) => {
+                    const nodeAngleCandidate = multiply(multiply(sign, i), nodeAngleBase);
+                    return nodeAngleCandidate;
+                });
+                return arrNodeAngle;
+            })
+                .filter((nodeAngleCandidate) => Math.abs(nodeAngleCandidate.evaluate() - valueAngle) < 0.05);
+            return nodeAngleCandidate;
+        }
+    })();
+    if (nodeAngleExactCandidate &&
+        NodeComparator.isEqualViaSub(nodeAngleExactCandidate, opposite(PiNode))) {
+        return PiNode;
+    }
+    return nodeAngleExactCandidate;
+};

package/lib/math/utils/geometry/angleNWSE.d.ts

@@ -0,0 +1,3 @@
+export declare function createTypeAngleSectorNWSE(valueAngle: number): "E" | "N" | "S" | "W";
+export declare function createTypeAngleSectorNWSESecondary(valueAngle: number): "WSW" | "SSW" | "SSE" | "ESE" | "ENE" | "NNE" | "NNW" | "WNW";
+//# sourceMappingURL=angleNWSE.d.ts.map

package/lib/math/utils/geometry/angleNWSE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"angleNWSE.d.ts","sourceRoot":"","sources":["../../../../src/math/utils/geometry/angleNWSE.ts"],"names":[],"mappings":"AAEA,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,MAAM,yBAyB3D;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,iEA2CpE"}

package/lib/math/utils/geometry/angleNWSE.js

@@ -0,0 +1,56 @@
+import { PiNode } from "../../../tree/nodes/numbers/piNode.js";
+export function createTypeAngleSectorNWSE(valueAngle) {
+    const valuePi = PiNode.evaluate();
+    const valueAngleOffsetForTuningSectors = valuePi * 0.25; //ici on veut des secteurs de type N W S E
+    const valueAngleInMinusPiPlusPi = (valueAngle - valueAngleOffsetForTuningSectors) % valuePi;
+    if (-valuePi <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.5) {
+        return "S";
+    }
+    else if (-valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < 0) {
+        return "W";
+    }
+    else if (0 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.5) {
+        return "N";
+    }
+    else {
+        return "E";
+    }
+}
+export function createTypeAngleSectorNWSESecondary(valueAngle) {
+    const valuePi = PiNode.evaluate();
+    const valueAngleInMinusPiPlusPi = valueAngle % valuePi;
+    if (-valuePi <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.75) {
+        return "WSW";
+    }
+    else if (-valuePi * 0.75 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.5) {
+        return "SSW";
+    }
+    else if (-valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < -valuePi * 0.25) {
+        return "SSE";
+    }
+    else if (-valuePi * 0.25 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < 0) {
+        return "ESE";
+    }
+    else if (0 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.25) {
+        return "ENE";
+    }
+    else if (valuePi * 0.25 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.5) {
+        return "NNE";
+    }
+    else if (valuePi * 0.5 <= valueAngleInMinusPiPlusPi &&
+        valueAngleInMinusPiPlusPi < valuePi * 0.75) {
+        return "NNW";
+    }
+    else {
+        return "WNW";
+    }
+}

package/lib/tests/singleExo.test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"singleExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/singleExo.test.ts"],"names":[],"mappings":"AAEA,OAAO,6BAA6B,CAAC"}
+{"version":3,"file":"singleExo.test.d.ts","sourceRoot":"","sources":["../../src/tests/singleExo.test.ts"],"names":[],"mappings":"AAGA,OAAO,6BAA6B,CAAC"}

package/lib/tests/singleExo.test.js

@@ -1,9 +1,9 @@
+import { factoIdRmq1 } from "../exercises/math/index.js";
 import "../prototypesEnhancement.js";
 import { exoTest } from "./exoTest.js";
-import { pyLimitProgramExecution, } from "../exercises/math/index.js";
 try {
     for (let i = 0; i < 1000; i++)
-        exoTest(pyLimitProgramExecution);
+        exoTest(factoIdRmq1);
 }
 catch (err) {
     throw err;

package/lib/utils/strings/frenchDays.d.ts

@@ -0,0 +1,2 @@
+export declare const frenchDays: string[];
+//# sourceMappingURL=frenchDays.d.ts.map

package/lib/utils/strings/frenchDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frenchDays.d.ts","sourceRoot":"","sources":["../../../src/utils/strings/frenchDays.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,UAQtB,CAAC"}

package/lib/utils/strings/frenchDays.js

@@ -0,0 +1,9 @@
+export const frenchDays = [
+    "lundi",
+    "mardi",
+    "mercredi",
+    "jeudi",
+    "vendredi",
+    "samedi",
+    "dimanche",
+];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.213",
+  "version": "3.0.215",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [