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

package/dist/o-spreadsheet.iife.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
  */
 
 (function (exports, owl) {
@@ -2239,6 +2239,7 @@
       CommandResult["InvalidTableResize"] = "InvalidTableResize";
       CommandResult["PivotIdNotFound"] = "PivotIdNotFound";
       CommandResult["EmptyName"] = "EmptyName";
+      CommandResult["ValueCellIsInvalidFormula"] = "ValueCellIsInvalidFormula";
   })(exports.CommandResult || (exports.CommandResult = {}));
 
   const PLAIN_TEXT_FORMAT = "@"; // see OpenXML spec §18.8.31
@@ -2766,13 +2767,16 @@
       }
       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;
@@ -2854,7 +2858,7 @@
               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;
                   }
@@ -6162,6 +6166,132 @@
       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())));
@@ -6208,6 +6338,161 @@
       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) {
@@ -6545,6 +6830,9 @@
       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,
@@ -6565,6 +6853,9 @@
       return pivotTimeAdapter(granularity).normalizeFunctionValue(value);
   }
   function toFunctionPivotValue(value, dimension) {
+      if (value === null) {
+          return `"null"`;
+      }
       if (!pivotToFunctionValueRegistry.contains(dimension.type)) {
           return `"${value}"`;
       }
@@ -7766,6 +8057,7 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
 
+  const TREND_LINE_XAXIS_ID = "x1";
   /**
    * This file contains helpers that are common to different charts (mainly
    * line, bar and pie charts)
@@ -8087,6 +8379,84 @@ stores.inject(MyMetaStore, storeInstance);
       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 = {
@@ -9216,132 +9586,6 @@ stores.inject(MyMetaStore, storeInstance);
       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
   // -----------------------------------------------------------------------------
@@ -11072,161 +11316,6 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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
   // -----------------------------------------------------------------------------
@@ -18978,6 +19067,78 @@ stores.inject(MyMetaStore, storeInstance);
       return isMacOS() ? ev.metaKey : ev.ctrlKey;
   }
 
+  /**
+   * Return the o-spreadsheet element position relative
+   * to the browser viewport.
+   */
+  function useSpreadsheetRect() {
+      const position = owl.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;
+          }
+      }
+      owl.onMounted(updatePosition);
+      owl.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 = owl.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;
+      }
+      owl.onMounted(updateElRect);
+      owl.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 = owl.useState({ x: 0, y: 0, width: 0, height: 0 });
+      const component = owl.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();
+      owl.onMounted(updateRect);
+      owl.onPatched(updateRect);
+      return container;
+  }
+
   const arrowMap = {
       ArrowDown: "down",
       ArrowLeft: "left",
@@ -19576,7 +19737,9 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -19601,8 +19764,11 @@ stores.inject(MyMetaStore, storeInstance);
                   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);
       }
@@ -21690,6 +21856,7 @@ stores.inject(MyMetaStore, storeInstance);
           ["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"),
@@ -22223,7 +22390,22 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -22232,7 +22414,7 @@ stores.inject(MyMetaStore, storeInstance);
       const legend = {
           labels: { color: fontColor },
       };
-      if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+      if (chart.legendPosition === "none") {
           legend.display = false;
       }
       else {
@@ -22240,7 +22422,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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) => {
@@ -22298,27 +22483,11 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -22327,8 +22496,6 @@ stores.inject(MyMetaStore, storeInstance);
               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;
@@ -22341,6 +22508,30 @@ stores.inject(MyMetaStore, storeInstance);
           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 };
   }
@@ -22539,90 +22730,58 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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);
@@ -22645,7 +22804,97 @@ stores.inject(MyMetaStore, storeInstance);
       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 = {
@@ -22658,11 +22907,19 @@ stores.inject(MyMetaStore, storeInstance);
       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;
@@ -22702,6 +22959,8 @@ stores.inject(MyMetaStore, storeInstance);
           };
           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;
@@ -22717,6 +22976,32 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -22876,7 +23161,7 @@ stores.inject(MyMetaStore, storeInstance);
           labels: { color: fontColor },
           reverse: true,
       };
-      if ((!chart.labelRange && chart.dataSets.length === 1) || chart.legendPosition === "none") {
+      if (chart.legendPosition === "none") {
           legend.display = false;
       }
       else {
@@ -22884,7 +23169,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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: {
@@ -22946,6 +23234,8 @@ stores.inject(MyMetaStore, storeInstance);
           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();
@@ -22959,6 +23249,33 @@ stores.inject(MyMetaStore, storeInstance);
               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 };
   }
@@ -23815,28 +24132,12 @@ stores.inject(MyMetaStore, storeInstance);
       }
   }
   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 };
   }
@@ -24874,78 +25175,6 @@ stores.inject(MyMetaStore, storeInstance);
       };
   }
 
-  /**
-   * Return the o-spreadsheet element position relative
-   * to the browser viewport.
-   */
-  function useSpreadsheetRect() {
-      const position = owl.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;
-          }
-      }
-      owl.onMounted(updatePosition);
-      owl.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 = owl.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;
-      }
-      owl.onMounted(updateElRect);
-      owl.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 = owl.useState({ x: 0, y: 0, width: 0, height: 0 });
-      const component = owl.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();
-      owl.onMounted(updateRect);
-      owl.onPatched(updateRect);
-      return container;
-  }
-
   css /* scss */ `
   .o-popover {
     position: absolute;
@@ -27713,7 +27942,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (!pivot.isValid()) {
               return;
           }
-          env.model.dispatch("INSERT_PIVOT", {
+          env.model.dispatch("SPLIT_PIVOT_FORMULA", {
               sheetId,
               col,
               row,
@@ -31189,11 +31418,7 @@ stores.inject(MyMetaStore, storeInstance);
           });
       }
       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;
@@ -31205,9 +31430,10 @@ stores.inject(MyMetaStore, storeInstance);
           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,
@@ -31216,16 +31442,18 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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",
@@ -31234,8 +31462,9 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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() {
@@ -31243,9 +31472,10 @@ stores.inject(MyMetaStore, storeInstance);
       }
       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,
@@ -31262,6 +31492,81 @@ stores.inject(MyMetaStore, storeInstance);
       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 owl.Component {
@@ -33583,10 +33888,11 @@ stores.inject(MyMetaStore, storeInstance);
        * 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;
@@ -35825,6 +36131,14 @@ stores.inject(MyMetaStore, storeInstance);
     .pivot-dim-operator-label {
       min-width: 120px;
     }
+
+    &.pivot-dimension-invalid {
+      background-color: #ffdddd;
+      border-color: red !important;
+      select {
+        background-color: #ffdddd;
+      }
+    }
   }
 `;
   class PivotDimension extends owl.Component {
@@ -47571,12 +47885,13 @@ stores.inject(MyMetaStore, storeInstance);
                   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;
@@ -49013,7 +49328,7 @@ stores.inject(MyMetaStore, storeInstance);
                       "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
@@ -49130,6 +49445,17 @@ stores.inject(MyMetaStore, storeInstance);
           }
           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) {
@@ -51614,12 +51940,7 @@ stores.inject(MyMetaStore, storeInstance);
                           });
                       }
                       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);
                       }
                   }
               }
@@ -51629,7 +51950,7 @@ stores.inject(MyMetaStore, storeInstance);
        * 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) {
@@ -51638,20 +51959,20 @@ stores.inject(MyMetaStore, storeInstance);
                       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);
           }
       }
       /**
@@ -51684,12 +52005,7 @@ stores.inject(MyMetaStore, storeInstance);
                       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);
                       }
                   }
               }
@@ -54455,6 +54771,9 @@ stores.inject(MyMetaStore, storeInstance);
           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;
@@ -54495,7 +54814,6 @@ stores.inject(MyMetaStore, storeInstance);
           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));
@@ -58204,6 +58522,8 @@ stores.inject(MyMetaStore, storeInstance);
               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) {
@@ -58329,6 +58649,36 @@ stores.inject(MyMetaStore, storeInstance);
               });
           }
       }
+      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 {
@@ -63409,6 +63759,8 @@ stores.inject(MyMetaStore, storeInstance);
 
     .o-sidePanel-handle-container {
       width: 8px;
+      position: fixed;
+      top: 50%;
     }
     .o-sidePanel-handle {
       cursor: col-resize;
@@ -63816,13 +64168,6 @@ stores.inject(MyMetaStore, storeInstance);
               "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 });
       }
@@ -66044,7 +66389,7 @@ stores.inject(MyMetaStore, storeInstance);
   }
 
   class StateObserver {
-      changes = [];
+      changes;
       commands = [];
       /**
        * Record the changes which could happen in the given callback, save them in a
@@ -66076,7 +66421,7 @@ stores.inject(MyMetaStore, storeInstance);
           if (value[key] === val) {
               return;
           }
-          this.changes.push({
+          this.changes?.push({
               key,
               target: value,
               before: value[key],
@@ -68743,9 +69088,9 @@ stores.inject(MyMetaStore, storeInstance);
   exports.tokenize = 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";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);