pimath 0.0.65 → 0.0.68

package/src/maths/expressions/factors/ExpFactorPower.ts

@@ -0,0 +1,24 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorPower extends ExpressionFactor {
+private powerArgument: Expression
+    constructor(radical: Expression, power: Expression, power2?: number, root?:number) {
+        super(radical, power2, root);
+
+        this.powerArgument = power
+    }
+    derivative(variable: string): Expression {
+        return undefined
+    }
+
+    integrate(variable: string): Expression {
+        return undefined
+    }
+
+    makeTeX(): string {
+        let tex: string = `{ ${ this.argument.tex } }^{ ${this.powerArgument.tex } }`
+
+        return this.texPowerAndRoot(this.wrapWithParentheses(tex))
+    }
+}

package/src/maths/expressions/factors/ExpFactorTrigo.ts

@@ -0,0 +1,44 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export enum TRIGONOMETRIC {
+    sin='sin',
+    cos='cos',
+    tan='tan',
+    cot='cot',
+    asin='asin',
+    atan='atan',
+    acos='acos',
+    acot='acot'
+}
+export class ExpFactorTrigo extends ExpressionFactor {
+
+    private _trigo: string
+    constructor(trigo: string, argument: Expression, power?: number, root?: number) {
+
+        super(argument, power, root);
+
+        if(! (trigo in TRIGONOMETRIC)){
+            throw `The ${ trigo } is not a valid trigonometric function.`
+        }
+
+        this._trigo = trigo
+    }
+    derivative(variable: string): Expression {
+        return undefined
+    }
+
+    integrate(variable: string): Expression {
+        return undefined
+    }
+
+    makeTeX(): string {
+        let tex = `\\${this._trigo}`
+        if(this.root>1){
+            tex += `^{ ${this.root} }`
+        }
+
+        tex+= `\\left( ${this.argument.tex} \\right)`
+        return this.texRoot(tex);
+    }
+}

package/src/maths/expressions/factors/ExpFactorVariable.ts

@@ -0,0 +1,40 @@
+import {Expression} from "../internals";
+import {ExpressionFactor} from "../internals";
+
+export class ExpFactorVariable extends ExpressionFactor {
+    private _variable: string
+    constructor(value: string, power?: number, root?: number) {
+        super(null, power, root);
+
+        if (typeof value !== "string") {
+            throw `The variable ${value} is not a valid value.`
+        }
+
+        this._variable = value
+    }
+
+
+    get variable(): string {
+        return this._variable;
+    }
+
+    set variable(value: string) {
+        this._variable = value;
+    }
+
+    makeTeX(): string {
+        return this.texPower(this.texRoot(this._variable))
+    }
+
+    derivative(variable: string): Expression {
+        return undefined;
+    }
+
+    integrate(variable: string): Expression {
+        return undefined;
+    }
+
+    hasVariable(variable?: string): boolean {
+        return this._variable === variable
+    }
+}

package/src/maths/expressions/internals.ts

@@ -0,0 +1,14 @@
+export * from "./expression"
+export * from "./expressionParser"
+export * from "./expressionMember"
+
+export * from "./expressionFactor"
+export * from "./factors/ExpFactor"
+export * from "./factors/ExpFactorConstant"
+export * from "./factors/ExpFactorExponential"
+export * from "./factors/ExpFactorNumber"
+export * from "./factors/ExpFactorPower"
+export * from "./factors/ExpFactorTrigo"
+export * from "./factors/ExpFactorVariable"
+
+export * from "../shutingyard"

package/src/maths/shutingyard.ts

@@ -21,6 +21,7 @@ export enum ShutingyardType {
 }
 
 export enum ShutingyardMode {
+    EXPRESSION = 'expression',
     POLYNOM = 'polynom',
     SET = 'set',
     NUMERIC = 'numeric'
@@ -30,6 +31,7 @@ export type Token = { token: string, tokenType: string }
 
 export class Shutingyard {
     readonly _mode: ShutingyardMode;
+    private _rpn: Token[] = [];
     private _tokenConfig: tokenType;
     private _tokenConstant: { [Key: string]: number }
     private _tokenKeys: string[]
@@ -40,14 +42,16 @@ export class Shutingyard {
         this.tokenConfigInitialization()
     }
 
-    private _rpn: Token[] = [];
-
     // Getter
     get rpn() {
         // console.log(this._rpn)
         return this._rpn;
     }
 
+    get rpnToken() {
+        return this._rpn.map(x => x.token)
+    }
+
     /**
      * Determin if the token is a defined operation
      * Defined operations: + - * / ^ sin cos tan
@@ -88,6 +92,21 @@ export class Shutingyard {
                 'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = false
+        } else if (this._mode === ShutingyardMode.EXPRESSION) {
+            this._tokenConfig = {
+                '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
+                '*': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
+                '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
+                '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
+                'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'sqrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+                'nthrt': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
+            }
+            this._uniformize = true
         } else {
             this._tokenConfig = {
                 '^': {precedence: 4, associative: 'right', type: ShutingyardType.OPERATION},
@@ -95,10 +114,6 @@ export class Shutingyard {
                 '/': {precedence: 3, associative: 'left', type: ShutingyardType.OPERATION},
                 '+': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
                 '-': {precedence: 2, associative: 'left', type: ShutingyardType.OPERATION},
-                // '%': {precedence: 3, associative: 'right', type: ShutingyardType.OPERATION},
-                // 'sin': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                // 'cos': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
-                // 'tan': {precedence: 4, associative: 'right', type: ShutingyardType.FUNCTION},
             }
             this._uniformize = true
         }
@@ -131,10 +146,6 @@ export class Shutingyard {
             token = ',';
             tokenType = 'function-argument';
         } else {
-            // Order token keys by token characters length (descending)
-            // TODO: this is done each time ! SHould be done once !
-            // const keys = Object.keys(this._tokenConfig).sort((a,b)=>b.length-a.length)
-
             // Extract operation and function tokens
             for (let key of this._tokenKeys) {
                 if (expr.substring(start, start + key.length) === key) {
@@ -159,7 +170,7 @@ export class Shutingyard {
                     if (this._mode === ShutingyardMode.POLYNOM && false) {
                         token = expr.substring(start).match(/^([0-9.,/]+)/)[0]
                     } else {
-                        token = expr.substring(start).match(/^([0-9.,]+)/)[0]
+                        token = expr.substring(start).match(/^([0-9.]+)/)[0]
                     }
                     tokenType = ShutingyardType.COEFFICIENT
                 } else if (expr[start].match(/[a-zA-Z]/)) {
@@ -177,21 +188,131 @@ export class Shutingyard {
         return [token, start + token.length, tokenType];
     }
 
+    normalize(expr: string): string {
+        // Get the list of function token.
+        let fnToken: string[] = [],
+            kToken: string[] = []
+        for (let token in this._tokenConfig) {
+            if (this._tokenConfig[token].type === ShutingyardType.FUNCTION) {
+                fnToken.push(token)
+            }
+        }
+        // sort if from the lengthy to the smallest function
+        fnToken.sort((a, b) => b.length - a.length)
+
+        for (let token in tokenConstant) {
+                kToken.push(token)
+        }
+        // sort if from the lengthy to the smallest function
+        kToken.sort((a, b) => b.length - a.length)
+
+
+        let normalizedExpr: string = "",
+            i = 0,
+            crtToken,
+            nextToken
+
+        while (i < expr.length - 1) {
+            // Check if we have a function token.
+            // The function MUST have an open parentheses
+            let tokenIdx = 0
+            while (tokenIdx < fnToken.length) {
+                let token = fnToken[tokenIdx]
+                if (expr.slice(i, i + token.length + 1) === token + '(') {
+                    normalizedExpr += token + '('
+                    i += token.length + 1
+
+                    // Restart the scan for the function token
+                    tokenIdx = 0
+                } else {
+                    // scan for a next function token
+                    tokenIdx++
+                }
+            }
+
+            // Check for a constant
+            tokenIdx = 0
+            while (tokenIdx < kToken.length) {
+                let token = kToken[tokenIdx]
+                if (expr.slice(i, i + token.length) === token) {
+                    // We have found a constant.
+                    // add it, but with remove the last letter
+                    normalizedExpr += token.slice(0, -1)
+                    i += token.length-1
+
+                    // Exit the loop
+                    break
+                }
+                tokenIdx++
+            }
+
+            // The function token are solved.
+            crtToken = expr[i]
+            nextToken = expr[i + 1]
+            normalizedExpr += crtToken
+            if (crtToken.match(/[a-zA-Z]/g)) {
+                // Current element is a letter.
+                // if the next element is a letter, a number or an opening parentheses, add the multiplication sign.
+                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                    normalizedExpr += '*'
+                }
+            } else if (crtToken.match(/\d/)) {
+                // Current element is a number.
+                // if the next element is a letter or a parentheses, add the multiplication sign.
+                if (nextToken.match(/[a-zA-Z(]/)) {
+                    normalizedExpr += '*'
+                }
+            } else if (crtToken === ')') {
+                // Current element is a closing parentheses.
+                // if the next element is a letter, a number or an opening parentheses, add the multiplication sign
+                if (nextToken.match(/[a-zA-Z\d(]/)) {
+                    normalizedExpr += '*'
+                }
+            }
+
+            // Go to next token
+            i++
+        }
+
+        // add the last token
+        return normalizedExpr + nextToken
+    }
+
     /**
      * Sanitize an expression by adding missing common operation (multiplication between parentheseses)
      * @param expr
      * @constructor
      */
     Uniformizer(expr: string): string {
+        // TODO: Delete this old version
+        // Prefere "normalize", much more robust !
         // Determiner if need to be uniformized
         if (!this._uniformize) {
             return expr
         }
 
+        // Generate the list of function token.
+        let fnToken: string[] = []
+        for (let token in this._tokenConfig) {
+            if (this._tokenConfig[token].type === ShutingyardType.FUNCTION) {
+                fnToken.push(token)
+            }
+        }
+        // sort if from the lengthy to the smallest function
+        fnToken.sort((a, b) => b.length - a.length)
+        let tokenRegExp = new RegExp(`(${fnToken.join('|')})`, 'g')
+        let functionTokenOrder = Array.from(expr.matchAll(tokenRegExp))
+
+
         let expr2;
 
+        // Replace all function by @
+        expr2 = expr.replace(tokenRegExp, '@')
+        // Add * before @ (functionn)
+        expr2 = expr2.replace(/([\da-zA-Z])(@)/g, "$1*$2");
+
         // Replace missing multiplication between two parenthese
-        expr2 = expr.replace(/\)\(/g, ')*(');
+        expr2 = expr2.replace(/\)\(/g, ')*(');
 
         // Replace missing multiplication between number or setLetter and parenthese.
 
@@ -206,15 +327,27 @@ export class Shutingyard {
         expr2 = expr2.replace(/([0-9])([a-zA-Z])/g, "$1*$2");
         expr2 = expr2.replace(/([a-zA-Z])([0-9])/g, "$1*$2");
 
+        // Remove letter between function token and it's parenthese.
+        // for (let token of fnToken) {
+        //     // Remove
+        //     expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+        // }
         // Add multiplication between letters ?
-        // TODO: More robust solution to handle all letters ?
-        expr2 = expr2.replace(/([abcxyz])([abcxyz])/g, "$1*$2");
-
-        // Restore operation auto formating (prevent adding the mutliplcation star)
-        // TODO: Accept list of functions
-        let fnToken = ['sin', 'cos', 'tan']
-        for (let token of fnToken) {
-            expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+        expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
+        expr2 = expr2.replace(/([a-zA-Z])([a-zA-Z])/g, "$1*$2");
+
+        // Restore operation auto formatting (prevent adding the multiplication star)
+        let exprAsArray = expr2.split('@')
+
+        if (exprAsArray.length > 0) {
+            expr2 = ""
+            for (let idx in exprAsArray) {
+            }
+            for (let token of fnToken) {
+                // Remove
+
+                // expr2 = expr2.replace(new RegExp(token + '\\*', 'g'), token);
+            }
         }
 
         return expr2;
@@ -234,7 +367,9 @@ export class Shutingyard {
             tokenType: string = '',
             previousOpStatckLength = 0
 
-        expr = this.Uniformizer(expr);
+        // Normalize the input if required.
+        if (this._uniformize) expr = this.normalize(expr)
+
 
         let securityLoopLvl1 = 50,
             securityLoopLvl2_default = 50,
@@ -259,10 +394,6 @@ export class Shutingyard {
                         token,
                         tokenType
                     });
-                    // if(previousOpStatckLength == opStack.length && outQueue.length>=2){
-                    //     console.log('opStatckLength', outQueue, opStack.length)
-                    //     outQueue.push('*')
-                    // }
                     break;
                 case 'operation':
                     previousOpStatckLength = opStack.length;
@@ -270,7 +401,6 @@ export class Shutingyard {
                     if (opStack.length > 0) {
                         let opTop = opStack[opStack.length - 1];
 
-
                         securityLoopLvl2 = +securityLoopLvl2_default;
 
                         //while there is an operator token o2, at the top of the operator stack and

package/tests/algebra/study.test.ts

@@ -2,6 +2,7 @@ import {describe} from "mocha";
 import {Rational} from "../../src/maths/algebra/rational";
 import {RationalStudy} from "../../src/maths/algebra/study/rationalStudy";
 import {expect} from "chai";
+import {ASYMPTOTE} from "../../src/maths/algebra/study";
 
 describe('Study tests', () => {
     it('should get the zeroes', function () {
@@ -10,14 +11,18 @@ describe('Study tests', () => {
             new Rational('(3x-2)(x-3)(x+4)', 'x^2-5x+6')
         )
 
-        console.log(study.texSigns)
-        console.log(study.asymptotes)
-        console.log(study.derivative.fx.texFactors)
-        console.log(study.texGrows)
+        // console.log(study.texSigns)
+        // console.log(study.asymptotes)
+        // console.log(study.derivative.fx.texFactors)
+        // console.log(study.texGrows)
+        //
+        //
+        // console.log('----------------')
 
 
-        console.log('----------------')
+        let AO = study.asymptotes.filter(x => x.type === ASYMPTOTE.SLOPE)[0]
 
+        console.log(AO.tableOfSign.signs)
     });
 
     it('should create draw code block', function () {
@@ -34,4 +39,5 @@ describe('Study tests', () => {
             "Z_8(-2.5,0)*\n" +
             "Z_9(1.3333333333333333,0)*")
     });
+
 })

package/tests/coefficients/fraction.test.ts

@@ -75,4 +75,21 @@ describe("Fraction static functions", ()=>{
 
         expect(Fraction.average(...list).tex).to.be.equal('\\frac{ 19 }{ 10 }')
     })
+})
+
+describe("Evaluate fraction", () => {
+    it('should evaluate and convert to decimal if not exact', function () {
+        let F = new Fraction(Math.sqrt(2))
+
+        expect(F.isApproximative()).to.be.true
+        expect(F.isExact()).to.be.false
+
+        console.log(F.tex, F.value)
+
+        let G = new Fraction('1/7')
+        expect(G.isApproximative()).to.be.false
+        expect(G.isExact()).to.be.true
+
+        console.log(G.tex, G.value)
+    });
 })

package/tests/expressions/expressions.test.ts

@@ -0,0 +1,124 @@
+import {ExpFactorVariable} from "../../src/maths/expressions/factors/ExpFactorVariable";
+import {expect} from "chai";
+import {ExpFactorNumber} from "../../src/maths/expressions/factors/ExpFactorNumber";
+import {Expression} from "../../src/maths/expressions/expression";
+import {ExpFactorTrigo} from "../../src/maths/expressions/factors/ExpFactorTrigo";
+import {ExpFactor} from "../../src/maths/expressions/factors/ExpFactor";
+import {ExpressionMember} from "../../src/maths/expressions/expressionMember";
+import {ExpressionParser} from "../../src/maths/expressions/expressionParser";
+import {expressionOperators} from "../../src/maths/expressions/expressionOperators";
+
+describe('Expressions tests', () => { // the tests container
+    it('should make some test', () => {
+
+        // let a = new ExpressionParser('3x').expression
+        // let a = new ExpressionParser('3x+5').expression
+        // let a = new ExpressionParser('3x^2+5').expression
+        // let a = new ExpressionParser('3x^(2/3)+5').expression
+        // let a = new ExpressionParser('3x(x+4)').expression
+        // let a = new ExpressionParser('sin(cos(3picos(3pi)-5))+sqrt(e-sin(3pi/2))').expression
+        let a = new ExpressionParser('3+nthrt(x-3,5)').expression
+        console.log('TeX output: ', a.tex)
+        console.log(a.structure())
+
+    })
+
+    it('should make some operations', ()=>{
+        let a = new ExpressionParser('3x').expression,
+            b = new ExpressionParser('5x^2').expression,
+            c = new ExpressionParser('9x-2').expression
+
+        console.log(a.tex)
+        console.log(b.tex)
+        console.log(c.tex)
+
+        let sum = expressionOperators.add(a, b, c)
+        console.log(sum.tex)
+
+        let diff = expressionOperators.subtract(a, b)
+        console.log(diff.tex)
+
+        let mult = expressionOperators.multiply(a, b, c)
+        console.log(mult.tex)
+
+        let div = expressionOperators.divide(a, c)
+        console.log(div.tex)
+    })
+    it('should work :)', () => {
+
+        const expVar = new ExpFactorVariable('y', 3, 5)
+        expect(expVar.tex).to.be.equal('\\sqrt[5]{ y }^{ 3 }')
+
+        const expNum = new ExpFactorNumber(17, 3, 5)
+        expect(expNum.tex).to.be.equal('\\sqrt[5]{ 17 }^{ 3 }')
+
+        const expProduct1 = new ExpressionMember(expNum, expVar)
+        const expProduct2 = new ExpressionMember(
+            new ExpFactorNumber(4),
+            new ExpFactorVariable('t', 7, 2)
+        )
+        expect(expProduct2.tex).to.be.equal("4\\sqrt{ t }^{ 7 }")
+
+        const expr = new Expression(
+            expProduct1,
+            expProduct2
+        )
+
+        const ExpSin = new ExpFactorTrigo(
+            'sin',
+            expr,
+            3, 7
+        )
+
+        const expNum1 = new Expression(
+            new ExpressionMember(
+                new ExpFactorNumber(3, 2, 7),
+                new ExpFactorNumber(4, -3, 2)
+            ),
+            new ExpressionMember(
+                new ExpFactorNumber(5),
+                new ExpFactor(
+                    new Expression(
+                        new ExpressionMember(
+                            new ExpFactorNumber(3, 2),
+                            new ExpFactorNumber(2, 1, 3)
+                        ),
+                        new ExpressionMember(
+                            new ExpFactorNumber(-4, 3),
+                            new ExpFactorNumber(7, 2, 6)
+                        ),
+                        new ExpressionMember(
+                            new ExpFactorNumber(-3),
+                            ExpSin
+                        )
+                    ), 2, 3
+                )
+            )
+        )
+
+        expect(expNum1.hasVariable()).to.be.false;
+        const expNumSin = new Expression(
+            new ExpressionMember(
+                new ExpFactorTrigo('sin', expNum1)
+            )
+        )
+
+        expect(expNumSin.isNumeric()).to.be.true;
+
+    })
+
+    it('should parse an expression', () => {
+
+        // let E = new Expression().parse('3x')
+        // console.log(E.tex)
+        //
+        // const SY5: Shutingyard = new Shutingyard().parse('3/2*x^(-3)-5*x*y-12');
+        //
+        // console.log(SY5.rpn.map(x=>x.token))
+        // console.log(SY5.rpn)
+        //
+        // const expr = new Expression()
+        // expr.parse('3/2*x^(-3)-5*x*y-12')
+    })
+
+});

package/tests/shutingyard.test.ts

@@ -33,4 +33,26 @@ describe('Shuting yard', () => { // the tests container
 		expect(SY1.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '|', 'C', '&'])
 		expect(SY2.rpn.map(x=>x.token)).to.have.all.members(['A', 'B', '-', 'C', '!', '&'])
 	})
+
+    it('should uniformize the expression', ()=>{
+        // const SY1: Shutingyard = new Shutingyard(ShutingyardMode.POLYNOM).parse('3xx^2(x+5)')
+        // expect(SY1.rpn.map(x=>x.token)).to.have.all.members([
+        //     '3', 'x', '*', 'x',
+        //     '2', '^', '*', 'x',
+        //     '5', '+', '*'
+        // ])
+        //
+        // const SY2: Shutingyard = new Shutingyard(ShutingyardMode.EXPRESSION).parse('3xysqrt(x-b)-ab')
+        // expect(SY2.rpn.map(x=>x.token)).to.have.all.members([
+        //     '3', 'x',    '*',
+        //     'y', 'x',    'b',
+        //     '-', 'sqrt', '*',
+        //     'a', 'b',    '*',
+        //     '-'
+        // ])
+
+        console.log(new Shutingyard(ShutingyardMode.EXPRESSION).normalize('3x(x-5)^(2(x+7))'))
+        console.log(new Shutingyard(ShutingyardMode.EXPRESSION).normalize('sin(cos(3pi-5))+sqrt(e-sin(3pi/2))'))
+        console.log(new Shutingyard(ShutingyardMode.EXPRESSION).normalize('sin(cos(3picos(3pi)-5))+sqrt(e-sin(3pi/2))'))
+    })
 });

package/.idea/shelf/Uncommitted_changes_before_Update_at_17_04_2022_12_40_[Changes]/shelved.patch

@@ -1,21 +0,0 @@
-Index: .idea/misc.xml
-IDEA additional info:
-Subsystem: com.intellij.openapi.diff.impl.patch.BaseRevisionTextPatchEP
-<+><?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<project version=\"4\">\r\n  <component name=\"JavaScriptSettings\">\r\n    <option name=\"languageLevel\" value=\"ES6\" />\r\n  </component>\r\n</project>
-Subsystem: com.intellij.openapi.diff.impl.patch.CharsetEP
-<+>UTF-8
-===================================================================
-diff --git a/.idea/misc.xml b/.idea/misc.xml
---- a/.idea/misc.xml	(revision 086de26cdf0bc1b6bbd0062eb9ca7bf11d946bae)
-+++ b/.idea/misc.xml	(date 1650192033467)
-@@ -3,4 +3,9 @@
-   <component name="JavaScriptSettings">
-     <option name="languageLevel" value="ES6" />
-   </component>
-+  <component name="SwUserDefinedSpecifications">
-+    <option name="specTypeByUrl">
-+      <map />
-+    </option>
-+  </component>
- </project>
-

package/.idea/shelf/Uncommitted_changes_before_Update_at_17_04_2022_12_40__Changes_.xml

@@ -1,4 +0,0 @@
-<changelist name="Uncommitted_changes_before_Update_at_17_04_2022_12_40_[Changes]" date="1650192056419" recycled="true" deleted="true">
-  <option name="PATH" value="$PROJECT_DIR$/.idea/shelf/Uncommitted_changes_before_Update_at_17_04_2022_12_40_[Changes]/shelved.patch" />
-  <option name="DESCRIPTION" value="Uncommitted changes before Update at 17.04.2022 12:40 [Changes]" />
-</changelist>