@odoo/o-spreadsheet 17.5.0-alpha.2 → 17.5.0-alpha.3

package/dist/o-spreadsheet.esm.js

@@ -2,9 +2,9 @@
 /**
  * This file is generated by o-spreadsheet build tools. Do not edit it.
  * @see https://github.com/odoo/o-spreadsheet
- * @version 17.5.0-alpha.2
- * @date 2024-07-24T10:25:55.208Z
- * @hash 15fd5a8
+ * @version 17.5.0-alpha.3
+ * @date 2024-08-02T08:24:53.425Z
+ * @hash 767725f
  */
 
 import { useEnv, useSubEnv, onWillUnmount, useComponent, status, Component, useRef, onMounted, useEffect, useState, onPatched, onWillPatch, onWillUpdateProps, useExternalListener, onWillStart, xml, useChildSubEnv, markRaw, toRaw } from '@odoo/owl';
@@ -2238,6 +2238,7 @@ var CommandResult;
     CommandResult["InvalidTableResize"] = "InvalidTableResize";
     CommandResult["PivotIdNotFound"] = "PivotIdNotFound";
     CommandResult["EmptyName"] = "EmptyName";
+    CommandResult["ValueCellIsInvalidFormula"] = "ValueCellIsInvalidFormula";
 })(CommandResult || (CommandResult = {}));
 
 const PLAIN_TEXT_FORMAT = "@"; // see OpenXML spec §18.8.31
@@ -2765,13 +2766,16 @@ const wildcardToRegExp = memoize(function wildcardToRegExp(operand) {
     }
     return new RegExp("^" + exp + "$", "i");
 });
-function evaluatePredicate(value = "", criterion) {
+function evaluatePredicate(value = "", criterion, locale) {
     const { operator, operand } = criterion;
     if (operand === undefined || value === null || operand === null) {
         return false;
     }
     if (typeof operand === "number" && operator === "=") {
-        return value.toString() === operand.toString();
+        if (typeof value === "string" && (isNumber(value, locale) || isDateTime(value, locale))) {
+            return toNumber(value, locale) === operand;
+        }
+        return value === operand;
     }
     if (operator === "<>" || operator === "=") {
         let result;
@@ -2853,7 +2857,7 @@ function visitMatchingRanges(args, cb, locale, isQuery = false) {
             for (let k = 0; k < countArg - 1; k += 2) {
                 const criteriaValue = toMatrix(args[k])[i][j].value;
                 const criterion = predicates[k / 2];
-                validatedPredicates = evaluatePredicate(criteriaValue ?? undefined, criterion);
+                validatedPredicates = evaluatePredicate(criteriaValue ?? undefined, criterion, locale);
                 if (!validatedPredicates) {
                     break;
                 }
@@ -6161,6 +6165,132 @@ function countUnique(args) {
     return reduceAny(args, (acc, a) => (isDataNonEmpty(a) ? acc.add(a?.value) : acc), new Set()).size;
 }
 
+function getUnitMatrix(n) {
+    const matrix = Array(n);
+    for (let i = 0; i < n; i++) {
+        matrix[i] = Array(n).fill(0);
+        matrix[i][i] = 1;
+    }
+    return matrix;
+}
+/**
+ * Invert a matrix and compute its determinant using Gaussian Elimination.
+ *
+ * The Matrix should be a square matrix, and should be indexed [col][row] instead of the
+ * standard mathematical indexing [row][col].
+ */
+function invertMatrix(M) {
+    // Use Gaussian Elimination to calculate the inverse:
+    // (1) 'augment' the matrix (left) by the identity (on the right)
+    // (2) Turn the matrix on the left into the identity using elementary row operations
+    // (3) The matrix on the right becomes the inverse (was the identity matrix)
+    //
+    // There are 3 elementary row operations:
+    // (a) Swap 2 rows. This multiply the determinant by -1.
+    // (b) Multiply a row by a scalar. This multiply the determinant by that scalar.
+    // (c) Add to a row a multiple of another row. This does not change the determinant.
+    if (M.length !== M[0].length) {
+        throw new EvaluationError(_t("Function [[FUNCTION_NAME]] invert matrix error, only square matrices are invertible"));
+    }
+    let determinant = 1;
+    const dim = M.length;
+    const I = getUnitMatrix(dim);
+    const C = M.map((row) => row.slice());
+    // Perform elementary row operations
+    for (let pivot = 0; pivot < dim; pivot++) {
+        let diagonalElement = C[pivot][pivot];
+        // if we have a 0 on the diagonal we'll need to swap with a lower row
+        if (diagonalElement === 0) {
+            //look through every row below the i'th row
+            for (let row = pivot + 1; row < dim; row++) {
+                //if the ii'th row has a non-0 in the i'th col, swap it with that row
+                if (C[pivot][row] != 0) {
+                    swapMatrixRows(C, pivot, row);
+                    swapMatrixRows(I, pivot, row);
+                    determinant *= -1;
+                    break;
+                }
+            }
+            diagonalElement = C[pivot][pivot];
+            //if it's still 0, matrix isn't invertible
+            if (diagonalElement === 0) {
+                return { determinant: 0 };
+            }
+        }
+        // Scale this row down by e (so we have a 1 on the diagonal)
+        for (let col = 0; col < dim; col++) {
+            C[col][pivot] = C[col][pivot] / diagonalElement;
+            I[col][pivot] = I[col][pivot] / diagonalElement;
+        }
+        determinant *= diagonalElement;
+        // Subtract a multiple of the current row from ALL of
+        // the other rows so that there will be 0's in this column in the
+        // rows above and below this one
+        for (let row = 0; row < dim; row++) {
+            if (row === pivot) {
+                continue;
+            }
+            // We want to change this element to 0
+            const e = C[pivot][row];
+            // Subtract (the row above(or below) scaled by e) from (the
+            // current row) but start at the i'th column and assume all the
+            // stuff left of diagonal is 0 (which it should be if we made this
+            // algorithm correctly)
+            for (let col = 0; col < dim; col++) {
+                C[col][row] -= e * C[col][pivot];
+                I[col][row] -= e * I[col][pivot];
+            }
+        }
+    }
+    // We've done all operations, C should be the identity matrix I should be the inverse
+    return { inverted: I, determinant };
+}
+function swapMatrixRows(matrix, row1, row2) {
+    for (let i = 0; i < matrix.length; i++) {
+        const tmp = matrix[i][row1];
+        matrix[i][row1] = matrix[i][row2];
+        matrix[i][row2] = tmp;
+    }
+}
+/**
+ * Matrix multiplication of 2 matrices.
+ * ex: matrix1 : n x l, matrix2 : m x n => result : m x l
+ *
+ * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
+ */
+function multiplyMatrices(matrix1, matrix2) {
+    if (matrix1.length !== matrix2[0].length) {
+        throw new EvaluationError(_t("Cannot multiply matrices : incompatible matrices size."));
+    }
+    const rowsM1 = matrix1[0].length;
+    const colsM2 = matrix2.length;
+    const n = matrix1.length;
+    const result = Array(colsM2);
+    for (let col = 0; col < colsM2; col++) {
+        result[col] = Array(rowsM1);
+        for (let row = 0; row < rowsM1; row++) {
+            let sum = 0;
+            for (let k = 0; k < n; k++) {
+                sum += matrix1[k][row] * matrix2[col][k];
+            }
+            result[col][row] = sum;
+        }
+    }
+    return result;
+}
+/**
+ * Return the input if it's a scalar or the first element of the input if it's a matrix.
+ */
+function toScalar(matrix) {
+    if (!isMatrix(matrix)) {
+        return matrix;
+    }
+    if (matrix.length !== 1 || matrix[0].length !== 1) {
+        throw new EvaluationError(_t("The value should be a scalar or a 1x1 matrix"));
+    }
+    return matrix[0][0];
+}
+
 function assertSameNumberOfElements(...args) {
     const dims = args[0].length;
     args.forEach((arg, i) => assert(() => arg.length === dims, _t("[[FUNCTION_NAME]] has mismatched dimensions for argument %s (%s vs %s).", i.toString(), dims.toString(), arg.length.toString())));
@@ -6207,6 +6337,161 @@ function min(values, locale) {
     const result = reduceNumbers(values, (acc, a) => (a < acc ? a : acc), Infinity, locale);
     return result === Infinity ? 0 : result;
 }
+function prepareDataForRegression(X, Y, newX) {
+    const _X = X[0].length ? X : [range(1, Y.flat().length + 1)];
+    const nVar = _X.length;
+    let _newX = newX[0].length ? newX : _X;
+    _newX = _newX.length === nVar ? transposeMatrix(_newX) : _newX;
+    return { _X, _newX };
+}
+/*
+ * This function performs a linear regression on the data set. It returns an array with two elements.
+ * The first element is the slope, and the second element is the intercept.
+ * The linear regression line is: y = slope*x + intercept
+ * The function use the least squares method to find the best fit for the data set :
+ * see https://www.mathsisfun.com/data/least-squares-regression.html
+ *     https://www.statology.org/standard-error-of-estimate/
+ *     https://agronomy4future.org/?p=16670
+ *     https://vitalflux.com/interpreting-f-statistics-in-linear-regression-formula-examples/
+ *     https://web.ist.utl.pt/~ist11038/compute/errtheory/,regression/regrthroughorigin.pdf
+ */
+function fullLinearRegression(X, Y, computeIntercept = true, verbose = false) {
+    const y = Y.flat();
+    const n = y.length;
+    let { _X } = prepareDataForRegression(X, Y, [[]]);
+    _X = _X.length === n ? transposeMatrix(_X) : _X.slice();
+    assertSameNumberOfElements(_X[0], y);
+    const nVar = _X.length;
+    const nDeg = n - nVar - (computeIntercept ? 1 : 0);
+    const yMatrix = [y];
+    const xMatrix = transposeMatrix(_X.reverse());
+    let avgX = [];
+    for (let i = 0; i < nVar; i++) {
+        avgX.push(0);
+        if (computeIntercept) {
+            for (const xij of _X[i]) {
+                avgX[i] += xij;
+            }
+            avgX[i] /= n;
+        }
+    }
+    let avgY = 0;
+    if (computeIntercept) {
+        for (const yi of y) {
+            avgY += yi;
+        }
+        avgY /= n;
+    }
+    const redX = xMatrix.map((row) => row.map((value, i) => value - avgX[i]));
+    if (computeIntercept) {
+        xMatrix.forEach((row) => row.push(1));
+    }
+    const coeffs = getLMSCoefficients(xMatrix, yMatrix);
+    if (!computeIntercept) {
+        coeffs.push([0]);
+    }
+    if (!verbose) {
+        return coeffs;
+    }
+    const dot1 = multiplyMatrices(redX, transposeMatrix(redX));
+    const { inverted: dotInv } = invertMatrix(dot1);
+    if (dotInv === undefined) {
+        throw new EvaluationError(_t("Matrix is not invertible"));
+    }
+    let SSE = 0, SSR = 0;
+    for (let i = 0; i < n; i++) {
+        const yi = y[i] - avgY;
+        let temp = 0;
+        for (let j = 0; j < nVar; j++) {
+            const xi = redX[i][j];
+            temp += xi * coeffs[j][0];
+        }
+        const ei = yi - temp;
+        SSE += ei * ei;
+        SSR += temp * temp;
+    }
+    const RMSE = Math.sqrt(SSE / nDeg);
+    const r2 = SSR / (SSR + SSE);
+    const f_stat = SSR / nVar / (SSE / nDeg);
+    const deltaCoeffs = [];
+    for (let i = 0; i < nVar; i++) {
+        deltaCoeffs.push(RMSE * Math.sqrt(dotInv[i][i]));
+    }
+    if (computeIntercept) {
+        const dot2 = multiplyMatrices(dotInv, [avgX]);
+        const dot3 = multiplyMatrices(transposeMatrix([avgX]), dot2);
+        deltaCoeffs.push(RMSE * Math.sqrt(dot3[0][0] + 1 / y.length));
+    }
+    const returned = [
+        [coeffs[0][0], deltaCoeffs[0], r2, f_stat, SSR],
+        [coeffs[1][0], deltaCoeffs[1], RMSE, nDeg, SSE],
+    ];
+    for (let i = 2; i < nVar; i++) {
+        returned.push([coeffs[i][0], deltaCoeffs[i], "", "", ""]);
+    }
+    if (computeIntercept) {
+        returned.push([coeffs[nVar][0], deltaCoeffs[nVar], "", "", ""]);
+    }
+    else {
+        returned.push([0, "", "", "", ""]);
+    }
+    return returned;
+}
+/*
+  This function performs a polynomial regression on the data set. It returns the coefficients of
+  the polynomial function that best fits the data set.
+  The polynomial function is: y = c0 + c1*x + c2*x^2 + ... + cn*x^n, where n is the order (degree)
+  of the polynomial. The returned coefficients are then in the form: [c0, c1, c2, ..., cn]
+  The function is based on the method of least squares :
+  see: https://mathworld.wolfram.com/LeastSquaresFittingPolynomial.html
+*/
+function polynomialRegression(flatY, flatX, order, intercept) {
+    assertSameNumberOfElements(flatX, flatY);
+    assert(() => order >= 1, _t("Function [[FUNCTION_NAME]] A regression of order less than 1 cannot be possible."));
+    const yMatrix = [flatY];
+    const xMatrix = flatX.map((x) => range(0, order).map((i) => Math.pow(x, order - i)));
+    if (intercept) {
+        xMatrix.forEach((row) => row.push(1));
+    }
+    const coeffs = getLMSCoefficients(xMatrix, yMatrix);
+    if (!intercept) {
+        coeffs.push([0]);
+    }
+    return coeffs;
+}
+function getLMSCoefficients(xMatrix, yMatrix) {
+    const xMatrixT = transposeMatrix(xMatrix);
+    const dot1 = multiplyMatrices(xMatrix, xMatrixT);
+    const { inverted: dotInv } = invertMatrix(dot1);
+    if (dotInv === undefined) {
+        throw new EvaluationError(_t("Matrix is not invertible"));
+    }
+    const dot2 = multiplyMatrices(xMatrix, yMatrix);
+    return transposeMatrix(multiplyMatrices(dotInv, dot2));
+}
+function evaluatePolynomial(coeffs, x, order) {
+    return coeffs.reduce((acc, coeff, i) => acc + coeff * Math.pow(x, order - i), 0);
+}
+function expM(M) {
+    return M.map((col) => col.map((cell) => Math.exp(cell)));
+}
+function logM(M) {
+    return M.map((col) => col.map((cell) => Math.log(cell)));
+}
+function predictLinearValues(Y, X, newX, computeIntercept) {
+    const { _X, _newX } = prepareDataForRegression(X, Y, newX);
+    const coeffs = fullLinearRegression(_X, Y, computeIntercept, false);
+    const nVar = coeffs.length - 1;
+    const newY = _newX.map((col) => {
+        let value = 0;
+        for (let i = 0; i < nVar; i++) {
+            value += coeffs[i][0] * col[nVar - i - 1];
+        }
+        value += coeffs[nVar][0];
+        return [value];
+    });
+    return newY.length === newX.length ? newY : transposeMatrix(newY);
+}
 
 const pivotTimeAdapterRegistry = new Registry();
 function pivotTimeAdapter(granularity) {
@@ -6544,6 +6829,9 @@ function toNormalizedPivotValue(dimension, groupValue) {
     const groupValueString = typeof groupValue === "boolean"
         ? toString(groupValue).toLocaleLowerCase()
         : toString(groupValue);
+    if (groupValueString === "null") {
+        return null;
+    }
     if (!pivotNormalizationValueRegistry.contains(dimension.type)) {
         throw new EvaluationError(_t("Field %(field)s is not supported because of its type (%(type)s)", {
             field: dimension.displayName,
@@ -6564,6 +6852,9 @@ function normalizeDateTime(value, granularity) {
     return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
 }
 function toFunctionPivotValue(value, dimension) {
+    if (value === null) {
+        return `"null"`;
+    }
     if (!pivotToFunctionValueRegistry.contains(dimension.type)) {
         return `"${value}"`;
     }
@@ -7765,6 +8056,7 @@ class ComposerFocusStore extends SpreadsheetStore {
     }
 }
 
+const TREND_LINE_XAXIS_ID = "x1";
 /**
  * This file contains helpers that are common to different charts (mainly
  * line, bar and pie charts)
@@ -8086,6 +8378,84 @@ function getDefinedAxis(definition) {
     useLeftAxis ||= !useRightAxis;
     return { useLeftAxis, useRightAxis };
 }
+function computeChartPadding({ displayTitle, displayLegend, }) {
+    let top = 25;
+    if (displayTitle) {
+        top = 0;
+    }
+    else if (displayLegend) {
+        top = 10;
+    }
+    return { left: 20, right: 20, top, bottom: 10 };
+}
+function getTrendDatasetForBarChart(config, dataset) {
+    const filteredValues = [];
+    const filteredLabels = [];
+    const labels = [];
+    for (let i = 0; i < dataset.data.length; i++) {
+        if (dataset.data[i] !== null) {
+            filteredValues.push(dataset.data[i]);
+            filteredLabels.push(i + 1);
+        }
+        labels.push(i + 1);
+    }
+    const newLabels = range(0.5, labels.length + 0.55, 0.2);
+    const newValues = interpolateData(config, filteredValues, filteredLabels, newLabels);
+    if (!newValues.length) {
+        return;
+    }
+    return getFullTrendingLineDataSet(dataset, config, newValues);
+}
+function getFullTrendingLineDataSet(dataset, config, data) {
+    const backgroundColor = config.color ?? lightenColor(dataset.backgroundColor, 0.5);
+    return {
+        ...dataset,
+        type: "line",
+        xAxisID: TREND_LINE_XAXIS_ID,
+        label: dataset.label ? _t("Trend line for %s", dataset.label) : "",
+        data,
+        order: -1,
+        showLine: true,
+        pointRadius: 0,
+        backgroundColor,
+        borderColor: backgroundColor,
+        borderDash: [5, 5],
+    };
+}
+function interpolateData(config, values, labels, newLabels) {
+    if (values.length === 0 || labels.length === 0 || newLabels.length === 0) {
+        return [];
+    }
+    switch (config.type) {
+        case "polynomial": {
+            const order = config.order ?? 2;
+            if (order === 1) {
+                return predictLinearValues([values], [labels], [newLabels], true)[0];
+            }
+            const coeffs = polynomialRegression(values, labels, order, true).flat();
+            return newLabels.map((v) => evaluatePolynomial(coeffs, v, order));
+        }
+        case "exponential": {
+            const positiveLogValues = [];
+            const filteredLabels = [];
+            for (let i = 0; i < values.length; i++) {
+                if (values[i] > 0) {
+                    positiveLogValues.push(Math.log(values[i]));
+                    filteredLabels.push(labels[i]);
+                }
+            }
+            if (!filteredLabels.length) {
+                return [];
+            }
+            return expM(predictLinearValues([positiveLogValues], [filteredLabels], [newLabels], true))[0];
+        }
+        case "logarithmic": {
+            return predictLinearValues([values], logM([labels]), logM([newLabels]), true)[0];
+        }
+        default:
+            return [];
+    }
+}
 
 /** This is a chartJS plugin that will draw the values of each data next to the point/bar/pie slice */
 const chartShowValuesPlugin = {
@@ -9215,132 +9585,6 @@ function assertSquareMatrix(errorStr, arg) {
     assert(() => arg.length === arg[0].length, errorStr);
 }
 
-function getUnitMatrix(n) {
-    const matrix = Array(n);
-    for (let i = 0; i < n; i++) {
-        matrix[i] = Array(n).fill(0);
-        matrix[i][i] = 1;
-    }
-    return matrix;
-}
-/**
- * Invert a matrix and compute its determinant using Gaussian Elimination.
- *
- * The Matrix should be a square matrix, and should be indexed [col][row] instead of the
- * standard mathematical indexing [row][col].
- */
-function invertMatrix(M) {
-    // Use Gaussian Elimination to calculate the inverse:
-    // (1) 'augment' the matrix (left) by the identity (on the right)
-    // (2) Turn the matrix on the left into the identity using elementary row operations
-    // (3) The matrix on the right becomes the inverse (was the identity matrix)
-    //
-    // There are 3 elementary row operations:
-    // (a) Swap 2 rows. This multiply the determinant by -1.
-    // (b) Multiply a row by a scalar. This multiply the determinant by that scalar.
-    // (c) Add to a row a multiple of another row. This does not change the determinant.
-    if (M.length !== M[0].length) {
-        throw new EvaluationError(_t("Function [[FUNCTION_NAME]] invert matrix error, only square matrices are invertible"));
-    }
-    let determinant = 1;
-    const dim = M.length;
-    const I = getUnitMatrix(dim);
-    const C = M.map((row) => row.slice());
-    // Perform elementary row operations
-    for (let pivot = 0; pivot < dim; pivot++) {
-        let diagonalElement = C[pivot][pivot];
-        // if we have a 0 on the diagonal we'll need to swap with a lower row
-        if (diagonalElement === 0) {
-            //look through every row below the i'th row
-            for (let row = pivot + 1; row < dim; row++) {
-                //if the ii'th row has a non-0 in the i'th col, swap it with that row
-                if (C[pivot][row] != 0) {
-                    swapMatrixRows(C, pivot, row);
-                    swapMatrixRows(I, pivot, row);
-                    determinant *= -1;
-                    break;
-                }
-            }
-            diagonalElement = C[pivot][pivot];
-            //if it's still 0, matrix isn't invertible
-            if (diagonalElement === 0) {
-                return { determinant: 0 };
-            }
-        }
-        // Scale this row down by e (so we have a 1 on the diagonal)
-        for (let col = 0; col < dim; col++) {
-            C[col][pivot] = C[col][pivot] / diagonalElement;
-            I[col][pivot] = I[col][pivot] / diagonalElement;
-        }
-        determinant *= diagonalElement;
-        // Subtract a multiple of the current row from ALL of
-        // the other rows so that there will be 0's in this column in the
-        // rows above and below this one
-        for (let row = 0; row < dim; row++) {
-            if (row === pivot) {
-                continue;
-            }
-            // We want to change this element to 0
-            const e = C[pivot][row];
-            // Subtract (the row above(or below) scaled by e) from (the
-            // current row) but start at the i'th column and assume all the
-            // stuff left of diagonal is 0 (which it should be if we made this
-            // algorithm correctly)
-            for (let col = 0; col < dim; col++) {
-                C[col][row] -= e * C[col][pivot];
-                I[col][row] -= e * I[col][pivot];
-            }
-        }
-    }
-    // We've done all operations, C should be the identity matrix I should be the inverse
-    return { inverted: I, determinant };
-}
-function swapMatrixRows(matrix, row1, row2) {
-    for (let i = 0; i < matrix.length; i++) {
-        const tmp = matrix[i][row1];
-        matrix[i][row1] = matrix[i][row2];
-        matrix[i][row2] = tmp;
-    }
-}
-/**
- * Matrix multiplication of 2 matrices.
- * ex: matrix1 : n x l, matrix2 : m x n => result : m x l
- *
- * Note: we use indexing [col][row] instead of the standard mathematical notation [row][col]
- */
-function multiplyMatrices(matrix1, matrix2) {
-    if (matrix1.length !== matrix2[0].length) {
-        throw new EvaluationError(_t("Cannot multiply matrices : incompatible matrices size."));
-    }
-    const rowsM1 = matrix1[0].length;
-    const colsM2 = matrix2.length;
-    const n = matrix1.length;
-    const result = Array(colsM2);
-    for (let col = 0; col < colsM2; col++) {
-        result[col] = Array(rowsM1);
-        for (let row = 0; row < rowsM1; row++) {
-            let sum = 0;
-            for (let k = 0; k < n; k++) {
-                sum += matrix1[k][row] * matrix2[col][k];
-            }
-            result[col][row] = sum;
-        }
-    }
-    return result;
-}
-/**
- * Return the input if it's a scalar or the first element of the input if it's a matrix.
- */
-function toScalar(matrix) {
-    if (!isMatrix(matrix)) {
-        return matrix;
-    }
-    if (matrix.length !== 1 || matrix[0].length !== 1) {
-        throw new EvaluationError(_t("The value should be a scalar or a 1x1 matrix"));
-    }
-    return matrix[0][0];
-}
-
 // -----------------------------------------------------------------------------
 // ARRAY_CONSTRAIN
 // -----------------------------------------------------------------------------
@@ -11071,161 +11315,6 @@ function centile(data, percent, isInclusive, locale) {
     }
     return percentile(sortedArray, _percent, isInclusive);
 }
-function prepareDataForRegression(X, Y, newX) {
-    const _X = X[0].length ? X : [range(1, Y.flat().length + 1)];
-    const nVar = _X.length;
-    let _newX = newX[0].length ? newX : _X;
-    _newX = _newX.length === nVar ? transposeMatrix(_newX) : _newX;
-    return { _X, _newX };
-}
-/*
- * This function performs a linear regression on the data set. It returns an array with two elements.
- * The first element is the slope, and the second element is the intercept.
- * The linear regression line is: y = slope*x + intercept
- * The function use the least squares method to find the best fit for the data set :
- * see https://www.mathsisfun.com/data/least-squares-regression.html
- *     https://www.statology.org/standard-error-of-estimate/
- *     https://agronomy4future.org/?p=16670
- *     https://vitalflux.com/interpreting-f-statistics-in-linear-regression-formula-examples/
- *     https://web.ist.utl.pt/~ist11038/compute/errtheory/,regression/regrthroughorigin.pdf
- */
-function fullLinearRegression(X, Y, computeIntercept = true, verbose = false) {
-    const y = Y.flat();
-    const n = y.length;
-    let { _X } = prepareDataForRegression(X, Y, [[]]);
-    _X = _X.length === n ? transposeMatrix(_X) : _X.slice();
-    assertSameNumberOfElements(_X[0], y);
-    const nVar = _X.length;
-    const nDeg = n - nVar - (computeIntercept ? 1 : 0);
-    const yMatrix = [y];
-    const xMatrix = transposeMatrix(_X.reverse());
-    let avgX = [];
-    for (let i = 0; i < nVar; i++) {
-        avgX.push(0);
-        if (computeIntercept) {
-            for (const xij of _X[i]) {
-                avgX[i] += xij;
-            }
-            avgX[i] /= n;
-        }
-    }
-    let avgY = 0;
-    if (computeIntercept) {
-        for (const yi of y) {
-            avgY += yi;
-        }
-        avgY /= n;
-    }
-    const redX = xMatrix.map((row) => row.map((value, i) => value - avgX[i]));
-    if (computeIntercept) {
-        xMatrix.forEach((row) => row.push(1));
-    }
-    const coeffs = getLMSCoefficients(xMatrix, yMatrix);
-    if (!computeIntercept) {
-        coeffs.push([0]);
-    }
-    if (!verbose) {
-        return coeffs;
-    }
-    const dot1 = multiplyMatrices(redX, transposeMatrix(redX));
-    const { inverted: dotInv } = invertMatrix(dot1);
-    if (dotInv === undefined) {
-        throw new EvaluationError(_t("Matrix is not invertible"));
-    }
-    let SSE = 0, SSR = 0;
-    for (let i = 0; i < n; i++) {
-        const yi = y[i] - avgY;
-        let temp = 0;
-        for (let j = 0; j < nVar; j++) {
-            const xi = redX[i][j];
-            temp += xi * coeffs[j][0];
-        }
-        const ei = yi - temp;
-        SSE += ei * ei;
-        SSR += temp * temp;
-    }
-    const RMSE = Math.sqrt(SSE / nDeg);
-    const r2 = SSR / (SSR + SSE);
-    const f_stat = SSR / nVar / (SSE / nDeg);
-    const deltaCoeffs = [];
-    for (let i = 0; i < nVar; i++) {
-        deltaCoeffs.push(RMSE * Math.sqrt(dotInv[i][i]));
-    }
-    if (computeIntercept) {
-        const dot2 = multiplyMatrices(dotInv, [avgX]);
-        const dot3 = multiplyMatrices(transposeMatrix([avgX]), dot2);
-        deltaCoeffs.push(RMSE * Math.sqrt(dot3[0][0] + 1 / y.length));
-    }
-    const returned = [
-        [coeffs[0][0], deltaCoeffs[0], r2, f_stat, SSR],
-        [coeffs[1][0], deltaCoeffs[1], RMSE, nDeg, SSE],
-    ];
-    for (let i = 2; i < nVar; i++) {
-        returned.push([coeffs[i][0], deltaCoeffs[i], "", "", ""]);
-    }
-    if (computeIntercept) {
-        returned.push([coeffs[nVar][0], deltaCoeffs[nVar], "", "", ""]);
-    }
-    else {
-        returned.push([0, "", "", "", ""]);
-    }
-    return returned;
-}
-/*
-  This function performs a polynomial regression on the data set. It returns the coefficients of
-  the polynomial function that best fits the data set.
-  The polynomial function is: y = c0 + c1*x + c2*x^2 + ... + cn*x^n, where n is the order (degree)
-  of the polynomial. The returned coefficients are then in the form: [c0, c1, c2, ..., cn]
-  The function is based on the method of least squares :
-  see: https://mathworld.wolfram.com/LeastSquaresFittingPolynomial.html
-*/
-function polynomialRegression(flatY, flatX, order, intercept) {
-    assertSameNumberOfElements(flatX, flatY);
-    assert(() => order >= 1, _t("Function [[FUNCTION_NAME]] A regression of order less than 1 cannot be possible."));
-    const yMatrix = [flatY];
-    const xMatrix = flatX.map((x) => range(0, order).map((i) => Math.pow(x, order - i)));
-    if (intercept) {
-        xMatrix.forEach((row) => row.push(1));
-    }
-    const coeffs = getLMSCoefficients(xMatrix, yMatrix);
-    if (!intercept) {
-        coeffs.push([0]);
-    }
-    return coeffs;
-}
-function getLMSCoefficients(xMatrix, yMatrix) {
-    const xMatrixT = transposeMatrix(xMatrix);
-    const dot1 = multiplyMatrices(xMatrix, xMatrixT);
-    const { inverted: dotInv } = invertMatrix(dot1);
-    if (dotInv === undefined) {
-        throw new EvaluationError(_t("Matrix is not invertible"));
-    }
-    const dot2 = multiplyMatrices(xMatrix, yMatrix);
-    return transposeMatrix(multiplyMatrices(dotInv, dot2));
-}
-function evaluatePolynomial(coeffs, x, order) {
-    return coeffs.reduce((acc, coeff, i) => acc + coeff * Math.pow(x, order - i), 0);
-}
-function expM(M) {
-    return M.map((col) => col.map((cell) => Math.exp(cell)));
-}
-function logM(M) {
-    return M.map((col) => col.map((cell) => Math.log(cell)));
-}
-function predictLinearValues(Y, X, newX, computeIntercept) {
-    const { _X, _newX } = prepareDataForRegression(X, Y, newX);
-    const coeffs = fullLinearRegression(_X, Y, computeIntercept, false);
-    const nVar = coeffs.length - 1;
-    const newY = _newX.map((col) => {
-        let value = 0;
-        for (let i = 0; i < nVar; i++) {
-            value += coeffs[i][0] * col[nVar - i - 1];
-        }
-        value += coeffs[nVar][0];
-        return [value];
-    });
-    return newY.length === newX.length ? newY : transposeMatrix(newY);
-}
 // -----------------------------------------------------------------------------
 // AVEDEV
 // -----------------------------------------------------------------------------
@@ -18977,6 +19066,78 @@ function isCtrlKey(ev) {
     return isMacOS() ? ev.metaKey : ev.ctrlKey;
 }
 
+/**
+ * Return the o-spreadsheet element position relative
+ * to the browser viewport.
+ */
+function useSpreadsheetRect() {
+    const position = useState({ x: 0, y: 0, width: 0, height: 0 });
+    let spreadsheetElement = null;
+    function updatePosition() {
+        if (!spreadsheetElement) {
+            spreadsheetElement = document.querySelector(".o-spreadsheet");
+        }
+        if (spreadsheetElement) {
+            const { top, left, width, height } = spreadsheetElement.getBoundingClientRect();
+            position.x = left;
+            position.y = top;
+            position.width = width;
+            position.height = height;
+        }
+    }
+    onMounted(updatePosition);
+    onPatched(updatePosition);
+    return position;
+}
+/**
+ * Return the component (or ref's component) BoundingRect, relative
+ * to the upper left corner of the screen (<body> element).
+ *
+ * Note: when used with a <Portal/> component, it will
+ * return the portal position, not the teleported position.
+ */
+function useAbsoluteBoundingRect(ref) {
+    const rect = useState({ x: 0, y: 0, width: 0, height: 0 });
+    function updateElRect() {
+        const el = ref.el;
+        if (el === null) {
+            return;
+        }
+        const { top, left, width, height } = el.getBoundingClientRect();
+        rect.x = left;
+        rect.y = top;
+        rect.width = width;
+        rect.height = height;
+    }
+    onMounted(updateElRect);
+    onPatched(updateElRect);
+    return rect;
+}
+/**
+ * Get the rectangle inside which a popover should stay when being displayed.
+ * It's the value defined in `env.getPopoverContainerRect`, or the Rect of the "o-spreadsheet"
+ * element by default.
+ *
+ * Coordinates are expressed expressed as absolute DOM position.
+ */
+function usePopoverContainer() {
+    const container = useState({ x: 0, y: 0, width: 0, height: 0 });
+    const component = useComponent();
+    const spreadsheetRect = useSpreadsheetRect();
+    function updateRect() {
+        const env = component.env;
+        const newRect = "getPopoverContainerRect" in env ? env.getPopoverContainerRect() : spreadsheetRect;
+        container.x = newRect.x;
+        container.y = newRect.y;
+        container.width = newRect.width;
+        container.height = newRect.height;
+    }
+    updateRect();
+    onMounted(updateRect);
+    onPatched(updateRect);
+    return container;
+}
+
 const arrowMap = {
     ArrowDown: "down",
     ArrowLeft: "left",
@@ -19575,7 +19736,9 @@ class CellComposer extends Component {
         argToFocus: 0,
     });
     compositionActive = false;
+    spreadsheetRect = useSpreadsheetRect();
     get assistantStyle() {
+        const composerRect = this.composerRef.el.getBoundingClientRect();
         const assistantStyle = {};
         assistantStyle["min-width"] = `${this.props.rect?.width || ASSISTANT_WIDTH}px`;
         const proposals = this.autoCompleteState.provider?.proposals;
@@ -19600,8 +19763,11 @@ class CellComposer extends Component {
                 assistantStyle.right = `0px`;
             }
         }
-        else if (this.props.delimitation) {
-            assistantStyle["max-height"] = `${this.props.delimitation.height}px`;
+        else {
+            assistantStyle["max-height"] = `${this.spreadsheetRect.height - composerRect.bottom}px`;
+            if (composerRect.left + ASSISTANT_WIDTH > this.spreadsheetRect.width) {
+                assistantStyle.right = `0px`;
+            }
         }
         return cssPropertiesToCss(assistantStyle);
     }
@@ -21689,6 +21855,7 @@ const CfTerms = {
         ["ValueUpperInvalidFormula" /* CommandResult.ValueUpperInvalidFormula */]: _t("Invalid upper inflection point formula"),
         ["ValueLowerInvalidFormula" /* CommandResult.ValueLowerInvalidFormula */]: _t("Invalid lower inflection point formula"),
         ["EmptyRange" /* CommandResult.EmptyRange */]: _t("A range needs to be defined"),
+        ["ValueCellIsInvalidFormula" /* CommandResult.ValueCellIsInvalidFormula */]: _t("At least one of the provided values is an invalid formula"),
         Unexpected: _t("The rule is invalid for an unknown reason"),
     },
     ColorScale: _t("Color scale"),
@@ -22222,7 +22389,22 @@ class BarChart extends AbstractChart {
         return new BarChart(definition, this.sheetId, this.getters);
     }
 }
-function getBarConfiguration(chart, labels, localeFormat) {
+function createBarChartRuntime(chart, getters) {
+    const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
+    let labels = labelValues.formattedValues;
+    let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
+    if (chart.dataSetsHaveTitle &&
+        dataSetsValues[0] &&
+        labels.length > dataSetsValues[0].data.length) {
+        labels.shift();
+    }
+    ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
+    if (chart.aggregated) {
+        ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
+    }
+    const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
+    const locale = getters.getLocale();
+    const localeFormat = { format: dataSetFormat, locale };
     const fontColor = chartFontColor(chart.background);
     const config = getDefaultChartJsRuntime(chart, labels, fontColor, {
         ...localeFormat,
@@ -22231,7 +22413,7 @@ function getBarConfiguration(chart, labels, localeFormat) {
     const legend = {
         labels: { color: fontColor },
     };
-    if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+    if (chart.legendPosition === "none") {
         legend.display = false;
     }
     else {
@@ -22239,7 +22421,10 @@ function getBarConfiguration(chart, labels, localeFormat) {
     }
     config.options.plugins.legend = { ...config.options.plugins?.legend, ...legend };
     config.options.layout = {
-        padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
+        padding: computeChartPadding({
+            displayTitle: !!chart.title.text,
+            displayLegend: chart.legendPosition === "top",
+        }),
     };
     config.options.indexAxis = chart.horizontal ? "y" : "x";
     const formatCallback = (value) => {
@@ -22297,27 +22482,11 @@ function getBarConfiguration(chart, labels, localeFormat) {
         horizontal: chart.horizontal,
         callback: formatCallback,
     };
-    return config;
-}
-function createBarChartRuntime(chart, getters) {
-    const labelValues = getChartLabelValues(getters, chart.dataSets, chart.labelRange);
-    let labels = labelValues.formattedValues;
-    let dataSetsValues = getChartDatasetValues(getters, chart.dataSets);
-    if (chart.dataSetsHaveTitle &&
-        dataSetsValues[0] &&
-        labels.length > dataSetsValues[0].data.length) {
-        labels.shift();
-    }
-    ({ labels, dataSetsValues } = filterEmptyDataPoints(labels, dataSetsValues));
-    if (chart.aggregated) {
-        ({ labels, dataSetsValues } = aggregateDataForLabels(labels, dataSetsValues));
-    }
-    const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
-    const locale = getters.getLocale();
-    const config = getBarConfiguration(chart, labels, { format: dataSetFormat, locale });
     const colors = new ColorGenerator();
+    const trendDatasets = [];
     const definition = chart.getDefinition();
-    for (const { label, data } of dataSetsValues) {
+    for (const index in dataSetsValues) {
+        const { label, data } = dataSetsValues[index];
         const color = colors.next();
         const dataset = {
             label,
@@ -22326,8 +22495,6 @@ function createBarChartRuntime(chart, getters) {
             backgroundColor: color,
         };
         config.data.datasets.push(dataset);
-    }
-    for (const [index, dataset] of config.data.datasets.entries()) {
         if (definition.dataSets?.[index]?.backgroundColor) {
             const color = definition.dataSets[index].backgroundColor;
             dataset.backgroundColor = color;
@@ -22340,6 +22507,30 @@ function createBarChartRuntime(chart, getters) {
         if (definition.dataSets?.[index]?.yAxisId && !chart.horizontal) {
             dataset["yAxisID"] = definition.dataSets[index].yAxisId;
         }
+        const trend = definition.dataSets?.[index].trend;
+        if (!trend?.display || chart.horizontal) {
+            continue;
+        }
+        const trendDataset = getTrendDatasetForBarChart(trend, dataset);
+        if (trendDataset) {
+            trendDatasets.push(trendDataset);
+        }
+    }
+    if (trendDatasets.length) {
+        /* We add a second x axis here to draw the trend lines, with the labels length being
+         * set so that the second axis points match the classical x axis
+         */
+        const maxLength = Math.max(...trendDatasets.map((trendDataset) => trendDataset.data.length));
+        config.options.scales[TREND_LINE_XAXIS_ID] = {
+            ...xAxis,
+            labels: Array(maxLength).fill(""),
+            offset: false,
+            display: false,
+        };
+        /* These datasets must be inserted after the original
+         * datasets to ensure the way we distinguish the originals and trendLine datasets after
+         */
+        trendDatasets.forEach((x) => config.data.datasets.push(x));
     }
     return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
 }
@@ -22538,90 +22729,58 @@ function isLuxonTimeAdapterInstalled() {
     }
     return isInstalled;
 }
-function getLineOrScatterConfiguration(chart, labels, options) {
-    const fontColor = chartFontColor(chart.background);
-    const config = getDefaultChartJsRuntime(chart, labels, fontColor, options);
-    const legend = {
-        labels: {
-            color: fontColor,
-            generateLabels(chart) {
-                // color the legend labels with the dataset color, without any transparency
-                const { data } = chart;
-                const labels = window.Chart.defaults.plugins.legend.labels.generateLabels(chart);
-                for (const [index, label] of labels.entries()) {
-                    label.fillStyle = data.datasets[index].borderColor;
+function getTrendDatasetForLineChart(config, dataset, axisType, locale) {
+    const filteredValues = [];
+    const filteredLabels = [];
+    const labels = [];
+    const datasetLength = dataset.data.length;
+    switch (axisType) {
+        case "category":
+            for (let i = 0; i < datasetLength; i++) {
+                if (dataset.data[i] !== null) {
+                    filteredValues.push(dataset.data[i]);
+                    filteredLabels.push(i + 1);
                 }
-                return labels;
-            },
-        },
-    };
-    if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
-        legend.display = false;
-    }
-    else {
-        legend.position = chart.legendPosition;
-    }
-    Object.assign(config.options.plugins.legend || {}, legend);
-    config.options.layout = {
-        padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
-    };
-    config.options.scales = {
-        x: {
-            ticks: {
-                padding: 5,
-                color: fontColor,
-            },
-            title: getChartAxisTitleRuntime(chart.axesDesign?.x),
-        },
-    };
-    const formatCallback = (value) => {
-        value = Number(value);
-        if (isNaN(value))
-            return value;
-        const { locale, format } = options;
-        return formatValue(value, {
-            locale,
-            format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
-        });
-    };
-    const yAxis = {
-        beginAtZero: true, // the origin of the y axis is always zero
-        ticks: {
-            color: fontColor,
-            callback: formatCallback,
-        },
-    };
-    const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
-    if (useLeftAxis) {
-        config.options.scales.y = {
-            ...yAxis,
-            position: "left",
-            title: getChartAxisTitleRuntime(chart.axesDesign?.y),
-        };
+                labels.push(i + 1);
+            }
+            break;
+        case "linear":
+            for (const point of dataset.data) {
+                const label = Number(point.x);
+                if (isNaN(label)) {
+                    continue;
+                }
+                if (point.y !== null) {
+                    filteredValues.push(point.y);
+                    filteredLabels.push(label);
+                }
+                labels.push(label);
+            }
+            break;
+        case "time":
+            for (const point of dataset.data) {
+                const date = toJsDate({ value: point.x }, locale).getTime();
+                if (point.y !== null) {
+                    filteredValues.push(point.y);
+                    filteredLabels.push(date);
+                }
+                labels.push(date);
+            }
+            break;
     }
-    if (useRightAxis) {
-        config.options.scales.y1 = {
-            ...yAxis,
-            position: "right",
-            title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
-        };
+    const xmin = Math.min(...labels);
+    const xmax = Math.max(...labels);
+    if (xmax === xmin) {
+        return;
     }
-    if ("stacked" in chart && chart.stacked) {
-        if (useLeftAxis) {
-            // @ts-ignore chart.js type is broken
-            config.options.scales.y.stacked = true;
-        }
-        if (useRightAxis) {
-            // @ts-ignore chart.js type is broken
-            config.options.scales.y1.stacked = true;
-        }
+    const numberOfStep = 5 * labels.length;
+    const step = (xmax - xmin) / numberOfStep;
+    const newLabels = range(xmin, xmax + step / 2, step);
+    const newValues = interpolateData(config, filteredValues, filteredLabels, newLabels);
+    if (!newValues.length) {
+        return;
     }
-    config.options.plugins.chartShowValuesPlugin = {
-        showValues: chart.showValues,
-        background: chart.background,
-        callback: formatCallback,
-    };
-    return config;
+    return getFullTrendingLineDataSet(dataset, config, newValues);
 }
 function createLineOrScatterChartRuntime(chart, getters) {
     const axisType = getChartAxisType(chart, getters);
@@ -22644,7 +22803,97 @@ function createLineOrScatterChartRuntime(chart, getters) {
     const truncateLabels = axisType === "category";
     const dataSetFormat = getChartDatasetFormat(getters, chart.dataSets);
     const options = { format: dataSetFormat, locale, truncateLabels };
-    const config = getLineOrScatterConfiguration(chart, labels, options);
+    const fontColor = chartFontColor(chart.background);
+    const config = getDefaultChartJsRuntime(chart, labels, fontColor, options);
+    const legend = {
+        labels: {
+            color: fontColor,
+            generateLabels(chart) {
+                // color the legend labels with the dataset color, without any transparency
+                const { data } = chart;
+                const labels = window.Chart.defaults.plugins.legend.labels.generateLabels(chart);
+                for (const [index, label] of labels.entries()) {
+                    label.fillStyle = data.datasets[index].borderColor;
+                }
+                return labels;
+            },
+        },
+    };
+    if (chart.legendPosition === "none") {
+        legend.display = false;
+    }
+    else {
+        legend.position = chart.legendPosition;
+    }
+    Object.assign(config.options.plugins.legend || {}, legend);
+    config.options.layout = {
+        padding: computeChartPadding({
+            displayTitle: !!chart.title.text,
+            displayLegend: chart.legendPosition === "top",
+        }),
+    };
+    const xAxis = {
+        ticks: {
+            padding: 5,
+            color: fontColor,
+        },
+        title: getChartAxisTitleRuntime(chart.axesDesign?.x),
+    };
+    config.options.scales = {
+        x: xAxis,
+    };
+    const formatCallback = (value) => {
+        value = Number(value);
+        if (isNaN(value))
+            return value;
+        const { locale, format } = options;
+        return formatValue(value, {
+            locale,
+            format: !format && Math.abs(value) >= 1000 ? "#,##" : format,
+        });
+    };
+    const yAxis = {
+        beginAtZero: true, // the origin of the y axis is always zero
+        ticks: {
+            color: fontColor,
+            callback: formatCallback,
+        },
+    };
+    const { useLeftAxis, useRightAxis } = getDefinedAxis(chart.getDefinition());
+    if (useLeftAxis) {
+        config.options.scales.y = {
+            ...yAxis,
+            position: "left",
+            title: getChartAxisTitleRuntime(chart.axesDesign?.y),
+        };
+    }
+    if (useRightAxis) {
+        config.options.scales.y1 = {
+            ...yAxis,
+            position: "right",
+            title: getChartAxisTitleRuntime(chart.axesDesign?.y1),
+        };
+    }
+    if ("stacked" in chart && chart.stacked) {
+        if (useLeftAxis) {
+            // @ts-ignore chart.js type is broken
+            config.options.scales.y.stacked = true;
+        }
+        if (useRightAxis) {
+            // @ts-ignore chart.js type is broken
+            config.options.scales.y1.stacked = true;
+        }
+    }
+    config.options.plugins.chartShowValuesPlugin = {
+        showValues: chart.showValues,
+        background: chart.background,
+        callback: formatCallback,
+    };
+    if (chart.dataSetsHaveTitle &&
+        dataSetsValues[0] &&
+        labels.length > dataSetsValues[0].data.length) {
+        labels.shift();
+    }
     const labelFormat = getChartLabelFormat(getters, chart.labelRange);
     if (axisType === "time") {
         const axis = {
@@ -22657,11 +22906,19 @@ function createLineOrScatterChartRuntime(chart, getters) {
     else if (axisType === "linear") {
         config.options.scales.x.type = "linear";
         config.options.scales.x.ticks.callback = (value) => formatValue(value, { format: labelFormat, locale });
-        config.options.plugins.tooltip.callbacks.title = (tooltipItem) => {
-            return formatValue(tooltipItem[0].parsed.x || tooltipItem[0].label, {
-                locale,
-                format: labelFormat,
-            });
+        config.options.plugins.tooltip.callbacks.title = () => "";
+        config.options.plugins.tooltip.callbacks.label = (tooltipItem) => {
+            const dataSetPoint = dataSetsValues[tooltipItem.datasetIndex].data[tooltipItem.dataIndex];
+            let label = tooltipItem.label || labelValues.values[tooltipItem.dataIndex];
+            if (isNumber(label, locale)) {
+                label = toNumber(label, locale);
+            }
+            const formattedX = formatValue(label, { locale, format: labelFormat });
+            const formattedY = formatValue(dataSetPoint, { locale, format: dataSetFormat });
+            const dataSetTitle = tooltipItem.dataset.label;
+            return formattedX
+                ? `${dataSetTitle}: (${formattedX}, ${formattedY})`
+                : `${dataSetTitle}: ${formattedY}`;
         };
     }
     const areaChart = "fillArea" in chart ? chart.fillArea : false;
@@ -22701,6 +22958,8 @@ function createLineOrScatterChartRuntime(chart, getters) {
         };
         config.data.datasets.push(dataset);
     }
+    let maxLength = 0;
+    const trendDatasets = [];
     for (const [index, dataset] of config.data.datasets.entries()) {
         if (definition.dataSets?.[index]?.backgroundColor) {
             const color = definition.dataSets[index].backgroundColor;
@@ -22716,6 +22975,32 @@ function createLineOrScatterChartRuntime(chart, getters) {
         if (definition.dataSets?.[index]?.yAxisId) {
             dataset["yAxisID"] = definition.dataSets[index].yAxisId;
         }
+        const trend = definition.dataSets?.[index].trend;
+        if (!trend?.display) {
+            continue;
+        }
+        const trendDataset = getTrendDatasetForLineChart(trend, dataset, axisType, locale);
+        if (trendDataset) {
+            maxLength = Math.max(maxLength, trendDataset.data.length);
+            trendDatasets.push(trendDataset);
+            dataSetsValues.push(trendDataset);
+        }
+    }
+    if (trendDatasets.length) {
+        /* We add a second x axis here to draw the trend lines, with the labels length being
+         * set so that the second axis points match the classical x axis
+         */
+        config.options.scales[TREND_LINE_XAXIS_ID] = {
+            ...xAxis,
+            type: "category",
+            labels: range(0, maxLength).map((x) => x.toString()),
+            offset: false,
+            display: false,
+        };
+        /* These datasets must be inserted after the original datasets to ensure the way we
+         * distinguish the originals and trendLine datasets after
+         */
+        trendDatasets.forEach((x) => config.data.datasets.push(x));
     }
     return {
         chartJsConfig: config,
@@ -22875,7 +23160,7 @@ function createComboChartRuntime(chart, getters) {
         labels: { color: fontColor },
         reverse: true,
     };
-    if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+    if (chart.legendPosition === "none") {
         legend.display = false;
     }
     else {
@@ -22883,7 +23168,10 @@ function createComboChartRuntime(chart, getters) {
     }
     config.options.plugins.legend = { ...config.options.plugins?.legend, ...legend };
     config.options.layout = {
-        padding: { left: 20, right: 20, top: chart.title ? 10 : 25, bottom: 10 },
+        padding: computeChartPadding({
+            displayTitle: !!chart.title.text,
+            displayLegend: chart.legendPosition === "top",
+        }),
     };
     config.options.scales = {
         x: {
@@ -22945,6 +23233,8 @@ function createComboChartRuntime(chart, getters) {
         callback: formatCallback(mainDataSetFormat),
     };
     const colors = new ColorGenerator();
+    let maxLength = 0;
+    const trendDatasets = [];
     for (let [index, { label, data }] of dataSetsValues.entries()) {
         const design = definition.dataSets[index];
         const color = colors.next();
@@ -22958,6 +23248,33 @@ function createComboChartRuntime(chart, getters) {
             order: -index,
         };
         config.data.datasets.push(dataset);
+        const trend = definition.dataSets?.[index].trend;
+        if (!trend?.display) {
+            continue;
+        }
+        maxLength = Math.max(maxLength, data.length);
+        const trendDataset = getTrendDatasetForBarChart(trend, dataset);
+        if (trendDataset) {
+            trendDatasets.push(trendDataset);
+        }
+    }
+    if (trendDatasets.length) {
+        /* We add a second x axis here to draw the trend lines, with the labels length being
+         * set so that the second axis points match the classical x axis
+         */
+        config.options.scales[TREND_LINE_XAXIS_ID] = {
+            ticks: {
+                padding: 5,
+                color: fontColor,
+            },
+            labels: Array(10 * maxLength + 1).fill(""),
+            offset: false,
+            display: false,
+        };
+        /* These datasets must be inserted after the original datasets to ensure the way we
+         * distinguish the originals and trendLine datasets after
+         */
+        trendDatasets.forEach((x) => config.data.datasets.push(x));
     }
     return { chartJsConfig: config, background: chart.background || BACKGROUND_CHART_COLOR };
 }
@@ -23814,28 +24131,12 @@ class ScatterChart extends AbstractChart {
     }
 }
 function createScatterChartRuntime(chart, getters) {
-    const { chartJsConfig, background, dataSetsValues, dataSetFormat, labelValues, labelFormat } = createLineOrScatterChartRuntime(chart, getters);
+    const { chartJsConfig, background } = createLineOrScatterChartRuntime(chart, getters);
     // use chartJS line chart and disable the lines instead of chartJS scatter chart. This is because the scatter chart
     // have less options than the line chart (it only works with linear labels)
     chartJsConfig.type = "line";
-    const configOptions = chartJsConfig.options;
-    const locale = getters.getLocale();
-    configOptions.plugins.tooltip.callbacks.title = () => "";
-    configOptions.plugins.tooltip.callbacks.label = (tooltipItem) => {
-        const dataSetPoint = dataSetsValues[tooltipItem.datasetIndex].data[tooltipItem.dataIndex];
-        let label = tooltipItem.label || labelValues.values[tooltipItem.dataIndex];
-        if (isNumber(label, locale)) {
-            label = toNumber(label, locale);
-        }
-        const formattedX = formatValue(label, { locale, format: labelFormat });
-        const formattedY = formatValue(dataSetPoint, { locale, format: dataSetFormat });
-        const dataSetTitle = tooltipItem.dataset.label;
-        return formattedX
-            ? `${dataSetTitle}: (${formattedX}, ${formattedY})`
-            : `${dataSetTitle}: ${formattedY}`;
-    };
     for (const dataSet of chartJsConfig.data.datasets) {
-        dataSet.showLine = false;
+        dataSet.showLine = "showLine" in dataSet ? dataSet.showLine : false;
     }
     return { chartJsConfig, background };
 }
@@ -24873,78 +25174,6 @@ function zoneToRect(zone) {
     };
 }
 
-/**
- * Return the o-spreadsheet element position relative
- * to the browser viewport.
- */
-function useSpreadsheetRect() {
-    const position = useState({ x: 0, y: 0, width: 0, height: 0 });
-    let spreadsheetElement = null;
-    function updatePosition() {
-        if (!spreadsheetElement) {
-            spreadsheetElement = document.querySelector(".o-spreadsheet");
-        }
-        if (spreadsheetElement) {
-            const { top, left, width, height } = spreadsheetElement.getBoundingClientRect();
-            position.x = left;
-            position.y = top;
-            position.width = width;
-            position.height = height;
-        }
-    }
-    onMounted(updatePosition);
-    onPatched(updatePosition);
-    return position;
-}
-/**
- * Return the component (or ref's component) BoundingRect, relative
- * to the upper left corner of the screen (<body> element).
- *
- * Note: when used with a <Portal/> component, it will
- * return the portal position, not the teleported position.
- */
-function useAbsoluteBoundingRect(ref) {
-    const rect = useState({ x: 0, y: 0, width: 0, height: 0 });
-    function updateElRect() {
-        const el = ref.el;
-        if (el === null) {
-            return;
-        }
-        const { top, left, width, height } = el.getBoundingClientRect();
-        rect.x = left;
-        rect.y = top;
-        rect.width = width;
-        rect.height = height;
-    }
-    onMounted(updateElRect);
-    onPatched(updateElRect);
-    return rect;
-}
-/**
- * Get the rectangle inside which a popover should stay when being displayed.
- * It's the value defined in `env.getPopoverContainerRect`, or the Rect of the "o-spreadsheet"
- * element by default.
- *
- * Coordinates are expressed expressed as absolute DOM position.
- */
-function usePopoverContainer() {
-    const container = useState({ x: 0, y: 0, width: 0, height: 0 });
-    const component = useComponent();
-    const spreadsheetRect = useSpreadsheetRect();
-    function updateRect() {
-        const env = component.env;
-        const newRect = "getPopoverContainerRect" in env ? env.getPopoverContainerRect() : spreadsheetRect;
-        container.x = newRect.x;
-        container.y = newRect.y;
-        container.width = newRect.width;
-        container.height = newRect.height;
-    }
-    updateRect();
-    onMounted(updateRect);
-    onPatched(updateRect);
-    return container;
-}
-
 css /* scss */ `
   .o-popover {
     position: absolute;
@@ -27712,7 +27941,7 @@ const FIX_FORMULAS = {
         if (!pivot.isValid()) {
             return;
         }
-        env.model.dispatch("INSERT_PIVOT", {
+        env.model.dispatch("SPLIT_PIVOT_FORMULA", {
             sheetId,
             col,
             row,
@@ -31188,11 +31417,7 @@ class ChartWithAxisDesignPanel extends Component {
         });
     }
     getDataSeries() {
-        const runtime = this.env.model.getters.getChartRuntime(this.props.figureId);
-        if (!runtime || !("chartJsConfig" in runtime)) {
-            return [];
-        }
-        return runtime.chartJsConfig.data.datasets.map((d) => d.label);
+        return this.props.definition.dataSets.map((d, i) => d.label ?? `${ChartTerms.Series} ${i + 1}`);
     }
     updateSerieEditor(ev) {
         const chartId = this.props.figureId;
@@ -31204,9 +31429,10 @@ class ChartWithAxisDesignPanel extends Component {
         this.state.index = selectedIndex;
     }
     updateDataSeriesColor(color) {
-        const dataSets = this.props.definition.dataSets;
-        if (!dataSets?.[this.state.index])
+        const dataSets = [...this.props.definition.dataSets];
+        if (!dataSets?.[this.state.index]) {
             return;
+        }
         dataSets[this.state.index] = {
             ...dataSets[this.state.index],
             backgroundColor: color,
@@ -31215,16 +31441,18 @@ class ChartWithAxisDesignPanel extends Component {
     }
     getDataSerieColor() {
         const dataSets = this.props.definition.dataSets;
-        if (!dataSets?.[this.state.index])
+        if (!dataSets?.[this.state.index]) {
             return "";
+        }
         const color = dataSets[this.state.index].backgroundColor;
         return color ? toHex(color) : getNthColor(this.state.index);
     }
     updateDataSeriesAxis(ev) {
         const axis = ev.target.value;
-        const dataSets = this.props.definition.dataSets;
-        if (!dataSets?.[this.state.index])
+        const dataSets = [...this.props.definition.dataSets];
+        if (!dataSets?.[this.state.index]) {
             return;
+        }
         dataSets[this.state.index] = {
             ...dataSets[this.state.index],
             yAxisId: axis === "left" ? "y" : "y1",
@@ -31233,8 +31461,9 @@ class ChartWithAxisDesignPanel extends Component {
     }
     getDataSerieAxis() {
         const dataSets = this.props.definition.dataSets;
-        if (!dataSets?.[this.state.index])
+        if (!dataSets?.[this.state.index]) {
             return "left";
+        }
         return dataSets[this.state.index].yAxisId === "y1" ? "right" : "left";
     }
     get canHaveTwoVerticalAxis() {
@@ -31242,9 +31471,10 @@ class ChartWithAxisDesignPanel extends Component {
     }
     updateDataSeriesLabel(ev) {
         const label = ev.target.value;
-        const dataSets = this.props.definition.dataSets;
-        if (!dataSets?.[this.state.index])
+        const dataSets = [...this.props.definition.dataSets];
+        if (!dataSets?.[this.state.index]) {
             return;
+        }
         dataSets[this.state.index] = {
             ...dataSets[this.state.index],
             label,
@@ -31261,6 +31491,81 @@ class ChartWithAxisDesignPanel extends Component {
     updateShowValues(showValues) {
         this.props.updateChart(this.props.figureId, { showValues });
     }
+    toggleDataTrend(display) {
+        const dataSets = [...this.props.definition.dataSets];
+        if (!dataSets?.[this.state.index]) {
+            return;
+        }
+        dataSets[this.state.index] = {
+            ...dataSets[this.state.index],
+            trend: {
+                type: "polynomial",
+                order: 1,
+                ...dataSets[this.state.index].trend,
+                display,
+            },
+        };
+        this.props.updateChart(this.props.figureId, { dataSets });
+    }
+    getTrendLineConfiguration() {
+        const dataSets = this.props.definition.dataSets;
+        return dataSets?.[this.state.index]?.trend;
+    }
+    getTrendType(config) {
+        if (!config) {
+            return "";
+        }
+        return config.type === "polynomial" && config.order === 1 ? "linear" : config.type;
+    }
+    onChangeTrendType(ev) {
+        const type = ev.target.value;
+        let config;
+        switch (type) {
+            case "linear":
+            case "polynomial":
+                config = {
+                    type: "polynomial",
+                    order: type === "linear" ? 1 : 2,
+                };
+                break;
+            case "exponential":
+            case "logarithmic":
+                config = { type };
+                break;
+            default:
+                return;
+        }
+        this.updateTrendLineValue(config);
+    }
+    onChangePolynomialDegree(ev) {
+        const element = ev.target;
+        const order = parseInt(element.value || "1");
+        if (order < 2) {
+            element.value = `${this.getTrendLineConfiguration()?.order ?? 2}`;
+            return;
+        }
+        this.updateTrendLineValue({ order });
+    }
+    getTrendLineColor() {
+        return this.getTrendLineConfiguration()?.color ?? setColorAlpha(this.getDataSerieColor(), 0.5);
+    }
+    updateTrendLineColor(color) {
+        this.updateTrendLineValue({ color });
+    }
+    updateTrendLineValue(config) {
+        const dataSets = [...this.props.definition.dataSets];
+        if (!dataSets?.[this.state.index]) {
+            return;
+        }
+        dataSets[this.state.index] = {
+            ...dataSets[this.state.index],
+            trend: {
+                ...dataSets[this.state.index].trend,
+                ...config,
+            },
+        };
+        this.props.updateChart(this.props.figureId, { dataSets });
+    }
 }
 
 class GaugeChartConfigPanel extends Component {
@@ -33582,10 +33887,11 @@ class ConditionalFormattingEditor extends Component {
      * Cell Is Rule
      ****************************************************************************/
     get isValue1Invalid() {
-        return !!this.state.errors?.includes("FirstArgMissing" /* CommandResult.FirstArgMissing */);
+        return (this.state.errors.includes("FirstArgMissing" /* CommandResult.FirstArgMissing */) ||
+            this.state.errors.includes("ValueCellIsInvalidFormula" /* CommandResult.ValueCellIsInvalidFormula */));
     }
     get isValue2Invalid() {
-        return !!this.state.errors?.includes("SecondArgMissing" /* CommandResult.SecondArgMissing */);
+        return this.state.errors.includes("SecondArgMissing" /* CommandResult.SecondArgMissing */);
     }
     toggleStyle(tool) {
         const style = this.state.rules.cellIs.style;
@@ -35824,6 +36130,14 @@ css /* scss */ `
     .pivot-dim-operator-label {
       min-width: 120px;
     }
+
+    &.pivot-dimension-invalid {
+      background-color: #ffdddd;
+      border-color: red !important;
+      select {
+        background-color: #ffdddd;
+      }
+    }
   }
 `;
 class PivotDimension extends Component {
@@ -47570,12 +47884,13 @@ class BordersPlugin extends CorePlugin {
                 this.clearBorders(cmd.sheetId, cmd.target);
                 break;
             case "REMOVE_COLUMNS_ROWS":
-                for (let el of [...cmd.elements].sort((a, b) => b - a)) {
+                const elements = [...cmd.elements].sort((a, b) => b - a);
+                for (const group of groupConsecutive(elements)) {
                     if (cmd.dimension === "COL") {
-                        this.shiftBordersHorizontally(cmd.sheetId, el + 1, -1);
+                        this.shiftBordersHorizontally(cmd.sheetId, group[group.length - 1] + 1, -group.length);
                     }
                     else {
-                        this.shiftBordersVertically(cmd.sheetId, el + 1, -1);
+                        this.shiftBordersVertically(cmd.sheetId, group[group.length - 1] + 1, -group.length);
                     }
                 }
                 break;
@@ -49012,7 +49327,7 @@ class ConditionalFormatPlugin extends CorePlugin {
                     "LessThan",
                     "LessThanOrEqual",
                     "NotContains",
-                ]), this.checkOperatorArgsNumber(0, ["IsEmpty", "IsNotEmpty"]));
+                ]), this.checkOperatorArgsNumber(0, ["IsEmpty", "IsNotEmpty"]), this.checkCFValues);
             case "ColorScaleRule": {
                 return this.checkValidations(rule, this.chainValidations(this.checkThresholds(this.checkFormulaCompilation)), this.chainValidations(this.checkThresholds(this.checkNaN), this.batchValidations(this.checkMinBiggerThanMax, this.checkMinBiggerThanMid, this.checkMidBiggerThanMax
                 // Those three validations can be factorized further
@@ -49129,6 +49444,17 @@ class ConditionalFormatPlugin extends CorePlugin {
         }
         return "Success" /* CommandResult.Success */;
     }
+    checkCFValues(rule) {
+        for (const value of rule.values) {
+            if (!value.startsWith("="))
+                continue;
+            const compiledFormula = compile(value || "");
+            if (compiledFormula.isBadExpression) {
+                return "ValueCellIsInvalidFormula" /* CommandResult.ValueCellIsInvalidFormula */;
+            }
+        }
+        return "Success" /* CommandResult.Success */;
+    }
     removeConditionalFormatting(id, sheet) {
         const cfIndex = this.cfRules[sheet].findIndex((s) => s.id === id);
         if (cfIndex !== -1) {
@@ -51613,12 +51939,7 @@ class SheetPlugin extends CorePlugin {
                         });
                     }
                     if (colIndex > deletedColumn) {
-                        this.dispatch("UPDATE_CELL_POSITION", {
-                            sheetId: sheet.id,
-                            cellId: cellId,
-                            col: colIndex - 1,
-                            row: rowIndex,
-                        });
+                        this.setNewPosition(cellId, sheet.id, colIndex - 1, rowIndex);
                     }
                 }
             }
@@ -51628,7 +51949,7 @@ class SheetPlugin extends CorePlugin {
      * Move the cells after a column or rows insertion
      */
     moveCellsOnAddition(sheet, addedElement, quantity, dimension) {
-        const commands = [];
+        const updates = [];
         for (let rowIndex = 0; rowIndex < sheet.rows.length; rowIndex++) {
             const row = sheet.rows[rowIndex];
             if (dimension !== "rows" || rowIndex >= addedElement) {
@@ -51637,20 +51958,20 @@ class SheetPlugin extends CorePlugin {
                     const cellId = row.cells[i];
                     if (cellId) {
                         if (dimension === "rows" || colIndex >= addedElement) {
-                            commands.push({
-                                type: "UPDATE_CELL_POSITION",
+                            updates.push({
                                 sheetId: sheet.id,
                                 cellId: cellId,
                                 col: colIndex + (dimension === "columns" ? quantity : 0),
                                 row: rowIndex + (dimension === "rows" ? quantity : 0),
+                                type: "UPDATE_CELL_POSITION",
                             });
                         }
                     }
                 }
             }
         }
-        for (let cmd of commands.reverse()) {
-            this.dispatch(cmd.type, cmd);
+        for (let update of updates.reverse()) {
+            this.updateCellPosition(update);
         }
     }
     /**
@@ -51683,12 +52004,7 @@ class SheetPlugin extends CorePlugin {
                     const colIndex = Number(i);
                     const cellId = row.cells[i];
                     if (cellId) {
-                        this.dispatch("UPDATE_CELL_POSITION", {
-                            sheetId: sheet.id,
-                            cellId: cellId,
-                            col: colIndex,
-                            row: rowIndex - numberRows,
-                        });
+                        this.setNewPosition(cellId, sheet.id, colIndex, rowIndex - numberRows);
                     }
                 }
             }
@@ -54454,6 +54770,9 @@ class Evaluator {
         if (!this.blockedArrayFormulas.has(position)) {
             this.invalidateSpreading(position);
         }
+        if (this.spreadingRelations.isArrayFormula(position)) {
+            this.spreadingRelations.removeNode(position);
+        }
         const cell = this.getters.getCell(position);
         if (cell === undefined) {
             return EMPTY_CELL;
@@ -54494,7 +54813,6 @@ class Evaluator {
         this.assertSheetHasEnoughSpaceToSpreadFormulaResult(formulaPosition, formulaReturn);
         const nbColumns = formulaReturn.length;
         const nbRows = formulaReturn[0].length;
-        this.spreadingRelations.removeNode(formulaPosition);
         forEachSpreadPositionInMatrix(nbColumns, nbRows, this.updateSpreadRelation(formulaPosition));
         this.assertNoMergedCellsInSpreadZone(formulaPosition, formulaReturn);
         forEachSpreadPositionInMatrix(nbColumns, nbRows, this.checkCollision(formulaPosition));
@@ -58203,6 +58521,8 @@ class InsertPivotPlugin extends UIPlugin {
             case "INSERT_PIVOT_WITH_TABLE":
                 this.insertPivotWithTable(cmd.sheetId, cmd.col, cmd.row, cmd.pivotId, cmd.table);
                 break;
+            case "SPLIT_PIVOT_FORMULA":
+                this.splitPivotFormula(cmd.sheetId, cmd.col, cmd.row, cmd.pivotId, cmd.table);
         }
     }
     insertNewPivot(pivotId, sheetId) {
@@ -58328,6 +58648,36 @@ class InsertPivotPlugin extends UIPlugin {
             });
         }
     }
+    splitPivotFormula(sheetId, col, row, pivotId, pivotTableData) {
+        this.dispatch("INSERT_PIVOT", {
+            sheetId,
+            col,
+            row,
+            pivotId,
+            table: pivotTableData,
+        });
+        const table = this.getters.getCoreTable({ sheetId, col, row });
+        if (table?.type === "dynamic") {
+            const zone = positionToZone({ col, row });
+            const { cols, rows, measures, fieldsType } = pivotTableData;
+            const pivotTable = new SpreadsheetPivotTable(cols, rows, measures, fieldsType || {});
+            const colNumber = pivotTable.getNumberOfDataColumns() + 1;
+            const rowNumber = pivotTable.columns.length + pivotTable.rows.length;
+            const tableZone = {
+                left: col,
+                top: row,
+                right: col + colNumber - 1,
+                bottom: row + rowNumber - 1,
+            };
+            const rangeData = this.getters.getRangeDataFromZone(sheetId, tableZone);
+            this.dispatch("UPDATE_TABLE", {
+                sheetId,
+                zone,
+                newTableRange: rangeData,
+                tableType: "static",
+            });
+        }
+    }
 }
 
 class SortPlugin extends UIPlugin {
@@ -63408,6 +63758,8 @@ css /* scss */ `
 
     .o-sidePanel-handle-container {
       width: 8px;
+      position: fixed;
+      top: 50%;
     }
     .o-sidePanel-handle {
       cursor: col-resize;
@@ -63815,13 +64167,6 @@ class TopBarComposer extends Component {
             "border-color": SELECTION_BORDER_COLOR,
         });
     }
-    get delimitation() {
-        const { width, height } = this.env.model.getters.getSheetViewDimensionWithHeaders();
-        return {
-            width,
-            height,
-        };
-    }
     onFocus(selection) {
         this.composerFocusStore.focusComposer(this.composerInterface, { selection });
     }
@@ -66043,7 +66388,7 @@ function createEmptyStructure(node) {
 }
 
 class StateObserver {
-    changes = [];
+    changes;
     commands = [];
     /**
      * Record the changes which could happen in the given callback, save them in a
@@ -66075,7 +66420,7 @@ class StateObserver {
         if (value[key] === val) {
             return;
         }
-        this.changes.push({
+        this.changes?.push({
             key,
             target: value,
             before: value[key],
@@ -68699,6 +69044,6 @@ const constants = {
 export { AbstractCellClipboardHandler, AbstractChart, AbstractFigureClipboardHandler, CellErrorType, CommandResult, CorePlugin, DispatchResult, EvaluationError, Model, PivotRuntimeDefinition, Registry, Revision, SPREADSHEET_DIMENSIONS, Spreadsheet, SpreadsheetPivotTable, UIPlugin, __info__, addFunction, addRenderingLayer, astToFormula, compile, compileTokens, components, constants, convertAstNodes, coreTypes, findCellInNewZone, functionCache, helpers, hooks, invalidateCFEvaluationCommands, invalidateDependenciesCommands, invalidateEvaluationCommands, iterateAstNodes, links, load, parse, parseTokens, readonlyAllowedCommands, registries, setDefaultSheetViewSize, setTranslationMethod, stores, tokenColors, tokenize };
 
 
-__info__.version = "17.5.0-alpha.2";
-__info__.date = "2024-07-24T10:25:55.208Z";
-__info__.hash = "15fd5a8";
+__info__.version = "17.5.0-alpha.3";
+__info__.date = "2024-08-02T08:24:53.425Z";
+__info__.hash = "767725f";