math-exercises 3.0.185 → 3.0.187

package/lib/exercises/math/python/list/pyListSetElemAtIndexWaterfall.d.ts

@@ -0,0 +1,29 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Append<T> = {
+    nameList: string;
+    value: T;
+};
+type Remove<T> = {
+    nameList: string;
+    value: T;
+};
+type Inject<T> = {
+    nameList: string;
+    index: number;
+    value: T;
+};
+type Instruction<T> = ({
+    type: "append";
+} & Append<T>) | ({
+    type: "remove";
+} & Remove<T>) | ({
+    type: "inject";
+} & Inject<T>);
+type Identifiers = {
+    nameList: string;
+    listInitial: unknown[];
+    arrInstruction: Instruction<unknown>[];
+};
+export declare const pyListSetElemAtIndexWaterfall: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyListSetElemAtIndexWaterfall.d.ts.map

package/lib/exercises/math/python/list/pyListSetElemAtIndexWaterfall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyListSetElemAtIndexWaterfall.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListSetElemAtIndexWaterfall.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AA+WF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}

package/lib/exercises/math/python/list/pyListSetElemAtIndexWaterfall.js

@@ -0,0 +1,394 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { zip } from "../../../../utils/arrays/arrayZip.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrPythonInstruction = (instruction) => {
+    const { nameList, value } = instruction;
+    switch (instruction.type) {
+        case "append":
+            return `${nameList}.append(${strPythonForListElem(value)})`;
+        case "remove":
+            return `${nameList}.remove(${strPythonForListElem(value)})`;
+        case "inject": {
+            const { index } = instruction;
+            return `${nameList}[${index}] = ${strPythonForListElem(value)}`;
+        }
+    }
+};
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const strPythonForList = (list) => {
+    return `[${list.map((elem) => strPythonForListElem(elem)).join(", ")}]`;
+};
+const strPythonForListElem = (elem) => {
+    if (typeof elem === "string") {
+        if (elem === "None") {
+            return `${elem}`;
+        }
+        else {
+            return `'${elem}'`;
+        }
+    }
+    else {
+        return `${elem}`;
+    }
+};
+const getStrPythonProgram = (identifiers) => {
+    const { nameList, listInitial, arrInstruction } = identifiers;
+    return `${nameList} = ${strPythonForList(listInitial)}
+${arrInstruction.map(getStrPythonInstruction).join(`
+`)}
+print(${nameList})
+`;
+};
+const getFunctionPythonInstruction = (instruction) => {
+    return (l) => {
+        const { nameList, value } = instruction;
+        switch (instruction.type) {
+            case "append":
+                {
+                    const lWork = [...l];
+                    lWork.push(value);
+                    return lWork;
+                }
+                break;
+            case "remove":
+                {
+                    const lWork = [...l];
+                    const indexFound = lWork.findIndex((v) => v === value);
+                    if (indexFound === -1) {
+                        throw new Error(`ValueError: ${nameList}.remove(x): x not in list`);
+                    }
+                    lWork.splice(indexFound, 1);
+                    return lWork;
+                }
+                break;
+            case "inject":
+                {
+                    const { index } = instruction;
+                    if (index < -l.length || l.length <= index) {
+                        throw new Error(`IndexError: list assignment index out of range`);
+                    }
+                    else {
+                        const lWork = [...l];
+                        const indexPositive = index >= 0 ? index : l.length + index;
+                        lWork[indexPositive] = value;
+                        return lWork;
+                    }
+                }
+                break;
+        }
+    };
+};
+const getFunctionForPythonProgram = (identifiers) => {
+    const { nameList, listInitial, arrInstruction } = identifiers;
+    return (..._otherArgs) => {
+        const outDict = {};
+        //init
+        let list = listInitial;
+        outDict[0] = {
+            [nameList]: list,
+        };
+        //main
+        {
+            arrInstruction.forEach((instruction, i) => {
+                let err;
+                try {
+                    list = getFunctionPythonInstruction(instruction)(list);
+                }
+                catch (e) {
+                    err = e;
+                }
+                outDict[i + 1] = {
+                    [nameList]: list,
+                    err,
+                };
+            });
+        }
+        //convenience: store last step in -1
+        outDict[-1] = outDict[Math.max(...Object.keys(outDict).map((k) => +k))];
+        return outDict;
+    };
+};
+const getInstruction = (identifiers) => {
+    return `Qu'affichera le script en Python suivant ?
+
+${codify(getStrPythonProgram(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { nameList } = identifiers;
+    const stepDictEnd = getFunctionForPythonProgram(identifiers)()[-1];
+    if (stepDictEnd.err) {
+        return `${stepDictEnd.err.message}`;
+    }
+    else {
+        return strPythonForList(stepDictEnd[nameList]);
+    }
+};
+const getHint = () => {
+    return `Pour affecter la valeur $\\text{'toto'}$ à la variable $nom$, on écrit ${codifyChunk("nom = 'toto'")}.
+  
+Pour affecter la valeur $\\text{'toto'}$ à la variable $maListe[6]$, c'est le même principe. 
+
+Attention ! Il faut tout de même s'assurer que cet emplacement mémoire existe.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameList, arrInstruction } = identifiers;
+    const dictSteps = getFunctionForPythonProgram(identifiers)();
+    const maxLength = Math.max(...Object.entries(dictSteps).map(([_, { [nameList]: l }]) => l.length));
+    const err = dictSteps[-1].err;
+    let indexStepWithErr;
+    if (err) {
+        indexStepWithErr = Number(Object.entries(dictSteps).find(([_, stepDict]) => stepDict.err)[0]);
+    }
+    return `Voici l'évolution de la liste $${nameList}$ au fil des instructions.  
+    
+  ${mdTable([
+        (() => {
+            const l = dictSteps[0][nameList];
+            return [
+                "\\text{Initialement}",
+                ...[...Array(maxLength).keys()].map((i) => l.length > i ? `\\text{${l[i]}}` : "\\text{}"),
+            ];
+        })(),
+        ...arrInstruction.map((instruction, i) => {
+            const l = dictSteps[i + 1][nameList];
+            if (indexStepWithErr) {
+                const indexInstructionWithErr = indexStepWithErr - 1;
+                if (i < indexInstructionWithErr) {
+                    return [
+                        `\\text{Après ${getStrPythonInstruction(instruction)}}`,
+                        ...[...Array(maxLength).keys()].map((i) => {
+                            return l.length > i ? `\\text{${l[i]}}` : "\\text{}";
+                        }),
+                    ];
+                }
+                else if (i === indexInstructionWithErr) {
+                    return [
+                        `\\text{Après ${getStrPythonInstruction(instruction)}}`,
+                        ...[...Array(maxLength).keys()].map(() => {
+                            return "\\text{}";
+                        }),
+                    ];
+                }
+                else {
+                    return [
+                        `\\text{}`,
+                        ...[...Array(maxLength).keys()].map(() => {
+                            return "\\text{}";
+                        }),
+                    ];
+                }
+            }
+            else {
+                return [
+                    `\\text{Après ${getStrPythonInstruction(instruction)}}`,
+                    ...[...Array(maxLength).keys()].map((i) => {
+                        return l.length > i ? `\\text{${l[i]}}` : "\\text{}";
+                    }),
+                ];
+            }
+        }),
+    ], true)}
+
+${(() => {
+        if (err) {
+            const indexInstructionWithErr = indexStepWithErr - 1;
+            const instructionWithErr = arrInstruction[indexInstructionWithErr];
+            switch (instructionWithErr.type) {
+                case "inject": {
+                    const instructionInject = instructionWithErr;
+                    const index = instructionInject.index;
+                    return `Quand l'instruction ${codifyChunk(getStrPythonInstruction(instructionInject))} va être exécutée,
+
+étant donné qu'aucun élément de $${nameList}$ n'existe à l'indice $${index}$
+, l'exécution ne va pas pouvoir s'effectuer correctement.
+
+Un message d'erreur va donc s'afficher.`;
+                }
+                case "remove": {
+                    const instructionRemove = instructionWithErr;
+                    const valueRemoved = instructionRemove.value;
+                    return `Quand l'instruction ${codifyChunk(getStrPythonInstruction(instructionRemove))} va être exécutée,
+
+étant donné qu'il n'y a aucun élément de $${nameList}$ qui a la valeur ${codifyChunk(strPythonForListElem(valueRemoved))}, l'exécution ne va pas pouvoir s'effectuer correctement.
+
+Un message d'erreur va donc s'afficher.`;
+                }
+                default:
+                    throw new Error("Unsupported instructionWithErr.type: " + instructionWithErr.type);
+            }
+        }
+        else {
+            return "";
+        }
+    })()}
+
+Le programme affichera donc :
+
+${codify(getAnswer(identifiers))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, codifyChunk(answer), "raw");
+    const { arrInstruction } = identifiers;
+    const [instructionInject] = arrInstruction;
+    const { index, value } = instructionInject;
+    function createAnswerWrong(funcIndexWrong, funcValueWrong = (v) => v) {
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                if (instruction.type === "inject") {
+                    return {
+                        ...instruction,
+                        index: funcIndexWrong(instruction.index),
+                        value: funcValueWrong(instruction.value),
+                    };
+                }
+                else {
+                    return instruction;
+                }
+            }),
+        };
+        return getAnswer(identifiersWrong);
+    }
+    //indexAsked-1
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index - 1)), "raw");
+    }
+    //indexAsked+1
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index + 1)), "raw");
+    }
+    //student: lst[index]=value -> lst[value]=index
+    if (typeof value === "number") {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong(() => value, () => index)), "raw");
+    }
+    //-indexAsked
+    {
+        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => -index)), "raw");
+    }
+    //error
+    {
+        const identifiersWrong = Object.assign({}, identifiers, {
+            indexAsked: 404,
+        });
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //append
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            arrInstruction: arrInstruction.map((instruction) => {
+                return { ...instruction, type: "append" };
+            }),
+        };
+        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+    }
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            const identifiersWrong = createRandomIdentifiers();
+            tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const poolNameList = ["l", "lst", "liste"];
+    const nameList = random(poolNameList);
+    const rand = randint(0, 4);
+    function createRandomListInitial(minLength, maxLength) {
+        const length = randint(minLength, maxLength + 1);
+        const poolNumber = [...Array(61).keys()].map((i) => i - 30);
+        const subPoolNumber = randomMany(poolNumber, Math.max(Math.floor(length * 1.5), length + 2));
+        const listNumber = [...Array(length).keys()].map(() => random(subPoolNumber));
+        const poolLetter = "abcdefghijklmnopqrstuvwxyz".split("");
+        const subPoolLetters = randomMany(poolLetter, Math.max(Math.floor(length * 1.5), length + 2));
+        const listLetters = [...Array(length).keys()].map(() => random(subPoolLetters));
+        switch (rand) {
+            case 0:
+                return listNumber;
+            case 1:
+                return listLetters;
+            case 2: {
+                return [...Array(length).keys()].map(() => {
+                    const word = [...Array(randint(1, 4)).keys()]
+                        .map(() => random(poolLetter))
+                        .join("");
+                    return word;
+                });
+            }
+            case 3:
+                return zip(listNumber, listLetters).map(([n, letter]) => random([n, letter]));
+            default:
+                throw new Error("Unsupported rand: " + rand);
+        }
+    }
+    const listInitial = createRandomListInitial(2, 6);
+    function createRandomInstructionInject() {
+        const index = probaLawFlip([
+            [randint(-(listInitial.length * 2), -listInitial.length), 0.05],
+            [randint(-listInitial.length, 0), 0.25],
+            [randint(0, listInitial.length), 0.65],
+            [randint(listInitial.length, listInitial.length * 2), 0.05],
+        ]);
+        const [value] = createRandomListInitial(1, 1);
+        const instruction = {
+            type: "inject",
+            nameList,
+            value,
+            index,
+        };
+        return instruction;
+    }
+    const nbInstructions = randint(2, 4);
+    const arrInstruction = [
+        ...Array(nbInstructions).keys(),
+    ].map(createRandomInstructionInject);
+    const identifiers = { nameList, listInitial, arrInstruction };
+    return identifiers;
+};
+const getPyListSetElemAtIndexWaterfallQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const pyListSetElemAtIndexWaterfall = {
+    id: "pyListSetElemAtIndexWaterfall",
+    label: "Affecter une valeur à un élément dans une liste en Python (enchaînement d'instructions)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyListSetElemAtIndexWaterfallQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/geogebra/geogebraConstructor.d.ts

@@ -35,6 +35,7 @@ export declare class GeogebraConstructor {
     maxHeight?: number;
     maxWidth?: number;
     hideFullScreenButton?: boolean;
+    interactiveObjects?: string[];
     constructor(options: Omit<GeogebraOptions, "coords">);
     getCoordsForPoints(points: Point[]): number[];
     getAdaptedCoords({ xMin, xMax, yMin, yMax, zMin, zMax, forceShowAxes, minCoords, ratio, }: GetAdaptedCoords): number[];

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;gBACnB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAsBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CAyBzD"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,eAAe,EAChB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAC;AAErD,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,eAAe,GAAG;IACrB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AACF,qBAAa,mBAAmB;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACjC,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,KAAK,CAAC,EAAE,mBAAmB,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;gBAClB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC;IAuBpD,kBAAkB,CAAC,MAAM,EAAE,KAAK,EAAE;IAOlC,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,EACb,SAAS,EACT,KAAK,GACN,EAAE,gBAAgB;IAsDnB,UAAU,CAAC,EAAE,MAAM,EAAE,EAAE,eAAe,GAAG,eAAe;CA0BzD"}

package/lib/geogebra/geogebraConstructor.js

@@ -20,6 +20,7 @@ export class GeogebraConstructor {
     maxHeight;
     maxWidth;
     hideFullScreenButton;
+    interactiveObjects;
     constructor(options) {
         this.customToolBar = options?.customToolBar ?? toolBarConstructor({});
         this.forbidShiftDragZoom = options?.forbidShiftDragZoom ?? false;
@@ -41,6 +42,7 @@ export class GeogebraConstructor {
         this.maxHeight = options?.maxHeight;
         this.hideFullScreenButton = options?.hideFullScreenButton;
         this.maxWidth = options?.maxWidth;
+        this.interactiveObjects = options?.interactiveObjects;
     }
     getCoordsForPoints(points) {
         const xMin = Math.min(...points.map((p) => p.x.evaluate()));
@@ -124,6 +126,7 @@ export class GeogebraConstructor {
             maxHeight: this.maxHeight,
             hideFullScreenButton: this.hideFullScreenButton,
             maxWidth: this.maxWidth,
+            interactiveObjects: this.interactiveObjects,
         };
     }
 }