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

package/dist/o-spreadsheet.cjs.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
+ */
+
 'use strict';
 
 var owl = require('@odoo/owl');
@@ -233,13 +242,26 @@ const MENU_ITEM_PADDING_HORIZONTAL = 11;
 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 };
@@ -617,13 +639,17 @@ function getAddHeaderStartIndex(position, base) {
     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));
@@ -739,6 +765,10 @@ function insertItemsAtIndex(array, items, index) {
     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}$/;
@@ -4405,6 +4435,16 @@ function toNumber(value, locale) {
             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));
@@ -5349,6 +5389,7 @@ css /* scss */ `
     padding: 10px;
     width: ${ERROR_TOOLTIP_WIDTH}px;
     box-sizing: border-box !important;
+    overflow-wrap: break-word;
   }
 `;
 class ErrorToolTip extends owl.Component {
@@ -8354,43 +8395,53 @@ var math = /*#__PURE__*/Object.freeze({
   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));
 }
@@ -8427,6 +8478,161 @@ function centile(data, percent, isInclusive, locale) {
     }
     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
 // -----------------------------------------------------------------------------
@@ -8711,6 +8917,56 @@ const COVARIANCE_S = {
     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 = {
@@ -8738,12 +8994,94 @@ const LARGE = {
         });
         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 = {
@@ -8898,6 +9236,41 @@ const MINIFS = {
     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 = {
@@ -8952,6 +9325,45 @@ const PERCENTILE_INC = {
     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 = {
@@ -9008,6 +9420,39 @@ const QUARTILE_INC = {
     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 = {
@@ -9035,12 +9480,39 @@ const SMALL = {
         });
         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 = {
@@ -9131,6 +9603,39 @@ const STDEVPA = {
     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 = {
@@ -9229,12 +9734,19 @@ var statistical = /*#__PURE__*/Object.freeze({
   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,
@@ -9242,19 +9754,27 @@ var statistical = /*#__PURE__*/Object.freeze({
   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,
@@ -13889,7 +14409,7 @@ const TRIM = {
     ],
     returns: ["STRING"],
     compute: function (text) {
-        return toString(text).trim();
+        return trimContent(toString(text));
     },
     isExported: true,
 };
@@ -19438,6 +19958,12 @@ const removeDuplicates = {
         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) => {
@@ -20797,6 +21323,10 @@ topbarMenuRegistry
     .addChild("remove_duplicates", ["data", "data_cleanup"], {
     ...removeDuplicates,
     sequence: 10,
+})
+    .addChild("trim_whitespace", ["data", "data_cleanup"], {
+    ...trimWhitespace,
+    sequence: 20,
 })
     .addChild("split_to_columns", ["data"], {
     ...splitToColumns,
@@ -25972,9 +26502,11 @@ function useCellHovered(env, gridRef, callback) {
         }
     }
     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();
@@ -32456,8 +32988,9 @@ class CellPlugin extends CorePlugin {
             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,
                 };
@@ -32476,6 +33009,15 @@ class CellPlugin extends CorePlugin {
     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
     // ---------------------------------------------------------------------------
@@ -39814,6 +40356,7 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
     cells;
     copiedTables;
     zones;
+    uuidGenerator = new UuidGenerator();
     constructor(zones, operation, getters, dispatch, selection) {
         super(operation, getters, dispatch, selection);
         if (!zones.length) {
@@ -40266,8 +40809,9 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
                         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], []);
                     }
                 }
             }
@@ -40291,6 +40835,12 @@ class ClipboardCellsState extends ClipboardCellsAbstractState {
             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 {
@@ -40309,6 +40859,9 @@ class DataCleanupPlugin extends UIPlugin {
             case "REMOVE_DUPLICATES":
                 this.removeDuplicates(cmd.columns, cmd.hasHeader);
                 break;
+            case "TRIM_WHITESPACE":
+                this.trimWhitespace();
+                break;
         }
     }
     // ---------------------------------------------------------------------------
@@ -40429,6 +40982,35 @@ class DataCleanupPlugin extends UIPlugin {
         }
         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";
@@ -43227,7 +43809,7 @@ class ClipboardPlugin extends UIPlugin {
     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":
@@ -43262,7 +43844,7 @@ class ClipboardPlugin extends UIPlugin {
         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();
@@ -44926,26 +45508,24 @@ class GridSelectionPlugin extends UIPlugin {
         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) {
@@ -52294,6 +52874,6 @@ exports.setTranslationMethod = setTranslationMethod;
 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";