@odoo/o-spreadsheet 16.5.0-alpha.7 → 16.5.0-alpha.8

package/dist/o-spreadsheet.iife.js

@@ -1,3 +1,12 @@
+
+/**
+ * This file is generated by o-spreadsheet build tools. Do not edit it.
+ * @see https://github.com/odoo/o-spreadsheet
+ * @version 16.5.0-alpha.8
+ * @date 2023-09-21T15:59:10.959Z
+ * @hash 0b7527d
+ */
+
 (function (exports, owl) {
   'use strict';
 
@@ -232,13 +241,26 @@
   const MENU_ITEM_PADDING_VERTICAL = 4;
   const MENU_SEPARATOR_BORDER_WIDTH = 1;
   const MENU_SEPARATOR_PADDING = 5;
+  // Style
+  const DEFAULT_STYLE = {
+      align: "left",
+      verticalAlign: "bottom",
+      wrapping: "overflow",
+      bold: false,
+      italic: false,
+      strikethrough: false,
+      underline: false,
+      fontSize: 10,
+      fillColor: "",
+      textColor: "#000000",
+  };
+  const DEFAULT_VERTICAL_ALIGN = DEFAULT_STYLE.verticalAlign;
+  const DEFAULT_WRAPPING_MODE = DEFAULT_STYLE.wrapping;
   // Fonts
   const DEFAULT_FONT_WEIGHT = "400";
-  const DEFAULT_FONT_SIZE = 10;
+  const DEFAULT_FONT_SIZE = DEFAULT_STYLE.fontSize;
   const HEADER_FONT_SIZE = 11;
   const DEFAULT_FONT = "'Roboto', arial";
-  const DEFAULT_VERTICAL_ALIGN = "bottom";
-  const DEFAULT_WRAPPING_MODE = "overflow";
   // Borders
   const DEFAULT_BORDER_DESC = { style: "thin", color: "#000000" };
   const DEFAULT_FILTER_BORDER_DESC = { style: "thin", color: FILTERS_COLOR };
@@ -616,13 +638,17 @@
       return position === "after" ? base + 1 : base;
   }
   /**
-   * Compare two objects.
+   * Compares two objects.
    */
   function deepEquals(o1, o2) {
       if (o1 === o2)
           return true;
       if ((o1 && !o2) || (o2 && !o1))
           return false;
+      if (typeof o1 !== typeof o2)
+          return false;
+      if (typeof o1 !== "object")
+          return o1 === o2;
       // Objects can have different keys if the values are undefined
       const keys = new Set();
       Object.keys(o1).forEach((key) => keys.add(key));
@@ -738,6 +764,10 @@
       newArray.splice(index, 0, ...items);
       return newArray;
   }
+  function trimContent(content) {
+      const contentLines = content.split("\n");
+      return contentLines.map((line) => line.replace(/\s+/g, " ").trim()).join("\n");
+  }
 
   const RBA_REGEX = /rgba?\(|\s+|\)/gi;
   const HEX_MATCH = /^#([A-F\d]{2}){3,4}$/;
@@ -4404,6 +4434,16 @@
               return 0;
       }
   }
+  function tryCastAsNumberMatrix(data, argName) {
+      data.forEach((row) => {
+          row.forEach((cell) => {
+              if (typeof cell !== "number") {
+                  throw new Error(_t("Function [[FUNCTION_NAME]] expects number values for %s, but got a %s.", typeof cell, argName));
+              }
+          });
+      });
+      return data;
+  }
   function strictToNumber(value, locale) {
       if (value === "") {
           throw new Error(expectNumberValueError(value));
@@ -5348,6 +5388,7 @@
     padding: 10px;
     width: ${ERROR_TOOLTIP_WIDTH}px;
     box-sizing: border-box !important;
+    overflow-wrap: break-word;
   }
 `;
   class ErrorToolTip extends owl.Component {
@@ -8353,43 +8394,53 @@
     TRUNC: TRUNC
   });
 
-  // Note: dataY and dataX may not have the same dimension
-  function covariance(dataY, dataX, isSample) {
-      let flatDataY = [];
-      let flatDataX = [];
+  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())));
+  }
+
+  function filterAndFlatData(dataY, dataX) {
+      const _flatDataY = [];
+      const _flatDataX = [];
       let lenY = 0;
       let lenX = 0;
       visitAny([dataY], (y) => {
-          flatDataY.push(y);
+          _flatDataY.push(y);
           lenY += 1;
       });
       visitAny([dataX], (x) => {
-          flatDataX.push(x);
+          _flatDataX.push(x);
           lenX += 1;
       });
-      assert(() => lenY === lenX, _t("[[FUNCTION_NAME]] has mismatched argument count %s vs %s.", lenY.toString(), lenX.toString()));
-      let count = 0;
-      let sumY = 0;
-      let sumX = 0;
+      assert(() => lenY === lenX, _t("[[FUNCTION_NAME]] has mismatched argument count %s vs %s.", lenY, lenX));
+      const flatDataX = [];
+      const flatDataY = [];
       for (let i = 0; i < lenY; i++) {
-          const valueY = flatDataY[i];
-          const valueX = flatDataX[i];
+          const valueY = _flatDataY[i];
+          const valueX = _flatDataX[i];
           if (typeof valueY === "number" && typeof valueX === "number") {
-              count += 1;
-              sumY += valueY;
-              sumX += valueX;
+              flatDataY.push(valueY);
+              flatDataX.push(valueX);
           }
       }
+      return { flatDataX, flatDataY };
+  }
+  // Note: dataY and dataX may not have the same dimension
+  function covariance(dataY, dataX, isSample) {
+      const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+      const count = flatDataY.length;
       assert(() => count !== 0 && (!isSample || count !== 1), _t(`Evaluation of function [[FUNCTION_NAME]] caused a divide by zero error.`));
+      let sumY = 0;
+      let sumX = 0;
+      for (let i = 0; i < count; i++) {
+          sumY += flatDataY[i];
+          sumX += flatDataX[i];
+      }
       const averageY = sumY / count;
       const averageX = sumX / count;
       let acc = 0;
-      for (let i = 0; i < lenY; i++) {
-          const valueY = flatDataY[i];
-          const valueX = flatDataX[i];
-          if (typeof valueY === "number" && typeof valueX === "number") {
-              acc += (valueY - averageY) * (valueX - averageX);
-          }
+      for (let i = 0; i < count; i++) {
+          acc += (flatDataY[i] - averageY) * (flatDataX[i] - averageX);
       }
       return acc / (count - (isSample ? 1 : 0));
   }
@@ -8426,6 +8477,161 @@
       }
       return percentile(sortedArray, _percent, isInclusive);
   }
+  function prepareDataForRegression(X, Y, newX) {
+      const _X = X.length ? X : [range(1, Y.flat().length + 1)];
+      const nVar = _X.length;
+      let _newX = newX.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 Error(_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 Error(_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
   // -----------------------------------------------------------------------------
@@ -8710,6 +8916,56 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // FORECAST
+  // -----------------------------------------------------------------------------
+  const FORECAST = {
+      description: _t("Calculates the expected y-value for a specified x based on a linear regression of a dataset."),
+      args: [
+          arg("x (number, range<number>)", _t("The value(s) on the x-axis to forecast.")),
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (x, dataY, dataX) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          return predictLinearValues([flatDataY], [flatDataX], matrixMap(toMatrix(x), (value) => toNumber(value, this.locale)), true);
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // GROWTH
+  // -----------------------------------------------------------------------------
+  const GROWTH = {
+      description: _t("Fits points to exponential growth trend."),
+      args: [
+          arg("known_data_y (range<number>)", _t("The array or range containing dependent (y) values that are already known, used to curve fit an ideal exponential growth curve.")),
+          arg("known_data_x (range<number>, default={1;2;3;...})", _t("The values of the independent variable(s) corresponding with known_data_y.")),
+          arg("new_data_x (any, range, default=known_data_x)", _t("The data points to return the y values for on the ideal curve fit.")),
+          arg("b (boolean, default=TRUE)", _t("Given a general exponential form of y = b*m^x for a curve fit, calculates b if TRUE or forces b to be 1 and only calculates the m values if FALSE.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (knownDataY, knownDataX = [], newDataX = [], b = true) {
+          return expM(predictLinearValues(logM(tryCastAsNumberMatrix(knownDataY, "the first argument (known_data_y)")), tryCastAsNumberMatrix(knownDataX, "the second argument (known_data_x)"), tryCastAsNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b)));
+      },
+  };
+  // -----------------------------------------------------------------------------
+  // INTERCEPT
+  // -----------------------------------------------------------------------------
+  const INTERCEPT = {
+      description: _t("Compute the intercept of the linear regression."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          const [[], [intercept]] = fullLinearRegression([flatDataX], [flatDataY]);
+          return intercept;
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // LARGE
   // -----------------------------------------------------------------------------
   const LARGE = {
@@ -8737,12 +8993,94 @@
           });
           const result = largests.shift();
           assert(() => result !== undefined, _t(`[[FUNCTION_NAME]] has no valid input data.`));
-          assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n.toString()));
+          assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
           return result;
       },
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // LINEST
+  // -----------------------------------------------------------------------------
+  const LINEST = {
+      description: _t("Compute the intercept of the linear regression."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>, default={1;2;3;...})", _t("The range representing the array or matrix of independent data.")),
+          arg("calculate_b (boolean, default=TRUE)", _t("A flag specifying wheter to compute the slope or not")),
+          arg("verbose (boolean, default=FALSE)", _t("A flag specifying whether to return additional regression statistics or only the linear coefficients and the y-intercept")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX = [], calculateB = true, verbose = false) {
+          return fullLinearRegression(tryCastAsNumberMatrix(dataX, "the first argument (data_y)"), tryCastAsNumberMatrix(dataY, "the second argument (data_x)"), toBoolean(calculateB), toBoolean(verbose));
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // LOGEST
+  // -----------------------------------------------------------------------------
+  const LOGEST = {
+      description: _t("Compute the intercept of the linear regression."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>, optional, default={1;2;3;...})", _t("The range representing the array or matrix of independent data.")),
+          arg("calculate_b (boolean, default=TRUE)", _t("A flag specifying wheter to compute the slope or not")),
+          arg("verbose (boolean, default=FALSE)", _t("A flag specifying whether to return additional regression statistics or only the linear coefficients and the y-intercept")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX = [], calculateB = true, verbose = false) {
+          const coeffs = fullLinearRegression(tryCastAsNumberMatrix(dataX, "the second argument (data_x)"), logM(tryCastAsNumberMatrix(dataY, "the first argument (data_y)")), toBoolean(calculateB), toBoolean(verbose));
+          for (let i = 0; i < coeffs.length; i++) {
+              coeffs[i][0] = Math.exp(coeffs[i][0]);
+          }
+          return coeffs;
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // MATTHEWS
+  // -----------------------------------------------------------------------------
+  const MATTHEWS = {
+      description: _t("Compute the Matthews correlation coefficient of a dataset."),
+      args: [
+          arg("data_x (range)", _t("The range representing the array or matrix of observed data.")),
+          arg("data_y (range)", _t("The range representing the array or matrix of predicted data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataX, dataY) {
+          const flatX = dataX.flat();
+          const flatY = dataY.flat();
+          assertSameNumberOfElements(flatX, flatY);
+          if (flatX.length === 0) {
+              throw new Error(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
+          }
+          const n = flatX.length;
+          let trueN = 0, trueP = 0, falseP = 0, falseN = 0;
+          for (let i = 0; i < n; ++i) {
+              const isTrue1 = toBoolean(flatX[i]);
+              const isTrue2 = toBoolean(flatY[i]);
+              if (isTrue1 === isTrue2) {
+                  if (isTrue1) {
+                      trueP++;
+                  }
+                  else {
+                      trueN++;
+                  }
+              }
+              else {
+                  if (isTrue1) {
+                      falseN++;
+                  }
+                  else {
+                      falseP++;
+                  }
+              }
+          }
+          return ((trueP * trueN - falseP * falseN) /
+              Math.sqrt((trueP + falseP) * (trueP + falseN) * (trueN + falseP) * (trueN + falseN)));
+      },
+      isExported: false,
+  };
+  // -----------------------------------------------------------------------------
   // MAX
   // -----------------------------------------------------------------------------
   const MAX = {
@@ -8897,6 +9235,41 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // PEARSON
+  // -----------------------------------------------------------------------------
+  const PEARSON = {
+      description: _t("Compute the Pearson product-moment correlation coefficient of a dataset."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataX, dataY);
+          if (flatDataX.length === 0) {
+              throw new Error(_t("[[FUNCTION_NAME]] expects non-empty ranges for both parameters."));
+          }
+          if (flatDataX.length < 2) {
+              throw new Error(_t("[[FUNCTION_NAME]] needs at least two values for both parameters"));
+          }
+          const n = flatDataX.length;
+          let sumX = 0, sumY = 0, sumXY = 0, sumXX = 0, sumYY = 0;
+          for (let i = 0; i < n; i++) {
+              const xij = flatDataX[i];
+              const yij = flatDataY[i];
+              sumX += xij;
+              sumY += yij;
+              sumXY += xij * yij;
+              sumXX += xij * xij;
+              sumYY += yij * yij;
+          }
+          return ((n * sumXY - sumX * sumY) / Math.sqrt((n * sumXX - sumX * sumX) * (n * sumYY - sumY * sumY)));
+      },
+      isExported: true,
+  };
+  // In GSheet, CORREL is just an alias to PEARSON
+  const CORREL = PEARSON;
+  // -----------------------------------------------------------------------------
   // PERCENTILE
   // -----------------------------------------------------------------------------
   const PERCENTILE = {
@@ -8951,6 +9324,45 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // POLYFIT
+  // -----------------------------------------------------------------------------
+  const POLYFIT_COEFFS = {
+      description: _t("Compute the coefficients of polynomial regression of the dataset."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+          arg("order (number)", _t("The order of the polynomial to fit the data, between 1 and 6.")),
+          arg("intercept (boolean, default=TRUE)", _t("A flag specifying whether to compute the intercept or not.")),
+      ],
+      returns: ["RANGE<NUMBER>"],
+      compute: function (dataY, dataX, order, intercept = true) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          return polynomialRegression(flatDataY, flatDataX, toNumber(order, this.locale), toBoolean(intercept));
+      },
+      isExported: false,
+  };
+  // -----------------------------------------------------------------------------
+  // POLYFIT.FORECAST
+  // -----------------------------------------------------------------------------
+  const POLYFIT_FORECAST = {
+      description: _t("Predict value by computing a polynomial regression of the dataset."),
+      args: [
+          arg("x (number, range<number>)", _t("The value(s) on the x-axis to forecast.")),
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+          arg("order (number)", _t("The order of the polynomial to fit the data, between 1 and 6.")),
+          arg("intercept (boolean, default=TRUE)", _t("A flag specifying whether to compute the intercept or not.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (x, dataY, dataX, order, intercept = true) {
+          const _order = toNumber(order, this.locale);
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          const coeffs = polynomialRegression(flatDataY, flatDataX, _order, toBoolean(intercept)).flat();
+          return matrixMap(toMatrix(x), (xij) => evaluatePolynomial(coeffs, toNumber(xij, this.locale), _order));
+      },
+      isExported: false,
+  };
+  // -----------------------------------------------------------------------------
   // QUARTILE
   // -----------------------------------------------------------------------------
   const QUARTILE = {
@@ -9007,6 +9419,39 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // RSQ
+  // -----------------------------------------------------------------------------
+  const RSQ = {
+      description: _t("Compute the square of r, the Pearson product-moment correlation coefficient of a dataset."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX) {
+          const pearson = PEARSON.compute.bind(this);
+          return Math.pow(pearson(dataX, dataY), 2.0);
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // SLOPE
+  // -----------------------------------------------------------------------------
+  const SLOPE = {
+      description: _t("Compute the slope of the linear regression."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          const [[slope]] = fullLinearRegression([flatDataX], [flatDataY]);
+          return slope;
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
   // SMALL
   // -----------------------------------------------------------------------------
   const SMALL = {
@@ -9034,12 +9479,39 @@
           });
           const result = largests.pop();
           assert(() => result !== undefined, _t(`[[FUNCTION_NAME]] has no valid input data.`));
-          assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n.toString()));
+          assert(() => count >= _n, _t("Function [[FUNCTION_NAME]] parameter 2 value (%s) is out of range.", _n));
           return result;
       },
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // SPEARMAN
+  // -----------------------------------------------------------------------------
+  const SPEARMAN = {
+      description: _t("Compute the Spearman rank correlation coefficient of a dataset."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataX, dataY) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          const n = flatDataX.length;
+          const order = flatDataX.map((e, i) => [e, flatDataY[i]]);
+          order.sort((a, b) => a[0] - b[0]);
+          for (let i = 0; i < n; ++i) {
+              order[i][0] = i;
+          }
+          order.sort((a, b) => a[1] - b[1]);
+          let sum = 0.0;
+          for (let i = 0; i < n; ++i) {
+              sum += (order[i][0] - i) ** 2;
+          }
+          return 1 - (6 * sum) / (n ** 3 - n);
+      },
+      isExported: false,
+  };
+  // -----------------------------------------------------------------------------
   // STDEV
   // -----------------------------------------------------------------------------
   const STDEV = {
@@ -9130,6 +9602,39 @@
       isExported: true,
   };
   // -----------------------------------------------------------------------------
+  // STEYX
+  // -----------------------------------------------------------------------------
+  const STEYX = {
+      description: _t("Calculates the standard error of the predicted y-value for each x in the regression of a dataset."),
+      args: [
+          arg("data_y (range<number>)", _t("The range representing the array or matrix of dependent data.")),
+          arg("data_x (range<number>)", _t("The range representing the array or matrix of independent data.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (dataY, dataX) {
+          const { flatDataX, flatDataY } = filterAndFlatData(dataY, dataX);
+          const data = fullLinearRegression([flatDataX], [flatDataY], true, true);
+          return data[1][2];
+      },
+      isExported: true,
+  };
+  // -----------------------------------------------------------------------------
+  // TREND
+  // -----------------------------------------------------------------------------
+  const TREND = {
+      description: _t("Fits points to linear trend derived via least-squares."),
+      args: [
+          arg("known_data_y (number, range<number>)", _t("The array or range containing dependent (y) values that are already known, used to curve fit an ideal linear trend.")),
+          arg("known_data_x (number, range<number>, optional, default={1;2;3;...})", _t("The values of the independent variable(s) corresponding with known_data_y.")),
+          arg("new_data_x (number, range<number>, optional, default=known_data_x)", _t("The data points to return the y values for on the ideal curve fit.")),
+          arg("b (boolean, optional, default=TRUE)", _t("Given a general linear form of y = m*x+b for a curve fit, calculates b if TRUE or forces b to be 0 and only calculates the m values if FALSE, i.e. forces the curve fit to pass through the origin.")),
+      ],
+      returns: ["NUMBER"],
+      compute: function (knownDataY, knownDataX = [], newDataX = [], b = true) {
+          return predictLinearValues(tryCastAsNumberMatrix(knownDataY, "the first argument (known_data_y)"), tryCastAsNumberMatrix(knownDataX, "the second argument (known_data_x)"), tryCastAsNumberMatrix(newDataX, "the third argument (new_data_y)"), toBoolean(b));
+      },
+  };
+  // -----------------------------------------------------------------------------
   // VAR
   // -----------------------------------------------------------------------------
   const VAR = {
@@ -9228,12 +9733,19 @@
     AVERAGEIF: AVERAGEIF,
     AVERAGEIFS: AVERAGEIFS,
     AVERAGE_WEIGHTED: AVERAGE_WEIGHTED,
+    CORREL: CORREL,
     COUNT: COUNT,
     COUNTA: COUNTA,
     COVAR: COVAR,
     COVARIANCE_P: COVARIANCE_P,
     COVARIANCE_S: COVARIANCE_S,
+    FORECAST: FORECAST,
+    GROWTH: GROWTH,
+    INTERCEPT: INTERCEPT,
     LARGE: LARGE,
+    LINEST: LINEST,
+    LOGEST: LOGEST,
+    MATTHEWS: MATTHEWS,
     MAX: MAX,
     MAXA: MAXA,
     MAXIFS: MAXIFS,
@@ -9241,19 +9753,27 @@
     MIN: MIN,
     MINA: MINA,
     MINIFS: MINIFS,
+    PEARSON: PEARSON,
     PERCENTILE: PERCENTILE,
     PERCENTILE_EXC: PERCENTILE_EXC,
     PERCENTILE_INC: PERCENTILE_INC,
+    POLYFIT_COEFFS: POLYFIT_COEFFS,
+    POLYFIT_FORECAST: POLYFIT_FORECAST,
     QUARTILE: QUARTILE,
     QUARTILE_EXC: QUARTILE_EXC,
     QUARTILE_INC: QUARTILE_INC,
+    RSQ: RSQ,
+    SLOPE: SLOPE,
     SMALL: SMALL,
+    SPEARMAN: SPEARMAN,
     STDEV: STDEV,
     STDEVA: STDEVA,
     STDEVP: STDEVP,
     STDEVPA: STDEVPA,
     STDEV_P: STDEV_P,
     STDEV_S: STDEV_S,
+    STEYX: STEYX,
+    TREND: TREND,
     VAR: VAR,
     VARA: VARA,
     VARP: VARP,
@@ -13888,7 +14408,7 @@
       ],
       returns: ["STRING"],
       compute: function (text) {
-          return toString(text).trim();
+          return trimContent(toString(text));
       },
       isExported: true,
   };
@@ -19437,6 +19957,12 @@
           env.openSidePanel("RemoveDuplicates", {});
       },
   };
+  const trimWhitespace = {
+      name: _t("Trim whitespace"),
+      execute: (env) => {
+          env.model.dispatch("TRIM_WHITESPACE");
+      },
+  };
   const sortDescending = {
       name: _t("Descending (Z ⟶ A)"),
       execute: (env) => {
@@ -20796,6 +21322,10 @@
       .addChild("remove_duplicates", ["data", "data_cleanup"], {
       ...removeDuplicates,
       sequence: 10,
+  })
+      .addChild("trim_whitespace", ["data", "data_cleanup"], {
+      ...trimWhitespace,
+      sequence: 20,
   })
       .addChild("split_to_columns", ["data"], {
       ...splitToColumns,
@@ -25971,9 +26501,11 @@
           }
       }
       function updateMousePosition(e) {
-          x = e.offsetX;
-          y = e.offsetY;
-          lastMoved = Date.now();
+          if (gridRef.el === e.target) {
+              x = e.offsetX;
+              y = e.offsetY;
+              lastMoved = Date.now();
+          }
       }
       function recompute() {
           const { col, row } = getPosition();
@@ -32455,8 +32987,9 @@
               for (const position of positions) {
                   const cell = this.getters.getCell(position);
                   const xc = toXC(position.col, position.row);
+                  const style = this.removeDefaultStyleValues(cell.style);
                   cells[xc] = {
-                      style: cell.style ? getItemId(cell.style, styles) : undefined,
+                      style: Object.keys(style).length ? getItemId(style, styles) : undefined,
                       format: cell.format ? getItemId(cell.format, formats) : undefined,
                       content: cell.content || undefined,
                   };
@@ -32475,6 +33008,15 @@
       exportForExcel(data) {
           this.export(data);
       }
+      removeDefaultStyleValues(style) {
+          const cleanedStyle = { ...style };
+          for (const [property, defaultValue] of Object.entries(DEFAULT_STYLE)) {
+              if (cleanedStyle[property] === defaultValue) {
+                  delete cleanedStyle[property];
+              }
+          }
+          return cleanedStyle;
+      }
       // ---------------------------------------------------------------------------
       // GETTERS
       // ---------------------------------------------------------------------------
@@ -39813,6 +40355,7 @@
       cells;
       copiedTables;
       zones;
+      uuidGenerator = new UuidGenerator();
       constructor(zones, operation, getters, dispatch, selection) {
           super(operation, getters, dispatch, selection);
           if (!zones.length) {
@@ -40265,8 +40808,9 @@
                           this.adaptCFRules(origin.sheetId, cf, [xc], toRemoveRange);
                       }
                       else {
-                          this.adaptCFRules(target.sheetId, cf, [xc], []);
                           this.adaptCFRules(origin.sheetId, cf, [], toRemoveRange);
+                          const cfToCopyTo = this.getCFToCopyTo(target.sheetId, cf);
+                          this.adaptCFRules(target.sheetId, cfToCopyTo, [xc], []);
                       }
                   }
               }
@@ -40290,6 +40834,12 @@
               sheetId,
           });
       }
+      getCFToCopyTo(targetSheetId, originCF) {
+          const cfInTarget = this.getters
+              .getConditionalFormats(targetSheetId)
+              .find((cf) => cf.stopIfTrue === originCF.stopIfTrue && deepEquals(cf.rule, originCF.rule));
+          return cfInTarget ? cfInTarget : { ...originCF, id: this.uuidGenerator.uuidv4(), ranges: [] };
+      }
   }
 
   class DataCleanupPlugin extends UIPlugin {
@@ -40308,6 +40858,9 @@
               case "REMOVE_DUPLICATES":
                   this.removeDuplicates(cmd.columns, cmd.hasHeader);
                   break;
+              case "TRIM_WHITESPACE":
+                  this.trimWhitespace();
+                  break;
           }
       }
       // ---------------------------------------------------------------------------
@@ -40428,6 +40981,35 @@
           }
           return "Success" /* CommandResult.Success */;
       }
+      trimWhitespace() {
+          const zones = this.getters.getSelectedZones();
+          const sheetId = this.getters.getActiveSheetId();
+          let count = 0;
+          for (const { col, row } of zones.map(positions).flat()) {
+              const cell = this.getters.getCell({ col, row, sheetId });
+              if (!cell) {
+                  continue;
+              }
+              const trimmedContent = trimContent(cell.content);
+              if (trimmedContent !== cell.content) {
+                  count += 1;
+                  this.dispatch("UPDATE_CELL", {
+                      sheetId,
+                      col,
+                      row,
+                      content: trimmedContent,
+                  });
+              }
+          }
+          const text = count
+              ? _t("Trimmed whitespace from %s cells.", count)
+              : _t("No selected cells had whitespace trimmed.");
+          this.ui.notifyUI({
+              type: "info",
+              text: text,
+              sticky: false,
+          });
+      }
   }
 
   const BORDER_COLOR = "#8B008B";
@@ -43226,7 +43808,7 @@
       allowDispatch(cmd) {
           switch (cmd.type) {
               case "CUT":
-                  const zones = cmd.cutTarget || this.getters.getSelectedZones();
+                  const zones = this.getters.getSelectedZones();
                   const state = this.getClipboardState(zones, cmd.type);
                   return state.isCutAllowed(zones);
               case "PASTE":
@@ -43261,7 +43843,7 @@
           switch (cmd.type) {
               case "COPY":
               case "CUT":
-                  const zones = ("cutTarget" in cmd && cmd.cutTarget) || this.getters.getSelectedZones();
+                  const zones = this.getters.getSelectedZones();
                   this.state = this.getClipboardState(zones, cmd.type);
                   this.status = "visible";
                   this.originSheetId = this.getters.getActiveSheetId();
@@ -44925,26 +45507,24 @@
           const isBasedBefore = cmd.base < start;
           const deltaCol = isBasedBefore && isCol ? thickness : 0;
           const deltaRow = isBasedBefore && !isCol ? thickness : 0;
-          this.dispatch("CUT", {
-              cutTarget: [
-                  {
-                      left: isCol ? start + deltaCol : 0,
-                      right: isCol ? end + deltaCol : this.getters.getNumberCols(cmd.sheetId) - 1,
-                      top: !isCol ? start + deltaRow : 0,
-                      bottom: !isCol ? end + deltaRow : this.getters.getNumberRows(cmd.sheetId) - 1,
-                  },
-              ],
-          });
-          this.dispatch("PASTE", {
-              target: [
-                  {
-                      left: isCol ? cmd.base : 0,
-                      right: isCol ? cmd.base + thickness - 1 : this.getters.getNumberCols(cmd.sheetId) - 1,
-                      top: !isCol ? cmd.base : 0,
-                      bottom: !isCol ? cmd.base + thickness - 1 : this.getters.getNumberRows(cmd.sheetId) - 1,
-                  },
-              ],
-          });
+          const target = [
+              {
+                  left: isCol ? start + deltaCol : 0,
+                  right: isCol ? end + deltaCol : this.getters.getNumberCols(cmd.sheetId) - 1,
+                  top: !isCol ? start + deltaRow : 0,
+                  bottom: !isCol ? end + deltaRow : this.getters.getNumberRows(cmd.sheetId) - 1,
+              },
+          ];
+          const state = new ClipboardCellsState(target, "CUT", this.getters, this.dispatch, this.selection);
+          const pasteTarget = [
+              {
+                  left: isCol ? cmd.base : 0,
+                  right: isCol ? cmd.base + thickness - 1 : this.getters.getNumberCols(cmd.sheetId) - 1,
+                  top: !isCol ? cmd.base : 0,
+                  bottom: !isCol ? cmd.base + thickness - 1 : this.getters.getNumberRows(cmd.sheetId) - 1,
+              },
+          ];
+          state.paste(pasteTarget, { selectTarget: true });
           const toRemove = isBasedBefore ? cmd.elements.map((el) => el + thickness) : cmd.elements;
           let currentIndex = cmd.base;
           for (const element of toRemove) {
@@ -52293,9 +52873,9 @@
   exports.tokenize = tokenize;
 
 
-  __info__.version = '16.5.0-alpha.7';
-  __info__.date = '2023-09-12T11:43:41.584Z';
-  __info__.hash = '';
+  __info__.version = "16.5.0-alpha.8";
+  __info__.date = "2023-09-21T15:59:10.959Z";
+  __info__.hash = "0b7527d";
 
 
 })(this.o_spreadsheet = this.o_spreadsheet || {}, owl);