部署

vendor/phpoffice/phpspreadsheet/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 PhpSpreadsheet Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DMax.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Maximum;
+
+class DMax extends DatabaseAbstract
+{
+    /**
+     * DMAX.
+     *
+     * Returns the largest number in a column of a list or database that matches conditions you that
+     * specify.
+     *
+     * Excel Function:
+     *        DMAX(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return Maximum::max(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DMin.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Minimum;
+
+class DMin extends DatabaseAbstract
+{
+    /**
+     * DMIN.
+     *
+     * Returns the smallest number in a column of a list or database that matches conditions you that
+     * specify.
+     *
+     * Excel Function:
+     *        DMIN(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return Minimum::min(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DProduct.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+class DProduct extends DatabaseAbstract
+{
+    /**
+     * DPRODUCT.
+     *
+     * Multiplies the values in a column of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DPRODUCT(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return MathTrig\Operations::product(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DStDev.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StandardDeviations;
+
+class DStDev extends DatabaseAbstract
+{
+    /**
+     * DSTDEV.
+     *
+     * Estimates the standard deviation of a population based on a sample by using the numbers in a
+     * column of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DSTDEV(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return StandardDeviations::STDEV(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DStDevP.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StandardDeviations;
+
+class DStDevP extends DatabaseAbstract
+{
+    /**
+     * DSTDEVP.
+     *
+     * Calculates the standard deviation of a population based on the entire population by using the
+     * numbers in a column of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DSTDEVP(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return StandardDeviations::STDEVP(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DSum.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+class DSum extends DatabaseAbstract
+{
+    /**
+     * DSUM.
+     *
+     * Adds the numbers in a column of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DSUM(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return MathTrig\Sum::sumIgnoringStrings(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DVar.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Variances;
+
+class DVar extends DatabaseAbstract
+{
+    /**
+     * DVAR.
+     *
+     * Estimates the variance of a population based on a sample by using the numbers in a column
+     * of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DVAR(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string (string if result is an error)
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return Variances::VAR(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Database/DVarP.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Variances;
+
+class DVarP extends DatabaseAbstract
+{
+    /**
+     * DVARP.
+     *
+     * Calculates the variance of a population based on the entire population by using the numbers
+     * in a column of a list or database that match conditions that you specify.
+     *
+     * Excel Function:
+     *        DVARP(database,field,criteria)
+     *
+     * @param mixed[] $database The range of cells that makes up the list or database.
+     *                                        A database is a list of related data in which rows of related
+     *                                        information are records, and columns of data are fields. The
+     *                                        first row of the list contains labels for each column.
+     * @param int|string $field Indicates which column is used in the function. Enter the
+     *                                        column label enclosed between double quotation marks, such as
+     *                                        "Age" or "Yield," or a number (without quotation marks) that
+     *                                        represents the position of the column within the list: 1 for
+     *                                        the first column, 2 for the second column, and so on.
+     * @param mixed[] $criteria The range of cells that contains the conditions you specify.
+     *                                        You can use any range for the criteria argument, as long as it
+     *                                        includes at least one column label and at least one cell below
+     *                                        the column label in which you specify a condition for the
+     *                                        column.
+     *
+     * @return null|float|string (string if result is an error)
+     */
+    public static function evaluate($database, $field, $criteria)
+    {
+        $field = self::fieldExtract($database, $field);
+        if ($field === null) {
+            return null;
+        }
+
+        return Variances::VARP(
+            self::getFilteredColumn($database, $field, $criteria)
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/DateTimeExcel/Helpers.php

@@ -0,0 +1,306 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+
+use DateTime;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Shared\Date as SharedDateHelper;
+
+class Helpers
+{
+    /**
+     * Identify if a year is a leap year or not.
+     *
+     * @param int|string $year The year to test
+     *
+     * @return bool TRUE if the year is a leap year, otherwise FALSE
+     */
+    public static function isLeapYear($year): bool
+    {
+        return (($year % 4) === 0) && (($year % 100) !== 0) || (($year % 400) === 0);
+    }
+
+    /**
+     * getDateValue.
+     *
+     * @param mixed $dateValue
+     *
+     * @return float Excel date/time serial value
+     */
+    public static function getDateValue($dateValue, bool $allowBool = true): float
+    {
+        if (is_object($dateValue)) {
+            $retval = SharedDateHelper::PHPToExcel($dateValue);
+            if (is_bool($retval)) {
+                throw new Exception(Functions::VALUE());
+            }
+
+            return $retval;
+        }
+
+        self::nullFalseTrueToNumber($dateValue, $allowBool);
+        if (!is_numeric($dateValue)) {
+            $saveReturnDateType = Functions::getReturnDateType();
+            Functions::setReturnDateType(Functions::RETURNDATE_EXCEL);
+            $dateValue = DateValue::fromString($dateValue);
+            Functions::setReturnDateType($saveReturnDateType);
+            if (!is_numeric($dateValue)) {
+                throw new Exception(Functions::VALUE());
+            }
+        }
+        if ($dateValue < 0 && Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_OPENOFFICE) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return (float) $dateValue;
+    }
+
+    /**
+     * getTimeValue.
+     *
+     * @param string $timeValue
+     *
+     * @return mixed Excel date/time serial value, or string if error
+     */
+    public static function getTimeValue($timeValue)
+    {
+        $saveReturnDateType = Functions::getReturnDateType();
+        Functions::setReturnDateType(Functions::RETURNDATE_EXCEL);
+        $timeValue = TimeValue::fromString($timeValue);
+        Functions::setReturnDateType($saveReturnDateType);
+
+        return $timeValue;
+    }
+
+    /**
+     * Adjust date by given months.
+     *
+     * @param mixed $dateValue
+     */
+    public static function adjustDateByMonths($dateValue = 0, float $adjustmentMonths = 0): DateTime
+    {
+        // Execute function
+        $PHPDateObject = SharedDateHelper::excelToDateTimeObject($dateValue);
+        $oMonth = (int) $PHPDateObject->format('m');
+        $oYear = (int) $PHPDateObject->format('Y');
+
+        $adjustmentMonthsString = (string) $adjustmentMonths;
+        if ($adjustmentMonths > 0) {
+            $adjustmentMonthsString = '+' . $adjustmentMonths;
+        }
+        if ($adjustmentMonths != 0) {
+            $PHPDateObject->modify($adjustmentMonthsString . ' months');
+        }
+        $nMonth = (int) $PHPDateObject->format('m');
+        $nYear = (int) $PHPDateObject->format('Y');
+
+        $monthDiff = ($nMonth - $oMonth) + (($nYear - $oYear) * 12);
+        if ($monthDiff != $adjustmentMonths) {
+            $adjustDays = (int) $PHPDateObject->format('d');
+            $adjustDaysString = '-' . $adjustDays . ' days';
+            $PHPDateObject->modify($adjustDaysString);
+        }
+
+        return $PHPDateObject;
+    }
+
+    /**
+     * Help reduce perceived complexity of some tests.
+     *
+     * @param mixed $value
+     * @param mixed $altValue
+     */
+    public static function replaceIfEmpty(&$value, $altValue): void
+    {
+        $value = $value ?: $altValue;
+    }
+
+    /**
+     * Adjust year in ambiguous situations.
+     */
+    public static function adjustYear(string $testVal1, string $testVal2, string &$testVal3): void
+    {
+        if (!is_numeric($testVal1) || $testVal1 < 31) {
+            if (!is_numeric($testVal2) || $testVal2 < 12) {
+                if (is_numeric($testVal3) && $testVal3 < 12) {
+                    $testVal3 += 2000;
+                }
+            }
+        }
+    }
+
+    /**
+     * Return result in one of three formats.
+     *
+     * @return mixed
+     */
+    public static function returnIn3FormatsArray(array $dateArray, bool $noFrac = false)
+    {
+        $retType = Functions::getReturnDateType();
+        if ($retType === Functions::RETURNDATE_PHP_DATETIME_OBJECT) {
+            return new DateTime(
+                $dateArray['year']
+                . '-' . $dateArray['month']
+                . '-' . $dateArray['day']
+                . ' ' . $dateArray['hour']
+                . ':' . $dateArray['minute']
+                . ':' . $dateArray['second']
+            );
+        }
+        $excelDateValue =
+            SharedDateHelper::formattedPHPToExcel(
+                $dateArray['year'],
+                $dateArray['month'],
+                $dateArray['day'],
+                $dateArray['hour'],
+                $dateArray['minute'],
+                $dateArray['second']
+            );
+        if ($retType === Functions::RETURNDATE_EXCEL) {
+            return $noFrac ? floor($excelDateValue) : (float) $excelDateValue;
+        }
+        // RETURNDATE_UNIX_TIMESTAMP)
+
+        return (int) SharedDateHelper::excelToTimestamp($excelDateValue);
+    }
+
+    /**
+     * Return result in one of three formats.
+     *
+     * @return mixed
+     */
+    public static function returnIn3FormatsFloat(float $excelDateValue)
+    {
+        $retType = Functions::getReturnDateType();
+        if ($retType === Functions::RETURNDATE_EXCEL) {
+            return $excelDateValue;
+        }
+        if ($retType === Functions::RETURNDATE_UNIX_TIMESTAMP) {
+            return (int) SharedDateHelper::excelToTimestamp($excelDateValue);
+        }
+        // RETURNDATE_PHP_DATETIME_OBJECT
+
+        return SharedDateHelper::excelToDateTimeObject($excelDateValue);
+    }
+
+    /**
+     * Return result in one of three formats.
+     *
+     * @return mixed
+     */
+    public static function returnIn3FormatsObject(DateTime $PHPDateObject)
+    {
+        $retType = Functions::getReturnDateType();
+        if ($retType === Functions::RETURNDATE_PHP_DATETIME_OBJECT) {
+            return $PHPDateObject;
+        }
+        if ($retType === Functions::RETURNDATE_EXCEL) {
+            return (float) SharedDateHelper::PHPToExcel($PHPDateObject);
+        }
+        // RETURNDATE_UNIX_TIMESTAMP
+        $stamp = SharedDateHelper::PHPToExcel($PHPDateObject);
+        $stamp = is_bool($stamp) ? ((int) $stamp) : $stamp;
+
+        return (int) SharedDateHelper::excelToTimestamp($stamp);
+    }
+
+    private static function baseDate(): int
+    {
+        if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
+            return 0;
+        }
+        if (SharedDateHelper::getExcelCalendar() === SharedDateHelper::CALENDAR_MAC_1904) {
+            return 0;
+        }
+
+        return 1;
+    }
+
+    /**
+     * Many functions accept null/false/true argument treated as 0/0/1.
+     *
+     * @param mixed $number
+     */
+    public static function nullFalseTrueToNumber(&$number, bool $allowBool = true): void
+    {
+        $number = Functions::flattenSingleValue($number);
+        $nullVal = self::baseDate();
+        if ($number === null) {
+            $number = $nullVal;
+        } elseif ($allowBool && is_bool($number)) {
+            $number = $nullVal + (int) $number;
+        }
+    }
+
+    /**
+     * Many functions accept null argument treated as 0.
+     *
+     * @param mixed $number
+     *
+     * @return float|int
+     */
+    public static function validateNumericNull($number)
+    {
+        $number = Functions::flattenSingleValue($number);
+        if ($number === null) {
+            return 0;
+        }
+        if (is_int($number)) {
+            return $number;
+        }
+        if (is_numeric($number)) {
+            return (float) $number;
+        }
+
+        throw new Exception(Functions::VALUE());
+    }
+
+    /**
+     * Many functions accept null/false/true argument treated as 0/0/1.
+     *
+     * @param mixed $number
+     *
+     * @return float
+     */
+    public static function validateNotNegative($number)
+    {
+        if (!is_numeric($number)) {
+            throw new Exception(Functions::VALUE());
+        }
+        if ($number >= 0) {
+            return (float) $number;
+        }
+
+        throw new Exception(Functions::NAN());
+    }
+
+    public static function silly1900(DateTime $PHPDateObject, string $mod = '-1 day'): void
+    {
+        $isoDate = $PHPDateObject->format('c');
+        if ($isoDate < '1900-03-01') {
+            $PHPDateObject->modify($mod);
+        }
+    }
+
+    public static function dateParse(string $string): array
+    {
+        return self::forceArray(date_parse($string));
+    }
+
+    public static function dateParseSucceeded(array $dateArray): bool
+    {
+        return $dateArray['error_count'] === 0;
+    }
+
+    /**
+     * Despite documentation, date_parse probably never returns false.
+     * Just in case, this routine helps guarantee it.
+     *
+     * @param array|false $dateArray
+     */
+    private static function forceArray($dateArray): array
+    {
+        return is_array($dateArray) ? $dateArray : ['error_count' => 1];
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/DateTimeExcel/Month.php

@@ -0,0 +1,101 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+
+class Month
+{
+    use ArrayEnabled;
+
+    /**
+     * EDATE.
+     *
+     * Returns the serial number that represents the date that is the indicated number of months
+     * before or after a specified date (the start_date).
+     * Use EDATE to calculate maturity dates or due dates that fall on the same day of the month
+     * as the date of issue.
+     *
+     * Excel Function:
+     *        EDATE(dateValue,adjustmentMonths)
+     *
+     * @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
+     *                                        PHP DateTime object, or a standard date string
+     *                         Or can be an array of date values
+     * @param array|int $adjustmentMonths The number of months before or after start_date.
+     *                                        A positive value for months yields a future date;
+     *                                        a negative value yields a past date.
+     *                         Or can be an array of adjustment values
+     *
+     * @return array|mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
+     *                        depending on the value of the ReturnDateType flag
+     *         If an array of values is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function adjust($dateValue, $adjustmentMonths)
+    {
+        if (is_array($dateValue) || is_array($adjustmentMonths)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $dateValue, $adjustmentMonths);
+        }
+
+        try {
+            $dateValue = Helpers::getDateValue($dateValue, false);
+            $adjustmentMonths = Helpers::validateNumericNull($adjustmentMonths);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+        $adjustmentMonths = floor($adjustmentMonths);
+
+        // Execute function
+        $PHPDateObject = Helpers::adjustDateByMonths($dateValue, $adjustmentMonths);
+
+        return Helpers::returnIn3FormatsObject($PHPDateObject);
+    }
+
+    /**
+     * EOMONTH.
+     *
+     * Returns the date value for the last day of the month that is the indicated number of months
+     * before or after start_date.
+     * Use EOMONTH to calculate maturity dates or due dates that fall on the last day of the month.
+     *
+     * Excel Function:
+     *        EOMONTH(dateValue,adjustmentMonths)
+     *
+     * @param mixed $dateValue Excel date serial value (float), PHP date timestamp (integer),
+     *                                        PHP DateTime object, or a standard date string
+     *                         Or can be an array of date values
+     * @param array|int $adjustmentMonths The number of months before or after start_date.
+     *                                        A positive value for months yields a future date;
+     *                                        a negative value yields a past date.
+     *                         Or can be an array of adjustment values
+     *
+     * @return array|mixed Excel date/time serial value, PHP date/time serial value or PHP date/time object,
+     *                        depending on the value of the ReturnDateType flag
+     *         If an array of values is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function lastDay($dateValue, $adjustmentMonths)
+    {
+        if (is_array($dateValue) || is_array($adjustmentMonths)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $dateValue, $adjustmentMonths);
+        }
+
+        try {
+            $dateValue = Helpers::getDateValue($dateValue, false);
+            $adjustmentMonths = Helpers::validateNumericNull($adjustmentMonths);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+        $adjustmentMonths = floor($adjustmentMonths);
+
+        // Execute function
+        $PHPDateObject = Helpers::adjustDateByMonths($dateValue, $adjustmentMonths + 1);
+        $adjustDays = (int) $PHPDateObject->format('d');
+        $adjustDaysString = '-' . $adjustDays . ' days';
+        $PHPDateObject->modify($adjustDaysString);
+
+        return Helpers::returnIn3FormatsObject($PHPDateObject);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/DateTimeExcel/NetworkDays.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class NetworkDays
+{
+    use ArrayEnabled;
+
+    /**
+     * NETWORKDAYS.
+     *
+     * Returns the number of whole working days between start_date and end_date. Working days
+     * exclude weekends and any dates identified in holidays.
+     * Use NETWORKDAYS to calculate employee benefits that accrue based on the number of days
+     * worked during a specific term.
+     *
+     * Excel Function:
+     *        NETWORKDAYS(startDate,endDate[,holidays[,holiday[,...]]])
+     *
+     * @param mixed $startDate Excel date serial value (float), PHP date timestamp (integer),
+     *                                            PHP DateTime object, or a standard date string
+     *                         Or can be an array of date values
+     * @param mixed $endDate Excel date serial value (float), PHP date timestamp (integer),
+     *                                            PHP DateTime object, or a standard date string
+     *                         Or can be an array of date values
+     * @param mixed $dateArgs An array of dates (such as holidays) to exclude from the calculation
+     *
+     * @return array|int|string Interval between the dates
+     *         If an array of values is passed for the $startDate or $endDate arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function count($startDate, $endDate, ...$dateArgs)
+    {
+        if (is_array($startDate) || is_array($endDate)) {
+            return self::evaluateArrayArgumentsSubset(
+                [self::class, __FUNCTION__],
+                2,
+                $startDate,
+                $endDate,
+                ...$dateArgs
+            );
+        }
+
+        try {
+            //    Retrieve the mandatory start and end date that are referenced in the function definition
+            $sDate = Helpers::getDateValue($startDate);
+            $eDate = Helpers::getDateValue($endDate);
+            $startDate = min($sDate, $eDate);
+            $endDate = max($sDate, $eDate);
+            //    Get the optional days
+            $dateArgs = Functions::flattenArray($dateArgs);
+            //    Test any extra holiday parameters
+            $holidayArray = [];
+            foreach ($dateArgs as $holidayDate) {
+                $holidayArray[] = Helpers::getDateValue($holidayDate);
+            }
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Execute function
+        $startDow = self::calcStartDow($startDate);
+        $endDow = self::calcEndDow($endDate);
+        $wholeWeekDays = (int) floor(($endDate - $startDate) / 7) * 5;
+        $partWeekDays = self::calcPartWeekDays($startDow, $endDow);
+
+        //    Test any extra holiday parameters
+        $holidayCountedArray = [];
+        foreach ($holidayArray as $holidayDate) {
+            if (($holidayDate >= $startDate) && ($holidayDate <= $endDate)) {
+                if ((Week::day($holidayDate, 2) < 6) && (!in_array($holidayDate, $holidayCountedArray))) {
+                    --$partWeekDays;
+                    $holidayCountedArray[] = $holidayDate;
+                }
+            }
+        }
+
+        return self::applySign($wholeWeekDays + $partWeekDays, $sDate, $eDate);
+    }
+
+    private static function calcStartDow(float $startDate): int
+    {
+        $startDow = 6 - (int) Week::day($startDate, 2);
+        if ($startDow < 0) {
+            $startDow = 5;
+        }
+
+        return $startDow;
+    }
+
+    private static function calcEndDow(float $endDate): int
+    {
+        $endDow = (int) Week::day($endDate, 2);
+        if ($endDow >= 6) {
+            $endDow = 0;
+        }
+
+        return $endDow;
+    }
+
+    private static function calcPartWeekDays(int $startDow, int $endDow): int
+    {
+        $partWeekDays = $endDow + $startDow;
+        if ($partWeekDays > 5) {
+            $partWeekDays -= 5;
+        }
+
+        return $partWeekDays;
+    }
+
+    private static function applySign(int $result, float $sDate, float $eDate): int
+    {
+        return ($sDate > $eDate) ? -$result : $result;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Engine/Logger.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Engine;
+
+class Logger
+{
+    /**
+     * Flag to determine whether a debug log should be generated by the calculation engine
+     *        If true, then a debug log will be generated
+     *        If false, then a debug log will not be generated.
+     *
+     * @var bool
+     */
+    private $writeDebugLog = false;
+
+    /**
+     * Flag to determine whether a debug log should be echoed by the calculation engine
+     *        If true, then a debug log will be echoed
+     *        If false, then a debug log will not be echoed
+     * A debug log can only be echoed if it is generated.
+     *
+     * @var bool
+     */
+    private $echoDebugLog = false;
+
+    /**
+     * The debug log generated by the calculation engine.
+     *
+     * @var string[]
+     */
+    private $debugLog = [];
+
+    /**
+     * The calculation engine cell reference stack.
+     *
+     * @var CyclicReferenceStack
+     */
+    private $cellStack;
+
+    /**
+     * Instantiate a Calculation engine logger.
+     */
+    public function __construct(CyclicReferenceStack $stack)
+    {
+        $this->cellStack = $stack;
+    }
+
+    /**
+     * Enable/Disable Calculation engine logging.
+     *
+     * @param bool $writeDebugLog
+     */
+    public function setWriteDebugLog($writeDebugLog): void
+    {
+        $this->writeDebugLog = $writeDebugLog;
+    }
+
+    /**
+     * Return whether calculation engine logging is enabled or disabled.
+     *
+     * @return bool
+     */
+    public function getWriteDebugLog()
+    {
+        return $this->writeDebugLog;
+    }
+
+    /**
+     * Enable/Disable echoing of debug log information.
+     *
+     * @param bool $echoDebugLog
+     */
+    public function setEchoDebugLog($echoDebugLog): void
+    {
+        $this->echoDebugLog = $echoDebugLog;
+    }
+
+    /**
+     * Return whether echoing of debug log information is enabled or disabled.
+     *
+     * @return bool
+     */
+    public function getEchoDebugLog()
+    {
+        return $this->echoDebugLog;
+    }
+
+    /**
+     * Write an entry to the calculation engine debug log.
+     */
+    public function writeDebugLog(...$args): void
+    {
+        //    Only write the debug log if logging is enabled
+        if ($this->writeDebugLog) {
+            $message = implode('', $args);
+            $cellReference = implode(' -> ', $this->cellStack->showStack());
+            if ($this->echoDebugLog) {
+                echo $cellReference,
+                    ($this->cellStack->count() > 0 ? ' => ' : ''),
+                    $message,
+                    PHP_EOL;
+            }
+            $this->debugLog[] = $cellReference .
+                ($this->cellStack->count() > 0 ? ' => ' : '') .
+                $message;
+        }
+    }
+
+    /**
+     * Write a series of entries to the calculation engine debug log.
+     *
+     * @param string[] $args
+     */
+    public function mergeDebugLog(array $args): void
+    {
+        if ($this->writeDebugLog) {
+            foreach ($args as $entry) {
+                $this->writeDebugLog($entry);
+            }
+        }
+    }
+
+    /**
+     * Clear the calculation engine debug log.
+     */
+    public function clearLog(): void
+    {
+        $this->debugLog = [];
+    }
+
+    /**
+     * Return the calculation engine debug log.
+     *
+     * @return string[]
+     */
+    public function getLog()
+    {
+        return $this->debugLog;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Engineering/EngineeringValidations.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class EngineeringValidations
+{
+    /**
+     * @param mixed $value
+     */
+    public static function validateFloat($value): float
+    {
+        if (!is_numeric($value)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (float) $value;
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function validateInt($value): int
+    {
+        if (!is_numeric($value)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (int) floor((float) $value);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Engineering/Erf.php

@@ -0,0 +1,104 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Erf
+{
+    use ArrayEnabled;
+
+    private static $twoSqrtPi = 1.128379167095512574;
+
+    /**
+     * ERF.
+     *
+     * Returns the error function integrated between the lower and upper bound arguments.
+     *
+     *    Note: In Excel 2007 or earlier, if you input a negative value for the upper or lower bound arguments,
+     *            the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
+     *            improved, so that it can now calculate the function for both positive and negative ranges.
+     *            PhpSpreadsheet follows Excel 2010 behaviour, and accepts negative arguments.
+     *
+     *    Excel Function:
+     *        ERF(lower[,upper])
+     *
+     * @param mixed $lower Lower bound float for integrating ERF
+     *                      Or can be an array of values
+     * @param mixed $upper Upper bound float for integrating ERF.
+     *                           If omitted, ERF integrates between zero and lower_limit
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function ERF($lower, $upper = null)
+    {
+        if (is_array($lower) || is_array($upper)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $lower, $upper);
+        }
+
+        if (is_numeric($lower)) {
+            if ($upper === null) {
+                return self::erfValue($lower);
+            }
+            if (is_numeric($upper)) {
+                return self::erfValue($upper) - self::erfValue($lower);
+            }
+        }
+
+        return Functions::VALUE();
+    }
+
+    /**
+     * ERFPRECISE.
+     *
+     * Returns the error function integrated between the lower and upper bound arguments.
+     *
+     *    Excel Function:
+     *        ERF.PRECISE(limit)
+     *
+     * @param mixed $limit Float bound for integrating ERF, other bound is zero
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function ERFPRECISE($limit)
+    {
+        if (is_array($limit)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $limit);
+        }
+
+        return self::ERF($limit);
+    }
+
+    //
+    //    Private method to calculate the erf value
+    //
+    public static function erfValue($value)
+    {
+        if (abs($value) > 2.2) {
+            return 1 - ErfC::ERFC($value);
+        }
+        $sum = $term = $value;
+        $xsqr = ($value * $value);
+        $j = 1;
+        do {
+            $term *= $xsqr / $j;
+            $sum -= $term / (2 * $j + 1);
+            ++$j;
+            $term *= $xsqr / $j;
+            $sum += $term / (2 * $j + 1);
+            ++$j;
+            if ($sum == 0.0) {
+                break;
+            }
+        } while (abs($term / $sum) > Functions::PRECISION);
+
+        return self::$twoSqrtPi * $sum;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Engineering/ErfC.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class ErfC
+{
+    use ArrayEnabled;
+
+    /**
+     * ERFC.
+     *
+     *    Returns the complementary ERF function integrated between x and infinity
+     *
+     *    Note: In Excel 2007 or earlier, if you input a negative value for the lower bound argument,
+     *        the function would return a #NUM! error. However, in Excel 2010, the function algorithm was
+     *        improved, so that it can now calculate the function for both positive and negative x values.
+     *            PhpSpreadsheet follows Excel 2010 behaviour, and accepts nagative arguments.
+     *
+     *    Excel Function:
+     *        ERFC(x)
+     *
+     * @param mixed $value The float lower bound for integrating ERFC
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function ERFC($value)
+    {
+        if (is_array($value)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $value);
+        }
+
+        if (is_numeric($value)) {
+            return self::erfcValue($value);
+        }
+
+        return Functions::VALUE();
+    }
+
+    //
+    //    Private method to calculate the erfc value
+    //
+    private static $oneSqrtPi = 0.564189583547756287;
+
+    private static function erfcValue($value)
+    {
+        if (abs($value) < 2.2) {
+            return 1 - Erf::erfValue($value);
+        }
+        if ($value < 0) {
+            return 2 - self::erfcValue(-$value);
+        }
+        $a = $n = 1;
+        $b = $c = $value;
+        $d = ($value * $value) + 0.5;
+        $q1 = $q2 = $b / $d;
+        do {
+            $t = $a * $n + $b * $value;
+            $a = $b;
+            $b = $t;
+            $t = $c * $n + $d * $value;
+            $c = $d;
+            $d = $t;
+            $n += 0.5;
+            $q1 = $q2;
+            $q2 = $b / $d;
+        } while ((abs($q1 - $q2) / $q2) > Functions::PRECISION);
+
+        return self::$oneSqrtPi * exp(-$value * $value) * $q2;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Exception.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
+
+class Exception extends PhpSpreadsheetException
+{
+    /**
+     * Error handler callback.
+     *
+     * @param mixed $code
+     * @param mixed $string
+     * @param mixed $file
+     * @param mixed $line
+     * @param mixed $context
+     */
+    public static function errorHandlerCallback($code, $string, $file, $line, $context): void
+    {
+        $e = new self($string, $code);
+        $e->line = $line;
+        $e->file = $file;
+
+        throw $e;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/ExceptionHandler.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+class ExceptionHandler
+{
+    /**
+     * Register errorhandler.
+     */
+    public function __construct()
+    {
+        set_error_handler([Exception::class, 'errorHandlerCallback'], E_ALL);
+    }
+
+    /**
+     * Unregister errorhandler.
+     */
+    public function __destruct()
+    {
+        restore_error_handler();
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic.php

@@ -0,0 +1,199 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Periodic
+{
+    /**
+     * FV.
+     *
+     * Returns the Future Value of a cash flow with constant payments and interest rate (annuities).
+     *
+     * Excel Function:
+     *        FV(rate,nper,pmt[,pv[,type]])
+     *
+     * @param mixed $rate The interest rate per period
+     * @param mixed $numberOfPeriods Total number of payment periods in an annuity as an integer
+     * @param mixed $payment The payment made each period: it cannot change over the
+     *                            life of the annuity. Typically, pmt contains principal
+     *                            and interest but no other fees or taxes.
+     * @param mixed $presentValue present Value, or the lump-sum amount that a series of
+     *                            future payments is worth right now
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                      0 or omitted    At the end of the period.
+     *                      1               At the beginning of the period.
+     *
+     * @return float|string
+     */
+    public static function futureValue(
+        $rate,
+        $numberOfPeriods,
+        $payment = 0.0,
+        $presentValue = 0.0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $rate = Functions::flattenSingleValue($rate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = ($payment === null) ? 0.0 : Functions::flattenSingleValue($payment);
+        $presentValue = ($presentValue === null) ? 0.0 : Functions::flattenSingleValue($presentValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return self::calculateFutureValue($rate, $numberOfPeriods, $payment, $presentValue, $type);
+    }
+
+    /**
+     * PV.
+     *
+     * Returns the Present Value of a cash flow with constant payments and interest rate (annuities).
+     *
+     * @param mixed $rate Interest rate per period
+     * @param mixed $numberOfPeriods Number of periods as an integer
+     * @param mixed $payment Periodic payment (annuity)
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function presentValue(
+        $rate,
+        $numberOfPeriods,
+        $payment = 0.0,
+        $futureValue = 0.0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $rate = Functions::flattenSingleValue($rate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = ($payment === null) ? 0.0 : Functions::flattenSingleValue($payment);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($numberOfPeriods < 0) {
+            return Functions::NAN();
+        }
+
+        return self::calculatePresentValue($rate, $numberOfPeriods, $payment, $futureValue, $type);
+    }
+
+    /**
+     * NPER.
+     *
+     * Returns the number of periods for a cash flow with constant periodic payments (annuities), and interest rate.
+     *
+     * @param mixed $rate Interest rate per period
+     * @param mixed $payment Periodic payment (annuity)
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function periods(
+        $rate,
+        $payment,
+        $presentValue,
+        $futureValue = 0.0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $rate = Functions::flattenSingleValue($rate);
+        $payment = Functions::flattenSingleValue($payment);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $rate = CashFlowValidations::validateRate($rate);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($payment == 0.0) {
+            return Functions::NAN();
+        }
+
+        return self::calculatePeriods($rate, $payment, $presentValue, $futureValue, $type);
+    }
+
+    private static function calculateFutureValue(
+        float $rate,
+        int $numberOfPeriods,
+        float $payment,
+        float $presentValue,
+        int $type
+    ): float {
+        if ($rate !== null && $rate != 0) {
+            return -$presentValue *
+                (1 + $rate) ** $numberOfPeriods - $payment * (1 + $rate * $type) * ((1 + $rate) ** $numberOfPeriods - 1)
+                    / $rate;
+        }
+
+        return -$presentValue - $payment * $numberOfPeriods;
+    }
+
+    private static function calculatePresentValue(
+        float $rate,
+        int $numberOfPeriods,
+        float $payment,
+        float $futureValue,
+        int $type
+    ): float {
+        if ($rate != 0.0) {
+            return (-$payment * (1 + $rate * $type)
+                    * (((1 + $rate) ** $numberOfPeriods - 1) / $rate) - $futureValue) / (1 + $rate) ** $numberOfPeriods;
+        }
+
+        return -$futureValue - $payment * $numberOfPeriods;
+    }
+
+    /**
+     * @return float|string
+     */
+    private static function calculatePeriods(
+        float $rate,
+        float $payment,
+        float $presentValue,
+        float $futureValue,
+        int $type
+    ) {
+        if ($rate != 0.0) {
+            if ($presentValue == 0.0) {
+                return Functions::NAN();
+            }
+
+            return log(($payment * (1 + $rate * $type) / $rate - $futureValue) /
+                    ($presentValue + $payment * (1 + $rate * $type) / $rate)) / log(1 + $rate);
+        }
+
+        return (-$presentValue - $futureValue) / $payment;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/Interest.php

@@ -0,0 +1,216 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Interest
+{
+    private const FINANCIAL_MAX_ITERATIONS = 128;
+
+    private const FINANCIAL_PRECISION = 1.0e-08;
+
+    /**
+     * IPMT.
+     *
+     * Returns the interest payment for a given period for an investment based on periodic, constant payments
+     *         and a constant interest rate.
+     *
+     * Excel Function:
+     *        IPMT(rate,per,nper,pv[,fv][,type])
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $period Period for which we want to find the interest
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string
+     */
+    public static function payment(
+        $interestRate,
+        $period,
+        $numberOfPeriods,
+        $presentValue,
+        $futureValue = 0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return Functions::NAN();
+        }
+
+        // Calculate
+        $interestAndPrincipal = new InterestAndPrincipal(
+            $interestRate,
+            $period,
+            $numberOfPeriods,
+            $presentValue,
+            $futureValue,
+            $type
+        );
+
+        return $interestAndPrincipal->interest();
+    }
+
+    /**
+     * ISPMT.
+     *
+     * Returns the interest payment for an investment based on an interest rate and a constant payment schedule.
+     *
+     * Excel Function:
+     *     =ISPMT(interest_rate, period, number_payments, pv)
+     *
+     * @param mixed $interestRate is the interest rate for the investment
+     * @param mixed $period is the period to calculate the interest rate.  It must be betweeen 1 and number_payments.
+     * @param mixed $numberOfPeriods is the number of payments for the annuity
+     * @param mixed $principleRemaining is the loan amount or present value of the payments
+     */
+    public static function schedulePayment($interestRate, $period, $numberOfPeriods, $principleRemaining)
+    {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $principleRemaining = Functions::flattenSingleValue($principleRemaining);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $principleRemaining = CashFlowValidations::validateFloat($principleRemaining);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return Functions::NAN();
+        }
+
+        // Return value
+        $returnValue = 0;
+
+        // Calculate
+        $principlePayment = ($principleRemaining * 1.0) / ($numberOfPeriods * 1.0);
+        for ($i = 0; $i <= $period; ++$i) {
+            $returnValue = $interestRate * $principleRemaining * -1;
+            $principleRemaining -= $principlePayment;
+            // principle needs to be 0 after the last payment, don't let floating point screw it up
+            if ($i == $numberOfPeriods) {
+                $returnValue = 0.0;
+            }
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * RATE.
+     *
+     * Returns the interest rate per period of an annuity.
+     * RATE is calculated by iteration and can have zero or more solutions.
+     * If the successive results of RATE do not converge to within 0.0000001 after 20 iterations,
+     * RATE returns the #NUM! error value.
+     *
+     * Excel Function:
+     *        RATE(nper,pmt,pv[,fv[,type[,guess]]])
+     *
+     * @param mixed $numberOfPeriods The total number of payment periods in an annuity
+     * @param mixed $payment The payment made each period and cannot change over the life of the annuity.
+     *                           Typically, pmt includes principal and interest but no other fees or taxes.
+     * @param mixed $presentValue The present value - the total amount that a series of future payments is worth now
+     * @param mixed $futureValue The future value, or a cash balance you want to attain after the last payment is made.
+     *                               If fv is omitted, it is assumed to be 0 (the future value of a loan,
+     *                               for example, is 0).
+     * @param mixed $type A number 0 or 1 and indicates when payments are due:
+     *                      0 or omitted    At the end of the period.
+     *                      1               At the beginning of the period.
+     * @param mixed $guess Your guess for what the rate will be.
+     *                          If you omit guess, it is assumed to be 10 percent.
+     *
+     * @return float|string
+     */
+    public static function rate(
+        $numberOfPeriods,
+        $payment,
+        $presentValue,
+        $futureValue = 0.0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD,
+        $guess = 0.1
+    ) {
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $payment = Functions::flattenSingleValue($payment);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+        $guess = ($guess === null) ? 0.1 : Functions::flattenSingleValue($guess);
+
+        try {
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $payment = CashFlowValidations::validateFloat($payment);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+            $guess = CashFlowValidations::validateFloat($guess);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $rate = $guess;
+        // rest of code adapted from python/numpy
+        $close = false;
+        $iter = 0;
+        while (!$close && $iter < self::FINANCIAL_MAX_ITERATIONS) {
+            $nextdiff = self::rateNextGuess($rate, $numberOfPeriods, $payment, $presentValue, $futureValue, $type);
+            if (!is_numeric($nextdiff)) {
+                break;
+            }
+            $rate1 = $rate - $nextdiff;
+            $close = abs($rate1 - $rate) < self::FINANCIAL_PRECISION;
+            ++$iter;
+            $rate = $rate1;
+        }
+
+        return $close ? $rate : Functions::NAN();
+    }
+
+    private static function rateNextGuess($rate, $numberOfPeriods, $payment, $presentValue, $futureValue, $type)
+    {
+        if ($rate == 0.0) {
+            return Functions::NAN();
+        }
+        $tt1 = ($rate + 1) ** $numberOfPeriods;
+        $tt2 = ($rate + 1) ** ($numberOfPeriods - 1);
+        $numerator = $futureValue + $tt1 * $presentValue + $payment * ($tt1 - 1) * ($rate * $type + 1) / $rate;
+        $denominator = $numberOfPeriods * $tt2 * $presentValue - $payment * ($tt1 - 1)
+            * ($rate * $type + 1) / ($rate * $rate) + $numberOfPeriods
+            * $payment * $tt2 * ($rate * $type + 1) / $rate + $payment * ($tt1 - 1) * $type / $rate;
+        if ($denominator == 0) {
+            return Functions::NAN();
+        }
+
+        return $numerator / $denominator;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/InterestAndPrincipal.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+
+class InterestAndPrincipal
+{
+    protected $interest;
+
+    protected $principal;
+
+    public function __construct(
+        float $rate = 0.0,
+        int $period = 0,
+        int $numberOfPeriods = 0,
+        float $presentValue = 0,
+        float $futureValue = 0,
+        int $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $payment = Payments::annuity($rate, $numberOfPeriods, $presentValue, $futureValue, $type);
+        $capital = $presentValue;
+        $interest = 0.0;
+        $principal = 0.0;
+        for ($i = 1; $i <= $period; ++$i) {
+            $interest = ($type === FinancialConstants::PAYMENT_BEGINNING_OF_PERIOD && $i == 1) ? 0 : -$capital * $rate;
+            $principal = $payment - $interest;
+            $capital += $principal;
+        }
+
+        $this->interest = $interest;
+        $this->principal = $principal;
+    }
+
+    public function interest(): float
+    {
+        return $this->interest;
+    }
+
+    public function principal(): float
+    {
+        return $this->principal;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/Payments.php

@@ -0,0 +1,115 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\CashFlowValidations;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Payments
+{
+    /**
+     * PMT.
+     *
+     * Returns the constant payment (annuity) for a cash flow with a constant interest rate.
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function annuity(
+        $interestRate,
+        $numberOfPeriods,
+        $presentValue,
+        $futureValue = 0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Calculate
+        if ($interestRate != 0.0) {
+            return (-$futureValue - $presentValue * (1 + $interestRate) ** $numberOfPeriods) /
+                (1 + $interestRate * $type) / (((1 + $interestRate) ** $numberOfPeriods - 1) / $interestRate);
+        }
+
+        return (-$presentValue - $futureValue) / $numberOfPeriods;
+    }
+
+    /**
+     * PPMT.
+     *
+     * Returns the interest payment for a given period for an investment based on periodic, constant payments
+     *         and a constant interest rate.
+     *
+     * @param mixed $interestRate Interest rate per period
+     * @param mixed $period Period for which we want to find the interest
+     * @param mixed $numberOfPeriods Number of periods
+     * @param mixed $presentValue Present Value
+     * @param mixed $futureValue Future Value
+     * @param mixed $type Payment type: 0 = at the end of each period, 1 = at the beginning of each period
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function interestPayment(
+        $interestRate,
+        $period,
+        $numberOfPeriods,
+        $presentValue,
+        $futureValue = 0,
+        $type = FinancialConstants::PAYMENT_END_OF_PERIOD
+    ) {
+        $interestRate = Functions::flattenSingleValue($interestRate);
+        $period = Functions::flattenSingleValue($period);
+        $numberOfPeriods = Functions::flattenSingleValue($numberOfPeriods);
+        $presentValue = Functions::flattenSingleValue($presentValue);
+        $futureValue = ($futureValue === null) ? 0.0 : Functions::flattenSingleValue($futureValue);
+        $type = ($type === null) ? FinancialConstants::PAYMENT_END_OF_PERIOD : Functions::flattenSingleValue($type);
+
+        try {
+            $interestRate = CashFlowValidations::validateRate($interestRate);
+            $period = CashFlowValidations::validateInt($period);
+            $numberOfPeriods = CashFlowValidations::validateInt($numberOfPeriods);
+            $presentValue = CashFlowValidations::validatePresentValue($presentValue);
+            $futureValue = CashFlowValidations::validateFutureValue($futureValue);
+            $type = CashFlowValidations::validatePeriodType($type);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if ($period <= 0 || $period > $numberOfPeriods) {
+            return Functions::NAN();
+        }
+
+        // Calculate
+        $interestAndPrincipal = new InterestAndPrincipal(
+            $interestRate,
+            $period,
+            $numberOfPeriods,
+            $presentValue,
+            $futureValue,
+            $type
+        );
+
+        return $interestAndPrincipal->principal();
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Variable/NonPeriodic.php

@@ -0,0 +1,258 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Variable;
+
+use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class NonPeriodic
+{
+    const FINANCIAL_MAX_ITERATIONS = 128;
+
+    const FINANCIAL_PRECISION = 1.0e-08;
+
+    const DEFAULT_GUESS = 0.1;
+
+    /**
+     * XIRR.
+     *
+     * Returns the internal rate of return for a schedule of cash flows that is not necessarily periodic.
+     *
+     * Excel Function:
+     *        =XIRR(values,dates,guess)
+     *
+     * @param float[] $values     A series of cash flow payments
+     *                                The series of values must contain at least one positive value & one negative value
+     * @param mixed[] $dates      A series of payment dates
+     *                                The first payment date indicates the beginning of the schedule of payments
+     *                                All other dates must be later than this date, but they may occur in any order
+     * @param mixed $guess        An optional guess at the expected answer
+     *
+     * @return float|string
+     */
+    public static function rate($values, $dates, $guess = self::DEFAULT_GUESS)
+    {
+        $rslt = self::xirrPart1($values, $dates);
+        if ($rslt !== '') {
+            return $rslt;
+        }
+
+        // create an initial range, with a root somewhere between 0 and guess
+        $guess = Functions::flattenSingleValue($guess) ?? self::DEFAULT_GUESS;
+        if (!is_numeric($guess)) {
+            return Functions::VALUE();
+        }
+        $guess = ($guess + 0.0) ?: self::DEFAULT_GUESS;
+        $x1 = 0.0;
+        $x2 = $guess + 0.0;
+        $f1 = self::xnpvOrdered($x1, $values, $dates, false);
+        $f2 = self::xnpvOrdered($x2, $values, $dates, false);
+        $found = false;
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            if (!is_numeric($f1) || !is_numeric($f2)) {
+                break;
+            }
+            $f1 = (float) $f1;
+            $f2 = (float) $f2;
+            if (($f1 * $f2) < 0.0) {
+                $found = true;
+
+                break;
+            } elseif (abs($f1) < abs($f2)) {
+                $x1 += 1.6 * ($x1 - $x2);
+                $f1 = self::xnpvOrdered($x1, $values, $dates, false);
+            } else {
+                $x2 += 1.6 * ($x2 - $x1);
+                $f2 = self::xnpvOrdered($x2, $values, $dates, false);
+            }
+        }
+        if (!$found) {
+            return Functions::NAN();
+        }
+
+        return self::xirrPart3($values, $dates, $x1, $x2);
+    }
+
+    /**
+     * XNPV.
+     *
+     * Returns the net present value for a schedule of cash flows that is not necessarily periodic.
+     * To calculate the net present value for a series of cash flows that is periodic, use the NPV function.
+     *
+     * Excel Function:
+     *        =XNPV(rate,values,dates)
+     *
+     * @param float $rate the discount rate to apply to the cash flows
+     * @param float[] $values A series of cash flows that corresponds to a schedule of payments in dates.
+     *                          The first payment is optional and corresponds to a cost or payment that occurs
+     *                              at the beginning of the investment.
+     *                          If the first value is a cost or payment, it must be a negative value.
+     *                             All succeeding payments are discounted based on a 365-day year.
+     *                          The series of values must contain at least one positive value and one negative value.
+     * @param mixed[] $dates A schedule of payment dates that corresponds to the cash flow payments.
+     *                         The first payment date indicates the beginning of the schedule of payments.
+     *                         All other dates must be later than this date, but they may occur in any order.
+     *
+     * @return float|string
+     */
+    public static function presentValue($rate, $values, $dates)
+    {
+        return self::xnpvOrdered($rate, $values, $dates, true);
+    }
+
+    private static function bothNegAndPos(bool $neg, bool $pos): bool
+    {
+        return $neg && $pos;
+    }
+
+    /**
+     * @param mixed $values
+     * @param mixed $dates
+     */
+    private static function xirrPart1(&$values, &$dates): string
+    {
+        $values = Functions::flattenArray($values);
+        $dates = Functions::flattenArray($dates);
+        $valuesIsArray = count($values) > 1;
+        $datesIsArray = count($dates) > 1;
+        if (!$valuesIsArray && !$datesIsArray) {
+            return Functions::NA();
+        }
+        if (count($values) != count($dates)) {
+            return Functions::NAN();
+        }
+
+        $datesCount = count($dates);
+        for ($i = 0; $i < $datesCount; ++$i) {
+            try {
+                $dates[$i] = DateTimeExcel\Helpers::getDateValue($dates[$i]);
+            } catch (Exception $e) {
+                return $e->getMessage();
+            }
+        }
+
+        return self::xirrPart2($values);
+    }
+
+    private static function xirrPart2(array &$values): string
+    {
+        $valCount = count($values);
+        $foundpos = false;
+        $foundneg = false;
+        for ($i = 0; $i < $valCount; ++$i) {
+            $fld = $values[$i];
+            if (!is_numeric($fld)) {
+                return Functions::VALUE();
+            } elseif ($fld > 0) {
+                $foundpos = true;
+            } elseif ($fld < 0) {
+                $foundneg = true;
+            }
+        }
+        if (!self::bothNegAndPos($foundneg, $foundpos)) {
+            return Functions::NAN();
+        }
+
+        return '';
+    }
+
+    /**
+     * @return float|string
+     */
+    private static function xirrPart3(array $values, array $dates, float $x1, float $x2)
+    {
+        $f = self::xnpvOrdered($x1, $values, $dates, false);
+        if ($f < 0.0) {
+            $rtb = $x1;
+            $dx = $x2 - $x1;
+        } else {
+            $rtb = $x2;
+            $dx = $x1 - $x2;
+        }
+
+        $rslt = Functions::VALUE();
+        for ($i = 0; $i < self::FINANCIAL_MAX_ITERATIONS; ++$i) {
+            $dx *= 0.5;
+            $x_mid = $rtb + $dx;
+            $f_mid = (float) self::xnpvOrdered($x_mid, $values, $dates, false);
+            if ($f_mid <= 0.0) {
+                $rtb = $x_mid;
+            }
+            if ((abs($f_mid) < self::FINANCIAL_PRECISION) || (abs($dx) < self::FINANCIAL_PRECISION)) {
+                $rslt = $x_mid;
+
+                break;
+            }
+        }
+
+        return $rslt;
+    }
+
+    /**
+     * @param mixed $rate
+     * @param mixed $values
+     * @param mixed $dates
+     *
+     * @return float|string
+     */
+    private static function xnpvOrdered($rate, $values, $dates, bool $ordered = true)
+    {
+        $rate = Functions::flattenSingleValue($rate);
+        $values = Functions::flattenArray($values);
+        $dates = Functions::flattenArray($dates);
+        $valCount = count($values);
+
+        try {
+            self::validateXnpv($rate, $values, $dates);
+            $date0 = DateTimeExcel\Helpers::getDateValue($dates[0]);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $xnpv = 0.0;
+        for ($i = 0; $i < $valCount; ++$i) {
+            if (!is_numeric($values[$i])) {
+                return Functions::VALUE();
+            }
+
+            try {
+                $datei = DateTimeExcel\Helpers::getDateValue($dates[$i]);
+            } catch (Exception $e) {
+                return $e->getMessage();
+            }
+            if ($date0 > $datei) {
+                $dif = $ordered ? Functions::NAN() : -((int) DateTimeExcel\Difference::interval($datei, $date0, 'd'));
+            } else {
+                $dif = DateTimeExcel\Difference::interval($date0, $datei, 'd');
+            }
+            if (!is_numeric($dif)) {
+                return $dif;
+            }
+            if ($rate <= -1.0) {
+                $xnpv += -abs($values[$i]) / (-1 - $rate) ** ($dif / 365);
+            } else {
+                $xnpv += $values[$i] / (1 + $rate) ** ($dif / 365);
+            }
+        }
+
+        return is_finite($xnpv) ? $xnpv : Functions::VALUE();
+    }
+
+    /**
+     * @param mixed $rate
+     */
+    private static function validateXnpv($rate, array $values, array $dates): void
+    {
+        if (!is_numeric($rate)) {
+            throw new Exception(Functions::VALUE());
+        }
+        $valCount = count($values);
+        if ($valCount != count($dates)) {
+            throw new Exception(Functions::NAN());
+        }
+        if ($valCount > 1 && ((min($values) > 0) || (max($values) < 0))) {
+            throw new Exception(Functions::NAN());
+        }
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/Dollar.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\TextData\Format;
+
+class Dollar
+{
+    use ArrayEnabled;
+
+    /**
+     * DOLLAR.
+     *
+     * This function converts a number to text using currency format, with the decimals rounded to the specified place.
+     * The format used is $#,##0.00_);($#,##0.00)..
+     *
+     * @param mixed $number The value to format, or can be an array of numbers
+     *                         Or can be an array of values
+     * @param mixed $precision The number of digits to display to the right of the decimal point (as an integer).
+     *                            If precision is negative, number is rounded to the left of the decimal point.
+     *                            If you omit precision, it is assumed to be 2
+     *              Or can be an array of precision values
+     *
+     * @return array|string
+     *         If an array of values is passed for either of the arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function format($number, $precision = 2)
+    {
+        return Format::DOLLAR($number, $precision);
+    }
+
+    /**
+     * DOLLARDE.
+     *
+     * Converts a dollar price expressed as an integer part and a fraction
+     *        part into a dollar price expressed as a decimal number.
+     * Fractional dollar numbers are sometimes used for security prices.
+     *
+     * Excel Function:
+     *        DOLLARDE(fractional_dollar,fraction)
+     *
+     * @param mixed $fractionalDollar Fractional Dollar
+     *              Or can be an array of values
+     * @param mixed $fraction Fraction
+     *              Or can be an array of values
+     *
+     * @return array|float|string
+     */
+    public static function decimal($fractionalDollar = null, $fraction = 0)
+    {
+        if (is_array($fractionalDollar) || is_array($fraction)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $fractionalDollar, $fraction);
+        }
+
+        try {
+            $fractionalDollar = FinancialValidations::validateFloat(
+                Functions::flattenSingleValue($fractionalDollar) ?? 0.0
+            );
+            $fraction = FinancialValidations::validateInt(Functions::flattenSingleValue($fraction));
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Additional parameter validations
+        if ($fraction < 0) {
+            return Functions::NAN();
+        }
+        if ($fraction == 0) {
+            return Functions::DIV0();
+        }
+
+        $dollars = ($fractionalDollar < 0) ? ceil($fractionalDollar) : floor($fractionalDollar);
+        $cents = fmod($fractionalDollar, 1.0);
+        $cents /= $fraction;
+        $cents *= 10 ** ceil(log10($fraction));
+
+        return $dollars + $cents;
+    }
+
+    /**
+     * DOLLARFR.
+     *
+     * Converts a dollar price expressed as a decimal number into a dollar price
+     *        expressed as a fraction.
+     * Fractional dollar numbers are sometimes used for security prices.
+     *
+     * Excel Function:
+     *        DOLLARFR(decimal_dollar,fraction)
+     *
+     * @param mixed $decimalDollar Decimal Dollar
+     *              Or can be an array of values
+     * @param mixed $fraction Fraction
+     *              Or can be an array of values
+     *
+     * @return array|float|string
+     */
+    public static function fractional($decimalDollar = null, $fraction = 0)
+    {
+        if (is_array($decimalDollar) || is_array($fraction)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $decimalDollar, $fraction);
+        }
+
+        try {
+            $decimalDollar = FinancialValidations::validateFloat(
+                Functions::flattenSingleValue($decimalDollar) ?? 0.0
+            );
+            $fraction = FinancialValidations::validateInt(Functions::flattenSingleValue($fraction));
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Additional parameter validations
+        if ($fraction < 0) {
+            return Functions::NAN();
+        }
+        if ($fraction == 0) {
+            return Functions::DIV0();
+        }
+
+        $dollars = ($decimalDollar < 0.0) ? ceil($decimalDollar) : floor($decimalDollar);
+        $cents = fmod($decimalDollar, 1);
+        $cents *= $fraction;
+        $cents *= 10 ** (-ceil(log10($fraction)));
+
+        return $dollars + $cents;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/FinancialValidations.php

@@ -0,0 +1,158 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
+
+use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class FinancialValidations
+{
+    /**
+     * @param mixed $date
+     */
+    public static function validateDate($date): float
+    {
+        return DateTimeExcel\Helpers::getDateValue($date);
+    }
+
+    /**
+     * @param mixed $settlement
+     */
+    public static function validateSettlementDate($settlement): float
+    {
+        return self::validateDate($settlement);
+    }
+
+    /**
+     * @param mixed $maturity
+     */
+    public static function validateMaturityDate($maturity): float
+    {
+        return self::validateDate($maturity);
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function validateFloat($value): float
+    {
+        if (!is_numeric($value)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (float) $value;
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function validateInt($value): int
+    {
+        if (!is_numeric($value)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (int) floor((float) $value);
+    }
+
+    /**
+     * @param mixed $rate
+     */
+    public static function validateRate($rate): float
+    {
+        $rate = self::validateFloat($rate);
+        if ($rate < 0.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $rate;
+    }
+
+    /**
+     * @param mixed $frequency
+     */
+    public static function validateFrequency($frequency): int
+    {
+        $frequency = self::validateInt($frequency);
+        if (
+            ($frequency !== FinancialConstants::FREQUENCY_ANNUAL) &&
+            ($frequency !== FinancialConstants::FREQUENCY_SEMI_ANNUAL) &&
+            ($frequency !== FinancialConstants::FREQUENCY_QUARTERLY)
+        ) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $frequency;
+    }
+
+    /**
+     * @param mixed $basis
+     */
+    public static function validateBasis($basis): int
+    {
+        if (!is_numeric($basis)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        $basis = (int) $basis;
+        if (($basis < 0) || ($basis > 4)) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $basis;
+    }
+
+    /**
+     * @param mixed $price
+     */
+    public static function validatePrice($price): float
+    {
+        $price = self::validateFloat($price);
+        if ($price < 0.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $price;
+    }
+
+    /**
+     * @param mixed $parValue
+     */
+    public static function validateParValue($parValue): float
+    {
+        $parValue = self::validateFloat($parValue);
+        if ($parValue < 0.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $parValue;
+    }
+
+    /**
+     * @param mixed $yield
+     */
+    public static function validateYield($yield): float
+    {
+        $yield = self::validateFloat($yield);
+        if ($yield < 0.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $yield;
+    }
+
+    /**
+     * @param mixed $discount
+     */
+    public static function validateDiscount($discount): float
+    {
+        $discount = self::validateFloat($discount);
+        if ($discount <= 0.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $discount;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/Helpers.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
+
+use DateTimeInterface;
+use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Helpers
+{
+    /**
+     * daysPerYear.
+     *
+     * Returns the number of days in a specified year, as defined by the "basis" value
+     *
+     * @param int|string $year The year against which we're testing
+     * @param int|string $basis The type of day count:
+     *                              0 or omitted US (NASD)   360
+     *                              1                        Actual (365 or 366 in a leap year)
+     *                              2                        360
+     *                              3                        365
+     *                              4                        European 360
+     *
+     * @return int|string Result, or a string containing an error
+     */
+    public static function daysPerYear($year, $basis = 0)
+    {
+        if (!is_numeric($basis)) {
+            return Functions::NAN();
+        }
+
+        switch ($basis) {
+            case FinancialConstants::BASIS_DAYS_PER_YEAR_NASD:
+            case FinancialConstants::BASIS_DAYS_PER_YEAR_360:
+            case FinancialConstants::BASIS_DAYS_PER_YEAR_360_EUROPEAN:
+                return 360;
+            case FinancialConstants::BASIS_DAYS_PER_YEAR_365:
+                return 365;
+            case FinancialConstants::BASIS_DAYS_PER_YEAR_ACTUAL:
+                return (DateTimeExcel\Helpers::isLeapYear($year)) ? 366 : 365;
+        }
+
+        return Functions::NAN();
+    }
+
+    /**
+     * isLastDayOfMonth.
+     *
+     * Returns a boolean TRUE/FALSE indicating if this date is the last date of the month
+     *
+     * @param DateTimeInterface $date The date for testing
+     */
+    public static function isLastDayOfMonth(DateTimeInterface $date): bool
+    {
+        return $date->format('d') === $date->format('t');
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Financial/InterestRate.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class InterestRate
+{
+    /**
+     * EFFECT.
+     *
+     * Returns the effective interest rate given the nominal rate and the number of
+     *        compounding payments per year.
+     *
+     * Excel Function:
+     *        EFFECT(nominal_rate,npery)
+     *
+     * @param mixed $nominalRate Nominal interest rate as a float
+     * @param mixed $periodsPerYear Integer number of compounding payments per year
+     *
+     * @return float|string
+     */
+    public static function effective($nominalRate = 0, $periodsPerYear = 0)
+    {
+        $nominalRate = Functions::flattenSingleValue($nominalRate);
+        $periodsPerYear = Functions::flattenSingleValue($periodsPerYear);
+
+        try {
+            $nominalRate = FinancialValidations::validateFloat($nominalRate);
+            $periodsPerYear = FinancialValidations::validateInt($periodsPerYear);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($nominalRate <= 0 || $periodsPerYear < 1) {
+            return Functions::NAN();
+        }
+
+        return ((1 + $nominalRate / $periodsPerYear) ** $periodsPerYear) - 1;
+    }
+
+    /**
+     * NOMINAL.
+     *
+     * Returns the nominal interest rate given the effective rate and the number of compounding payments per year.
+     *
+     * @param mixed $effectiveRate Effective interest rate as a float
+     * @param mixed $periodsPerYear Integer number of compounding payments per year
+     *
+     * @return float|string Result, or a string containing an error
+     */
+    public static function nominal($effectiveRate = 0, $periodsPerYear = 0)
+    {
+        $effectiveRate = Functions::flattenSingleValue($effectiveRate);
+        $periodsPerYear = Functions::flattenSingleValue($periodsPerYear);
+
+        try {
+            $effectiveRate = FinancialValidations::validateFloat($effectiveRate);
+            $periodsPerYear = FinancialValidations::validateInt($periodsPerYear);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($effectiveRate <= 0 || $periodsPerYear < 1) {
+            return Functions::NAN();
+        }
+
+        // Calculate
+        return $periodsPerYear * (($effectiveRate + 1) ** (1 / $periodsPerYear) - 1);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/FormulaParser.php

@@ -0,0 +1,629 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+/**
+ * PARTLY BASED ON:
+ * Copyright (c) 2007 E. W. Bachtal, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * The software is provided "as is", without warranty of any kind, express or implied, including but not
+ * limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In
+ * no event shall the authors or copyright holders be liable for any claim, damages or other liability,
+ * whether in an action of contract, tort or otherwise, arising from, out of or in connection with the
+ * software or the use or other dealings in the software.
+ *
+ * https://ewbi.blogs.com/develops/2007/03/excel_formula_p.html
+ * https://ewbi.blogs.com/develops/2004/12/excel_formula_p.html
+ */
+class FormulaParser
+{
+    // Character constants
+    const QUOTE_DOUBLE = '"';
+    const QUOTE_SINGLE = '\'';
+    const BRACKET_CLOSE = ']';
+    const BRACKET_OPEN = '[';
+    const BRACE_OPEN = '{';
+    const BRACE_CLOSE = '}';
+    const PAREN_OPEN = '(';
+    const PAREN_CLOSE = ')';
+    const SEMICOLON = ';';
+    const WHITESPACE = ' ';
+    const COMMA = ',';
+    const ERROR_START = '#';
+
+    const OPERATORS_SN = '+-';
+    const OPERATORS_INFIX = '+-*/^&=><';
+    const OPERATORS_POSTFIX = '%';
+
+    /**
+     * Formula.
+     *
+     * @var string
+     */
+    private $formula;
+
+    /**
+     * Tokens.
+     *
+     * @var FormulaToken[]
+     */
+    private $tokens = [];
+
+    /**
+     * Create a new FormulaParser.
+     *
+     * @param string $formula Formula to parse
+     */
+    public function __construct($formula = '')
+    {
+        // Check parameters
+        if ($formula === null) {
+            throw new Exception('Invalid parameter passed: formula');
+        }
+
+        // Initialise values
+        $this->formula = trim($formula);
+        // Parse!
+        $this->parseToTokens();
+    }
+
+    /**
+     * Get Formula.
+     *
+     * @return string
+     */
+    public function getFormula()
+    {
+        return $this->formula;
+    }
+
+    /**
+     * Get Token.
+     *
+     * @param int $id Token id
+     */
+    public function getToken(int $id = 0): FormulaToken
+    {
+        if (isset($this->tokens[$id])) {
+            return $this->tokens[$id];
+        }
+
+        throw new Exception("Token with id $id does not exist.");
+    }
+
+    /**
+     * Get Token count.
+     *
+     * @return int
+     */
+    public function getTokenCount()
+    {
+        return count($this->tokens);
+    }
+
+    /**
+     * Get Tokens.
+     *
+     * @return FormulaToken[]
+     */
+    public function getTokens()
+    {
+        return $this->tokens;
+    }
+
+    /**
+     * Parse to tokens.
+     */
+    private function parseToTokens(): void
+    {
+        // No attempt is made to verify formulas; assumes formulas are derived from Excel, where
+        // they can only exist if valid; stack overflows/underflows sunk as nulls without exceptions.
+
+        // Check if the formula has a valid starting =
+        $formulaLength = strlen($this->formula);
+        if ($formulaLength < 2 || $this->formula[0] != '=') {
+            return;
+        }
+
+        // Helper variables
+        $tokens1 = $tokens2 = $stack = [];
+        $inString = $inPath = $inRange = $inError = false;
+        $token = $previousToken = $nextToken = null;
+
+        $index = 1;
+        $value = '';
+
+        $ERRORS = ['#NULL!', '#DIV/0!', '#VALUE!', '#REF!', '#NAME?', '#NUM!', '#N/A'];
+        $COMPARATORS_MULTI = ['>=', '<=', '<>'];
+
+        while ($index < $formulaLength) {
+            // state-dependent character evaluation (order is important)
+
+            // double-quoted strings
+            // embeds are doubled
+            // end marks token
+            if ($inString) {
+                if ($this->formula[$index] == self::QUOTE_DOUBLE) {
+                    if ((($index + 2) <= $formulaLength) && ($this->formula[$index + 1] == self::QUOTE_DOUBLE)) {
+                        $value .= self::QUOTE_DOUBLE;
+                        ++$index;
+                    } else {
+                        $inString = false;
+                        $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND, FormulaToken::TOKEN_SUBTYPE_TEXT);
+                        $value = '';
+                    }
+                } else {
+                    $value .= $this->formula[$index];
+                }
+                ++$index;
+
+                continue;
+            }
+
+            // single-quoted strings (links)
+            // embeds are double
+            // end does not mark a token
+            if ($inPath) {
+                if ($this->formula[$index] == self::QUOTE_SINGLE) {
+                    if ((($index + 2) <= $formulaLength) && ($this->formula[$index + 1] == self::QUOTE_SINGLE)) {
+                        $value .= self::QUOTE_SINGLE;
+                        ++$index;
+                    } else {
+                        $inPath = false;
+                    }
+                } else {
+                    $value .= $this->formula[$index];
+                }
+                ++$index;
+
+                continue;
+            }
+
+            // bracked strings (R1C1 range index or linked workbook name)
+            // no embeds (changed to "()" by Excel)
+            // end does not mark a token
+            if ($inRange) {
+                if ($this->formula[$index] == self::BRACKET_CLOSE) {
+                    $inRange = false;
+                }
+                $value .= $this->formula[$index];
+                ++$index;
+
+                continue;
+            }
+
+            // error values
+            // end marks a token, determined from absolute list of values
+            if ($inError) {
+                $value .= $this->formula[$index];
+                ++$index;
+                if (in_array($value, $ERRORS)) {
+                    $inError = false;
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND, FormulaToken::TOKEN_SUBTYPE_ERROR);
+                    $value = '';
+                }
+
+                continue;
+            }
+
+            // scientific notation check
+            if (strpos(self::OPERATORS_SN, $this->formula[$index]) !== false) {
+                if (strlen($value) > 1) {
+                    if (preg_match('/^[1-9]{1}(\\.\\d+)?E{1}$/', $this->formula[$index]) != 0) {
+                        $value .= $this->formula[$index];
+                        ++$index;
+
+                        continue;
+                    }
+                }
+            }
+
+            // independent character evaluation (order not important)
+
+            // establish state-dependent character evaluations
+            if ($this->formula[$index] == self::QUOTE_DOUBLE) {
+                if (strlen($value) > 0) {
+                    // unexpected
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_UNKNOWN);
+                    $value = '';
+                }
+                $inString = true;
+                ++$index;
+
+                continue;
+            }
+
+            if ($this->formula[$index] == self::QUOTE_SINGLE) {
+                if (strlen($value) > 0) {
+                    // unexpected
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_UNKNOWN);
+                    $value = '';
+                }
+                $inPath = true;
+                ++$index;
+
+                continue;
+            }
+
+            if ($this->formula[$index] == self::BRACKET_OPEN) {
+                $inRange = true;
+                $value .= self::BRACKET_OPEN;
+                ++$index;
+
+                continue;
+            }
+
+            if ($this->formula[$index] == self::ERROR_START) {
+                if (strlen($value) > 0) {
+                    // unexpected
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_UNKNOWN);
+                    $value = '';
+                }
+                $inError = true;
+                $value .= self::ERROR_START;
+                ++$index;
+
+                continue;
+            }
+
+            // mark start and end of arrays and array rows
+            if ($this->formula[$index] == self::BRACE_OPEN) {
+                if (strlen($value) > 0) {
+                    // unexpected
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_UNKNOWN);
+                    $value = '';
+                }
+
+                $tmp = new FormulaToken('ARRAY', FormulaToken::TOKEN_TYPE_FUNCTION, FormulaToken::TOKEN_SUBTYPE_START);
+                $tokens1[] = $tmp;
+                $stack[] = clone $tmp;
+
+                $tmp = new FormulaToken('ARRAYROW', FormulaToken::TOKEN_TYPE_FUNCTION, FormulaToken::TOKEN_SUBTYPE_START);
+                $tokens1[] = $tmp;
+                $stack[] = clone $tmp;
+
+                ++$index;
+
+                continue;
+            }
+
+            if ($this->formula[$index] == self::SEMICOLON) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+
+                $tmp = array_pop($stack);
+                $tmp->setValue('');
+                $tmp->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_STOP);
+                $tokens1[] = $tmp;
+
+                $tmp = new FormulaToken(',', FormulaToken::TOKEN_TYPE_ARGUMENT);
+                $tokens1[] = $tmp;
+
+                $tmp = new FormulaToken('ARRAYROW', FormulaToken::TOKEN_TYPE_FUNCTION, FormulaToken::TOKEN_SUBTYPE_START);
+                $tokens1[] = $tmp;
+                $stack[] = clone $tmp;
+
+                ++$index;
+
+                continue;
+            }
+
+            if ($this->formula[$index] == self::BRACE_CLOSE) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+
+                $tmp = array_pop($stack);
+                $tmp->setValue('');
+                $tmp->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_STOP);
+                $tokens1[] = $tmp;
+
+                $tmp = array_pop($stack);
+                $tmp->setValue('');
+                $tmp->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_STOP);
+                $tokens1[] = $tmp;
+
+                ++$index;
+
+                continue;
+            }
+
+            // trim white-space
+            if ($this->formula[$index] == self::WHITESPACE) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+                $tokens1[] = new FormulaToken('', FormulaToken::TOKEN_TYPE_WHITESPACE);
+                ++$index;
+                while (($this->formula[$index] == self::WHITESPACE) && ($index < $formulaLength)) {
+                    ++$index;
+                }
+
+                continue;
+            }
+
+            // multi-character comparators
+            if (($index + 2) <= $formulaLength) {
+                if (in_array(substr($this->formula, $index, 2), $COMPARATORS_MULTI)) {
+                    if (strlen($value) > 0) {
+                        $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                        $value = '';
+                    }
+                    $tokens1[] = new FormulaToken(substr($this->formula, $index, 2), FormulaToken::TOKEN_TYPE_OPERATORINFIX, FormulaToken::TOKEN_SUBTYPE_LOGICAL);
+                    $index += 2;
+
+                    continue;
+                }
+            }
+
+            // standard infix operators
+            if (strpos(self::OPERATORS_INFIX, $this->formula[$index]) !== false) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+                $tokens1[] = new FormulaToken($this->formula[$index], FormulaToken::TOKEN_TYPE_OPERATORINFIX);
+                ++$index;
+
+                continue;
+            }
+
+            // standard postfix operators (only one)
+            if (strpos(self::OPERATORS_POSTFIX, $this->formula[$index]) !== false) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+                $tokens1[] = new FormulaToken($this->formula[$index], FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX);
+                ++$index;
+
+                continue;
+            }
+
+            // start subexpression or function
+            if ($this->formula[$index] == self::PAREN_OPEN) {
+                if (strlen($value) > 0) {
+                    $tmp = new FormulaToken($value, FormulaToken::TOKEN_TYPE_FUNCTION, FormulaToken::TOKEN_SUBTYPE_START);
+                    $tokens1[] = $tmp;
+                    $stack[] = clone $tmp;
+                    $value = '';
+                } else {
+                    $tmp = new FormulaToken('', FormulaToken::TOKEN_TYPE_SUBEXPRESSION, FormulaToken::TOKEN_SUBTYPE_START);
+                    $tokens1[] = $tmp;
+                    $stack[] = clone $tmp;
+                }
+                ++$index;
+
+                continue;
+            }
+
+            // function, subexpression, or array parameters, or operand unions
+            if ($this->formula[$index] == self::COMMA) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+
+                $tmp = array_pop($stack);
+                $tmp->setValue('');
+                $tmp->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_STOP);
+                $stack[] = $tmp;
+
+                if ($tmp->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) {
+                    $tokens1[] = new FormulaToken(',', FormulaToken::TOKEN_TYPE_OPERATORINFIX, FormulaToken::TOKEN_SUBTYPE_UNION);
+                } else {
+                    $tokens1[] = new FormulaToken(',', FormulaToken::TOKEN_TYPE_ARGUMENT);
+                }
+                ++$index;
+
+                continue;
+            }
+
+            // stop subexpression
+            if ($this->formula[$index] == self::PAREN_CLOSE) {
+                if (strlen($value) > 0) {
+                    $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+                    $value = '';
+                }
+
+                $tmp = array_pop($stack);
+                $tmp->setValue('');
+                $tmp->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_STOP);
+                $tokens1[] = $tmp;
+
+                ++$index;
+
+                continue;
+            }
+
+            // token accumulation
+            $value .= $this->formula[$index];
+            ++$index;
+        }
+
+        // dump remaining accumulation
+        if (strlen($value) > 0) {
+            $tokens1[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERAND);
+        }
+
+        // move tokenList to new set, excluding unnecessary white-space tokens and converting necessary ones to intersections
+        $tokenCount = count($tokens1);
+        for ($i = 0; $i < $tokenCount; ++$i) {
+            $token = $tokens1[$i];
+            if (isset($tokens1[$i - 1])) {
+                $previousToken = $tokens1[$i - 1];
+            } else {
+                $previousToken = null;
+            }
+            if (isset($tokens1[$i + 1])) {
+                $nextToken = $tokens1[$i + 1];
+            } else {
+                $nextToken = null;
+            }
+
+            if ($token === null) {
+                continue;
+            }
+
+            if ($token->getTokenType() != FormulaToken::TOKEN_TYPE_WHITESPACE) {
+                $tokens2[] = $token;
+
+                continue;
+            }
+
+            if ($previousToken === null) {
+                continue;
+            }
+
+            if (
+                !(
+                    (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                ($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERAND)
+                )
+            ) {
+                continue;
+            }
+
+            if ($nextToken === null) {
+                continue;
+            }
+
+            if (
+                !(
+                    (($nextToken->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) && ($nextToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_START)) ||
+                (($nextToken->getTokenType() == FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($nextToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_START)) ||
+                ($nextToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERAND)
+                )
+            ) {
+                continue;
+            }
+
+            $tokens2[] = new FormulaToken($value, FormulaToken::TOKEN_TYPE_OPERATORINFIX, FormulaToken::TOKEN_SUBTYPE_INTERSECTION);
+        }
+
+        // move tokens to final list, switching infix "-" operators to prefix when appropriate, switching infix "+" operators
+        // to noop when appropriate, identifying operand and infix-operator subtypes, and pulling "@" from function names
+        $this->tokens = [];
+
+        $tokenCount = count($tokens2);
+        for ($i = 0; $i < $tokenCount; ++$i) {
+            $token = $tokens2[$i];
+            if (isset($tokens2[$i - 1])) {
+                $previousToken = $tokens2[$i - 1];
+            } else {
+                $previousToken = null;
+            }
+            if (isset($tokens2[$i + 1])) {
+                $nextToken = $tokens2[$i + 1];
+            } else {
+                $nextToken = null;
+            }
+
+            if ($token === null) {
+                continue;
+            }
+
+            if ($token->getTokenType() == FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == '-') {
+                if ($i == 0) {
+                    $token->setTokenType(FormulaToken::TOKEN_TYPE_OPERATORPREFIX);
+                } elseif (
+                    (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) &&
+                        ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                    (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_SUBEXPRESSION) &&
+                        ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                    ($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) ||
+                    ($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERAND)
+                ) {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_MATH);
+                } else {
+                    $token->setTokenType(FormulaToken::TOKEN_TYPE_OPERATORPREFIX);
+                }
+
+                $this->tokens[] = $token;
+
+                continue;
+            }
+
+            if ($token->getTokenType() == FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == '+') {
+                if ($i == 0) {
+                    continue;
+                } elseif (
+                    (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) &&
+                        ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                    (($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_SUBEXPRESSION) &&
+                        ($previousToken->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_STOP)) ||
+                    ($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) ||
+                    ($previousToken->getTokenType() == FormulaToken::TOKEN_TYPE_OPERAND)
+                ) {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_MATH);
+                } else {
+                    continue;
+                }
+
+                $this->tokens[] = $token;
+
+                continue;
+            }
+
+            if (
+                $token->getTokenType() == FormulaToken::TOKEN_TYPE_OPERATORINFIX &&
+                $token->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_NOTHING
+            ) {
+                if (strpos('<>=', substr($token->getValue(), 0, 1)) !== false) {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_LOGICAL);
+                } elseif ($token->getValue() == '&') {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_CONCATENATION);
+                } else {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_MATH);
+                }
+
+                $this->tokens[] = $token;
+
+                continue;
+            }
+
+            if (
+                $token->getTokenType() == FormulaToken::TOKEN_TYPE_OPERAND &&
+                $token->getTokenSubType() == FormulaToken::TOKEN_SUBTYPE_NOTHING
+            ) {
+                if (!is_numeric($token->getValue())) {
+                    if (strtoupper($token->getValue()) == 'TRUE' || strtoupper($token->getValue()) == 'FALSE') {
+                        $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_LOGICAL);
+                    } else {
+                        $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_RANGE);
+                    }
+                } else {
+                    $token->setTokenSubType(FormulaToken::TOKEN_SUBTYPE_NUMBER);
+                }
+
+                $this->tokens[] = $token;
+
+                continue;
+            }
+
+            if ($token->getTokenType() == FormulaToken::TOKEN_TYPE_FUNCTION) {
+                if (strlen($token->getValue()) > 0) {
+                    if (substr($token->getValue(), 0, 1) == '@') {
+                        $token->setValue(substr($token->getValue(), 1));
+                    }
+                }
+            }
+
+            $this->tokens[] = $token;
+        }
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/FormulaToken.php

@@ -0,0 +1,150 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+/**
+ * PARTLY BASED ON:
+ * Copyright (c) 2007 E. W. Bachtal, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software
+ * and associated documentation files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial
+ * portions of the Software.
+ *
+ * The software is provided "as is", without warranty of any kind, express or implied, including but not
+ * limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In
+ * no event shall the authors or copyright holders be liable for any claim, damages or other liability,
+ * whether in an action of contract, tort or otherwise, arising from, out of or in connection with the
+ * software or the use or other dealings in the software.
+ *
+ * https://ewbi.blogs.com/develops/2007/03/excel_formula_p.html
+ * https://ewbi.blogs.com/develops/2004/12/excel_formula_p.html
+ */
+class FormulaToken
+{
+    // Token types
+    const TOKEN_TYPE_NOOP = 'Noop';
+    const TOKEN_TYPE_OPERAND = 'Operand';
+    const TOKEN_TYPE_FUNCTION = 'Function';
+    const TOKEN_TYPE_SUBEXPRESSION = 'Subexpression';
+    const TOKEN_TYPE_ARGUMENT = 'Argument';
+    const TOKEN_TYPE_OPERATORPREFIX = 'OperatorPrefix';
+    const TOKEN_TYPE_OPERATORINFIX = 'OperatorInfix';
+    const TOKEN_TYPE_OPERATORPOSTFIX = 'OperatorPostfix';
+    const TOKEN_TYPE_WHITESPACE = 'Whitespace';
+    const TOKEN_TYPE_UNKNOWN = 'Unknown';
+
+    // Token subtypes
+    const TOKEN_SUBTYPE_NOTHING = 'Nothing';
+    const TOKEN_SUBTYPE_START = 'Start';
+    const TOKEN_SUBTYPE_STOP = 'Stop';
+    const TOKEN_SUBTYPE_TEXT = 'Text';
+    const TOKEN_SUBTYPE_NUMBER = 'Number';
+    const TOKEN_SUBTYPE_LOGICAL = 'Logical';
+    const TOKEN_SUBTYPE_ERROR = 'Error';
+    const TOKEN_SUBTYPE_RANGE = 'Range';
+    const TOKEN_SUBTYPE_MATH = 'Math';
+    const TOKEN_SUBTYPE_CONCATENATION = 'Concatenation';
+    const TOKEN_SUBTYPE_INTERSECTION = 'Intersection';
+    const TOKEN_SUBTYPE_UNION = 'Union';
+
+    /**
+     * Value.
+     *
+     * @var string
+     */
+    private $value;
+
+    /**
+     * Token Type (represented by TOKEN_TYPE_*).
+     *
+     * @var string
+     */
+    private $tokenType;
+
+    /**
+     * Token SubType (represented by TOKEN_SUBTYPE_*).
+     *
+     * @var string
+     */
+    private $tokenSubType;
+
+    /**
+     * Create a new FormulaToken.
+     *
+     * @param string $value
+     * @param string $tokenType Token type (represented by TOKEN_TYPE_*)
+     * @param string $tokenSubType Token Subtype (represented by TOKEN_SUBTYPE_*)
+     */
+    public function __construct($value, $tokenType = self::TOKEN_TYPE_UNKNOWN, $tokenSubType = self::TOKEN_SUBTYPE_NOTHING)
+    {
+        // Initialise values
+        $this->value = $value;
+        $this->tokenType = $tokenType;
+        $this->tokenSubType = $tokenSubType;
+    }
+
+    /**
+     * Get Value.
+     *
+     * @return string
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+
+    /**
+     * Set Value.
+     *
+     * @param string $value
+     */
+    public function setValue($value): void
+    {
+        $this->value = $value;
+    }
+
+    /**
+     * Get Token Type (represented by TOKEN_TYPE_*).
+     *
+     * @return string
+     */
+    public function getTokenType()
+    {
+        return $this->tokenType;
+    }
+
+    /**
+     * Set Token Type (represented by TOKEN_TYPE_*).
+     *
+     * @param string $value
+     */
+    public function setTokenType($value): void
+    {
+        $this->tokenType = $value;
+    }
+
+    /**
+     * Get Token SubType (represented by TOKEN_SUBTYPE_*).
+     *
+     * @return string
+     */
+    public function getTokenSubType()
+    {
+        return $this->tokenSubType;
+    }
+
+    /**
+     * Set Token SubType (represented by TOKEN_SUBTYPE_*).
+     *
+     * @param string $value
+     */
+    public function setTokenSubType($value): void
+    {
+        $this->tokenSubType = $value;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Functions.php

@@ -0,0 +1,729 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Functions
+{
+    const PRECISION = 8.88E-016;
+
+    /**
+     * 2 / PI.
+     */
+    const M_2DIVPI = 0.63661977236758134307553505349006;
+
+    const COMPATIBILITY_EXCEL = 'Excel';
+    const COMPATIBILITY_GNUMERIC = 'Gnumeric';
+    const COMPATIBILITY_OPENOFFICE = 'OpenOfficeCalc';
+
+    /** Use of RETURNDATE_PHP_NUMERIC is discouraged - not 32-bit Y2038-safe, no timezone. */
+    const RETURNDATE_PHP_NUMERIC = 'P';
+    /** Use of RETURNDATE_UNIX_TIMESTAMP is discouraged - not 32-bit Y2038-safe, no timezone. */
+    const RETURNDATE_UNIX_TIMESTAMP = 'P';
+    const RETURNDATE_PHP_OBJECT = 'O';
+    const RETURNDATE_PHP_DATETIME_OBJECT = 'O';
+    const RETURNDATE_EXCEL = 'E';
+
+    /**
+     * Compatibility mode to use for error checking and responses.
+     *
+     * @var string
+     */
+    protected static $compatibilityMode = self::COMPATIBILITY_EXCEL;
+
+    /**
+     * Data Type to use when returning date values.
+     *
+     * @var string
+     */
+    protected static $returnDateType = self::RETURNDATE_EXCEL;
+
+    /**
+     * List of error codes.
+     *
+     * @var array
+     */
+    protected static $errorCodes = [
+        'null' => '#NULL!',
+        'divisionbyzero' => '#DIV/0!',
+        'value' => '#VALUE!',
+        'reference' => '#REF!',
+        'name' => '#NAME?',
+        'num' => '#NUM!',
+        'na' => '#N/A',
+        'gettingdata' => '#GETTING_DATA',
+    ];
+
+    /**
+     * Set the Compatibility Mode.
+     *
+     * @param string $compatibilityMode Compatibility Mode
+     *                                                Permitted values are:
+     *                                                    Functions::COMPATIBILITY_EXCEL            'Excel'
+     *                                                    Functions::COMPATIBILITY_GNUMERIC        'Gnumeric'
+     *                                                    Functions::COMPATIBILITY_OPENOFFICE    'OpenOfficeCalc'
+     *
+     * @return bool (Success or Failure)
+     */
+    public static function setCompatibilityMode($compatibilityMode)
+    {
+        if (
+            ($compatibilityMode == self::COMPATIBILITY_EXCEL) ||
+            ($compatibilityMode == self::COMPATIBILITY_GNUMERIC) ||
+            ($compatibilityMode == self::COMPATIBILITY_OPENOFFICE)
+        ) {
+            self::$compatibilityMode = $compatibilityMode;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Return the current Compatibility Mode.
+     *
+     * @return string Compatibility Mode
+     *                            Possible Return values are:
+     *                                Functions::COMPATIBILITY_EXCEL            'Excel'
+     *                                Functions::COMPATIBILITY_GNUMERIC        'Gnumeric'
+     *                                Functions::COMPATIBILITY_OPENOFFICE    'OpenOfficeCalc'
+     */
+    public static function getCompatibilityMode()
+    {
+        return self::$compatibilityMode;
+    }
+
+    /**
+     * Set the Return Date Format used by functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object).
+     *
+     * @param string $returnDateType Return Date Format
+     *                                                Permitted values are:
+     *                                                    Functions::RETURNDATE_UNIX_TIMESTAMP        'P'
+     *                                                    Functions::RETURNDATE_PHP_DATETIME_OBJECT        'O'
+     *                                                    Functions::RETURNDATE_EXCEL            'E'
+     *
+     * @return bool Success or failure
+     */
+    public static function setReturnDateType($returnDateType)
+    {
+        if (
+            ($returnDateType == self::RETURNDATE_UNIX_TIMESTAMP) ||
+            ($returnDateType == self::RETURNDATE_PHP_DATETIME_OBJECT) ||
+            ($returnDateType == self::RETURNDATE_EXCEL)
+        ) {
+            self::$returnDateType = $returnDateType;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Return the current Return Date Format for functions that return a date/time (Excel, PHP Serialized Numeric or PHP Object).
+     *
+     * @return string Return Date Format
+     *                            Possible Return values are:
+     *                                Functions::RETURNDATE_UNIX_TIMESTAMP        'P'
+     *                                Functions::RETURNDATE_PHP_DATETIME_OBJECT        'O'
+     *                                Functions::RETURNDATE_EXCEL            'E'
+     */
+    public static function getReturnDateType()
+    {
+        return self::$returnDateType;
+    }
+
+    /**
+     * DUMMY.
+     *
+     * @return string #Not Yet Implemented
+     */
+    public static function DUMMY()
+    {
+        return '#Not Yet Implemented';
+    }
+
+    /**
+     * DIV0.
+     *
+     * @return string #Not Yet Implemented
+     */
+    public static function DIV0()
+    {
+        return self::$errorCodes['divisionbyzero'];
+    }
+
+    /**
+     * NA.
+     *
+     * Excel Function:
+     *        =NA()
+     *
+     * Returns the error value #N/A
+     *        #N/A is the error value that means "no value is available."
+     *
+     * @return string #N/A!
+     */
+    public static function NA()
+    {
+        return self::$errorCodes['na'];
+    }
+
+    /**
+     * NaN.
+     *
+     * Returns the error value #NUM!
+     *
+     * @return string #NUM!
+     */
+    public static function NAN()
+    {
+        return self::$errorCodes['num'];
+    }
+
+    /**
+     * NAME.
+     *
+     * Returns the error value #NAME?
+     *
+     * @return string #NAME?
+     */
+    public static function NAME()
+    {
+        return self::$errorCodes['name'];
+    }
+
+    /**
+     * REF.
+     *
+     * Returns the error value #REF!
+     *
+     * @return string #REF!
+     */
+    public static function REF()
+    {
+        return self::$errorCodes['reference'];
+    }
+
+    /**
+     * NULL.
+     *
+     * Returns the error value #NULL!
+     *
+     * @return string #NULL!
+     */
+    public static function null()
+    {
+        return self::$errorCodes['null'];
+    }
+
+    /**
+     * VALUE.
+     *
+     * Returns the error value #VALUE!
+     *
+     * @return string #VALUE!
+     */
+    public static function VALUE()
+    {
+        return self::$errorCodes['value'];
+    }
+
+    public static function isMatrixValue($idx)
+    {
+        return (substr_count($idx, '.') <= 1) || (preg_match('/\.[A-Z]/', $idx) > 0);
+    }
+
+    public static function isValue($idx)
+    {
+        return substr_count($idx, '.') == 0;
+    }
+
+    public static function isCellValue($idx)
+    {
+        return substr_count($idx, '.') > 1;
+    }
+
+    public static function ifCondition($condition)
+    {
+        $condition = self::flattenSingleValue($condition);
+
+        if ($condition === '') {
+            return '=""';
+        }
+        if (!is_string($condition) || !in_array($condition[0], ['>', '<', '='])) {
+            $condition = self::operandSpecialHandling($condition);
+            if (is_bool($condition)) {
+                return '=' . ($condition ? 'TRUE' : 'FALSE');
+            } elseif (!is_numeric($condition)) {
+                $condition = Calculation::wrapResult(strtoupper($condition));
+            }
+
+            return str_replace('""""', '""', '=' . $condition);
+        }
+        preg_match('/(=|<[>=]?|>=?)(.*)/', $condition, $matches);
+        [, $operator, $operand] = $matches;
+
+        $operand = self::operandSpecialHandling($operand);
+        if (is_numeric(trim($operand, '"'))) {
+            $operand = trim($operand, '"');
+        } elseif (!is_numeric($operand) && $operand !== 'FALSE' && $operand !== 'TRUE') {
+            $operand = str_replace('"', '""', $operand);
+            $operand = Calculation::wrapResult(strtoupper($operand));
+        }
+
+        return str_replace('""""', '""', $operator . $operand);
+    }
+
+    private static function operandSpecialHandling($operand)
+    {
+        if (is_numeric($operand) || is_bool($operand)) {
+            return $operand;
+        } elseif (strtoupper($operand) === Calculation::getTRUE() || strtoupper($operand) === Calculation::getFALSE()) {
+            return strtoupper($operand);
+        }
+
+        // Check for percentage
+        if (preg_match('/^\-?\d*\.?\d*\s?\%$/', $operand)) {
+            return ((float) rtrim($operand, '%')) / 100;
+        }
+
+        // Check for dates
+        if (($dateValueOperand = Date::stringToExcel($operand)) !== false) {
+            return $dateValueOperand;
+        }
+
+        return $operand;
+    }
+
+    /**
+     * ERROR_TYPE.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return int|string
+     */
+    public static function errorType($value = '')
+    {
+        $value = self::flattenSingleValue($value);
+
+        $i = 1;
+        foreach (self::$errorCodes as $errorCode) {
+            if ($value === $errorCode) {
+                return $i;
+            }
+            ++$i;
+        }
+
+        return self::NA();
+    }
+
+    /**
+     * IS_BLANK.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isBlank($value = null)
+    {
+        if ($value !== null) {
+            $value = self::flattenSingleValue($value);
+        }
+
+        return $value === null;
+    }
+
+    /**
+     * IS_ERR.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isErr($value = '')
+    {
+        $value = self::flattenSingleValue($value);
+
+        return self::isError($value) && (!self::isNa(($value)));
+    }
+
+    /**
+     * IS_ERROR.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isError($value = '')
+    {
+        $value = self::flattenSingleValue($value);
+
+        if (!is_string($value)) {
+            return false;
+        }
+
+        return in_array($value, self::$errorCodes);
+    }
+
+    /**
+     * IS_NA.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isNa($value = '')
+    {
+        $value = self::flattenSingleValue($value);
+
+        return $value === self::NA();
+    }
+
+    /**
+     * IS_EVEN.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool|string
+     */
+    public static function isEven($value = null)
+    {
+        $value = self::flattenSingleValue($value);
+
+        if ($value === null) {
+            return self::NAME();
+        } elseif ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value)))) {
+            return self::VALUE();
+        }
+
+        return $value % 2 == 0;
+    }
+
+    /**
+     * IS_ODD.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool|string
+     */
+    public static function isOdd($value = null)
+    {
+        $value = self::flattenSingleValue($value);
+
+        if ($value === null) {
+            return self::NAME();
+        } elseif ((is_bool($value)) || ((is_string($value)) && (!is_numeric($value)))) {
+            return self::VALUE();
+        }
+
+        return abs($value) % 2 == 1;
+    }
+
+    /**
+     * IS_NUMBER.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isNumber($value = null)
+    {
+        $value = self::flattenSingleValue($value);
+
+        if (is_string($value)) {
+            return false;
+        }
+
+        return is_numeric($value);
+    }
+
+    /**
+     * IS_LOGICAL.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isLogical($value = null)
+    {
+        $value = self::flattenSingleValue($value);
+
+        return is_bool($value);
+    }
+
+    /**
+     * IS_TEXT.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isText($value = null)
+    {
+        $value = self::flattenSingleValue($value);
+
+        return is_string($value) && !self::isError($value);
+    }
+
+    /**
+     * IS_NONTEXT.
+     *
+     * @param mixed $value Value to check
+     *
+     * @return bool
+     */
+    public static function isNonText($value = null)
+    {
+        return !self::isText($value);
+    }
+
+    /**
+     * N.
+     *
+     * Returns a value converted to a number
+     *
+     * @param null|mixed $value The value you want converted
+     *
+     * @return number N converts values listed in the following table
+     *        If value is or refers to N returns
+     *        A number            That number
+     *        A date                The serial number of that date
+     *        TRUE                1
+     *        FALSE                0
+     *        An error value        The error value
+     *        Anything else        0
+     */
+    public static function n($value = null)
+    {
+        while (is_array($value)) {
+            $value = array_shift($value);
+        }
+
+        switch (gettype($value)) {
+            case 'double':
+            case 'float':
+            case 'integer':
+                return $value;
+            case 'boolean':
+                return (int) $value;
+            case 'string':
+                //    Errors
+                if ((strlen($value) > 0) && ($value[0] == '#')) {
+                    return $value;
+                }
+
+                break;
+        }
+
+        return 0;
+    }
+
+    /**
+     * TYPE.
+     *
+     * Returns a number that identifies the type of a value
+     *
+     * @param null|mixed $value The value you want tested
+     *
+     * @return number N converts values listed in the following table
+     *        If value is or refers to N returns
+     *        A number            1
+     *        Text                2
+     *        Logical Value        4
+     *        An error value        16
+     *        Array or Matrix        64
+     */
+    public static function TYPE($value = null)
+    {
+        $value = self::flattenArrayIndexed($value);
+        if (is_array($value) && (count($value) > 1)) {
+            end($value);
+            $a = key($value);
+            //    Range of cells is an error
+            if (self::isCellValue($a)) {
+                return 16;
+            //    Test for Matrix
+            } elseif (self::isMatrixValue($a)) {
+                return 64;
+            }
+        } elseif (empty($value)) {
+            //    Empty Cell
+            return 1;
+        }
+        $value = self::flattenSingleValue($value);
+
+        if (($value === null) || (is_float($value)) || (is_int($value))) {
+            return 1;
+        } elseif (is_bool($value)) {
+            return 4;
+        } elseif (is_array($value)) {
+            return 64;
+        } elseif (is_string($value)) {
+            //    Errors
+            if ((strlen($value) > 0) && ($value[0] == '#')) {
+                return 16;
+            }
+
+            return 2;
+        }
+
+        return 0;
+    }
+
+    /**
+     * Convert a multi-dimensional array to a simple 1-dimensional array.
+     *
+     * @param array|mixed $array Array to be flattened
+     *
+     * @return array Flattened array
+     */
+    public static function flattenArray($array)
+    {
+        if (!is_array($array)) {
+            return (array) $array;
+        }
+
+        $arrayValues = [];
+        foreach ($array as $value) {
+            if (is_array($value)) {
+                foreach ($value as $val) {
+                    if (is_array($val)) {
+                        foreach ($val as $v) {
+                            $arrayValues[] = $v;
+                        }
+                    } else {
+                        $arrayValues[] = $val;
+                    }
+                }
+            } else {
+                $arrayValues[] = $value;
+            }
+        }
+
+        return $arrayValues;
+    }
+
+    /**
+     * @param mixed $value
+     *
+     * @return null|mixed
+     */
+    public static function scalar($value)
+    {
+        if (!is_array($value)) {
+            return $value;
+        }
+
+        do {
+            $value = array_pop($value);
+        } while (is_array($value));
+
+        return $value;
+    }
+
+    /**
+     * Convert a multi-dimensional array to a simple 1-dimensional array, but retain an element of indexing.
+     *
+     * @param array|mixed $array Array to be flattened
+     *
+     * @return array Flattened array
+     */
+    public static function flattenArrayIndexed($array)
+    {
+        if (!is_array($array)) {
+            return (array) $array;
+        }
+
+        $arrayValues = [];
+        foreach ($array as $k1 => $value) {
+            if (is_array($value)) {
+                foreach ($value as $k2 => $val) {
+                    if (is_array($val)) {
+                        foreach ($val as $k3 => $v) {
+                            $arrayValues[$k1 . '.' . $k2 . '.' . $k3] = $v;
+                        }
+                    } else {
+                        $arrayValues[$k1 . '.' . $k2] = $val;
+                    }
+                }
+            } else {
+                $arrayValues[$k1] = $value;
+            }
+        }
+
+        return $arrayValues;
+    }
+
+    /**
+     * Convert an array to a single scalar value by extracting the first element.
+     *
+     * @param mixed $value Array or scalar value
+     *
+     * @return mixed
+     */
+    public static function flattenSingleValue($value = '')
+    {
+        while (is_array($value)) {
+            $value = array_shift($value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * ISFORMULA.
+     *
+     * @param mixed $cellReference The cell to check
+     * @param ?Cell $cell The current cell (containing this formula)
+     *
+     * @return bool|string
+     */
+    public static function isFormula($cellReference = '', ?Cell $cell = null)
+    {
+        if ($cell === null) {
+            return self::REF();
+        }
+        $cellReference = self::expandDefinedName((string) $cellReference, $cell);
+        $cellReference = self::trimTrailingRange($cellReference);
+
+        preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellReference, $matches);
+
+        $cellReference = $matches[6] . $matches[7];
+        $worksheetName = str_replace("''", "'", trim($matches[2], "'"));
+
+        $worksheet = (!empty($worksheetName))
+            ? $cell->getWorksheet()->getParent()->getSheetByName($worksheetName)
+            : $cell->getWorksheet();
+
+        return $worksheet->getCell($cellReference)->isFormula();
+    }
+
+    public static function expandDefinedName(string $coordinate, Cell $cell): string
+    {
+        $worksheet = $cell->getWorksheet();
+        $spreadsheet = $worksheet->getParent();
+        // Uppercase coordinate
+        $pCoordinatex = strtoupper($coordinate);
+        // Eliminate leading equal sign
+        $pCoordinatex = Worksheet::pregReplace('/^=/', '', $pCoordinatex);
+        $defined = $spreadsheet->getDefinedName($pCoordinatex, $worksheet);
+        if ($defined !== null) {
+            $worksheet2 = $defined->getWorkSheet();
+            if (!$defined->isFormula() && $worksheet2 !== null) {
+                $coordinate = "'" . $worksheet2->getTitle() . "'!" . Worksheet::pregReplace('/^=/', '', $defined->getValue());
+            }
+        }
+
+        return $coordinate;
+    }
+
+    public static function trimTrailingRange(string $coordinate): string
+    {
+        return Worksheet::pregReplace('/:[\\w\$]+$/', '', $coordinate);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Internal/MakeMatrix.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Internal;
+
+class MakeMatrix
+{
+    public static function make(...$args): array
+    {
+        return $args;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Logical.php

@@ -0,0 +1,314 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Logical\Boolean;
+
+/**
+ * @deprecated 1.17.0
+ */
+class Logical
+{
+    /**
+     * TRUE.
+     *
+     * Returns the boolean TRUE.
+     *
+     * Excel Function:
+     *        =TRUE()
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Boolean::TRUE()
+     * Use the TRUE() method in the Logical\Boolean class instead
+     *
+     * @return bool True
+     */
+    public static function true(): bool
+    {
+        return Boolean::true();
+    }
+
+    /**
+     * FALSE.
+     *
+     * Returns the boolean FALSE.
+     *
+     * Excel Function:
+     *        =FALSE()
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Boolean::FALSE()
+     * Use the FALSE() method in the Logical\Boolean class instead
+     *
+     * @return bool False
+     */
+    public static function false(): bool
+    {
+        return Boolean::false();
+    }
+
+    /**
+     * LOGICAL_AND.
+     *
+     * Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
+     *
+     * Excel Function:
+     *        =AND(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Operations::logicalAnd()
+     * Use the logicalAnd() method in the Logical\Operations class instead
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return bool|string the logical AND of the arguments
+     */
+    public static function logicalAnd(...$args)
+    {
+        return Logical\Operations::logicalAnd(...$args);
+    }
+
+    /**
+     * LOGICAL_OR.
+     *
+     * Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
+     *
+     * Excel Function:
+     *        =OR(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Operations::logicalOr()
+     * Use the logicalOr() method in the Logical\Operations class instead
+     *
+     * @param mixed $args Data values
+     *
+     * @return bool|string the logical OR of the arguments
+     */
+    public static function logicalOr(...$args)
+    {
+        return Logical\Operations::logicalOr(...$args);
+    }
+
+    /**
+     * LOGICAL_XOR.
+     *
+     * Returns the Exclusive Or logical operation for one or more supplied conditions.
+     * i.e. the Xor function returns TRUE if an odd number of the supplied conditions evaluate to TRUE,
+     *      and FALSE otherwise.
+     *
+     * Excel Function:
+     *        =XOR(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Operations::logicalXor()
+     * Use the logicalXor() method in the Logical\Operations class instead
+     *
+     * @param mixed $args Data values
+     *
+     * @return bool|string the logical XOR of the arguments
+     */
+    public static function logicalXor(...$args)
+    {
+        return Logical\Operations::logicalXor(...$args);
+    }
+
+    /**
+     * NOT.
+     *
+     * Returns the boolean inverse of the argument.
+     *
+     * Excel Function:
+     *        =NOT(logical)
+     *
+     *        The argument must evaluate to a logical value such as TRUE or FALSE
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Operations::NOT()
+     * Use the NOT() method in the Logical\Operations class instead
+     *
+     * @param mixed $logical A value or expression that can be evaluated to TRUE or FALSE
+     *
+     * @return array|bool|string the boolean inverse of the argument
+     */
+    public static function NOT($logical = false)
+    {
+        return Logical\Operations::NOT($logical);
+    }
+
+    /**
+     * STATEMENT_IF.
+     *
+     * Returns one value if a condition you specify evaluates to TRUE and another value if it evaluates to FALSE.
+     *
+     * Excel Function:
+     *        =IF(condition[,returnIfTrue[,returnIfFalse]])
+     *
+     *        Condition is any value or expression that can be evaluated to TRUE or FALSE.
+     *            For example, A10=100 is a logical expression; if the value in cell A10 is equal to 100,
+     *            the expression evaluates to TRUE. Otherwise, the expression evaluates to FALSE.
+     *            This argument can use any comparison calculation operator.
+     *        ReturnIfTrue is the value that is returned if condition evaluates to TRUE.
+     *            For example, if this argument is the text string "Within budget" and the condition argument
+     *                evaluates to TRUE, then the IF function returns the text "Within budget"
+     *            If condition is TRUE and ReturnIfTrue is blank, this argument returns 0 (zero).
+     *               To display the word TRUE, use the logical value TRUE for this argument.
+     *            ReturnIfTrue can be another formula.
+     *        ReturnIfFalse is the value that is returned if condition evaluates to FALSE.
+     *            For example, if this argument is the text string "Over budget" and the condition argument
+     *                evaluates to FALSE, then the IF function returns the text "Over budget".
+     *            If condition is FALSE and ReturnIfFalse is omitted, then the logical value FALSE is returned.
+     *            If condition is FALSE and ReturnIfFalse is blank, then the value 0 (zero) is returned.
+     *            ReturnIfFalse can be another formula.
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Conditional::statementIf()
+     * Use the statementIf() method in the Logical\Conditional class instead
+     *
+     * @param mixed $condition Condition to evaluate
+     * @param mixed $returnIfTrue Value to return when condition is true
+     * @param mixed $returnIfFalse Optional value to return when condition is false
+     *
+     * @return mixed The value of returnIfTrue or returnIfFalse determined by condition
+     */
+    public static function statementIf($condition = true, $returnIfTrue = 0, $returnIfFalse = false)
+    {
+        return Logical\Conditional::statementIf($condition, $returnIfTrue, $returnIfFalse);
+    }
+
+    /**
+     * STATEMENT_SWITCH.
+     *
+     * Returns corresponding with first match (any data type such as a string, numeric, date, etc).
+     *
+     * Excel Function:
+     *        =SWITCH (expression, value1, result1, value2, result2, ... value_n, result_n [, default])
+     *
+     *        Expression
+     *              The expression to compare to a list of values.
+     *        value1, value2, ... value_n
+     *              A list of values that are compared to expression.
+     *              The SWITCH function is looking for the first value that matches the expression.
+     *        result1, result2, ... result_n
+     *              A list of results. The SWITCH function returns the corresponding result when a value
+     *              matches expression.
+     *         default
+     *              Optional. It is the default to return if expression does not match any of the values
+     *              (value1, value2, ... value_n).
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Conditional::statementSwitch()
+     * Use the statementSwitch() method in the Logical\Conditional class instead
+     *
+     * @param mixed $arguments Statement arguments
+     *
+     * @return mixed The value of matched expression
+     */
+    public static function statementSwitch(...$arguments)
+    {
+        return Logical\Conditional::statementSwitch(...$arguments);
+    }
+
+    /**
+     * IFERROR.
+     *
+     * Excel Function:
+     *        =IFERROR(testValue,errorpart)
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Conditional::IFERROR()
+     * Use the IFERROR() method in the Logical\Conditional class instead
+     *
+     * @param mixed $testValue Value to check, is also the value returned when no error
+     * @param mixed $errorpart Value to return when testValue is an error condition
+     *
+     * @return mixed The value of errorpart or testValue determined by error condition
+     */
+    public static function IFERROR($testValue = '', $errorpart = '')
+    {
+        return Logical\Conditional::IFERROR($testValue, $errorpart);
+    }
+
+    /**
+     * IFNA.
+     *
+     * Excel Function:
+     *        =IFNA(testValue,napart)
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Conditional::IFNA()
+     * Use the IFNA() method in the Logical\Conditional class instead
+     *
+     * @param mixed $testValue Value to check, is also the value returned when not an NA
+     * @param mixed $napart Value to return when testValue is an NA condition
+     *
+     * @return mixed The value of errorpart or testValue determined by error condition
+     */
+    public static function IFNA($testValue = '', $napart = '')
+    {
+        return Logical\Conditional::IFNA($testValue, $napart);
+    }
+
+    /**
+     * IFS.
+     *
+     * Excel Function:
+     *         =IFS(testValue1;returnIfTrue1;testValue2;returnIfTrue2;...;testValue_n;returnIfTrue_n)
+     *
+     *         testValue1 ... testValue_n
+     *             Conditions to Evaluate
+     *         returnIfTrue1 ... returnIfTrue_n
+     *             Value returned if corresponding testValue (nth) was true
+     *
+     * @Deprecated 1.17.0
+     *
+     * @see Logical\Conditional::IFS()
+     * Use the IFS() method in the Logical\Conditional class instead
+     *
+     * @param mixed ...$arguments Statement arguments
+     *
+     * @return mixed|string The value of returnIfTrue_n, if testValue_n was true. #N/A if none of testValues was true
+     */
+    public static function IFS(...$arguments)
+    {
+        return Logical\Conditional::IFS(...$arguments);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Logical/Operations.php

@@ -0,0 +1,206 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Logical;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Operations
+{
+    use ArrayEnabled;
+
+    /**
+     * LOGICAL_AND.
+     *
+     * Returns boolean TRUE if all its arguments are TRUE; returns FALSE if one or more argument is FALSE.
+     *
+     * Excel Function:
+     *        =AND(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return bool|string the logical AND of the arguments
+     */
+    public static function logicalAnd(...$args)
+    {
+        $args = Functions::flattenArray($args);
+
+        if (count($args) == 0) {
+            return Functions::VALUE();
+        }
+
+        $args = array_filter($args, function ($value) {
+            return $value !== null || (is_string($value) && trim($value) == '');
+        });
+
+        $returnValue = self::countTrueValues($args);
+        if (is_string($returnValue)) {
+            return $returnValue;
+        }
+        $argCount = count($args);
+
+        return ($returnValue > 0) && ($returnValue == $argCount);
+    }
+
+    /**
+     * LOGICAL_OR.
+     *
+     * Returns boolean TRUE if any argument is TRUE; returns FALSE if all arguments are FALSE.
+     *
+     * Excel Function:
+     *        =OR(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @param mixed $args Data values
+     *
+     * @return bool|string the logical OR of the arguments
+     */
+    public static function logicalOr(...$args)
+    {
+        $args = Functions::flattenArray($args);
+
+        if (count($args) == 0) {
+            return Functions::VALUE();
+        }
+
+        $args = array_filter($args, function ($value) {
+            return $value !== null || (is_string($value) && trim($value) == '');
+        });
+
+        $returnValue = self::countTrueValues($args);
+        if (is_string($returnValue)) {
+            return $returnValue;
+        }
+
+        return $returnValue > 0;
+    }
+
+    /**
+     * LOGICAL_XOR.
+     *
+     * Returns the Exclusive Or logical operation for one or more supplied conditions.
+     * i.e. the Xor function returns TRUE if an odd number of the supplied conditions evaluate to TRUE,
+     *      and FALSE otherwise.
+     *
+     * Excel Function:
+     *        =XOR(logical1[,logical2[, ...]])
+     *
+     *        The arguments must evaluate to logical values such as TRUE or FALSE, or the arguments must be arrays
+     *            or references that contain logical values.
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @param mixed $args Data values
+     *
+     * @return bool|string the logical XOR of the arguments
+     */
+    public static function logicalXor(...$args)
+    {
+        $args = Functions::flattenArray($args);
+
+        if (count($args) == 0) {
+            return Functions::VALUE();
+        }
+
+        $args = array_filter($args, function ($value) {
+            return $value !== null || (is_string($value) && trim($value) == '');
+        });
+
+        $returnValue = self::countTrueValues($args);
+        if (is_string($returnValue)) {
+            return $returnValue;
+        }
+
+        return $returnValue % 2 == 1;
+    }
+
+    /**
+     * NOT.
+     *
+     * Returns the boolean inverse of the argument.
+     *
+     * Excel Function:
+     *        =NOT(logical)
+     *
+     *        The argument must evaluate to a logical value such as TRUE or FALSE
+     *
+     *        Boolean arguments are treated as True or False as appropriate
+     *        Integer or floating point arguments are treated as True, except for 0 or 0.0 which are False
+     *        If any argument value is a string, or a Null, the function returns a #VALUE! error, unless the string
+     *            holds the value TRUE or FALSE, in which case it is evaluated as the corresponding boolean value
+     *
+     * @param mixed $logical A value or expression that can be evaluated to TRUE or FALSE
+     *                      Or can be an array of values
+     *
+     * @return array|bool|string the boolean inverse of the argument
+     *         If an array of values is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function NOT($logical = false)
+    {
+        if (is_array($logical)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $logical);
+        }
+
+        if (is_string($logical)) {
+            $logical = mb_strtoupper($logical, 'UTF-8');
+            if (($logical == 'TRUE') || ($logical == Calculation::getTRUE())) {
+                return false;
+            } elseif (($logical == 'FALSE') || ($logical == Calculation::getFALSE())) {
+                return true;
+            }
+
+            return Functions::VALUE();
+        }
+
+        return !$logical;
+    }
+
+    /**
+     * @return int|string
+     */
+    private static function countTrueValues(array $args)
+    {
+        $trueValueCount = 0;
+
+        foreach ($args as $arg) {
+            // Is it a boolean value?
+            if (is_bool($arg)) {
+                $trueValueCount += $arg;
+            } elseif ((is_numeric($arg)) && (!is_string($arg))) {
+                $trueValueCount += ((int) $arg != 0);
+            } elseif (is_string($arg)) {
+                $arg = mb_strtoupper($arg, 'UTF-8');
+                if (($arg == 'TRUE') || ($arg == Calculation::getTRUE())) {
+                    $arg = true;
+                } elseif (($arg == 'FALSE') || ($arg == Calculation::getFALSE())) {
+                    $arg = false;
+                } else {
+                    return Functions::VALUE();
+                }
+                $trueValueCount += ($arg != 0);
+            }
+        }
+
+        return $trueValueCount;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef.php

@@ -0,0 +1,416 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation;
+
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Address;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\HLookup;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Indirect;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Lookup;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Matrix;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\Offset;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\RowColumnInformation;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef\VLookup;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+/**
+ * @deprecated 1.18.0
+ */
+class LookupRef
+{
+    /**
+     * CELL_ADDRESS.
+     *
+     * Creates a cell address as text, given specified row and column numbers.
+     *
+     * Excel Function:
+     *        =ADDRESS(row, column, [relativity], [referenceStyle], [sheetText])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Address::cell()
+     *      Use the cell() method in the LookupRef\Address class instead
+     *
+     * @param mixed $row Row number to use in the cell reference
+     * @param mixed $column Column number to use in the cell reference
+     * @param int $relativity Flag indicating the type of reference to return
+     *                                1 or omitted    Absolute
+     *                                2               Absolute row; relative column
+     *                                3               Relative row; absolute column
+     *                                4               Relative
+     * @param bool $referenceStyle A logical value that specifies the A1 or R1C1 reference style.
+     *                                TRUE or omitted      CELL_ADDRESS returns an A1-style reference
+     *                                FALSE                CELL_ADDRESS returns an R1C1-style reference
+     * @param string $sheetText Optional Name of worksheet to use
+     *
+     * @return string
+     */
+    public static function cellAddress($row, $column, $relativity = 1, $referenceStyle = true, $sheetText = '')
+    {
+        return Address::cell($row, $column, $relativity, $referenceStyle, $sheetText);
+    }
+
+    /**
+     * COLUMN.
+     *
+     * Returns the column number of the given cell reference
+     *     If the cell reference is a range of cells, COLUMN returns the column numbers of each column
+     *        in the reference as a horizontal array.
+     *     If cell reference is omitted, and the function is being called through the calculation engine,
+     *        then it is assumed to be the reference of the cell in which the COLUMN function appears;
+     *        otherwise this function returns 1.
+     *
+     * Excel Function:
+     *        =COLUMN([cellAddress])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\RowColumnInformation::COLUMN()
+     *      Use the COLUMN() method in the LookupRef\RowColumnInformation class instead
+     *
+     * @param null|array|string $cellAddress A reference to a range of cells for which you want the column numbers
+     *
+     * @return int|int[]|string
+     */
+    public static function COLUMN($cellAddress = null, ?Cell $cell = null)
+    {
+        return RowColumnInformation::COLUMN($cellAddress, $cell);
+    }
+
+    /**
+     * COLUMNS.
+     *
+     * Returns the number of columns in an array or reference.
+     *
+     * Excel Function:
+     *        =COLUMNS(cellAddress)
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\RowColumnInformation::COLUMNS()
+     *      Use the COLUMNS() method in the LookupRef\RowColumnInformation class instead
+     *
+     * @param null|array|string $cellAddress An array or array formula, or a reference to a range of cells
+     *                                          for which you want the number of columns
+     *
+     * @return int|string The number of columns in cellAddress, or a string if arguments are invalid
+     */
+    public static function COLUMNS($cellAddress = null)
+    {
+        return RowColumnInformation::COLUMNS($cellAddress);
+    }
+
+    /**
+     * ROW.
+     *
+     * Returns the row number of the given cell reference
+     *     If the cell reference is a range of cells, ROW returns the row numbers of each row in the reference
+     *        as a vertical array.
+     *     If cell reference is omitted, and the function is being called through the calculation engine,
+     *        then it is assumed to be the reference of the cell in which the ROW function appears;
+     *        otherwise this function returns 1.
+     *
+     * Excel Function:
+     *        =ROW([cellAddress])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\RowColumnInformation::ROW()
+     *      Use the ROW() method in the LookupRef\RowColumnInformation class instead
+     *
+     * @param null|array|string $cellAddress A reference to a range of cells for which you want the row numbers
+     *
+     * @return int|mixed[]|string
+     */
+    public static function ROW($cellAddress = null, ?Cell $cell = null)
+    {
+        return RowColumnInformation::ROW($cellAddress, $cell);
+    }
+
+    /**
+     * ROWS.
+     *
+     * Returns the number of rows in an array or reference.
+     *
+     * Excel Function:
+     *        =ROWS(cellAddress)
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\RowColumnInformation::ROWS()
+     *      Use the ROWS() method in the LookupRef\RowColumnInformation class instead
+     *
+     * @param null|array|string $cellAddress An array or array formula, or a reference to a range of cells
+     *                                          for which you want the number of rows
+     *
+     * @return int|string The number of rows in cellAddress, or a string if arguments are invalid
+     */
+    public static function ROWS($cellAddress = null)
+    {
+        return RowColumnInformation::ROWS($cellAddress);
+    }
+
+    /**
+     * HYPERLINK.
+     *
+     * Excel Function:
+     *        =HYPERLINK(linkURL,displayName)
+     *
+     * @Deprecated 1.18.0
+     *
+     * @param mixed $linkURL Expect string. Value to check, is also the value returned when no error
+     * @param mixed $displayName Expect string. Value to return when testValue is an error condition
+     * @param Cell $cell The cell to set the hyperlink in
+     *
+     * @return string The value of $displayName (or $linkURL if $displayName was blank)
+     *
+     *@see LookupRef\Hyperlink::set()
+     *      Use the set() method in the LookupRef\Hyperlink class instead
+     */
+    public static function HYPERLINK($linkURL = '', $displayName = null, ?Cell $cell = null)
+    {
+        return LookupRef\Hyperlink::set($linkURL, $displayName, $cell);
+    }
+
+    /**
+     * INDIRECT.
+     *
+     * Returns the reference specified by a text string.
+     * References are immediately evaluated to display their contents.
+     *
+     * Excel Function:
+     *        =INDIRECT(cellAddress)
+     *
+     * @Deprecated 1.18.0
+     *
+     * @param array|string $cellAddress $cellAddress The cell address of the current cell (containing this formula)
+     * @param Cell $cell The current cell (containing this formula)
+     *
+     * @return array|string An array containing a cell or range of cells, or a string on error
+     *
+     *@see LookupRef\Indirect::INDIRECT()
+     *      Use the INDIRECT() method in the LookupRef\Indirect class instead
+     *
+     * NOTE - INDIRECT() does not yet support the optional a1 parameter introduced in Excel 2010
+     */
+    public static function INDIRECT($cellAddress, Cell $cell)
+    {
+        return Indirect::INDIRECT($cellAddress, true, $cell);
+    }
+
+    /**
+     * OFFSET.
+     *
+     * Returns a reference to a range that is a specified number of rows and columns from a cell or range of cells.
+     * The reference that is returned can be a single cell or a range of cells. You can specify the number of rows and
+     * the number of columns to be returned.
+     *
+     * Excel Function:
+     *        =OFFSET(cellAddress, rows, cols, [height], [width])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Offset::OFFSET()
+     *      Use the OFFSET() method in the LookupRef\Offset class instead
+     *
+     * @param null|string $cellAddress The reference from which you want to base the offset.
+     *                                     Reference must refer to a cell or range of adjacent cells;
+     *                                     otherwise, OFFSET returns the #VALUE! error value.
+     * @param mixed $rows The number of rows, up or down, that you want the upper-left cell to refer to.
+     *                        Using 5 as the rows argument specifies that the upper-left cell in the
+     *                        reference is five rows below reference. Rows can be positive (which means
+     *                        below the starting reference) or negative (which means above the starting
+     *                        reference).
+     * @param mixed $columns The number of columns, to the left or right, that you want the upper-left cell
+     *                           of the result to refer to. Using 5 as the cols argument specifies that the
+     *                           upper-left cell in the reference is five columns to the right of reference.
+     *                           Cols can be positive (which means to the right of the starting reference)
+     *                           or negative (which means to the left of the starting reference).
+     * @param mixed $height The height, in number of rows, that you want the returned reference to be.
+     *                          Height must be a positive number.
+     * @param mixed $width The width, in number of columns, that you want the returned reference to be.
+     *                         Width must be a positive number.
+     *
+     * @return array|string An array containing a cell or range of cells, or a string on error
+     */
+    public static function OFFSET($cellAddress = null, $rows = 0, $columns = 0, $height = null, $width = null, ?Cell $cell = null)
+    {
+        return Offset::OFFSET($cellAddress, $rows, $columns, $height, $width, $cell);
+    }
+
+    /**
+     * CHOOSE.
+     *
+     * Uses lookup_value to return a value from the list of value arguments.
+     * Use CHOOSE to select one of up to 254 values based on the lookup_value.
+     *
+     * Excel Function:
+     *        =CHOOSE(index_num, value1, [value2], ...)
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Selection::choose()
+     *      Use the choose() method in the LookupRef\Selection class instead
+     *
+     * @return mixed The selected value
+     */
+    public static function CHOOSE(...$chooseArgs)
+    {
+        return LookupRef\Selection::choose(...$chooseArgs);
+    }
+
+    /**
+     * MATCH.
+     *
+     * The MATCH function searches for a specified item in a range of cells
+     *
+     * Excel Function:
+     *        =MATCH(lookup_value, lookup_array, [match_type])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\ExcelMatch::MATCH()
+     *      Use the MATCH() method in the LookupRef\ExcelMatch class instead
+     *
+     * @param mixed $lookupValue The value that you want to match in lookup_array
+     * @param mixed $lookupArray The range of cells being searched
+     * @param mixed $matchType The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below.
+     *                         If match_type is 1 or -1, the list has to be ordered.
+     *
+     * @return int|string The relative position of the found item
+     */
+    public static function MATCH($lookupValue, $lookupArray, $matchType = 1)
+    {
+        return LookupRef\ExcelMatch::MATCH($lookupValue, $lookupArray, $matchType);
+    }
+
+    /**
+     * INDEX.
+     *
+     * Uses an index to choose a value from a reference or array
+     *
+     * Excel Function:
+     *        =INDEX(range_array, row_num, [column_num])
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Matrix::index()
+     *      Use the index() method in the LookupRef\Matrix class instead
+     *
+     * @param mixed $rowNum The row in the array or range from which to return a value.
+     *                          If row_num is omitted, column_num is required.
+     * @param mixed $columnNum The column in the array or range from which to return a value.
+     *                             If column_num is omitted, row_num is required.
+     * @param mixed $matrix
+     *
+     * @return mixed the value of a specified cell or array of cells
+     */
+    public static function INDEX($matrix, $rowNum = 0, $columnNum = 0)
+    {
+        return Matrix::index($matrix, $rowNum, $columnNum);
+    }
+
+    /**
+     * TRANSPOSE.
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Matrix::transpose()
+     *      Use the transpose() method in the LookupRef\Matrix class instead
+     *
+     * @param array $matrixData A matrix of values
+     *
+     * @return array
+     *
+     * Unlike the Excel TRANSPOSE function, which will only work on a single row or column,
+     *     this function will transpose a full matrix
+     */
+    public static function TRANSPOSE($matrixData)
+    {
+        return Matrix::transpose($matrixData);
+    }
+
+    /**
+     * VLOOKUP
+     * The VLOOKUP function searches for value in the left-most column of lookup_array and returns the value
+     *     in the same row based on the index_number.
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\VLookup::lookup()
+     *      Use the lookup() method in the LookupRef\VLookup class instead
+     *
+     * @param mixed $lookup_value The value that you want to match in lookup_array
+     * @param mixed $lookup_array The range of cells being searched
+     * @param mixed $index_number The column number in table_array from which the matching value must be returned.
+     *                                The first column is 1.
+     * @param mixed $not_exact_match determines if you are looking for an exact match based on lookup_value
+     *
+     * @return mixed The value of the found cell
+     */
+    public static function VLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match = true)
+    {
+        return VLookup::lookup($lookup_value, $lookup_array, $index_number, $not_exact_match);
+    }
+
+    /**
+     * HLOOKUP
+     * The HLOOKUP function searches for value in the top-most row of lookup_array and returns the value
+     *     in the same column based on the index_number.
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\HLookup::lookup()
+     *      Use the lookup() method in the LookupRef\HLookup class instead
+     *
+     * @param mixed $lookup_value The value that you want to match in lookup_array
+     * @param mixed $lookup_array The range of cells being searched
+     * @param mixed $index_number The row number in table_array from which the matching value must be returned.
+     *                                The first row is 1.
+     * @param mixed $not_exact_match determines if you are looking for an exact match based on lookup_value
+     *
+     * @return mixed The value of the found cell
+     */
+    public static function HLOOKUP($lookup_value, $lookup_array, $index_number, $not_exact_match = true)
+    {
+        return HLookup::lookup($lookup_value, $lookup_array, $index_number, $not_exact_match);
+    }
+
+    /**
+     * LOOKUP
+     * The LOOKUP function searches for value either from a one-row or one-column range or from an array.
+     *
+     * @Deprecated 1.18.0
+     *
+     * @see LookupRef\Lookup::lookup()
+     *      Use the lookup() method in the LookupRef\Lookup class instead
+     *
+     * @param mixed $lookup_value The value that you want to match in lookup_array
+     * @param mixed $lookup_vector The range of cells being searched
+     * @param null|mixed $result_vector The column from which the matching value must be returned
+     *
+     * @return mixed The value of the found cell
+     */
+    public static function LOOKUP($lookup_value, $lookup_vector, $result_vector = null)
+    {
+        return Lookup::lookup($lookup_value, $lookup_vector, $result_vector);
+    }
+
+    /**
+     * FORMULATEXT.
+     *
+     * @Deprecated 1.18.0
+     *
+     * @param mixed $cellReference The cell to check
+     * @param Cell $cell The current cell (containing this formula)
+     *
+     * @return string
+     *
+     *@see LookupRef\Formula::text()
+     *      Use the text() method in the LookupRef\Formula class instead
+     */
+    public static function FORMULATEXT($cellReference = '', ?Cell $cell = null)
+    {
+        return LookupRef\Formula::text($cellReference, $cell);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/ExcelMatch.php

@@ -0,0 +1,198 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Internal\WildcardMatch;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+
+class ExcelMatch
+{
+    public const MATCHTYPE_SMALLEST_VALUE = -1;
+    public const MATCHTYPE_FIRST_VALUE = 0;
+    public const MATCHTYPE_LARGEST_VALUE = 1;
+
+    /**
+     * MATCH.
+     *
+     * The MATCH function searches for a specified item in a range of cells
+     *
+     * Excel Function:
+     *        =MATCH(lookup_value, lookup_array, [match_type])
+     *
+     * @param mixed $lookupValue The value that you want to match in lookup_array
+     * @param mixed $lookupArray The range of cells being searched
+     * @param mixed $matchType The number -1, 0, or 1. -1 means above, 0 means exact match, 1 means below.
+     *                         If match_type is 1 or -1, the list has to be ordered.
+     *
+     * @return int|string The relative position of the found item
+     */
+    public static function MATCH($lookupValue, $lookupArray, $matchType = self::MATCHTYPE_LARGEST_VALUE)
+    {
+        $lookupArray = Functions::flattenArray($lookupArray);
+        $lookupValue = Functions::flattenSingleValue($lookupValue);
+        $matchType = ($matchType === null)
+            ? self::MATCHTYPE_LARGEST_VALUE
+            : (int) Functions::flattenSingleValue($matchType);
+
+        try {
+            // Input validation
+            self::validateLookupValue($lookupValue);
+            self::validateMatchType($matchType);
+            self::validateLookupArray($lookupArray);
+
+            $keySet = array_keys($lookupArray);
+            if ($matchType == self::MATCHTYPE_LARGEST_VALUE) {
+                // If match_type is 1 the list has to be processed from last to first
+                $lookupArray = array_reverse($lookupArray);
+                $keySet = array_reverse($keySet);
+            }
+
+            $lookupArray = self::prepareLookupArray($lookupArray, $matchType);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // MATCH() is not case sensitive, so we convert lookup value to be lower cased if it's a string type.
+        if (is_string($lookupValue)) {
+            $lookupValue = StringHelper::strToLower($lookupValue);
+        }
+
+        $valueKey = null;
+        switch ($matchType) {
+            case self::MATCHTYPE_LARGEST_VALUE:
+                $valueKey = self::matchLargestValue($lookupArray, $lookupValue, $keySet);
+
+                break;
+            case self::MATCHTYPE_FIRST_VALUE:
+                $valueKey = self::matchFirstValue($lookupArray, $lookupValue);
+
+                break;
+            case self::MATCHTYPE_SMALLEST_VALUE:
+            default:
+                $valueKey = self::matchSmallestValue($lookupArray, $lookupValue);
+        }
+
+        if ($valueKey !== null) {
+            return ++$valueKey;
+        }
+
+        // Unsuccessful in finding a match, return #N/A error value
+        return Functions::NA();
+    }
+
+    private static function matchFirstValue($lookupArray, $lookupValue)
+    {
+        $wildcardLookup = ((bool) preg_match('/([\?\*])/', $lookupValue));
+        $wildcard = WildcardMatch::wildcard($lookupValue);
+
+        foreach ($lookupArray as $i => $lookupArrayValue) {
+            $typeMatch = ((gettype($lookupValue) === gettype($lookupArrayValue)) ||
+                (is_numeric($lookupValue) && is_numeric($lookupArrayValue)));
+
+            if (
+                $typeMatch && is_string($lookupValue) &&
+                $wildcardLookup && WildcardMatch::compare($lookupArrayValue, $wildcard)
+            ) {
+                // wildcard match
+                return $i;
+            } elseif ($lookupArrayValue === $lookupValue) {
+                // exact match
+                return $i;
+            }
+        }
+
+        return null;
+    }
+
+    private static function matchLargestValue($lookupArray, $lookupValue, $keySet)
+    {
+        foreach ($lookupArray as $i => $lookupArrayValue) {
+            $typeMatch = ((gettype($lookupValue) === gettype($lookupArrayValue)) ||
+                (is_numeric($lookupValue) && is_numeric($lookupArrayValue)));
+
+            if ($typeMatch && ($lookupArrayValue <= $lookupValue)) {
+                return array_search($i, $keySet);
+            }
+        }
+
+        return null;
+    }
+
+    private static function matchSmallestValue($lookupArray, $lookupValue)
+    {
+        $valueKey = null;
+
+        // The basic algorithm is:
+        // Iterate and keep the highest match until the next element is smaller than the searched value.
+        // Return immediately if perfect match is found
+        foreach ($lookupArray as $i => $lookupArrayValue) {
+            $typeMatch = gettype($lookupValue) === gettype($lookupArrayValue);
+
+            if ($lookupArrayValue === $lookupValue) {
+                // Another "special" case. If a perfect match is found,
+                // the algorithm gives up immediately
+                return $i;
+            } elseif ($typeMatch && $lookupArrayValue >= $lookupValue) {
+                $valueKey = $i;
+            } elseif ($typeMatch && $lookupArrayValue < $lookupValue) {
+                //Excel algorithm gives up immediately if the first element is smaller than the searched value
+                break;
+            }
+        }
+
+        return $valueKey;
+    }
+
+    private static function validateLookupValue($lookupValue): void
+    {
+        // Lookup_value type has to be number, text, or logical values
+        if ((!is_numeric($lookupValue)) && (!is_string($lookupValue)) && (!is_bool($lookupValue))) {
+            throw new Exception(Functions::NA());
+        }
+    }
+
+    private static function validateMatchType($matchType): void
+    {
+        // Match_type is 0, 1 or -1
+        if (
+            ($matchType !== self::MATCHTYPE_FIRST_VALUE) &&
+            ($matchType !== self::MATCHTYPE_LARGEST_VALUE) && ($matchType !== self::MATCHTYPE_SMALLEST_VALUE)
+        ) {
+            throw new Exception(Functions::NA());
+        }
+    }
+
+    private static function validateLookupArray($lookupArray): void
+    {
+        // Lookup_array should not be empty
+        $lookupArraySize = count($lookupArray);
+        if ($lookupArraySize <= 0) {
+            throw new Exception(Functions::NA());
+        }
+    }
+
+    private static function prepareLookupArray($lookupArray, $matchType)
+    {
+        // Lookup_array should contain only number, text, or logical values, or empty (null) cells
+        foreach ($lookupArray as $i => $value) {
+            //    check the type of the value
+            if ((!is_numeric($value)) && (!is_string($value)) && (!is_bool($value)) && ($value !== null)) {
+                throw new Exception(Functions::NA());
+            }
+            // Convert strings to lowercase for case-insensitive testing
+            if (is_string($value)) {
+                $lookupArray[$i] = StringHelper::strToLower($value);
+            }
+            if (
+                ($value === null) &&
+                (($matchType == self::MATCHTYPE_LARGEST_VALUE) || ($matchType == self::MATCHTYPE_SMALLEST_VALUE))
+            ) {
+                unset($lookupArray[$i]);
+            }
+        }
+
+        return $lookupArray;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Formula.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+
+class Formula
+{
+    /**
+     * FORMULATEXT.
+     *
+     * @param mixed $cellReference The cell to check
+     * @param Cell $cell The current cell (containing this formula)
+     *
+     * @return string
+     */
+    public static function text($cellReference = '', ?Cell $cell = null)
+    {
+        if ($cell === null) {
+            return Functions::REF();
+        }
+
+        preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellReference, $matches);
+
+        $cellReference = $matches[6] . $matches[7];
+        $worksheetName = trim($matches[3], "'");
+        $worksheet = (!empty($worksheetName))
+            ? $cell->getWorksheet()->getParent()->getSheetByName($worksheetName)
+            : $cell->getWorksheet();
+
+        if (
+            $worksheet === null ||
+            !$worksheet->cellExists($cellReference) ||
+            !$worksheet->getCell($cellReference)->isFormula()
+        ) {
+            return Functions::NA();
+        }
+
+        return $worksheet->getCell($cellReference)->getValue();
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/HLookup.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+
+class HLookup extends LookupBase
+{
+    /**
+     * HLOOKUP
+     * The HLOOKUP function searches for value in the top-most row of lookup_array and returns the value
+     *     in the same column based on the index_number.
+     *
+     * @param mixed $lookupValue The value that you want to match in lookup_array
+     * @param mixed $lookupArray The range of cells being searched
+     * @param mixed $indexNumber The row number in table_array from which the matching value must be returned.
+     *                                The first row is 1.
+     * @param mixed $notExactMatch determines if you are looking for an exact match based on lookup_value
+     *
+     * @return mixed The value of the found cell
+     */
+    public static function lookup($lookupValue, $lookupArray, $indexNumber, $notExactMatch = true)
+    {
+        $lookupValue = Functions::flattenSingleValue($lookupValue);
+        $indexNumber = Functions::flattenSingleValue($indexNumber);
+        $notExactMatch = ($notExactMatch === null) ? true : Functions::flattenSingleValue($notExactMatch);
+        $lookupArray = self::convertLiteralArray($lookupArray);
+
+        try {
+            $indexNumber = self::validateIndexLookup($lookupArray, $indexNumber);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $f = array_keys($lookupArray);
+        $firstRow = reset($f);
+        if ((!is_array($lookupArray[$firstRow])) || ($indexNumber > count($lookupArray))) {
+            return Functions::REF();
+        }
+
+        $firstkey = $f[0] - 1;
+        $returnColumn = $firstkey + $indexNumber;
+        $firstColumn = array_shift($f);
+        $rowNumber = self::hLookupSearch($lookupValue, $lookupArray, $firstColumn, $notExactMatch);
+
+        if ($rowNumber !== null) {
+            //  otherwise return the appropriate value
+            return $lookupArray[$returnColumn][Coordinate::stringFromColumnIndex($rowNumber)];
+        }
+
+        return Functions::NA();
+    }
+
+    /**
+     * @param mixed $lookupValue The value that you want to match in lookup_array
+     * @param mixed $column The column to look up
+     * @param mixed $notExactMatch determines if you are looking for an exact match based on lookup_value
+     */
+    private static function hLookupSearch($lookupValue, array $lookupArray, $column, $notExactMatch): ?int
+    {
+        $lookupLower = StringHelper::strToLower($lookupValue);
+
+        $rowNumber = null;
+        foreach ($lookupArray[$column] as $rowKey => $rowData) {
+            // break if we have passed possible keys
+            $bothNumeric = is_numeric($lookupValue) && is_numeric($rowData);
+            $bothNotNumeric = !is_numeric($lookupValue) && !is_numeric($rowData);
+            $cellDataLower = StringHelper::strToLower($rowData);
+
+            if (
+                $notExactMatch &&
+                (($bothNumeric && $rowData > $lookupValue) || ($bothNotNumeric && $cellDataLower > $lookupLower))
+            ) {
+                break;
+            }
+
+            $rowNumber = self::checkMatch(
+                $bothNumeric,
+                $bothNotNumeric,
+                $notExactMatch,
+                Coordinate::columnIndexFromString($rowKey),
+                $cellDataLower,
+                $lookupLower,
+                $rowNumber
+            );
+        }
+
+        return $rowNumber;
+    }
+
+    private static function convertLiteralArray(array $lookupArray): array
+    {
+        if (array_key_exists(0, $lookupArray)) {
+            $lookupArray2 = [];
+            $row = 0;
+            foreach ($lookupArray as $arrayVal) {
+                ++$row;
+                if (!is_array($arrayVal)) {
+                    $arrayVal = [$arrayVal];
+                }
+                $arrayVal2 = [];
+                foreach ($arrayVal as $key2 => $val2) {
+                    $index = Coordinate::stringFromColumnIndex($key2 + 1);
+                    $arrayVal2[$index] = $val2;
+                }
+                $lookupArray2[$row] = $arrayVal2;
+            }
+            $lookupArray = $lookupArray2;
+        }
+
+        return $lookupArray;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Helpers.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Cell\AddressHelper;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Helpers
+{
+    public const CELLADDRESS_USE_A1 = true;
+
+    public const CELLADDRESS_USE_R1C1 = false;
+
+    private static function convertR1C1(string &$cellAddress1, ?string &$cellAddress2, bool $a1): string
+    {
+        if ($a1 === self::CELLADDRESS_USE_R1C1) {
+            $cellAddress1 = AddressHelper::convertToA1($cellAddress1);
+            if ($cellAddress2) {
+                $cellAddress2 = AddressHelper::convertToA1($cellAddress2);
+            }
+        }
+
+        return $cellAddress1 . ($cellAddress2 ? ":$cellAddress2" : '');
+    }
+
+    private static function adjustSheetTitle(string &$sheetTitle, ?string $value): void
+    {
+        if ($sheetTitle) {
+            $sheetTitle .= '!';
+            if (stripos($value ?? '', $sheetTitle) === 0) {
+                $sheetTitle = '';
+            }
+        }
+    }
+
+    public static function extractCellAddresses(string $cellAddress, bool $a1, Worksheet $sheet, string $sheetName = ''): array
+    {
+        $cellAddress1 = $cellAddress;
+        $cellAddress2 = null;
+        $namedRange = DefinedName::resolveName($cellAddress1, $sheet, $sheetName);
+        if ($namedRange !== null) {
+            $workSheet = $namedRange->getWorkSheet();
+            $sheetTitle = ($workSheet === null) ? '' : $workSheet->getTitle();
+            $value = preg_replace('/^=/', '', $namedRange->getValue());
+            self::adjustSheetTitle($sheetTitle, $value);
+            $cellAddress1 = $sheetTitle . $value;
+            $cellAddress = $cellAddress1;
+            $a1 = self::CELLADDRESS_USE_A1;
+        }
+        if (strpos($cellAddress, ':') !== false) {
+            [$cellAddress1, $cellAddress2] = explode(':', $cellAddress);
+        }
+        $cellAddress = self::convertR1C1($cellAddress1, $cellAddress2, $a1);
+
+        return [$cellAddress1, $cellAddress2, $cellAddress];
+    }
+
+    public static function extractWorksheet(string $cellAddress, Cell $cell): array
+    {
+        $sheetName = '';
+        if (strpos($cellAddress, '!') !== false) {
+            [$sheetName, $cellAddress] = Worksheet::extractSheetTitle($cellAddress, true);
+            $sheetName = trim($sheetName, "'");
+        }
+
+        $worksheet = ($sheetName !== '')
+            ? $cell->getWorksheet()->getParent()->getSheetByName($sheetName)
+            : $cell->getWorksheet();
+
+        return [$cellAddress, $worksheet, $sheetName];
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Hyperlink.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+
+class Hyperlink
+{
+    /**
+     * HYPERLINK.
+     *
+     * Excel Function:
+     *        =HYPERLINK(linkURL, [displayName])
+     *
+     * @param mixed $linkURL Expect string. Value to check, is also the value returned when no error
+     * @param mixed $displayName Expect string. Value to return when testValue is an error condition
+     * @param Cell $cell The cell to set the hyperlink in
+     *
+     * @return mixed The value of $displayName (or $linkURL if $displayName was blank)
+     */
+    public static function set($linkURL = '', $displayName = null, ?Cell $cell = null)
+    {
+        $linkURL = ($linkURL === null) ? '' : Functions::flattenSingleValue($linkURL);
+        $displayName = ($displayName === null) ? '' : Functions::flattenSingleValue($displayName);
+
+        if ((!is_object($cell)) || (trim($linkURL) == '')) {
+            return Functions::REF();
+        }
+
+        if ((is_object($displayName)) || trim($displayName) == '') {
+            $displayName = $linkURL;
+        }
+
+        $cell->getHyperlink()->setUrl($linkURL);
+        $cell->getHyperlink()->setTooltip($displayName);
+
+        return $displayName;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Indirect.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Indirect
+{
+    /**
+     * Determine whether cell address is in A1 (true) or R1C1 (false) format.
+     *
+     * @param mixed $a1fmt Expect bool Helpers::CELLADDRESS_USE_A1 or CELLADDRESS_USE_R1C1,
+     *                      but can be provided as numeric which is cast to bool
+     */
+    private static function a1Format($a1fmt): bool
+    {
+        $a1fmt = Functions::flattenSingleValue($a1fmt);
+        if ($a1fmt === null) {
+            return Helpers::CELLADDRESS_USE_A1;
+        }
+        if (is_string($a1fmt)) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (bool) $a1fmt;
+    }
+
+    /**
+     * Convert cellAddress to string, verify not null string.
+     *
+     * @param array|string $cellAddress
+     */
+    private static function validateAddress($cellAddress): string
+    {
+        $cellAddress = Functions::flattenSingleValue($cellAddress);
+        if (!is_string($cellAddress) || !$cellAddress) {
+            throw new Exception(Functions::REF());
+        }
+
+        return $cellAddress;
+    }
+
+    /**
+     * INDIRECT.
+     *
+     * Returns the reference specified by a text string.
+     * References are immediately evaluated to display their contents.
+     *
+     * Excel Function:
+     *        =INDIRECT(cellAddress, bool) where the bool argument is optional
+     *
+     * @param array|string $cellAddress $cellAddress The cell address of the current cell (containing this formula)
+     * @param mixed $a1fmt Expect bool Helpers::CELLADDRESS_USE_A1 or CELLADDRESS_USE_R1C1,
+     *                      but can be provided as numeric which is cast to bool
+     * @param Cell $cell The current cell (containing this formula)
+     *
+     * @return array|string An array containing a cell or range of cells, or a string on error
+     */
+    public static function INDIRECT($cellAddress, $a1fmt, Cell $cell)
+    {
+        try {
+            $a1 = self::a1Format($a1fmt);
+            $cellAddress = self::validateAddress($cellAddress);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        [$cellAddress, $worksheet, $sheetName] = Helpers::extractWorksheet($cellAddress, $cell);
+
+        [$cellAddress1, $cellAddress2, $cellAddress] = Helpers::extractCellAddresses($cellAddress, $a1, $cell->getWorkSheet(), $sheetName);
+
+        if (
+            (!preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellAddress1, $matches)) ||
+            (($cellAddress2 !== null) && (!preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellAddress2, $matches)))
+        ) {
+            return Functions::REF();
+        }
+
+        return self::extractRequiredCells($worksheet, $cellAddress);
+    }
+
+    /**
+     * Extract range values.
+     *
+     * @return mixed Array of values in range if range contains more than one element.
+     *                  Otherwise, a single value is returned.
+     */
+    private static function extractRequiredCells(?Worksheet $worksheet, string $cellAddress)
+    {
+        return Calculation::getInstance($worksheet !== null ? $worksheet->getParent() : null)
+            ->extractCellRange($cellAddress, $worksheet, false);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Lookup.php

@@ -0,0 +1,105 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+class Lookup
+{
+    /**
+     * LOOKUP
+     * The LOOKUP function searches for value either from a one-row or one-column range or from an array.
+     *
+     * @param mixed $lookupValue The value that you want to match in lookup_array
+     * @param mixed $lookupVector The range of cells being searched
+     * @param null|mixed $resultVector The column from which the matching value must be returned
+     *
+     * @return mixed The value of the found cell
+     */
+    public static function lookup($lookupValue, $lookupVector, $resultVector = null)
+    {
+        $lookupValue = Functions::flattenSingleValue($lookupValue);
+
+        if (!is_array($lookupVector)) {
+            return Functions::NA();
+        }
+        $hasResultVector = isset($resultVector);
+        $lookupRows = self::rowCount($lookupVector);
+        $lookupColumns = self::columnCount($lookupVector);
+        // we correctly orient our results
+        if (($lookupRows === 1 && $lookupColumns > 1) || (!$hasResultVector && $lookupRows === 2 && $lookupColumns !== 2)) {
+            $lookupVector = LookupRef\Matrix::transpose($lookupVector);
+            $lookupRows = self::rowCount($lookupVector);
+            $lookupColumns = self::columnCount($lookupVector);
+        }
+
+        $resultVector = self::verifyResultVector($lookupVector, $resultVector);
+
+        if ($lookupRows === 2 && !$hasResultVector) {
+            $resultVector = array_pop($lookupVector);
+            $lookupVector = array_shift($lookupVector);
+        }
+
+        if ($lookupColumns !== 2) {
+            $lookupVector = self::verifyLookupValues($lookupVector, $resultVector);
+        }
+
+        return VLookup::lookup($lookupValue, $lookupVector, 2);
+    }
+
+    private static function verifyLookupValues(array $lookupVector, array $resultVector): array
+    {
+        foreach ($lookupVector as &$value) {
+            if (is_array($value)) {
+                $k = array_keys($value);
+                $key1 = $key2 = array_shift($k);
+                ++$key2;
+                $dataValue1 = $value[$key1];
+            } else {
+                $key1 = 0;
+                $key2 = 1;
+                $dataValue1 = $value;
+            }
+
+            $dataValue2 = array_shift($resultVector);
+            if (is_array($dataValue2)) {
+                $dataValue2 = array_shift($dataValue2);
+            }
+            $value = [$key1 => $dataValue1, $key2 => $dataValue2];
+        }
+        unset($value);
+
+        return $lookupVector;
+    }
+
+    private static function verifyResultVector(array $lookupVector, $resultVector)
+    {
+        if ($resultVector === null) {
+            $resultVector = $lookupVector;
+        }
+
+        $resultRows = self::rowCount($resultVector);
+        $resultColumns = self::columnCount($resultVector);
+
+        // we correctly orient our results
+        if ($resultRows === 1 && $resultColumns > 1) {
+            $resultVector = LookupRef\Matrix::transpose($resultVector);
+        }
+
+        return $resultVector;
+    }
+
+    private static function rowCount(array $dataArray): int
+    {
+        return count($dataArray);
+    }
+
+    private static function columnCount(array $dataArray): int
+    {
+        $rowKeys = array_keys($dataArray);
+        $row = array_shift($rowKeys);
+
+        return count($dataArray[$row]);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/LookupBase.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+abstract class LookupBase
+{
+    protected static function validateIndexLookup($lookup_array, $index_number)
+    {
+        // index_number must be a number greater than or equal to 1
+        if (!is_numeric($index_number) || $index_number < 1) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        // index_number must be less than or equal to the number of columns in lookup_array
+        if ((!is_array($lookup_array)) || (empty($lookup_array))) {
+            throw new Exception(Functions::REF());
+        }
+
+        return (int) $index_number;
+    }
+
+    protected static function checkMatch(
+        bool $bothNumeric,
+        bool $bothNotNumeric,
+        $notExactMatch,
+        int $rowKey,
+        string $cellDataLower,
+        string $lookupLower,
+        ?int $rowNumber
+    ): ?int {
+        // remember the last key, but only if datatypes match
+        if ($bothNumeric || $bothNotNumeric) {
+            // Spreadsheets software returns first exact match,
+            // we have sorted and we might have broken key orders
+            // we want the first one (by its initial index)
+            if ($notExactMatch) {
+                $rowNumber = $rowKey;
+            } elseif (($cellDataLower == $lookupLower) && (($rowNumber === null) || ($rowKey < $rowNumber))) {
+                $rowNumber = $rowKey;
+            }
+        }
+
+        return $rowNumber;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/LookupRefValidations.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class LookupRefValidations
+{
+    /**
+     * @param mixed $value
+     */
+    public static function validateInt($value): int
+    {
+        if (!is_numeric($value)) {
+            if (Functions::isError($value)) {
+                throw new Exception($value);
+            }
+
+            throw new Exception(Functions::VALUE());
+        }
+
+        return (int) floor((float) $value);
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function validatePositiveInt($value, bool $allowZero = true): int
+    {
+        $value = self::validateInt($value);
+
+        if (($allowZero === false && $value <= 0) || $value < 0) {
+            throw new Exception(Functions::VALUE());
+        }
+
+        return $value;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Matrix.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Matrix
+{
+    /**
+     * TRANSPOSE.
+     *
+     * @param array|mixed $matrixData A matrix of values
+     *
+     * @return array
+     */
+    public static function transpose($matrixData)
+    {
+        $returnMatrix = [];
+        if (!is_array($matrixData)) {
+            $matrixData = [[$matrixData]];
+        }
+
+        $column = 0;
+        foreach ($matrixData as $matrixRow) {
+            $row = 0;
+            foreach ($matrixRow as $matrixCell) {
+                $returnMatrix[$row][$column] = $matrixCell;
+                ++$row;
+            }
+            ++$column;
+        }
+
+        return $returnMatrix;
+    }
+
+    /**
+     * INDEX.
+     *
+     * Uses an index to choose a value from a reference or array
+     *
+     * Excel Function:
+     *        =INDEX(range_array, row_num, [column_num], [area_num])
+     *
+     * @param mixed $matrix A range of cells or an array constant
+     * @param mixed $rowNum The row in the array or range from which to return a value.
+     *                          If row_num is omitted, column_num is required.
+     * @param mixed $columnNum The column in the array or range from which to return a value.
+     *                          If column_num is omitted, row_num is required.
+     *
+     * TODO Provide support for area_num, currently not supported
+     *
+     * @return mixed the value of a specified cell or array of cells
+     */
+    public static function index($matrix, $rowNum = 0, $columnNum = 0)
+    {
+        $rowNum = ($rowNum === null) ? 0 : Functions::flattenSingleValue($rowNum);
+        $columnNum = ($columnNum === null) ? 0 : Functions::flattenSingleValue($columnNum);
+
+        try {
+            $rowNum = LookupRefValidations::validatePositiveInt($rowNum);
+            $columnNum = LookupRefValidations::validatePositiveInt($columnNum);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (!is_array($matrix) || ($rowNum > count($matrix))) {
+            return Functions::REF();
+        }
+
+        $rowKeys = array_keys($matrix);
+        $columnKeys = @array_keys($matrix[$rowKeys[0]]);
+
+        if ($columnNum > count($columnKeys)) {
+            return Functions::REF();
+        }
+
+        if ($columnNum === 0) {
+            return self::extractRowValue($matrix, $rowKeys, $rowNum);
+        }
+
+        $columnNum = $columnKeys[--$columnNum];
+        if ($rowNum === 0) {
+            return array_map(
+                function ($value) {
+                    return [$value];
+                },
+                array_column($matrix, $columnNum)
+            );
+        }
+        $rowNum = $rowKeys[--$rowNum];
+
+        return $matrix[$rowNum][$columnNum];
+    }
+
+    private static function extractRowValue(array $matrix, array $rowKeys, int $rowNum)
+    {
+        if ($rowNum === 0) {
+            return $matrix;
+        }
+
+        $rowNum = $rowKeys[--$rowNum];
+        $row = $matrix[$rowNum];
+        if (is_array($row)) {
+            return [$rowNum => $row];
+        }
+
+        return $row;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/LookupRef/Offset.php

@@ -0,0 +1,136 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Offset
+{
+    /**
+     * OFFSET.
+     *
+     * Returns a reference to a range that is a specified number of rows and columns from a cell or range of cells.
+     * The reference that is returned can be a single cell or a range of cells. You can specify the number of rows and
+     * the number of columns to be returned.
+     *
+     * Excel Function:
+     *        =OFFSET(cellAddress, rows, cols, [height], [width])
+     *
+     * @param null|string $cellAddress The reference from which you want to base the offset.
+     *                                     Reference must refer to a cell or range of adjacent cells;
+     *                                     otherwise, OFFSET returns the #VALUE! error value.
+     * @param mixed $rows The number of rows, up or down, that you want the upper-left cell to refer to.
+     *                        Using 5 as the rows argument specifies that the upper-left cell in the
+     *                        reference is five rows below reference. Rows can be positive (which means
+     *                        below the starting reference) or negative (which means above the starting
+     *                        reference).
+     * @param mixed $columns The number of columns, to the left or right, that you want the upper-left cell
+     *                           of the result to refer to. Using 5 as the cols argument specifies that the
+     *                           upper-left cell in the reference is five columns to the right of reference.
+     *                           Cols can be positive (which means to the right of the starting reference)
+     *                           or negative (which means to the left of the starting reference).
+     * @param mixed $height The height, in number of rows, that you want the returned reference to be.
+     *                          Height must be a positive number.
+     * @param mixed $width The width, in number of columns, that you want the returned reference to be.
+     *                         Width must be a positive number.
+     *
+     * @return array|int|string An array containing a cell or range of cells, or a string on error
+     */
+    public static function OFFSET($cellAddress = null, $rows = 0, $columns = 0, $height = null, $width = null, ?Cell $cell = null)
+    {
+        $rows = Functions::flattenSingleValue($rows);
+        $columns = Functions::flattenSingleValue($columns);
+        $height = Functions::flattenSingleValue($height);
+        $width = Functions::flattenSingleValue($width);
+
+        if ($cellAddress === null || $cellAddress === '') {
+            return Functions::VALUE();
+        }
+
+        if (!is_object($cell)) {
+            return Functions::REF();
+        }
+
+        [$cellAddress, $worksheet] = self::extractWorksheet($cellAddress, $cell);
+
+        $startCell = $endCell = $cellAddress;
+        if (strpos($cellAddress, ':')) {
+            [$startCell, $endCell] = explode(':', $cellAddress);
+        }
+        [$startCellColumn, $startCellRow] = Coordinate::coordinateFromString($startCell);
+        [$endCellColumn, $endCellRow] = Coordinate::coordinateFromString($endCell);
+
+        $startCellRow += $rows;
+        $startCellColumn = Coordinate::columnIndexFromString($startCellColumn) - 1;
+        $startCellColumn += $columns;
+
+        if (($startCellRow <= 0) || ($startCellColumn < 0)) {
+            return Functions::REF();
+        }
+
+        $endCellColumn = self::adjustEndCellColumnForWidth($endCellColumn, $width, $startCellColumn, $columns);
+        $startCellColumn = Coordinate::stringFromColumnIndex($startCellColumn + 1);
+
+        $endCellRow = self::adustEndCellRowForHeight($height, $startCellRow, $rows, $endCellRow);
+
+        if (($endCellRow <= 0) || ($endCellColumn < 0)) {
+            return Functions::REF();
+        }
+        $endCellColumn = Coordinate::stringFromColumnIndex($endCellColumn + 1);
+
+        $cellAddress = "{$startCellColumn}{$startCellRow}";
+        if (($startCellColumn != $endCellColumn) || ($startCellRow != $endCellRow)) {
+            $cellAddress .= ":{$endCellColumn}{$endCellRow}";
+        }
+
+        return self::extractRequiredCells($worksheet, $cellAddress);
+    }
+
+    private static function extractRequiredCells(?Worksheet $worksheet, string $cellAddress)
+    {
+        return Calculation::getInstance($worksheet !== null ? $worksheet->getParent() : null)
+            ->extractCellRange($cellAddress, $worksheet, false);
+    }
+
+    private static function extractWorksheet($cellAddress, Cell $cell): array
+    {
+        $sheetName = '';
+        if (strpos($cellAddress, '!') !== false) {
+            [$sheetName, $cellAddress] = Worksheet::extractSheetTitle($cellAddress, true);
+            $sheetName = trim($sheetName, "'");
+        }
+
+        $worksheet = ($sheetName !== '')
+            ? $cell->getWorksheet()->getParent()->getSheetByName($sheetName)
+            : $cell->getWorksheet();
+
+        return [$cellAddress, $worksheet];
+    }
+
+    private static function adjustEndCellColumnForWidth(string $endCellColumn, $width, int $startCellColumn, $columns)
+    {
+        $endCellColumn = Coordinate::columnIndexFromString($endCellColumn) - 1;
+        if (($width !== null) && (!is_object($width))) {
+            $endCellColumn = $startCellColumn + (int) $width - 1;
+        } else {
+            $endCellColumn += (int) $columns;
+        }
+
+        return $endCellColumn;
+    }
+
+    private static function adustEndCellRowForHeight($height, int $startCellRow, $rows, $endCellRow): int
+    {
+        if (($height !== null) && (!is_object($height))) {
+            $endCellRow = $startCellRow + (int) $height - 1;
+        } else {
+            $endCellRow += (int) $rows;
+        }
+
+        return $endCellRow;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Exp.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+
+class Exp
+{
+    use ArrayEnabled;
+
+    /**
+     * EXP.
+     *
+     * Returns the result of builtin function exp after validating args.
+     *
+     * @param mixed $number Should be numeric, or can be an array of numbers
+     *
+     * @return array|float|string Rounded number
+     *         If an array of numbers is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function evaluate($number)
+    {
+        if (is_array($number)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return exp($number);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Factorial.php

@@ -0,0 +1,125 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical;
+
+class Factorial
+{
+    use ArrayEnabled;
+
+    /**
+     * FACT.
+     *
+     * Returns the factorial of a number.
+     * The factorial of a number is equal to 1*2*3*...* number.
+     *
+     * Excel Function:
+     *        FACT(factVal)
+     *
+     * @param array|float $factVal Factorial Value, or can be an array of numbers
+     *
+     * @return array|float|int|string Factorial, or a string containing an error
+     *         If an array of numbers is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function fact($factVal)
+    {
+        if (is_array($factVal)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $factVal);
+        }
+
+        try {
+            $factVal = Helpers::validateNumericNullBool($factVal);
+            Helpers::validateNotNegative($factVal);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $factLoop = floor($factVal);
+        if ($factVal > $factLoop) {
+            if (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC) {
+                return Statistical\Distributions\Gamma::gammaValue($factVal + 1);
+            }
+        }
+
+        $factorial = 1;
+        while ($factLoop > 1) {
+            $factorial *= $factLoop--;
+        }
+
+        return $factorial;
+    }
+
+    /**
+     * FACTDOUBLE.
+     *
+     * Returns the double factorial of a number.
+     *
+     * Excel Function:
+     *        FACTDOUBLE(factVal)
+     *
+     * @param array|float $factVal Factorial Value, or can be an array of numbers
+     *
+     * @return array|float|int|string Double Factorial, or a string containing an error
+     *         If an array of numbers is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function factDouble($factVal)
+    {
+        if (is_array($factVal)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $factVal);
+        }
+
+        try {
+            $factVal = Helpers::validateNumericNullSubstitution($factVal, 0);
+            Helpers::validateNotNegative($factVal);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $factLoop = floor($factVal);
+        $factorial = 1;
+        while ($factLoop > 1) {
+            $factorial *= $factLoop;
+            $factLoop -= 2;
+        }
+
+        return $factorial;
+    }
+
+    /**
+     * MULTINOMIAL.
+     *
+     * Returns the ratio of the factorial of a sum of values to the product of factorials.
+     *
+     * @param mixed[] $args An array of mixed values for the Data Series
+     *
+     * @return float|string The result, or a string containing an error
+     */
+    public static function multinomial(...$args)
+    {
+        $summer = 0;
+        $divisor = 1;
+
+        try {
+            // Loop through arguments
+            foreach (Functions::flattenArray($args) as $argx) {
+                $arg = Helpers::validateNumericNullSubstitution($argx, null);
+                Helpers::validateNotNegative($arg);
+                $arg = (int) $arg;
+                $summer += $arg;
+                $divisor *= self::fact($arg);
+            }
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $summer = self::fact($summer);
+
+        return $summer / $divisor;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Floor.php

@@ -0,0 +1,194 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Floor
+{
+    use ArrayEnabled;
+
+    private static function floorCheck1Arg(): void
+    {
+        $compatibility = Functions::getCompatibilityMode();
+        if ($compatibility === Functions::COMPATIBILITY_EXCEL) {
+            throw new Exception('Excel requires 2 arguments for FLOOR');
+        }
+    }
+
+    /**
+     * FLOOR.
+     *
+     * Rounds number down, toward zero, to the nearest multiple of significance.
+     *
+     * Excel Function:
+     *        FLOOR(number[,significance])
+     *
+     * @param mixed $number Expect float. Number to round
+     *                      Or can be an array of values
+     * @param mixed $significance Expect float. Significance
+     *                      Or can be an array of values
+     *
+     * @return array|float|string Rounded Number, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function floor($number, $significance = null)
+    {
+        if (is_array($number) || is_array($significance)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $number, $significance);
+        }
+
+        if ($significance === null) {
+            self::floorCheck1Arg();
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            $significance = Helpers::validateNumericNullSubstitution($significance, ($number < 0) ? -1 : 1);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return self::argumentsOk((float) $number, (float) $significance);
+    }
+
+    /**
+     * FLOOR.MATH.
+     *
+     * Round a number down to the nearest integer or to the nearest multiple of significance.
+     *
+     * Excel Function:
+     *        FLOOR.MATH(number[,significance[,mode]])
+     *
+     * @param mixed $number Number to round
+     *                      Or can be an array of values
+     * @param mixed $significance Significance
+     *                      Or can be an array of values
+     * @param mixed $mode direction to round negative numbers
+     *                      Or can be an array of values
+     *
+     * @return array|float|string Rounded Number, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function math($number, $significance = null, $mode = 0)
+    {
+        if (is_array($number) || is_array($significance) || is_array($mode)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $number, $significance, $mode);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            $significance = Helpers::validateNumericNullSubstitution($significance, ($number < 0) ? -1 : 1);
+            $mode = Helpers::validateNumericNullSubstitution($mode, null);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return self::argsOk((float) $number, (float) $significance, (int) $mode);
+    }
+
+    /**
+     * FLOOR.PRECISE.
+     *
+     * Rounds number down, toward zero, to the nearest multiple of significance.
+     *
+     * Excel Function:
+     *        FLOOR.PRECISE(number[,significance])
+     *
+     * @param array|float $number Number to round
+     *                      Or can be an array of values
+     * @param array|float $significance Significance
+     *                      Or can be an array of values
+     *
+     * @return array|float|string Rounded Number, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function precise($number, $significance = 1)
+    {
+        if (is_array($number) || is_array($significance)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $number, $significance);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            $significance = Helpers::validateNumericNullSubstitution($significance, null);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return self::argumentsOkPrecise((float) $number, (float) $significance);
+    }
+
+    /**
+     * Avoid Scrutinizer problems concerning complexity.
+     *
+     * @return float|string
+     */
+    private static function argumentsOkPrecise(float $number, float $significance)
+    {
+        if ($significance == 0.0) {
+            return Functions::DIV0();
+        }
+        if ($number == 0.0) {
+            return 0.0;
+        }
+
+        return floor($number / abs($significance)) * abs($significance);
+    }
+
+    /**
+     * Avoid Scrutinizer complexity problems.
+     *
+     * @return float|string Rounded Number, or a string containing an error
+     */
+    private static function argsOk(float $number, float $significance, int $mode)
+    {
+        if (!$significance) {
+            return Functions::DIV0();
+        }
+        if (!$number) {
+            return 0.0;
+        }
+        if (self::floorMathTest($number, $significance, $mode)) {
+            return ceil($number / $significance) * $significance;
+        }
+
+        return floor($number / $significance) * $significance;
+    }
+
+    /**
+     * Let FLOORMATH complexity pass Scrutinizer.
+     */
+    private static function floorMathTest(float $number, float $significance, int $mode): bool
+    {
+        return Helpers::returnSign($significance) == -1 || (Helpers::returnSign($number) == -1 && !empty($mode));
+    }
+
+    /**
+     * Avoid Scrutinizer problems concerning complexity.
+     *
+     * @return float|string
+     */
+    private static function argumentsOk(float $number, float $significance)
+    {
+        if ($significance == 0.0) {
+            return Functions::DIV0();
+        }
+        if ($number == 0.0) {
+            return 0.0;
+        }
+        if (Helpers::returnSign($significance) == 1) {
+            return floor($number / $significance) * $significance;
+        }
+        if (Helpers::returnSign($number) == -1 && Helpers::returnSign($significance) == -1) {
+            return floor($number / $significance) * $significance;
+        }
+
+        return Functions::NAN();
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Gcd.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Gcd
+{
+    /**
+     * Recursively determine GCD.
+     *
+     * Returns the greatest common divisor of a series of numbers.
+     * The greatest common divisor is the largest integer that divides both
+     *        number1 and number2 without a remainder.
+     *
+     * Excel Function:
+     *        GCD(number1[,number2[, ...]])
+     *
+     * @param float|int $a
+     * @param float|int $b
+     *
+     * @return float|int
+     */
+    private static function evaluateGCD($a, $b)
+    {
+        return $b ? self::evaluateGCD($b, $a % $b) : $a;
+    }
+
+    /**
+     * GCD.
+     *
+     * Returns the greatest common divisor of a series of numbers.
+     * The greatest common divisor is the largest integer that divides both
+     *        number1 and number2 without a remainder.
+     *
+     * Excel Function:
+     *        GCD(number1[,number2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float|int|string Greatest Common Divisor, or a string containing an error
+     */
+    public static function evaluate(...$args)
+    {
+        try {
+            $arrayArgs = [];
+            foreach (Functions::flattenArray($args) as $value1) {
+                if ($value1 !== null) {
+                    $value = Helpers::validateNumericNullSubstitution($value1, 1);
+                    Helpers::validateNotNegative($value);
+                    $arrayArgs[] = (int) $value;
+                }
+            }
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (count($arrayArgs) <= 0) {
+            return Functions::VALUE();
+        }
+        $gcd = (int) array_pop($arrayArgs);
+        do {
+            $gcd = self::evaluateGCD($gcd, (int) array_pop($arrayArgs));
+        } while (!empty($arrayArgs));
+
+        return $gcd;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Helpers.php

@@ -0,0 +1,129 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Helpers
+{
+    /**
+     * Many functions accept null/false/true argument treated as 0/0/1.
+     *
+     * @return float|string quotient or DIV0 if denominator is too small
+     */
+    public static function verySmallDenominator(float $numerator, float $denominator)
+    {
+        return (abs($denominator) < 1.0E-12) ? Functions::DIV0() : ($numerator / $denominator);
+    }
+
+    /**
+     * Many functions accept null/false/true argument treated as 0/0/1.
+     *
+     * @param mixed $number
+     *
+     * @return float|int
+     */
+    public static function validateNumericNullBool($number)
+    {
+        $number = Functions::flattenSingleValue($number);
+        if ($number === null) {
+            return 0;
+        }
+        if (is_bool($number)) {
+            return (int) $number;
+        }
+        if (is_numeric($number)) {
+            return 0 + $number;
+        }
+
+        throw new Exception(Functions::VALUE());
+    }
+
+    /**
+     * Validate numeric, but allow substitute for null.
+     *
+     * @param mixed $number
+     * @param null|float|int $substitute
+     *
+     * @return float|int
+     */
+    public static function validateNumericNullSubstitution($number, $substitute)
+    {
+        $number = Functions::flattenSingleValue($number);
+        if ($number === null && $substitute !== null) {
+            return $substitute;
+        }
+        if (is_numeric($number)) {
+            return 0 + $number;
+        }
+
+        throw new Exception(Functions::VALUE());
+    }
+
+    /**
+     * Confirm number >= 0.
+     *
+     * @param float|int $number
+     */
+    public static function validateNotNegative($number, ?string $except = null): void
+    {
+        if ($number >= 0) {
+            return;
+        }
+
+        throw new Exception($except ?? Functions::NAN());
+    }
+
+    /**
+     * Confirm number > 0.
+     *
+     * @param float|int $number
+     */
+    public static function validatePositive($number, ?string $except = null): void
+    {
+        if ($number > 0) {
+            return;
+        }
+
+        throw new Exception($except ?? Functions::NAN());
+    }
+
+    /**
+     * Confirm number != 0.
+     *
+     * @param float|int $number
+     */
+    public static function validateNotZero($number): void
+    {
+        if ($number) {
+            return;
+        }
+
+        throw new Exception(Functions::DIV0());
+    }
+
+    public static function returnSign(float $number): int
+    {
+        return $number ? (($number > 0) ? 1 : -1) : 0;
+    }
+
+    public static function getEven(float $number): float
+    {
+        $significance = 2 * self::returnSign($number);
+
+        return $significance ? (ceil($number / $significance) * $significance) : 0;
+    }
+
+    /**
+     * Return NAN or value depending on argument.
+     *
+     * @param float $result Number
+     *
+     * @return float|string
+     */
+    public static function numberOrNan($result)
+    {
+        return is_nan($result) ? Functions::NAN() : $result;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/IntClass.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+
+class IntClass
+{
+    use ArrayEnabled;
+
+    /**
+     * INT.
+     *
+     * Casts a floating point value to an integer
+     *
+     * Excel Function:
+     *        INT(number)
+     *
+     * @param array|float $number Number to cast to an integer, or can be an array of numbers
+     *
+     * @return array|string Integer value, or a string containing an error
+     *         If an array of numbers is passed as the argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function evaluate($number)
+    {
+        if (is_array($number)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return (int) floor($number);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Lcm.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Lcm
+{
+    //
+    //    Private method to return an array of the factors of the input value
+    //
+    private static function factors(float $value): array
+    {
+        $startVal = floor(sqrt($value));
+
+        $factorArray = [];
+        for ($i = $startVal; $i > 1; --$i) {
+            if (($value % $i) == 0) {
+                $factorArray = array_merge($factorArray, self::factors($value / $i));
+                $factorArray = array_merge($factorArray, self::factors($i));
+                if ($i <= sqrt($value)) {
+                    break;
+                }
+            }
+        }
+        if (!empty($factorArray)) {
+            rsort($factorArray);
+
+            return $factorArray;
+        }
+
+        return [(int) $value];
+    }
+
+    /**
+     * LCM.
+     *
+     * Returns the lowest common multiplier of a series of numbers
+     * The least common multiple is the smallest positive integer that is a multiple
+     * of all integer arguments number1, number2, and so on. Use LCM to add fractions
+     * with different denominators.
+     *
+     * Excel Function:
+     *        LCM(number1[,number2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return int|string Lowest Common Multiplier, or a string containing an error
+     */
+    public static function evaluate(...$args)
+    {
+        try {
+            $arrayArgs = [];
+            $anyZeros = 0;
+            $anyNonNulls = 0;
+            foreach (Functions::flattenArray($args) as $value1) {
+                $anyNonNulls += (int) ($value1 !== null);
+                $value = Helpers::validateNumericNullSubstitution($value1, 1);
+                Helpers::validateNotNegative($value);
+                $arrayArgs[] = (int) $value;
+                $anyZeros += (int) !((bool) $value);
+            }
+            self::testNonNulls($anyNonNulls);
+            if ($anyZeros) {
+                return 0;
+            }
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $returnValue = 1;
+        $allPoweredFactors = [];
+        // Loop through arguments
+        foreach ($arrayArgs as $value) {
+            $myFactors = self::factors(floor($value));
+            $myCountedFactors = array_count_values($myFactors);
+            $myPoweredFactors = [];
+            foreach ($myCountedFactors as $myCountedFactor => $myCountedPower) {
+                $myPoweredFactors[$myCountedFactor] = $myCountedFactor ** $myCountedPower;
+            }
+            self::processPoweredFactors($allPoweredFactors, $myPoweredFactors);
+        }
+        foreach ($allPoweredFactors as $allPoweredFactor) {
+            $returnValue *= (int) $allPoweredFactor;
+        }
+
+        return $returnValue;
+    }
+
+    private static function processPoweredFactors(array &$allPoweredFactors, array &$myPoweredFactors): void
+    {
+        foreach ($myPoweredFactors as $myPoweredValue => $myPoweredFactor) {
+            if (isset($allPoweredFactors[$myPoweredValue])) {
+                if ($allPoweredFactors[$myPoweredValue] < $myPoweredFactor) {
+                    $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
+                }
+            } else {
+                $allPoweredFactors[$myPoweredValue] = $myPoweredFactor;
+            }
+        }
+    }
+
+    private static function testNonNulls(int $anyNonNulls): void
+    {
+        if (!$anyNonNulls) {
+            throw new Exception(Functions::VALUE());
+        }
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Logarithms.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+
+class Logarithms
+{
+    use ArrayEnabled;
+
+    /**
+     * LOG_BASE.
+     *
+     * Returns the logarithm of a number to a specified base. The default base is 10.
+     *
+     * Excel Function:
+     *        LOG(number[,base])
+     *
+     * @param mixed $number The positive real number for which you want the logarithm
+     *                      Or can be an array of values
+     * @param mixed $base The base of the logarithm. If base is omitted, it is assumed to be 10.
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function withBase($number, $base = 10)
+    {
+        if (is_array($number) || is_array($base)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $number, $base);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            Helpers::validatePositive($number);
+            $base = Helpers::validateNumericNullBool($base);
+            Helpers::validatePositive($base);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return log($number, $base);
+    }
+
+    /**
+     * LOG10.
+     *
+     * Returns the result of builtin function log after validating args.
+     *
+     * @param mixed $number Should be numeric
+     *                      Or can be an array of values
+     *
+     * @return array|float|string Rounded number
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function base10($number)
+    {
+        if (is_array($number)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            Helpers::validatePositive($number);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return log10($number);
+    }
+
+    /**
+     * LN.
+     *
+     * Returns the result of builtin function log after validating args.
+     *
+     * @param mixed $number Should be numeric
+     *                      Or can be an array of values
+     *
+     * @return array|float|string Rounded number
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function natural($number)
+    {
+        if (is_array($number)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
+        }
+
+        try {
+            $number = Helpers::validateNumericNullBool($number);
+            Helpers::validatePositive($number);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return log($number);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/MatrixFunctions.php

@@ -0,0 +1,179 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use Matrix\Builder;
+use Matrix\Div0Exception as MatrixDiv0Exception;
+use Matrix\Exception as MatrixException;
+use Matrix\Matrix;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class MatrixFunctions
+{
+    /**
+     * Convert parameter to Matrix.
+     *
+     * @param mixed $matrixValues A matrix of values
+     */
+    private static function getMatrix($matrixValues): Matrix
+    {
+        $matrixData = [];
+        if (!is_array($matrixValues)) {
+            $matrixValues = [[$matrixValues]];
+        }
+
+        $row = 0;
+        foreach ($matrixValues as $matrixRow) {
+            if (!is_array($matrixRow)) {
+                $matrixRow = [$matrixRow];
+            }
+            $column = 0;
+            foreach ($matrixRow as $matrixCell) {
+                if ((is_string($matrixCell)) || ($matrixCell === null)) {
+                    throw new Exception(Functions::VALUE());
+                }
+                $matrixData[$row][$column] = $matrixCell;
+                ++$column;
+            }
+            ++$row;
+        }
+
+        return new Matrix($matrixData);
+    }
+
+    /**
+     * SEQUENCE.
+     *
+     * Generates a list of sequential numbers in an array.
+     *
+     * Excel Function:
+     *      SEQUENCE(rows,[columns],[start],[step])
+     *
+     * @param mixed $rows the number of rows to return, defaults to 1
+     * @param mixed $columns the number of columns to return, defaults to 1
+     * @param mixed $start the first number in the sequence, defaults to 1
+     * @param mixed $step the amount to increment each subsequent value in the array, defaults to 1
+     *
+     * @return array|string The resulting array, or a string containing an error
+     */
+    public static function sequence($rows = 1, $columns = 1, $start = 1, $step = 1)
+    {
+        try {
+            $rows = (int) Helpers::validateNumericNullSubstitution($rows, 1);
+            Helpers::validatePositive($rows);
+            $columns = (int) Helpers::validateNumericNullSubstitution($columns, 1);
+            Helpers::validatePositive($columns);
+            $start = Helpers::validateNumericNullSubstitution($start, 1);
+            $step = Helpers::validateNumericNullSubstitution($step, 1);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($step === 0) {
+            return array_chunk(
+                array_fill(0, $rows * $columns, $start),
+                max($columns, 1)
+            );
+        }
+
+        return array_chunk(
+            range($start, $start + (($rows * $columns - 1) * $step), $step),
+            max($columns, 1)
+        );
+    }
+
+    /**
+     * MDETERM.
+     *
+     * Returns the matrix determinant of an array.
+     *
+     * Excel Function:
+     *        MDETERM(array)
+     *
+     * @param mixed $matrixValues A matrix of values
+     *
+     * @return float|string The result, or a string containing an error
+     */
+    public static function determinant($matrixValues)
+    {
+        try {
+            $matrix = self::getMatrix($matrixValues);
+
+            return $matrix->determinant();
+        } catch (MatrixException $ex) {
+            return Functions::VALUE();
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+    }
+
+    /**
+     * MINVERSE.
+     *
+     * Returns the inverse matrix for the matrix stored in an array.
+     *
+     * Excel Function:
+     *        MINVERSE(array)
+     *
+     * @param mixed $matrixValues A matrix of values
+     *
+     * @return array|string The result, or a string containing an error
+     */
+    public static function inverse($matrixValues)
+    {
+        try {
+            $matrix = self::getMatrix($matrixValues);
+
+            return $matrix->inverse()->toArray();
+        } catch (MatrixDiv0Exception $e) {
+            return Functions::NAN();
+        } catch (MatrixException $e) {
+            return Functions::VALUE();
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+    }
+
+    /**
+     * MMULT.
+     *
+     * @param mixed $matrixData1 A matrix of values
+     * @param mixed $matrixData2 A matrix of values
+     *
+     * @return array|string The result, or a string containing an error
+     */
+    public static function multiply($matrixData1, $matrixData2)
+    {
+        try {
+            $matrixA = self::getMatrix($matrixData1);
+            $matrixB = self::getMatrix($matrixData2);
+
+            return $matrixA->multiply($matrixB)->toArray();
+        } catch (MatrixException $ex) {
+            return Functions::VALUE();
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+    }
+
+    /**
+     * MUnit.
+     *
+     * @param mixed $dimension Number of rows and columns
+     *
+     * @return array|string The result, or a string containing an error
+     */
+    public static function identity($dimension)
+    {
+        try {
+            $dimension = (int) Helpers::validateNumericNullBool($dimension);
+            Helpers::validatePositive($dimension, Functions::VALUE());
+            $matrix = Builder::createIdentityMatrix($dimension, 0)->toArray();
+
+            return $matrix;
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/MathTrig/Operations.php

@@ -0,0 +1,163 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Operations
+{
+    use ArrayEnabled;
+
+    /**
+     * MOD.
+     *
+     * @param mixed $dividend Dividend
+     *                      Or can be an array of values
+     * @param mixed $divisor Divisor
+     *                      Or can be an array of values
+     *
+     * @return array|float|int|string Remainder, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function mod($dividend, $divisor)
+    {
+        if (is_array($dividend) || is_array($divisor)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $dividend, $divisor);
+        }
+
+        try {
+            $dividend = Helpers::validateNumericNullBool($dividend);
+            $divisor = Helpers::validateNumericNullBool($divisor);
+            Helpers::validateNotZero($divisor);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($dividend < 0.0) && ($divisor > 0.0)) {
+            return $divisor - fmod(abs($dividend), $divisor);
+        }
+        if (($dividend > 0.0) && ($divisor < 0.0)) {
+            return $divisor + fmod($dividend, abs($divisor));
+        }
+
+        return fmod($dividend, $divisor);
+    }
+
+    /**
+     * POWER.
+     *
+     * Computes x raised to the power y.
+     *
+     * @param array|float|int $x
+     *                      Or can be an array of values
+     * @param array|float|int $y
+     *                      Or can be an array of values
+     *
+     * @return array|float|int|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function power($x, $y)
+    {
+        if (is_array($x) || is_array($y)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $x, $y);
+        }
+
+        try {
+            $x = Helpers::validateNumericNullBool($x);
+            $y = Helpers::validateNumericNullBool($y);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        // Validate parameters
+        if (!$x && !$y) {
+            return Functions::NAN();
+        }
+        if (!$x && $y < 0.0) {
+            return Functions::DIV0();
+        }
+
+        // Return
+        $result = $x ** $y;
+
+        return Helpers::numberOrNan($result);
+    }
+
+    /**
+     * PRODUCT.
+     *
+     * PRODUCT returns the product of all the values and cells referenced in the argument list.
+     *
+     * Excel Function:
+     *        PRODUCT(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float|string
+     */
+    public static function product(...$args)
+    {
+        // Return value
+        $returnValue = null;
+
+        // Loop through arguments
+        foreach (Functions::flattenArray($args) as $arg) {
+            // Is it a numeric value?
+            if (is_numeric($arg)) {
+                if ($returnValue === null) {
+                    $returnValue = $arg;
+                } else {
+                    $returnValue *= $arg;
+                }
+            } else {
+                return Functions::VALUE();
+            }
+        }
+
+        // Return
+        if ($returnValue === null) {
+            return 0;
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * QUOTIENT.
+     *
+     * QUOTIENT function returns the integer portion of a division. Numerator is the divided number
+     *        and denominator is the divisor.
+     *
+     * Excel Function:
+     *        QUOTIENT(value1,value2)
+     *
+     * @param mixed $numerator Expect float|int
+     *                      Or can be an array of values
+     * @param mixed $denominator Expect float|int
+     *                      Or can be an array of values
+     *
+     * @return array|int|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function quotient($numerator, $denominator)
+    {
+        if (is_array($numerator) || is_array($denominator)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $numerator, $denominator);
+        }
+
+        try {
+            $numerator = Helpers::validateNumericNullSubstitution($numerator, 0);
+            $denominator = Helpers::validateNumericNullSubstitution($denominator, 0);
+            Helpers::validateNotZero($denominator);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return (int) ($numerator / $denominator);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Averages/Mean.php

@@ -0,0 +1,131 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Averages;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Averages;
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Counts;
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Minimum;
+
+class Mean
+{
+    /**
+     * GEOMEAN.
+     *
+     * Returns the geometric mean of an array or range of positive data. For example, you
+     *        can use GEOMEAN to calculate average growth rate given compound interest with
+     *        variable rates.
+     *
+     * Excel Function:
+     *        GEOMEAN(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float|string
+     */
+    public static function geometric(...$args)
+    {
+        $aArgs = Functions::flattenArray($args);
+
+        $aMean = MathTrig\Operations::product($aArgs);
+        if (is_numeric($aMean) && ($aMean > 0)) {
+            $aCount = Counts::COUNT($aArgs);
+            if (Minimum::min($aArgs) > 0) {
+                return $aMean ** (1 / $aCount);
+            }
+        }
+
+        return Functions::NAN();
+    }
+
+    /**
+     * HARMEAN.
+     *
+     * Returns the harmonic mean of a data set. The harmonic mean is the reciprocal of the
+     *        arithmetic mean of reciprocals.
+     *
+     * Excel Function:
+     *        HARMEAN(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float|string
+     */
+    public static function harmonic(...$args)
+    {
+        // Loop through arguments
+        $aArgs = Functions::flattenArray($args);
+        if (Minimum::min($aArgs) < 0) {
+            return Functions::NAN();
+        }
+
+        $returnValue = 0;
+        $aCount = 0;
+        foreach ($aArgs as $arg) {
+            // Is it a numeric value?
+            if ((is_numeric($arg)) && (!is_string($arg))) {
+                if ($arg <= 0) {
+                    return Functions::NAN();
+                }
+                $returnValue += (1 / $arg);
+                ++$aCount;
+            }
+        }
+
+        // Return
+        if ($aCount > 0) {
+            return 1 / ($returnValue / $aCount);
+        }
+
+        return Functions::NA();
+    }
+
+    /**
+     * TRIMMEAN.
+     *
+     * Returns the mean of the interior of a data set. TRIMMEAN calculates the mean
+     *        taken by excluding a percentage of data points from the top and bottom tails
+     *        of a data set.
+     *
+     * Excel Function:
+     *        TRIMEAN(value1[,value2[, ...]], $discard)
+     *
+     * @param mixed $args Data values
+     *
+     * @return float|string
+     */
+    public static function trim(...$args)
+    {
+        $aArgs = Functions::flattenArray($args);
+
+        // Calculate
+        $percent = array_pop($aArgs);
+
+        if ((is_numeric($percent)) && (!is_string($percent))) {
+            if (($percent < 0) || ($percent > 1)) {
+                return Functions::NAN();
+            }
+
+            $mArgs = [];
+            foreach ($aArgs as $arg) {
+                // Is it a numeric value?
+                if ((is_numeric($arg)) && (!is_string($arg))) {
+                    $mArgs[] = $arg;
+                }
+            }
+
+            $discard = floor(Counts::COUNT($mArgs) * $percent / 2);
+            sort($mArgs);
+
+            for ($i = 0; $i < $discard; ++$i) {
+                array_pop($mArgs);
+                array_shift($mArgs);
+            }
+
+            return Averages::average($mArgs);
+        }
+
+        return Functions::VALUE();
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/DistributionValidations.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StatisticalValidations;
+
+class DistributionValidations extends StatisticalValidations
+{
+    /**
+     * @param mixed $probability
+     */
+    public static function validateProbability($probability): float
+    {
+        $probability = self::validateFloat($probability);
+
+        if ($probability < 0.0 || $probability > 1.0) {
+            throw new Exception(Functions::NAN());
+        }
+
+        return $probability;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/Exponential.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Exponential
+{
+    use ArrayEnabled;
+
+    /**
+     * EXPONDIST.
+     *
+     *    Returns the exponential distribution. Use EXPONDIST to model the time between events,
+     *        such as how long an automated bank teller takes to deliver cash. For example, you can
+     *        use EXPONDIST to determine the probability that the process takes at most 1 minute.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     * @param mixed $lambda The parameter value as a float
+     *                      Or can be an array of values
+     * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value, $lambda, $cumulative)
+    {
+        if (is_array($value) || is_array($lambda) || is_array($cumulative)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $lambda, $cumulative);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $lambda = DistributionValidations::validateFloat($lambda);
+            $cumulative = DistributionValidations::validateBool($cumulative);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($value < 0) || ($lambda < 0)) {
+            return Functions::NAN();
+        }
+
+        if ($cumulative === true) {
+            return 1 - exp(0 - $value * $lambda);
+        }
+
+        return $lambda * exp(0 - $value * $lambda);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/F.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class F
+{
+    use ArrayEnabled;
+
+    /**
+     * F.DIST.
+     *
+     *    Returns the F probability distribution.
+     *    You can use this function to determine whether two data sets have different degrees of diversity.
+     *    For example, you can examine the test scores of men and women entering high school, and determine
+     *        if the variability in the females is different from that found in the males.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     * @param mixed $u The numerator degrees of freedom as an integer
+     *                      Or can be an array of values
+     * @param mixed $v The denominator degrees of freedom as an integer
+     *                      Or can be an array of values
+     * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value, $u, $v, $cumulative)
+    {
+        if (is_array($value) || is_array($u) || is_array($v) || is_array($cumulative)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $u, $v, $cumulative);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $u = DistributionValidations::validateInt($u);
+            $v = DistributionValidations::validateInt($v);
+            $cumulative = DistributionValidations::validateBool($cumulative);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($value < 0 || $u < 1 || $v < 1) {
+            return Functions::NAN();
+        }
+
+        if ($cumulative) {
+            $adjustedValue = ($u * $value) / ($u * $value + $v);
+
+            return Beta::incompleteBeta($adjustedValue, $u / 2, $v / 2);
+        }
+
+        return (Gamma::gammaValue(($v + $u) / 2) /
+                (Gamma::gammaValue($u / 2) * Gamma::gammaValue($v / 2))) *
+            (($u / $v) ** ($u / 2)) *
+            (($value ** (($u - 2) / 2)) / ((1 + ($u / $v) * $value) ** (($u + $v) / 2)));
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/Fisher.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Fisher
+{
+    use ArrayEnabled;
+
+    /**
+     * FISHER.
+     *
+     * Returns the Fisher transformation at x. This transformation produces a function that
+     *        is normally distributed rather than skewed. Use this function to perform hypothesis
+     *        testing on the correlation coefficient.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value)
+    {
+        if (is_array($value)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $value);
+        }
+
+        try {
+            DistributionValidations::validateFloat($value);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($value <= -1) || ($value >= 1)) {
+            return Functions::NAN();
+        }
+
+        return 0.5 * log((1 + $value) / (1 - $value));
+    }
+
+    /**
+     * FISHERINV.
+     *
+     * Returns the inverse of the Fisher transformation. Use this transformation when
+     *        analyzing correlations between ranges or arrays of data. If y = FISHER(x), then
+     *        FISHERINV(y) = x.
+     *
+     * @param mixed $probability Float probability at which you want to evaluate the distribution
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function inverse($probability)
+    {
+        if (is_array($probability)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $probability);
+        }
+
+        try {
+            DistributionValidations::validateFloat($probability);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        return (exp(2 * $probability) - 1) / (exp(2 * $probability) + 1);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/Gamma.php

@@ -0,0 +1,151 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Gamma extends GammaBase
+{
+    use ArrayEnabled;
+
+    /**
+     * GAMMA.
+     *
+     * Return the gamma function value.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function gamma($value)
+    {
+        if (is_array($value)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $value);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ((((int) $value) == ((float) $value)) && $value <= 0.0) {
+            return Functions::NAN();
+        }
+
+        return self::gammaValue($value);
+    }
+
+    /**
+     * GAMMADIST.
+     *
+     * Returns the gamma distribution.
+     *
+     * @param mixed $value Float Value at which you want to evaluate the distribution
+     *                      Or can be an array of values
+     * @param mixed $a Parameter to the distribution as a float
+     *                      Or can be an array of values
+     * @param mixed $b Parameter to the distribution as a float
+     *                      Or can be an array of values
+     * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value, $a, $b, $cumulative)
+    {
+        if (is_array($value) || is_array($a) || is_array($b) || is_array($cumulative)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $a, $b, $cumulative);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $a = DistributionValidations::validateFloat($a);
+            $b = DistributionValidations::validateFloat($b);
+            $cumulative = DistributionValidations::validateBool($cumulative);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($value < 0) || ($a <= 0) || ($b <= 0)) {
+            return Functions::NAN();
+        }
+
+        return self::calculateDistribution($value, $a, $b, $cumulative);
+    }
+
+    /**
+     * GAMMAINV.
+     *
+     * Returns the inverse of the Gamma distribution.
+     *
+     * @param mixed $probability Float probability at which you want to evaluate the distribution
+     *                      Or can be an array of values
+     * @param mixed $alpha Parameter to the distribution as a float
+     *                      Or can be an array of values
+     * @param mixed $beta Parameter to the distribution as a float
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function inverse($probability, $alpha, $beta)
+    {
+        if (is_array($probability) || is_array($alpha) || is_array($beta)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $probability, $alpha, $beta);
+        }
+
+        try {
+            $probability = DistributionValidations::validateProbability($probability);
+            $alpha = DistributionValidations::validateFloat($alpha);
+            $beta = DistributionValidations::validateFloat($beta);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($alpha <= 0.0) || ($beta <= 0.0)) {
+            return Functions::NAN();
+        }
+
+        return self::calculateInverse($probability, $alpha, $beta);
+    }
+
+    /**
+     * GAMMALN.
+     *
+     * Returns the natural logarithm of the gamma function.
+     *
+     * @param mixed $value Float Value at which you want to evaluate the distribution
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function ln($value)
+    {
+        if (is_array($value)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $value);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($value <= 0) {
+            return Functions::NAN();
+        }
+
+        return log(self::gammaValue($value));
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/GammaBase.php

@@ -0,0 +1,381 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+abstract class GammaBase
+{
+    private const LOG_GAMMA_X_MAX_VALUE = 2.55e305;
+
+    private const EPS = 2.22e-16;
+
+    private const MAX_VALUE = 1.2e308;
+
+    private const SQRT2PI = 2.5066282746310005024157652848110452530069867406099;
+
+    private const MAX_ITERATIONS = 256;
+
+    protected static function calculateDistribution(float $value, float $a, float $b, bool $cumulative)
+    {
+        if ($cumulative) {
+            return self::incompleteGamma($a, $value / $b) / self::gammaValue($a);
+        }
+
+        return (1 / ($b ** $a * self::gammaValue($a))) * $value ** ($a - 1) * exp(0 - ($value / $b));
+    }
+
+    protected static function calculateInverse(float $probability, float $alpha, float $beta)
+    {
+        $xLo = 0;
+        $xHi = $alpha * $beta * 5;
+
+        $dx = 1024;
+        $x = $xNew = 1;
+        $i = 0;
+
+        while ((abs($dx) > Functions::PRECISION) && (++$i <= self::MAX_ITERATIONS)) {
+            // Apply Newton-Raphson step
+            $result = self::calculateDistribution($x, $alpha, $beta, true);
+            $error = $result - $probability;
+
+            if ($error == 0.0) {
+                $dx = 0;
+            } elseif ($error < 0.0) {
+                $xLo = $x;
+            } else {
+                $xHi = $x;
+            }
+
+            $pdf = self::calculateDistribution($x, $alpha, $beta, false);
+            // Avoid division by zero
+            if ($pdf !== 0.0) {
+                $dx = $error / $pdf;
+                $xNew = $x - $dx;
+            }
+
+            // If the NR fails to converge (which for example may be the
+            // case if the initial guess is too rough) we apply a bisection
+            // step to determine a more narrow interval around the root.
+            if (($xNew < $xLo) || ($xNew > $xHi) || ($pdf == 0.0)) {
+                $xNew = ($xLo + $xHi) / 2;
+                $dx = $xNew - $x;
+            }
+            $x = $xNew;
+        }
+
+        if ($i === self::MAX_ITERATIONS) {
+            return Functions::NA();
+        }
+
+        return $x;
+    }
+
+    //
+    //    Implementation of the incomplete Gamma function
+    //
+    public static function incompleteGamma(float $a, float $x): float
+    {
+        static $max = 32;
+        $summer = 0;
+        for ($n = 0; $n <= $max; ++$n) {
+            $divisor = $a;
+            for ($i = 1; $i <= $n; ++$i) {
+                $divisor *= ($a + $i);
+            }
+            $summer += ($x ** $n / $divisor);
+        }
+
+        return $x ** $a * exp(0 - $x) * $summer;
+    }
+
+    //
+    //    Implementation of the Gamma function
+    //
+    public static function gammaValue(float $value): float
+    {
+        if ($value == 0.0) {
+            return 0;
+        }
+
+        static $p0 = 1.000000000190015;
+        static $p = [
+            1 => 76.18009172947146,
+            2 => -86.50532032941677,
+            3 => 24.01409824083091,
+            4 => -1.231739572450155,
+            5 => 1.208650973866179e-3,
+            6 => -5.395239384953e-6,
+        ];
+
+        $y = $x = $value;
+        $tmp = $x + 5.5;
+        $tmp -= ($x + 0.5) * log($tmp);
+
+        $summer = $p0;
+        for ($j = 1; $j <= 6; ++$j) {
+            $summer += ($p[$j] / ++$y);
+        }
+
+        return exp(0 - $tmp + log(self::SQRT2PI * $summer / $x));
+    }
+
+    /**
+     * logGamma function.
+     *
+     * @version 1.1
+     *
+     * @author Jaco van Kooten
+     *
+     * Original author was Jaco van Kooten. Ported to PHP by Paul Meagher.
+     *
+     * The natural logarithm of the gamma function. <br />
+     * Based on public domain NETLIB (Fortran) code by W. J. Cody and L. Stoltz <br />
+     * Applied Mathematics Division <br />
+     * Argonne National Laboratory <br />
+     * Argonne, IL 60439 <br />
+     * <p>
+     * References:
+     * <ol>
+     * <li>W. J. Cody and K. E. Hillstrom, 'Chebyshev Approximations for the Natural
+     *     Logarithm of the Gamma Function,' Math. Comp. 21, 1967, pp. 198-203.</li>
+     * <li>K. E. Hillstrom, ANL/AMD Program ANLC366S, DGAMMA/DLGAMA, May, 1969.</li>
+     * <li>Hart, Et. Al., Computer Approximations, Wiley and sons, New York, 1968.</li>
+     * </ol>
+     * </p>
+     * <p>
+     * From the original documentation:
+     * </p>
+     * <p>
+     * This routine calculates the LOG(GAMMA) function for a positive real argument X.
+     * Computation is based on an algorithm outlined in references 1 and 2.
+     * The program uses rational functions that theoretically approximate LOG(GAMMA)
+     * to at least 18 significant decimal digits. The approximation for X > 12 is from
+     * reference 3, while approximations for X < 12.0 are similar to those in reference
+     * 1, but are unpublished. The accuracy achieved depends on the arithmetic system,
+     * the compiler, the intrinsic functions, and proper selection of the
+     * machine-dependent constants.
+     * </p>
+     * <p>
+     * Error returns: <br />
+     * The program returns the value XINF for X .LE. 0.0 or when overflow would occur.
+     * The computation is believed to be free of underflow and overflow.
+     * </p>
+     *
+     * @return float MAX_VALUE for x < 0.0 or when overflow would occur, i.e. x > 2.55E305
+     */
+
+    // Log Gamma related constants
+    private const  LG_D1 = -0.5772156649015328605195174;
+
+    private const LG_D2 = 0.4227843350984671393993777;
+
+    private const LG_D4 = 1.791759469228055000094023;
+
+    private const LG_P1 = [
+        4.945235359296727046734888,
+        201.8112620856775083915565,
+        2290.838373831346393026739,
+        11319.67205903380828685045,
+        28557.24635671635335736389,
+        38484.96228443793359990269,
+        26377.48787624195437963534,
+        7225.813979700288197698961,
+    ];
+
+    private const LG_P2 = [
+        4.974607845568932035012064,
+        542.4138599891070494101986,
+        15506.93864978364947665077,
+        184793.2904445632425417223,
+        1088204.76946882876749847,
+        3338152.967987029735917223,
+        5106661.678927352456275255,
+        3074109.054850539556250927,
+    ];
+
+    private const LG_P4 = [
+        14745.02166059939948905062,
+        2426813.369486704502836312,
+        121475557.4045093227939592,
+        2663432449.630976949898078,
+        29403789566.34553899906876,
+        170266573776.5398868392998,
+        492612579337.743088758812,
+        560625185622.3951465078242,
+    ];
+
+    private const LG_Q1 = [
+        67.48212550303777196073036,
+        1113.332393857199323513008,
+        7738.757056935398733233834,
+        27639.87074403340708898585,
+        54993.10206226157329794414,
+        61611.22180066002127833352,
+        36351.27591501940507276287,
+        8785.536302431013170870835,
+    ];
+
+    private const LG_Q2 = [
+        183.0328399370592604055942,
+        7765.049321445005871323047,
+        133190.3827966074194402448,
+        1136705.821321969608938755,
+        5267964.117437946917577538,
+        13467014.54311101692290052,
+        17827365.30353274213975932,
+        9533095.591844353613395747,
+    ];
+
+    private const LG_Q4 = [
+        2690.530175870899333379843,
+        639388.5654300092398984238,
+        41355999.30241388052042842,
+        1120872109.61614794137657,
+        14886137286.78813811542398,
+        101680358627.2438228077304,
+        341747634550.7377132798597,
+        446315818741.9713286462081,
+    ];
+
+    private const LG_C = [
+        -0.001910444077728,
+        8.4171387781295e-4,
+        -5.952379913043012e-4,
+        7.93650793500350248e-4,
+        -0.002777777777777681622553,
+        0.08333333333333333331554247,
+        0.0057083835261,
+    ];
+
+    // Rough estimate of the fourth root of logGamma_xBig
+    private const LG_FRTBIG = 2.25e76;
+
+    private const PNT68 = 0.6796875;
+
+    // Function cache for logGamma
+    private static $logGammaCacheResult = 0.0;
+
+    private static $logGammaCacheX = 0.0;
+
+    public static function logGamma(float $x): float
+    {
+        if ($x == self::$logGammaCacheX) {
+            return self::$logGammaCacheResult;
+        }
+
+        $y = $x;
+        if ($y > 0.0 && $y <= self::LOG_GAMMA_X_MAX_VALUE) {
+            if ($y <= self::EPS) {
+                $res = -log($y);
+            } elseif ($y <= 1.5) {
+                $res = self::logGamma1($y);
+            } elseif ($y <= 4.0) {
+                $res = self::logGamma2($y);
+            } elseif ($y <= 12.0) {
+                $res = self::logGamma3($y);
+            } else {
+                $res = self::logGamma4($y);
+            }
+        } else {
+            // --------------------------
+            //    Return for bad arguments
+            // --------------------------
+            $res = self::MAX_VALUE;
+        }
+
+        // ------------------------------
+        //    Final adjustments and return
+        // ------------------------------
+        self::$logGammaCacheX = $x;
+        self::$logGammaCacheResult = $res;
+
+        return $res;
+    }
+
+    private static function logGamma1(float $y)
+    {
+        // ---------------------
+        //    EPS .LT. X .LE. 1.5
+        // ---------------------
+        if ($y < self::PNT68) {
+            $corr = -log($y);
+            $xm1 = $y;
+        } else {
+            $corr = 0.0;
+            $xm1 = $y - 1.0;
+        }
+
+        $xden = 1.0;
+        $xnum = 0.0;
+        if ($y <= 0.5 || $y >= self::PNT68) {
+            for ($i = 0; $i < 8; ++$i) {
+                $xnum = $xnum * $xm1 + self::LG_P1[$i];
+                $xden = $xden * $xm1 + self::LG_Q1[$i];
+            }
+
+            return $corr + $xm1 * (self::LG_D1 + $xm1 * ($xnum / $xden));
+        }
+
+        $xm2 = $y - 1.0;
+        for ($i = 0; $i < 8; ++$i) {
+            $xnum = $xnum * $xm2 + self::LG_P2[$i];
+            $xden = $xden * $xm2 + self::LG_Q2[$i];
+        }
+
+        return $corr + $xm2 * (self::LG_D2 + $xm2 * ($xnum / $xden));
+    }
+
+    private static function logGamma2(float $y)
+    {
+        // ---------------------
+        //    1.5 .LT. X .LE. 4.0
+        // ---------------------
+        $xm2 = $y - 2.0;
+        $xden = 1.0;
+        $xnum = 0.0;
+        for ($i = 0; $i < 8; ++$i) {
+            $xnum = $xnum * $xm2 + self::LG_P2[$i];
+            $xden = $xden * $xm2 + self::LG_Q2[$i];
+        }
+
+        return $xm2 * (self::LG_D2 + $xm2 * ($xnum / $xden));
+    }
+
+    protected static function logGamma3(float $y)
+    {
+        // ----------------------
+        //    4.0 .LT. X .LE. 12.0
+        // ----------------------
+        $xm4 = $y - 4.0;
+        $xden = -1.0;
+        $xnum = 0.0;
+        for ($i = 0; $i < 8; ++$i) {
+            $xnum = $xnum * $xm4 + self::LG_P4[$i];
+            $xden = $xden * $xm4 + self::LG_Q4[$i];
+        }
+
+        return self::LG_D4 + $xm4 * ($xnum / $xden);
+    }
+
+    protected static function logGamma4(float $y)
+    {
+        // ---------------------------------
+        //    Evaluate for argument .GE. 12.0
+        // ---------------------------------
+        $res = 0.0;
+        if ($y <= self::LG_FRTBIG) {
+            $res = self::LG_C[6];
+            $ysq = $y * $y;
+            for ($i = 0; $i < 6; ++$i) {
+                $res = $res / $ysq + self::LG_C[$i];
+            }
+            $res /= $y;
+            $corr = log($y);
+            $res = $res + log(self::SQRT2PI) - 0.5 * $corr;
+            $res += $y * ($corr - 1.0);
+        }
+
+        return $res;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/HyperGeometric.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\MathTrig\Combinations;
+
+class HyperGeometric
+{
+    use ArrayEnabled;
+
+    /**
+     * HYPGEOMDIST.
+     *
+     * Returns the hypergeometric distribution. HYPGEOMDIST returns the probability of a given number of
+     * sample successes, given the sample size, population successes, and population size.
+     *
+     * @param mixed $sampleSuccesses Integer number of successes in the sample
+     *                      Or can be an array of values
+     * @param mixed $sampleNumber Integer size of the sample
+     *                      Or can be an array of values
+     * @param mixed $populationSuccesses Integer number of successes in the population
+     *                      Or can be an array of values
+     * @param mixed $populationNumber Integer population size
+     *                      Or can be an array of values
+     *
+     * @return array|float|string
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($sampleSuccesses, $sampleNumber, $populationSuccesses, $populationNumber)
+    {
+        if (
+            is_array($sampleSuccesses) || is_array($sampleNumber) ||
+            is_array($populationSuccesses) || is_array($populationNumber)
+        ) {
+            return self::evaluateArrayArguments(
+                [self::class, __FUNCTION__],
+                $sampleSuccesses,
+                $sampleNumber,
+                $populationSuccesses,
+                $populationNumber
+            );
+        }
+
+        try {
+            $sampleSuccesses = DistributionValidations::validateInt($sampleSuccesses);
+            $sampleNumber = DistributionValidations::validateInt($sampleNumber);
+            $populationSuccesses = DistributionValidations::validateInt($populationSuccesses);
+            $populationNumber = DistributionValidations::validateInt($populationNumber);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($sampleSuccesses < 0) || ($sampleSuccesses > $sampleNumber) || ($sampleSuccesses > $populationSuccesses)) {
+            return Functions::NAN();
+        }
+        if (($sampleNumber <= 0) || ($sampleNumber > $populationNumber)) {
+            return Functions::NAN();
+        }
+        if (($populationSuccesses <= 0) || ($populationSuccesses > $populationNumber)) {
+            return Functions::NAN();
+        }
+
+        $successesPopulationAndSample = (float) Combinations::withoutRepetition($populationSuccesses, $sampleSuccesses);
+        $numbersPopulationAndSample = (float) Combinations::withoutRepetition($populationNumber, $sampleNumber);
+        $adjustedPopulationAndSample = (float) Combinations::withoutRepetition(
+            $populationNumber - $populationSuccesses,
+            $sampleNumber - $sampleSuccesses
+        );
+
+        return $successesPopulationAndSample * $adjustedPopulationAndSample / $numbersPopulationAndSample;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/LogNormal.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class LogNormal
+{
+    use ArrayEnabled;
+
+    /**
+     * LOGNORMDIST.
+     *
+     * Returns the cumulative lognormal distribution of x, where ln(x) is normally distributed
+     * with parameters mean and standard_dev.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     * @param mixed $mean Mean value as a float
+     *                      Or can be an array of values
+     * @param mixed $stdDev Standard Deviation as a float
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function cumulative($value, $mean, $stdDev)
+    {
+        if (is_array($value) || is_array($mean) || is_array($stdDev)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $mean, $stdDev);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $mean = DistributionValidations::validateFloat($mean);
+            $stdDev = DistributionValidations::validateFloat($stdDev);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($value <= 0) || ($stdDev <= 0)) {
+            return Functions::NAN();
+        }
+
+        return StandardNormal::cumulative((log($value) - $mean) / $stdDev);
+    }
+
+    /**
+     * LOGNORM.DIST.
+     *
+     * Returns the lognormal distribution of x, where ln(x) is normally distributed
+     * with parameters mean and standard_dev.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     * @param mixed $mean Mean value as a float
+     *                      Or can be an array of values
+     * @param mixed $stdDev Standard Deviation as a float
+     *                      Or can be an array of values
+     * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value, $mean, $stdDev, $cumulative = false)
+    {
+        if (is_array($value) || is_array($mean) || is_array($stdDev) || is_array($cumulative)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $mean, $stdDev, $cumulative);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $mean = DistributionValidations::validateFloat($mean);
+            $stdDev = DistributionValidations::validateFloat($stdDev);
+            $cumulative = DistributionValidations::validateBool($cumulative);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($value <= 0) || ($stdDev <= 0)) {
+            return Functions::NAN();
+        }
+
+        if ($cumulative === true) {
+            return StandardNormal::distribution((log($value) - $mean) / $stdDev, true);
+        }
+
+        return (1 / (sqrt(2 * M_PI) * $stdDev * $value)) *
+            exp(0 - ((log($value) - $mean) ** 2 / (2 * $stdDev ** 2)));
+    }
+
+    /**
+     * LOGINV.
+     *
+     * Returns the inverse of the lognormal cumulative distribution
+     *
+     * @param mixed $probability Float probability for which we want the value
+     *                      Or can be an array of values
+     * @param mixed $mean Mean Value as a float
+     *                      Or can be an array of values
+     * @param mixed $stdDev Standard Deviation as a float
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     *
+     * @TODO    Try implementing P J Acklam's refinement algorithm for greater
+     *            accuracy if I can get my head round the mathematics
+     *            (as described at) http://home.online.no/~pjacklam/notes/invnorm/
+     */
+    public static function inverse($probability, $mean, $stdDev)
+    {
+        if (is_array($probability) || is_array($mean) || is_array($stdDev)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $probability, $mean, $stdDev);
+        }
+
+        try {
+            $probability = DistributionValidations::validateProbability($probability);
+            $mean = DistributionValidations::validateFloat($mean);
+            $stdDev = DistributionValidations::validateFloat($stdDev);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($stdDev <= 0) {
+            return Functions::NAN();
+        }
+
+        return exp($mean + $stdDev * StandardNormal::inverse($probability));
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/NewtonRaphson.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class NewtonRaphson
+{
+    private const MAX_ITERATIONS = 256;
+
+    protected $callback;
+
+    public function __construct(callable $callback)
+    {
+        $this->callback = $callback;
+    }
+
+    public function execute(float $probability)
+    {
+        $xLo = 100;
+        $xHi = 0;
+
+        $dx = 1;
+        $x = $xNew = 1;
+        $i = 0;
+
+        while ((abs($dx) > Functions::PRECISION) && ($i++ < self::MAX_ITERATIONS)) {
+            // Apply Newton-Raphson step
+            $result = call_user_func($this->callback, $x);
+            $error = $result - $probability;
+
+            if ($error == 0.0) {
+                $dx = 0;
+            } elseif ($error < 0.0) {
+                $xLo = $x;
+            } else {
+                $xHi = $x;
+            }
+
+            // Avoid division by zero
+            if ($result != 0.0) {
+                $dx = $error / $result;
+                $xNew = $x - $dx;
+            }
+
+            // If the NR fails to converge (which for example may be the
+            // case if the initial guess is too rough) we apply a bisection
+            // step to determine a more narrow interval around the root.
+            if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
+                $xNew = ($xLo + $xHi) / 2;
+                $dx = $xNew - $x;
+            }
+            $x = $xNew;
+        }
+
+        if ($i == self::MAX_ITERATIONS) {
+            return Functions::NA();
+        }
+
+        return $x;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Distributions/Normal.php

@@ -0,0 +1,180 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Normal
+{
+    use ArrayEnabled;
+
+    public const SQRT2PI = 2.5066282746310005024157652848110452530069867406099;
+
+    /**
+     * NORMDIST.
+     *
+     * Returns the normal distribution for the specified mean and standard deviation. This
+     * function has a very wide range of applications in statistics, including hypothesis
+     * testing.
+     *
+     * @param mixed $value Float value for which we want the probability
+     *                      Or can be an array of values
+     * @param mixed $mean Mean value as a float
+     *                      Or can be an array of values
+     * @param mixed $stdDev Standard Deviation as a float
+     *                      Or can be an array of values
+     * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function distribution($value, $mean, $stdDev, $cumulative)
+    {
+        if (is_array($value) || is_array($mean) || is_array($stdDev) || is_array($cumulative)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $mean, $stdDev, $cumulative);
+        }
+
+        try {
+            $value = DistributionValidations::validateFloat($value);
+            $mean = DistributionValidations::validateFloat($mean);
+            $stdDev = DistributionValidations::validateFloat($stdDev);
+            $cumulative = DistributionValidations::validateBool($cumulative);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($stdDev < 0) {
+            return Functions::NAN();
+        }
+
+        if ($cumulative) {
+            return 0.5 * (1 + Engineering\Erf::erfValue(($value - $mean) / ($stdDev * sqrt(2))));
+        }
+
+        return (1 / (self::SQRT2PI * $stdDev)) * exp(0 - (($value - $mean) ** 2 / (2 * ($stdDev * $stdDev))));
+    }
+
+    /**
+     * NORMINV.
+     *
+     * Returns the inverse of the normal cumulative distribution for the specified mean and standard deviation.
+     *
+     * @param mixed $probability Float probability for which we want the value
+     *                      Or can be an array of values
+     * @param mixed $mean Mean Value as a float
+     *                      Or can be an array of values
+     * @param mixed $stdDev Standard Deviation as a float
+     *                      Or can be an array of values
+     *
+     * @return array|float|string The result, or a string containing an error
+     *         If an array of numbers is passed as an argument, then the returned result will also be an array
+     *            with the same dimensions
+     */
+    public static function inverse($probability, $mean, $stdDev)
+    {
+        if (is_array($probability) || is_array($mean) || is_array($stdDev)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $probability, $mean, $stdDev);
+        }
+
+        try {
+            $probability = DistributionValidations::validateProbability($probability);
+            $mean = DistributionValidations::validateFloat($mean);
+            $stdDev = DistributionValidations::validateFloat($stdDev);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if ($stdDev < 0) {
+            return Functions::NAN();
+        }
+
+        return (self::inverseNcdf($probability) * $stdDev) + $mean;
+    }
+
+    /*
+     *                                inverse_ncdf.php
+     *                            -------------------
+     *    begin                : Friday, January 16, 2004
+     *    copyright            : (C) 2004 Michael Nickerson
+     *    email                : nickersonm@yahoo.com
+     *
+     */
+    private static function inverseNcdf($p)
+    {
+        //    Inverse ncdf approximation by Peter J. Acklam, implementation adapted to
+        //    PHP by Michael Nickerson, using Dr. Thomas Ziegler's C implementation as
+        //    a guide. http://home.online.no/~pjacklam/notes/invnorm/index.html
+        //    I have not checked the accuracy of this implementation. Be aware that PHP
+        //    will truncate the coeficcients to 14 digits.
+
+        //    You have permission to use and distribute this function freely for
+        //    whatever purpose you want, but please show common courtesy and give credit
+        //    where credit is due.
+
+        //    Input paramater is $p - probability - where 0 < p < 1.
+
+        //    Coefficients in rational approximations
+        static $a = [
+            1 => -3.969683028665376e+01,
+            2 => 2.209460984245205e+02,
+            3 => -2.759285104469687e+02,
+            4 => 1.383577518672690e+02,
+            5 => -3.066479806614716e+01,
+            6 => 2.506628277459239e+00,
+        ];
+
+        static $b = [
+            1 => -5.447609879822406e+01,
+            2 => 1.615858368580409e+02,
+            3 => -1.556989798598866e+02,
+            4 => 6.680131188771972e+01,
+            5 => -1.328068155288572e+01,
+        ];
+
+        static $c = [
+            1 => -7.784894002430293e-03,
+            2 => -3.223964580411365e-01,
+            3 => -2.400758277161838e+00,
+            4 => -2.549732539343734e+00,
+            5 => 4.374664141464968e+00,
+            6 => 2.938163982698783e+00,
+        ];
+
+        static $d = [
+            1 => 7.784695709041462e-03,
+            2 => 3.224671290700398e-01,
+            3 => 2.445134137142996e+00,
+            4 => 3.754408661907416e+00,
+        ];
+
+        //    Define lower and upper region break-points.
+        $p_low = 0.02425; //Use lower region approx. below this
+        $p_high = 1 - $p_low; //Use upper region approx. above this
+
+        if (0 < $p && $p < $p_low) {
+            //    Rational approximation for lower region.
+            $q = sqrt(-2 * log($p));
+
+            return ((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
+                (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
+        } elseif ($p_high < $p && $p < 1) {
+            //    Rational approximation for upper region.
+            $q = sqrt(-2 * log(1 - $p));
+
+            return -((((($c[1] * $q + $c[2]) * $q + $c[3]) * $q + $c[4]) * $q + $c[5]) * $q + $c[6]) /
+                (((($d[1] * $q + $d[2]) * $q + $d[3]) * $q + $d[4]) * $q + 1);
+        }
+
+        //    Rational approximation for central region.
+        $q = $p - 0.5;
+        $r = $q * $q;
+
+        return ((((($a[1] * $r + $a[2]) * $r + $a[3]) * $r + $a[4]) * $r + $a[5]) * $r + $a[6]) * $q /
+                ((((($b[1] * $r + $b[2]) * $r + $b[3]) * $r + $b[4]) * $r + $b[5]) * $r + 1);
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/MaxMinBase.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
+
+abstract class MaxMinBase
+{
+    protected static function datatypeAdjustmentAllowStrings($value)
+    {
+        if (is_bool($value)) {
+            return (int) $value;
+        } elseif (is_string($value)) {
+            return 0;
+        }
+
+        return $value;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Maximum.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Maximum extends MaxMinBase
+{
+    /**
+     * MAX.
+     *
+     * MAX returns the value of the element of the values passed that has the highest value,
+     *        with negative numbers considered smaller than positive numbers.
+     *
+     * Excel Function:
+     *        MAX(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float
+     */
+    public static function max(...$args)
+    {
+        $returnValue = null;
+
+        // Loop through arguments
+        $aArgs = Functions::flattenArray($args);
+        foreach ($aArgs as $arg) {
+            // Is it a numeric value?
+            if ((is_numeric($arg)) && (!is_string($arg))) {
+                if (($returnValue === null) || ($arg > $returnValue)) {
+                    $returnValue = $arg;
+                }
+            }
+        }
+
+        if ($returnValue === null) {
+            return 0;
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * MAXA.
+     *
+     * Returns the greatest value in a list of arguments, including numbers, text, and logical values
+     *
+     * Excel Function:
+     *        MAXA(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float
+     */
+    public static function maxA(...$args)
+    {
+        $returnValue = null;
+
+        // Loop through arguments
+        $aArgs = Functions::flattenArray($args);
+        foreach ($aArgs as $arg) {
+            // Is it a numeric value?
+            if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
+                $arg = self::datatypeAdjustmentAllowStrings($arg);
+                if (($returnValue === null) || ($arg > $returnValue)) {
+                    $returnValue = $arg;
+                }
+            }
+        }
+
+        if ($returnValue === null) {
+            return 0;
+        }
+
+        return $returnValue;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Minimum.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Minimum extends MaxMinBase
+{
+    /**
+     * MIN.
+     *
+     * MIN returns the value of the element of the values passed that has the smallest value,
+     *        with negative numbers considered smaller than positive numbers.
+     *
+     * Excel Function:
+     *        MIN(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float
+     */
+    public static function min(...$args)
+    {
+        $returnValue = null;
+
+        // Loop through arguments
+        $aArgs = Functions::flattenArray($args);
+        foreach ($aArgs as $arg) {
+            // Is it a numeric value?
+            if ((is_numeric($arg)) && (!is_string($arg))) {
+                if (($returnValue === null) || ($arg < $returnValue)) {
+                    $returnValue = $arg;
+                }
+            }
+        }
+
+        if ($returnValue === null) {
+            return 0;
+        }
+
+        return $returnValue;
+    }
+
+    /**
+     * MINA.
+     *
+     * Returns the smallest value in a list of arguments, including numbers, text, and logical values
+     *
+     * Excel Function:
+     *        MINA(value1[,value2[, ...]])
+     *
+     * @param mixed ...$args Data values
+     *
+     * @return float
+     */
+    public static function minA(...$args)
+    {
+        $returnValue = null;
+
+        // Loop through arguments
+        $aArgs = Functions::flattenArray($args);
+        foreach ($aArgs as $arg) {
+            // Is it a numeric value?
+            if ((is_numeric($arg)) || (is_bool($arg)) || ((is_string($arg) && ($arg != '')))) {
+                $arg = self::datatypeAdjustmentAllowStrings($arg);
+                if (($returnValue === null) || ($arg < $returnValue)) {
+                    $returnValue = $arg;
+                }
+            }
+        }
+
+        if ($returnValue === null) {
+            return 0;
+        }
+
+        return $returnValue;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/Statistical/Percentiles.php

@@ -0,0 +1,205 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Percentiles
+{
+    public const RANK_SORT_DESCENDING = 0;
+
+    public const RANK_SORT_ASCENDING = 1;
+
+    /**
+     * PERCENTILE.
+     *
+     * Returns the nth percentile of values in a range..
+     *
+     * Excel Function:
+     *        PERCENTILE(value1[,value2[, ...]],entry)
+     *
+     * @param mixed $args Data values
+     *
+     * @return float|string The result, or a string containing an error
+     */
+    public static function PERCENTILE(...$args)
+    {
+        $aArgs = Functions::flattenArray($args);
+
+        // Calculate
+        $entry = array_pop($aArgs);
+
+        try {
+            $entry = StatisticalValidations::validateFloat($entry);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        if (($entry < 0) || ($entry > 1)) {
+            return Functions::NAN();
+        }
+
+        $mArgs = self::percentileFilterValues($aArgs);
+        $mValueCount = count($mArgs);
+        if ($mValueCount > 0) {
+            sort($mArgs);
+            $count = Counts::COUNT($mArgs);
+            $index = $entry * ($count - 1);
+            $iBase = floor($index);
+            if ($index == $iBase) {
+                return $mArgs[$index];
+            }
+            $iNext = $iBase + 1;
+            $iProportion = $index - $iBase;
+
+            return $mArgs[$iBase] + (($mArgs[$iNext] - $mArgs[$iBase]) * $iProportion);
+        }
+
+        return Functions::NAN();
+    }
+
+    /**
+     * PERCENTRANK.
+     *
+     * Returns the rank of a value in a data set as a percentage of the data set.
+     * Note that the returned rank is simply rounded to the appropriate significant digits,
+     *      rather than floored (as MS Excel), so value 3 for a value set of  1, 2, 3, 4 will return
+     *      0.667 rather than 0.666
+     *
+     * @param mixed $valueSet An array of (float) values, or a reference to, a list of numbers
+     * @param mixed $value The number whose rank you want to find
+     * @param mixed $significance The (integer) number of significant digits for the returned percentage value
+     *
+     * @return float|string (string if result is an error)
+     */
+    public static function PERCENTRANK($valueSet, $value, $significance = 3)
+    {
+        $valueSet = Functions::flattenArray($valueSet);
+        $value = Functions::flattenSingleValue($value);
+        $significance = ($significance === null) ? 3 : Functions::flattenSingleValue($significance);
+
+        try {
+            $value = StatisticalValidations::validateFloat($value);
+            $significance = StatisticalValidations::validateInt($significance);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $valueSet = self::rankFilterValues($valueSet);
+        $valueCount = count($valueSet);
+        if ($valueCount == 0) {
+            return Functions::NA();
+        }
+        sort($valueSet, SORT_NUMERIC);
+
+        $valueAdjustor = $valueCount - 1;
+        if (($value < $valueSet[0]) || ($value > $valueSet[$valueAdjustor])) {
+            return Functions::NA();
+        }
+
+        $pos = array_search($value, $valueSet);
+        if ($pos === false) {
+            $pos = 0;
+            $testValue = $valueSet[0];
+            while ($testValue < $value) {
+                $testValue = $valueSet[++$pos];
+            }
+            --$pos;
+            $pos += (($value - $valueSet[$pos]) / ($testValue - $valueSet[$pos]));
+        }
+
+        return round($pos / $valueAdjustor, $significance);
+    }
+
+    /**
+     * QUARTILE.
+     *
+     * Returns the quartile of a data set.
+     *
+     * Excel Function:
+     *        QUARTILE(value1[,value2[, ...]],entry)
+     *
+     * @param mixed $args Data values
+     *
+     * @return float|string The result, or a string containing an error
+     */
+    public static function QUARTILE(...$args)
+    {
+        $aArgs = Functions::flattenArray($args);
+        $entry = array_pop($aArgs);
+
+        try {
+            $entry = StatisticalValidations::validateFloat($entry);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $entry = floor($entry);
+        $entry /= 4;
+        if (($entry < 0) || ($entry > 1)) {
+            return Functions::NAN();
+        }
+
+        return self::PERCENTILE($aArgs, $entry);
+    }
+
+    /**
+     * RANK.
+     *
+     * Returns the rank of a number in a list of numbers.
+     *
+     * @param mixed $value The number whose rank you want to find
+     * @param mixed $valueSet An array of float values, or a reference to, a list of numbers
+     * @param mixed $order Order to sort the values in the value set
+     *
+     * @return float|string The result, or a string containing an error (0 = Descending, 1 = Ascending)
+     */
+    public static function RANK($value, $valueSet, $order = self::RANK_SORT_DESCENDING)
+    {
+        $value = Functions::flattenSingleValue($value);
+        $valueSet = Functions::flattenArray($valueSet);
+        $order = ($order === null) ? self::RANK_SORT_DESCENDING : Functions::flattenSingleValue($order);
+
+        try {
+            $value = StatisticalValidations::validateFloat($value);
+            $order = StatisticalValidations::validateInt($order);
+        } catch (Exception $e) {
+            return $e->getMessage();
+        }
+
+        $valueSet = self::rankFilterValues($valueSet);
+        if ($order === self::RANK_SORT_DESCENDING) {
+            rsort($valueSet, SORT_NUMERIC);
+        } else {
+            sort($valueSet, SORT_NUMERIC);
+        }
+
+        $pos = array_search($value, $valueSet);
+        if ($pos === false) {
+            return Functions::NA();
+        }
+
+        return ++$pos;
+    }
+
+    protected static function percentileFilterValues(array $dataSet)
+    {
+        return array_filter(
+            $dataSet,
+            function ($value): bool {
+                return is_numeric($value) && !is_string($value);
+            }
+        );
+    }
+
+    protected static function rankFilterValues(array $dataSet)
+    {
+        return array_filter(
+            $dataSet,
+            function ($value): bool {
+                return is_numeric($value);
+            }
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/TextData/Extract.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\TextData;
+
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
+
+class Extract
+{
+    use ArrayEnabled;
+
+    /**
+     * LEFT.
+     *
+     * @param mixed $value String value from which to extract characters
+     *                         Or can be an array of values
+     * @param mixed $chars The number of characters to extract (as an integer)
+     *                         Or can be an array of values
+     *
+     * @return array|string The joined string
+     *         If an array of values is passed for the $value or $chars arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function left($value, $chars = 1)
+    {
+        if (is_array($value) || is_array($chars)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $chars);
+        }
+
+        try {
+            $value = Helpers::extractString($value);
+            $chars = Helpers::extractInt($chars, 0, 1);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        return mb_substr($value ?? '', 0, $chars, 'UTF-8');
+    }
+
+    /**
+     * MID.
+     *
+     * @param mixed $value String value from which to extract characters
+     *                         Or can be an array of values
+     * @param mixed $start Integer offset of the first character that we want to extract
+     *                         Or can be an array of values
+     * @param mixed $chars The number of characters to extract (as an integer)
+     *                         Or can be an array of values
+     *
+     * @return array|string The joined string
+     *         If an array of values is passed for the $value, $start or $chars arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function mid($value, $start, $chars)
+    {
+        if (is_array($value) || is_array($start) || is_array($chars)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $start, $chars);
+        }
+
+        try {
+            $value = Helpers::extractString($value);
+            $start = Helpers::extractInt($start, 1);
+            $chars = Helpers::extractInt($chars, 0);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        return mb_substr($value ?? '', --$start, $chars, 'UTF-8');
+    }
+
+    /**
+     * RIGHT.
+     *
+     * @param mixed $value String value from which to extract characters
+     *                         Or can be an array of values
+     * @param mixed $chars The number of characters to extract (as an integer)
+     *                         Or can be an array of values
+     *
+     * @return array|string The joined string
+     *         If an array of values is passed for the $value or $chars arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function right($value, $chars = 1)
+    {
+        if (is_array($value) || is_array($chars)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $chars);
+        }
+
+        try {
+            $value = Helpers::extractString($value);
+            $chars = Helpers::extractInt($chars, 0, 1);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        return mb_substr($value ?? '', mb_strlen($value ?? '', 'UTF-8') - $chars, $chars, 'UTF-8');
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/TextData/Format.php

@@ -0,0 +1,279 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\TextData;
+
+use DateTimeInterface;
+use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
+use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+
+class Format
+{
+    use ArrayEnabled;
+
+    /**
+     * DOLLAR.
+     *
+     * This function converts a number to text using currency format, with the decimals rounded to the specified place.
+     * The format used is $#,##0.00_);($#,##0.00)..
+     *
+     * @param mixed $value The value to format
+     *                         Or can be an array of values
+     * @param mixed $decimals The number of digits to display to the right of the decimal point (as an integer).
+     *                            If decimals is negative, number is rounded to the left of the decimal point.
+     *                            If you omit decimals, it is assumed to be 2
+     *                         Or can be an array of values
+     *
+     * @return array|string
+     *         If an array of values is passed for either of the arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function DOLLAR($value = 0, $decimals = 2)
+    {
+        if (is_array($value) || is_array($decimals)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $decimals);
+        }
+
+        try {
+            $value = Helpers::extractFloat($value);
+            $decimals = Helpers::extractInt($decimals, -100, 0, true);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        $mask = '$#,##0';
+        if ($decimals > 0) {
+            $mask .= '.' . str_repeat('0', $decimals);
+        } else {
+            $round = 10 ** abs($decimals);
+            if ($value < 0) {
+                $round = 0 - $round;
+            }
+            $value = MathTrig\Round::multiple($value, $round);
+        }
+        $mask = "{$mask};-{$mask}";
+
+        return NumberFormat::toFormattedString($value, $mask);
+    }
+
+    /**
+     * FIXED.
+     *
+     * @param mixed $value The value to format
+     *                         Or can be an array of values
+     * @param mixed $decimals Integer value for the number of decimal places that should be formatted
+     *                         Or can be an array of values
+     * @param mixed $noCommas Boolean value indicating whether the value should have thousands separators or not
+     *                         Or can be an array of values
+     *
+     * @return array|string
+     *         If an array of values is passed for either of the arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function FIXEDFORMAT($value, $decimals = 2, $noCommas = false)
+    {
+        if (is_array($value) || is_array($decimals) || is_array($noCommas)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $decimals, $noCommas);
+        }
+
+        try {
+            $value = Helpers::extractFloat($value);
+            $decimals = Helpers::extractInt($decimals, -100, 0, true);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        $valueResult = round($value, $decimals);
+        if ($decimals < 0) {
+            $decimals = 0;
+        }
+        if ($noCommas === false) {
+            $valueResult = number_format(
+                $valueResult,
+                $decimals,
+                StringHelper::getDecimalSeparator(),
+                StringHelper::getThousandsSeparator()
+            );
+        }
+
+        return (string) $valueResult;
+    }
+
+    /**
+     * TEXT.
+     *
+     * @param mixed $value The value to format
+     *                         Or can be an array of values
+     * @param mixed $format A string with the Format mask that should be used
+     *                         Or can be an array of values
+     *
+     * @return array|string
+     *         If an array of values is passed for either of the arguments, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function TEXTFORMAT($value, $format)
+    {
+        if (is_array($value) || is_array($format)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $format);
+        }
+
+        $value = Helpers::extractString($value);
+        $format = Helpers::extractString($format);
+
+        if (!is_numeric($value) && Date::isDateTimeFormatCode($format)) {
+            $value = DateTimeExcel\DateValue::fromString($value);
+        }
+
+        return (string) NumberFormat::toFormattedString($value, $format);
+    }
+
+    /**
+     * @param mixed $value Value to check
+     *
+     * @return mixed
+     */
+    private static function convertValue($value)
+    {
+        $value = $value ?? 0;
+        if (is_bool($value)) {
+            if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
+                $value = (int) $value;
+            } else {
+                throw new CalcExp(Functions::VALUE());
+            }
+        }
+
+        return $value;
+    }
+
+    /**
+     * VALUE.
+     *
+     * @param mixed $value Value to check
+     *                         Or can be an array of values
+     *
+     * @return array|DateTimeInterface|float|int|string A string if arguments are invalid
+     *         If an array of values is passed for the argument, then the returned result
+     *            will also be an array with matching dimensions
+     */
+    public static function VALUE($value = '')
+    {
+        if (is_array($value)) {
+            return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $value);
+        }
+
+        try {
+            $value = self::convertValue($value);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+        if (!is_numeric($value)) {
+            $numberValue = str_replace(
+                StringHelper::getThousandsSeparator(),
+                '',
+                trim($value, " \t\n\r\0\x0B" . StringHelper::getCurrencyCode())
+            );
+            if (is_numeric($numberValue)) {
+                return (float) $numberValue;
+            }
+
+            $dateSetting = Functions::getReturnDateType();
+            Functions::setReturnDateType(Functions::RETURNDATE_EXCEL);
+
+            if (strpos($value, ':') !== false) {
+                $timeValue = Functions::scalar(DateTimeExcel\TimeValue::fromString($value));
+                if ($timeValue !== Functions::VALUE()) {
+                    Functions::setReturnDateType($dateSetting);
+
+                    return $timeValue;
+                }
+            }
+            $dateValue = Functions::scalar(DateTimeExcel\DateValue::fromString($value));
+            if ($dateValue !== Functions::VALUE()) {
+                Functions::setReturnDateType($dateSetting);
+
+                return $dateValue;
+            }
+            Functions::setReturnDateType($dateSetting);
+
+            return Functions::VALUE();
+        }
+
+        return (float) $value;
+    }
+
+    /**
+     * @param mixed $decimalSeparator
+     */
+    private static function getDecimalSeparator($decimalSeparator): string
+    {
+        return empty($decimalSeparator) ? StringHelper::getDecimalSeparator() : (string) $decimalSeparator;
+    }
+
+    /**
+     * @param mixed $groupSeparator
+     */
+    private static function getGroupSeparator($groupSeparator): string
+    {
+        return empty($groupSeparator) ? StringHelper::getThousandsSeparator() : (string) $groupSeparator;
+    }
+
+    /**
+     * NUMBERVALUE.
+     *
+     * @param mixed $value The value to format
+     *                         Or can be an array of values
+     * @param mixed $decimalSeparator A string with the decimal separator to use, defaults to locale defined value
+     *                         Or can be an array of values
+     * @param mixed $groupSeparator A string with the group/thousands separator to use, defaults to locale defined value
+     *                         Or can be an array of values
+     *
+     * @return array|float|string
+     */
+    public static function NUMBERVALUE($value = '', $decimalSeparator = null, $groupSeparator = null)
+    {
+        if (is_array($value) || is_array($decimalSeparator) || is_array($groupSeparator)) {
+            return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $decimalSeparator, $groupSeparator);
+        }
+
+        try {
+            $value = self::convertValue($value);
+            $decimalSeparator = self::getDecimalSeparator($decimalSeparator);
+            $groupSeparator = self::getGroupSeparator($groupSeparator);
+        } catch (CalcExp $e) {
+            return $e->getMessage();
+        }
+
+        if (!is_numeric($value)) {
+            $decimalPositions = preg_match_all('/' . preg_quote($decimalSeparator) . '/', $value, $matches, PREG_OFFSET_CAPTURE);
+            if ($decimalPositions > 1) {
+                return Functions::VALUE();
+            }
+            $decimalOffset = array_pop($matches[0])[1];
+            if (strpos($value, $groupSeparator, $decimalOffset) !== false) {
+                return Functions::VALUE();
+            }
+
+            $value = str_replace([$groupSeparator, $decimalSeparator], ['', '.'], $value);
+
+            // Handle the special case of trailing % signs
+            $percentageString = rtrim($value, '%');
+            if (!is_numeric($percentageString)) {
+                return Functions::VALUE();
+            }
+
+            $percentageAdjustment = strlen($value) - strlen($percentageString);
+            if ($percentageAdjustment) {
+                $value = (float) $percentageString;
+                $value /= 10 ** ($percentageAdjustment * 2);
+            }
+        }
+
+        return is_array($value) ? Functions::VALUE() : (float) $value;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/TextData/Helpers.php

@@ -0,0 +1,86 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Calculation\TextData;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+
+class Helpers
+{
+    public static function convertBooleanValue(bool $value): string
+    {
+        if (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_OPENOFFICE) {
+            return $value ? '1' : '0';
+        }
+
+        return ($value) ? Calculation::getTRUE() : Calculation::getFALSE();
+    }
+
+    /**
+     * @param mixed $value String value from which to extract characters
+     */
+    public static function extractString($value): string
+    {
+        if (is_bool($value)) {
+            return self::convertBooleanValue($value);
+        }
+
+        return (string) $value;
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function extractInt($value, int $minValue, int $gnumericNull = 0, bool $ooBoolOk = false): int
+    {
+        if ($value === null) {
+            // usually 0, but sometimes 1 for Gnumeric
+            $value = (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_GNUMERIC) ? $gnumericNull : 0;
+        }
+        if (is_bool($value) && ($ooBoolOk || Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_OPENOFFICE)) {
+            $value = (int) $value;
+        }
+        if (!is_numeric($value)) {
+            throw new CalcExp(Functions::VALUE());
+        }
+        $value = (int) $value;
+        if ($value < $minValue) {
+            throw new CalcExp(Functions::VALUE());
+        }
+
+        return (int) $value;
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function extractFloat($value): float
+    {
+        if ($value === null) {
+            $value = 0.0;
+        }
+        if (is_bool($value)) {
+            $value = (float) $value;
+        }
+        if (!is_numeric($value)) {
+            throw new CalcExp(Functions::VALUE());
+        }
+
+        return (float) $value;
+    }
+
+    /**
+     * @param mixed $value
+     */
+    public static function validateInt($value): int
+    {
+        if ($value === null) {
+            $value = 0;
+        } elseif (is_bool($value)) {
+            $value = (int) $value;
+        }
+
+        return (int) $value;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/functionlist.txt

@@ -0,0 +1,400 @@
+ABS
+ACCRINT
+ACCRINTM
+ACOS
+ACOSH
+ACOT
+ACOTH
+ADDRESS
+AMORDEGRC
+AMORLINC
+AND
+ARABIC
+AREAS
+ASC
+ASIN
+ASINH
+ATAN
+ATAN2
+ATANH
+AVEDEV
+AVERAGE
+AVERAGEA
+AVERAGEIF
+AVERAGEIFS
+BAHTTEXT
+BASE
+BESSELI
+BESSELJ
+BESSELK
+BESSELY
+BETADIST
+BETAINV
+BIN2DEC
+BIN2HEX
+BIN2OCT
+BINOMDIST
+BITAND
+BITLSHIFT
+BITOR
+BITRSHIFT
+BITXOR
+CEILING
+CEILING.MATH
+CEILING.PRECISE
+CELL
+CHAR
+CHIDIST
+CHIINV
+CHITEST
+CHOOSE
+CLEAN
+CODE
+COLUMN
+COLUMNS
+COMBIN
+COMBINA
+COMPLEX
+CONCAT
+CONCATENATE
+CONFIDENCE
+CONVERT
+CORREL
+COS
+COSH
+COT
+COTH
+COUNT
+COUNTA
+COUNTBLANK
+COUNTIF
+COUNTIFS
+COUPDAYBS
+COUPDAYBS
+COUPDAYSNC
+COUPNCD
+COUPNUM
+COUPPCD
+COVAR
+CRITBINOM
+CSC
+CSCH
+CUBEKPIMEMBER
+CUBEMEMBER
+CUBEMEMBERPROPERTY
+CUBERANKEDMEMBER
+CUBESET
+CUBESETCOUNT
+CUBEVALUE
+CUMIPMT
+CUMPRINC
+DATE
+DATEDIF
+DATEVALUE
+DAVERAGE
+DAY
+DAYS
+DAYS360
+DB
+DCOUNT
+DCOUNTA
+DDB
+DEC2BIN
+DEC2HEX
+DEC2OCT
+DEGREES
+DELTA
+DEVSQ
+DGET
+DISC
+DMAX
+DMIN
+DOLLAR
+DOLLARDE
+DOLLARFR
+DPRODUCT
+DSTDEV
+DSTDEVP
+DSUM
+DURATION
+DVAR
+DVARP
+EDATE
+EFFECT
+EOMONTH
+ERF
+ERF.PRECISE
+ERFC
+ERFC.PRECISE
+ERROR.TYPE
+EVEN
+EXACT
+EXP
+EXPONDIST
+FACT
+FACTDOUBLE
+FALSE
+FDIST
+FIND
+FINDB
+FINV
+FISHER
+FISHERINV
+FIXED
+FLOOR
+FLOOR.MATH
+FLOOR.PRECISE
+FORECAST
+FREQUENCY
+FTEST
+FV
+FVSCHEDULE
+GAMAMDIST
+GAMMAINV
+GAMMALN
+GCD
+GEOMEAN
+GESTEP
+GETPIVOTDATA
+GROWTH
+HARMEAN
+HEX2BIN
+HEX2OCT
+HLOOKUP
+HOUR
+HYPERLINK
+HYPGEOMDIST
+IF
+IFERROR
+IFS
+IMABS
+IMAGINARY
+IMARGUMENT
+IMCONJUGATE
+IMCOS
+IMCOSH
+IMCOT
+IMCSC
+IMCSCH
+IMEXP
+IMLN
+IMLOG10
+IMLOG2
+IMPOWER
+IMPRODUCT
+IMREAL
+IMSEC
+IMSECH
+IMSIN
+IMSINH
+IMSQRT
+IMSUB
+IMSUM
+IMTAN
+INDEX
+INDIRECT
+INFO
+INT
+INTERCEPT
+INTRATE
+IPMT
+IRR
+ISBLANK
+ISERR
+ISERROR
+ISEVEN
+ISLOGICAL
+ISNA
+ISNONTEXT
+ISNUMBER
+ISODD
+ISOWEEKNUM
+ISPMT
+ISREF
+ISTEXT
+JIS
+KURT
+LARGE
+LCM
+LEFT
+LEFTB
+LEN
+LENB
+LINEST
+LN
+LOG
+LOG10
+LOGEST
+LOGINV
+LOGNORMDIST
+LOOKUP
+LOWER
+MATCH
+MAX
+MAXA
+MAXIFS
+MDETERM
+MDURATION
+MEDIAN
+MID
+MIDB
+MIN
+MINA
+MINIFS
+MINUTE
+MINVERSE
+MIRR
+MMULT
+MOD
+MODE
+MONTH
+MROUND
+MULTINOMIAL
+MUNIT
+N
+NA
+NEGBINOMDIST
+NETWORKDAYS
+NOMINAL
+NORMDIST
+NORMINV
+NORMSDIST
+NORMSINV
+NOT
+NOW
+NPER
+NPV
+NUMBERVALUE
+OCT2BIN
+OCT2DEC
+OCT2HEX
+ODD
+ODDFPRICE
+ODDFYIELD
+ODDLPRICE
+ODDLYIELD
+OFFSET
+OR
+PDURATION
+PEARSON
+PERCENTILE
+PERCENTRANK
+PERMUT
+PERMUTATIONA
+PHONETIC
+PI
+PMT
+POISSON
+POWER
+PPMT
+PRICE
+PRICEDISC
+PRICEMAT
+PROB
+PRODUCT
+PROPER
+PV
+QUARTILE
+QUOTIENT
+RADIANS
+RAND
+RANDBETWEEN
+RANK
+RATE
+RECEIVED
+REPLACE
+REPLACEB
+REPT
+RIGHT
+RIGHTB
+ROMAN
+ROUND
+ROUNDDOWN
+ROUNDUP
+ROW
+ROWS
+RRI
+RSQ
+RTD
+SEARCH
+SEARCHB
+SEC
+SECH
+SECOND
+SERIESSUM
+SHEET
+SHEETS
+SIGN
+SIN
+SINH
+SKEW
+SLN
+SLOPE
+SMALL
+SQRT
+SQRTPI
+STANDARDIZE
+STDEV
+STDEV.A
+STDEV.P
+STDEVA
+STDEVP
+STDEVPA
+STEYX
+SUBSTITUTE
+SUBTOTAL
+SUM
+SUMIF
+SUMIFS
+SUMPRODUCT
+SUMSQ
+SUMX2MY2
+SUMX2PY2
+SUMXMY2
+SWITCH
+SYD
+T
+TAN
+TANH
+TBILLEQ
+TBILLPRICE
+TBILLYIELD
+TDIST
+TEXT
+TEXTJOIN
+TIME
+TIMEVALUE
+TINV
+TODAY
+TRANSPOSE
+TREND
+TRIM
+TRIMMEAN
+TRUE
+TRUNC
+TTEST
+TYPE
+UNICHAR
+UNIORD
+UPPER
+USDOLLAR
+VALUE
+VAR
+VARA
+VARP
+VARPA
+VDB
+VLOOKUP
+WEEKDAY
+WEEKNUM
+WEIBULL
+WORKDAY
+XIRR
+XNPV
+XOR
+YEAR
+YEARFRAC
+YIELD
+YIELDDISC
+YIELDMAT
+ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/bg/functions

@@ -0,0 +1,417 @@
+##
+## PhpSpreadsheet
+##
+##
+## Data in this file derived from information provided by web-junior (http://www.web-junior.net/)
+##
+##
+
+
+##
+##	Add-in and Automation functions				Функции надстроек и автоматизации
+##
+GETPIVOTDATA		= ПОЛУЧИТЬ.ДАННЫЕ.СВОДНОЙ.ТАБЛИЦЫ	##	Возвращает данные, хранящиеся в отчете сводной таблицы.
+
+
+##
+##	Cube functions						Функции Куб
+##
+CUBEKPIMEMBER		= КУБЭЛЕМЕНТКИП				##	Возвращает свойство ключевого индикатора производительности «(КИП)» и отображает имя «КИП» в ячейке. «КИП» представляет собой количественную величину, такую как ежемесячная валовая прибыль или ежеквартальная текучесть кадров, используемой для контроля эффективности работы организации.
+CUBEMEMBER		= КУБЭЛЕМЕНТ				##	Возвращает элемент или кортеж из куба. Используется для проверки существования элемента или кортежа в кубе.
+CUBEMEMBERPROPERTY	= КУБСВОЙСТВОЭЛЕМЕНТА			##	Возвращает значение свойства элемента из куба. Используется для проверки существования имени элемента в кубе и возвращает указанное свойство для этого элемента.
+CUBERANKEDMEMBER	= КУБПОРЭЛЕМЕНТ				##	Возвращает n-ый или ранжированный элемент в множество. Используется для возвращения одного или нескольких элементов в множество, например, лучшего продавца или 10 лучших студентов.
+CUBESET			= КУБМНОЖ				##	Определяет вычислительное множество элементов или кортежей, отправляя на сервер выражение, которое создает множество, а затем возвращает его в Microsoft Office Excel.
+CUBESETCOUNT		= КУБЧИСЛОЭЛМНОЖ			##	Возвращает число элементов множества.
+CUBEVALUE		= КУБЗНАЧЕНИЕ				##	Возвращает обобщенное значение из куба.
+
+
+##
+##	Database functions					Функции для работы с базами данных
+##
+DAVERAGE		= ДСРЗНАЧ				##	Возвращает среднее значение выбранных записей базы данных.
+DCOUNT			= БСЧЁТ					##	Подсчитывает количество числовых ячеек в базе данных.
+DCOUNTA			= БСЧЁТА				##	Подсчитывает количество непустых ячеек в базе данных.
+DGET			= БИЗВЛЕЧЬ				##	Извлекает из базы данных одну запись, удовлетворяющую заданному условию.
+DMAX			= ДМАКС					##	Возвращает максимальное значение среди выделенных записей базы данных.
+DMIN			= ДМИН					##	Возвращает минимальное значение среди выделенных записей базы данных.
+DPRODUCT		= БДПРОИЗВЕД				##	Перемножает значения определенного поля в записях базы данных, удовлетворяющих условию.
+DSTDEV			= ДСТАНДОТКЛ				##	Оценивает стандартное отклонение по выборке для выделенных записей базы данных.
+DSTDEVP			= ДСТАНДОТКЛП				##	Вычисляет стандартное отклонение по генеральной совокупности для выделенных записей базы данных
+DSUM			= БДСУММ				##	Суммирует числа в поле для записей базы данных, удовлетворяющих условию.
+DVAR			= БДДИСП				##	Оценивает дисперсию по выборке из выделенных записей базы данных
+DVARP			= БДДИСПП				##	Вычисляет дисперсию по генеральной совокупности для выделенных записей базы данных
+
+
+##
+##	Date and time functions					Функции даты и времени
+##
+DATE			= ДАТА					##	Возвращает заданную дату в числовом формате.
+DATEVALUE		= ДАТАЗНАЧ				##	Преобразует дату из текстового формата в числовой формат.
+DAY			= ДЕНЬ					##	Преобразует дату в числовом формате в день месяца.
+DAYS360			= ДНЕЙ360				##	Вычисляет количество дней между двумя датами на основе 360-дневного года.
+EDATE			= ДАТАМЕС				##	Возвращает дату в числовом формате, отстоящую на заданное число месяцев вперед или назад от начальной даты.
+EOMONTH			= КОНМЕСЯЦА				##	Возвращает дату в числовом формате для последнего дня месяца, отстоящего вперед или назад на заданное число месяцев.
+HOUR			= ЧАС					##	Преобразует дату в числовом формате в часы.
+MINUTE			= МИНУТЫ				##	Преобразует дату в числовом формате в минуты.
+MONTH			= МЕСЯЦ					##	Преобразует дату в числовом формате в месяцы.
+NETWORKDAYS		= ЧИСТРАБДНИ				##	Возвращает количество рабочих дней между двумя датами.
+NOW			= ТДАТА					##	Возвращает текущую дату и время в числовом формате.
+SECOND			= СЕКУНДЫ				##	Преобразует дату в числовом формате в секунды.
+TIME			= ВРЕМЯ					##	Возвращает заданное время в числовом формате.
+TIMEVALUE		= ВРЕМЗНАЧ				##	Преобразует время из текстового формата в числовой формат.
+TODAY			= СЕГОДНЯ				##	Возвращает текущую дату в числовом формате.
+WEEKDAY			= ДЕНЬНЕД				##	Преобразует дату в числовом формате в день недели.
+WEEKNUM			= НОМНЕДЕЛИ				##	Преобразует числовое представление в число, которое указывает, на какую неделю года приходится указанная дата.
+WORKDAY			= РАБДЕНЬ				##	Возвращает дату в числовом формате, отстоящую вперед или назад на заданное количество рабочих дней.
+YEAR			= ГОД					##	Преобразует дату в числовом формате в год.
+YEARFRAC		= ДОЛЯГОДА				##	Возвращает долю года, которую составляет количество дней между начальной и конечной датами.
+
+
+##
+##	Engineering functions					Инженерные функции
+##
+BESSELI			= БЕССЕЛЬ.I	 			##	Возвращает модифицированную функцию Бесселя In(x).
+BESSELJ			= БЕССЕЛЬ.J				##	Возвращает функцию Бесселя Jn(x).
+BESSELK			= БЕССЕЛЬ.K				##	Возвращает модифицированную функцию Бесселя Kn(x).
+BESSELY			= БЕССЕЛЬ.Y				##	Возвращает функцию Бесселя Yn(x).
+BIN2DEC			= ДВ.В.ДЕС				##	Преобразует двоичное число в десятичное.
+BIN2HEX			= ДВ.В.ШЕСТН				##	Преобразует двоичное число в шестнадцатеричное.
+BIN2OCT			= ДВ.В.ВОСЬМ				##	Преобразует двоичное число в восьмеричное.
+COMPLEX			= КОМПЛЕКСН				##	Преобразует коэффициенты при вещественной и мнимой частях комплексного числа в комплексное число.
+CONVERT			= ПРЕОБР				##	Преобразует число из одной системы единиц измерения в другую.
+DEC2BIN			= ДЕС.В.ДВ				##	Преобразует десятичное число в двоичное.
+DEC2HEX			= ДЕС.В.ШЕСТН				##	Преобразует десятичное число в шестнадцатеричное.
+DEC2OCT			= ДЕС.В.ВОСЬМ				##	Преобразует десятичное число в восьмеричное.
+DELTA			= ДЕЛЬТА				##	Проверяет равенство двух значений.
+ERF			= ФОШ					##	Возвращает функцию ошибки.
+ERFC			= ДФОШ					##	Возвращает дополнительную функцию ошибки.
+GESTEP			= ПОРОГ					##	Проверяет, не превышает ли данное число порогового значения.
+HEX2BIN			= ШЕСТН.В.ДВ				##	Преобразует шестнадцатеричное число в двоичное.
+HEX2DEC			= ШЕСТН.В.ДЕС				##	Преобразует шестнадцатеричное число в десятичное.
+HEX2OCT			= ШЕСТН.В.ВОСЬМ				##	Преобразует шестнадцатеричное число в восьмеричное.
+IMABS			= МНИМ.ABS				##	Возвращает абсолютную величину (модуль) комплексного числа.
+IMAGINARY		= МНИМ.ЧАСТЬ				##	Возвращает коэффициент при мнимой части комплексного числа.
+IMARGUMENT		= МНИМ.АРГУМЕНТ				##	Возвращает значение аргумента комплексного числа (тета) — угол, выраженный в радианах.
+IMCONJUGATE		= МНИМ.СОПРЯЖ				##	Возвращает комплексно-сопряженное комплексное число.
+IMCOS			= МНИМ.COS				##	Возвращает косинус комплексного числа.
+IMDIV			= МНИМ.ДЕЛ				##	Возвращает частное от деления двух комплексных чисел.
+IMEXP			= МНИМ.EXP				##	Возвращает экспоненту комплексного числа.
+IMLN			= МНИМ.LN				##	Возвращает натуральный логарифм комплексного числа.
+IMLOG10			= МНИМ.LOG10				##	Возвращает обычный (десятичный) логарифм комплексного числа.
+IMLOG2			= МНИМ.LOG2				##	Возвращает двоичный логарифм комплексного числа.
+IMPOWER			= МНИМ.СТЕПЕНЬ				##	Возвращает комплексное число, возведенное в целую степень.
+IMPRODUCT		= МНИМ.ПРОИЗВЕД				##	Возвращает произведение от 2 до 29 комплексных чисел.
+IMREAL			= МНИМ.ВЕЩ				##	Возвращает коэффициент при вещественной части комплексного числа.
+IMSIN			= МНИМ.SIN				##	Возвращает синус комплексного числа.
+IMSQRT			= МНИМ.КОРЕНЬ				##	Возвращает значение квадратного корня из комплексного числа.
+IMSUB			= МНИМ.РАЗН				##	Возвращает разность двух комплексных чисел.
+IMSUM			= МНИМ.СУММ				##	Возвращает сумму комплексных чисел.
+OCT2BIN			= ВОСЬМ.В.ДВ				##	Преобразует восьмеричное число в двоичное.
+OCT2DEC			= ВОСЬМ.В.ДЕС				##	Преобразует восьмеричное число в десятичное.
+OCT2HEX			= ВОСЬМ.В.ШЕСТН				##	Преобразует восьмеричное число в шестнадцатеричное.
+
+
+##
+##	Financial functions					Финансовые функции
+##
+ACCRINT			= НАКОПДОХОД				##	Возвращает накопленный процент по ценным бумагам с периодической выплатой процентов.
+ACCRINTM		= НАКОПДОХОДПОГАШ			##	Возвращает накопленный процент по ценным бумагам, проценты по которым выплачиваются в срок погашения.
+AMORDEGRC		= АМОРУМ				##	Возвращает величину амортизации для каждого периода, используя коэффициент амортизации.
+AMORLINC		= АМОРУВ				##	Возвращает величину амортизации для каждого периода.
+COUPDAYBS		= ДНЕЙКУПОНДО				##	Возвращает количество дней от начала действия купона до даты соглашения.
+COUPDAYS		= ДНЕЙКУПОН				##	Возвращает число дней в периоде купона, содержащем дату соглашения.
+COUPDAYSNC		= ДНЕЙКУПОНПОСЛЕ			##	Возвращает число дней от даты соглашения до срока следующего купона.
+COUPNCD			= ДАТАКУПОНПОСЛЕ			##	Возвращает следующую дату купона после даты соглашения.
+COUPNUM			= ЧИСЛКУПОН				##	Возвращает количество купонов, которые могут быть оплачены между датой соглашения и сроком вступления в силу.
+COUPPCD			= ДАТАКУПОНДО				##	Возвращает предыдущую дату купона перед датой соглашения.
+CUMIPMT			= ОБЩПЛАТ				##	Возвращает общую выплату, произведенную между двумя периодическими выплатами.
+CUMPRINC		= ОБЩДОХОД				##	Возвращает общую выплату по займу между двумя периодами.
+DB			= ФУО					##	Возвращает величину амортизации актива для заданного периода, рассчитанную методом фиксированного уменьшения остатка.
+DDB			= ДДОБ					##	Возвращает величину амортизации актива за данный период, используя метод двойного уменьшения остатка или иной явно указанный метод.
+DISC			= СКИДКА				##	Возвращает норму скидки для ценных бумаг.
+DOLLARDE		= РУБЛЬ.ДЕС				##	Преобразует цену в рублях, выраженную в виде дроби, в цену в рублях, выраженную десятичным числом.
+DOLLARFR		= РУБЛЬ.ДРОБЬ				##	Преобразует цену в рублях, выраженную десятичным числом, в цену в рублях, выраженную в виде дроби.
+DURATION		= ДЛИТ					##	Возвращает ежегодную продолжительность действия ценных бумаг с периодическими выплатами по процентам.
+EFFECT			= ЭФФЕКТ				##	Возвращает действующие ежегодные процентные ставки.
+FV			= БС					##	Возвращает будущую стоимость инвестиции.
+FVSCHEDULE		= БЗРАСПИС				##	Возвращает будущую стоимость первоначальной основной суммы после начисления ряда сложных процентов.
+INTRATE			= ИНОРМА				##	Возвращает процентную ставку для полностью инвестированных ценных бумаг.
+IPMT			= ПРПЛТ					##	Возвращает величину выплаты прибыли на вложения за данный период.
+IRR			= ВСД					##	Возвращает внутреннюю ставку доходности для ряда потоков денежных средств.
+ISPMT			= ПРОЦПЛАТ				##	Вычисляет выплаты за указанный период инвестиции.
+MDURATION		= МДЛИТ					##	Возвращает модифицированную длительность Маколея для ценных бумаг с предполагаемой номинальной стоимостью 100 рублей.
+MIRR			= МВСД					##	Возвращает внутреннюю ставку доходности, при которой положительные и отрицательные денежные потоки имеют разные значения ставки.
+NOMINAL			= НОМИНАЛ				##	Возвращает номинальную годовую процентную ставку.
+NPER			= КПЕР					##	Возвращает общее количество периодов выплаты для данного вклада.
+NPV			= ЧПС					##	Возвращает чистую приведенную стоимость инвестиции, основанной на серии периодических денежных потоков и ставке дисконтирования.
+ODDFPRICE		= ЦЕНАПЕРВНЕРЕГ				##	Возвращает цену за 100 рублей нарицательной стоимости ценных бумаг с нерегулярным первым периодом.
+ODDFYIELD		= ДОХОДПЕРВНЕРЕГ			##	Возвращает доход по ценным бумагам с нерегулярным первым периодом.
+ODDLPRICE		= ЦЕНАПОСЛНЕРЕГ				##	Возвращает цену за 100 рублей нарицательной стоимости ценных бумаг с нерегулярным последним периодом.
+ODDLYIELD		= ДОХОДПОСЛНЕРЕГ			##	Возвращает доход по ценным бумагам с нерегулярным последним периодом.
+PMT			= ПЛТ					##	Возвращает величину выплаты за один период аннуитета.
+PPMT			= ОСПЛТ					##	Возвращает величину выплат в погашение основной суммы по инвестиции за заданный период.
+PRICE			= ЦЕНА					##	Возвращает цену за 100 рублей нарицательной стоимости ценных бумаг, по которым производится периодическая выплата процентов.
+PRICEDISC		= ЦЕНАСКИДКА				##	Возвращает цену за 100 рублей номинальной стоимости ценных бумаг, на которые сделана скидка.
+PRICEMAT		= ЦЕНАПОГАШ				##	Возвращает цену за 100 рублей номинальной стоимости ценных бумаг, проценты по которым выплачиваются в срок погашения.
+PV			= ПС					##	Возвращает приведенную (к текущему моменту) стоимость инвестиции.
+RATE			= СТАВКА				##	Возвращает процентную ставку по аннуитету за один период.
+RECEIVED		= ПОЛУЧЕНО				##	Возвращает сумму, полученную к сроку погашения полностью обеспеченных ценных бумаг.
+SLN			= АПЛ					##	Возвращает величину линейной амортизации актива за один период.
+SYD			= АСЧ					##	Возвращает величину амортизации актива за данный период, рассчитанную методом суммы годовых чисел.
+TBILLEQ			= РАВНОКЧЕК				##	Возвращает эквивалентный облигации доход по казначейскому чеку.
+TBILLPRICE		= ЦЕНАКЧЕК				##	Возвращает цену за 100 рублей нарицательной стоимости для казначейского чека.
+TBILLYIELD		= ДОХОДКЧЕК				##	Возвращает доход по казначейскому чеку.
+VDB			= ПУО					##	Возвращает величину амортизации актива для указанного или частичного периода при использовании метода сокращающегося баланса.
+XIRR			= ЧИСТВНДОХ				##	Возвращает внутреннюю ставку доходности для графика денежных потоков, которые не обязательно носят периодический характер.
+XNPV			= ЧИСТНЗ				##	Возвращает чистую приведенную стоимость для денежных потоков, которые не обязательно являются периодическими.
+YIELD			= ДОХОД					##	Возвращает доход от ценных бумаг, по которым производятся периодические выплаты процентов.
+YIELDDISC		= ДОХОДСКИДКА				##	Возвращает годовой доход по ценным бумагам, на которые сделана скидка (пример — казначейские чеки).
+YIELDMAT		= ДОХОДПОГАШ				##	Возвращает годовой доход от ценных бумаг, проценты по которым выплачиваются в срок погашения.
+
+
+##
+##	Information functions					Информационные функции
+##
+CELL			= ЯЧЕЙКА				##	Возвращает информацию о формате, расположении или содержимом ячейки.
+ERROR.TYPE		= ТИП.ОШИБКИ				##	Возвращает числовой код, соответствующий типу ошибки.
+INFO			= ИНФОРМ				##	Возвращает информацию о текущей операционной среде.
+ISBLANK			= ЕПУСТО				##	Возвращает значение ИСТИНА, если аргумент является ссылкой на пустую ячейку.
+ISERR			= ЕОШ					##	Возвращает значение ИСТИНА, если аргумент ссылается на любое значение ошибки, кроме #Н/Д.
+ISERROR			= ЕОШИБКА				##	Возвращает значение ИСТИНА, если аргумент ссылается на любое значение ошибки.
+ISEVEN			= ЕЧЁТН					##	Возвращает значение ИСТИНА, если значение аргумента является четным числом.
+ISLOGICAL		= ЕЛОГИЧ				##	Возвращает значение ИСТИНА, если аргумент ссылается на логическое значение.
+ISNA			= ЕНД					##	Возвращает значение ИСТИНА, если аргумент ссылается на значение ошибки #Н/Д.
+ISNONTEXT		= ЕНЕТЕКСТ				##	Возвращает значение ИСТИНА, если значение аргумента не является текстом.
+ISNUMBER		= ЕЧИСЛО				##	Возвращает значение ИСТИНА, если аргумент ссылается на число.
+ISODD			= ЕНЕЧЁТ				##	Возвращает значение ИСТИНА, если значение аргумента является нечетным числом.
+ISREF			= ЕССЫЛКА				##	Возвращает значение ИСТИНА, если значение аргумента является ссылкой.
+ISTEXT			= ЕТЕКСТ				##	Возвращает значение ИСТИНА, если значение аргумента является текстом.
+N			= Ч					##	Возвращает значение, преобразованное в число.
+NA			= НД					##	Возвращает значение ошибки #Н/Д.
+TYPE			= ТИП					##	Возвращает число, обозначающее тип данных значения.
+
+
+##
+##	Logical functions					Логические функции
+##
+AND			= И					##	Renvoie VRAI si tous ses arguments sont VRAI.
+FALSE			= ЛОЖЬ					##	Возвращает логическое значение ЛОЖЬ.
+IF			= ЕСЛИ					##	Выполняет проверку условия.
+IFERROR			= ЕСЛИОШИБКА				##	Возвращает введённое значение, если вычисление по формуле вызывает ошибку; в противном случае функция возвращает результат вычисления.
+NOT			= НЕ					##	Меняет логическое значение своего аргумента на противоположное.
+OR			= ИЛИ					##	Возвращает значение ИСТИНА, если хотя бы один аргумент имеет значение ИСТИНА.
+TRUE			= ИСТИНА				##	Возвращает логическое значение ИСТИНА.
+
+
+##
+##	Lookup and reference functions				Функции ссылки и поиска
+##
+ADDRESS			= АДРЕС					##	Возвращает ссылку на отдельную ячейку листа в виде текста.
+AREAS			= ОБЛАСТИ				##	Возвращает количество областей в ссылке.
+CHOOSE			= ВЫБОР					##	Выбирает значение из списка значений по индексу.
+COLUMN			= СТОЛБЕЦ				##	Возвращает номер столбца, на который указывает ссылка.
+COLUMNS			= ЧИСЛСТОЛБ				##	Возвращает количество столбцов в ссылке.
+HLOOKUP			= ГПР					##	Ищет в первой строке массива и возвращает значение отмеченной ячейки
+HYPERLINK		= ГИПЕРССЫЛКА				##	Создает ссылку, открывающую документ, который находится на сервере сети, в интрасети или в Интернете.
+INDEX			= ИНДЕКС				##	Использует индекс для выбора значения из ссылки или массива.
+INDIRECT		= ДВССЫЛ				##	Возвращает ссылку, заданную текстовым значением.
+LOOKUP			= ПРОСМОТР				##	Ищет значения в векторе или массиве.
+MATCH			= ПОИСКПОЗ				##	Ищет значения в ссылке или массиве.
+OFFSET			= СМЕЩ					##	Возвращает смещение ссылки относительно заданной ссылки.
+ROW			= СТРОКА				##	Возвращает номер строки, определяемой ссылкой.
+ROWS			= ЧСТРОК				##	Возвращает количество строк в ссылке.
+RTD			= ДРВ					##	Извлекает данные реального времени из программ, поддерживающих автоматизацию COM (Программирование объектов. Стандартное средство для работы с объектами некоторого приложения из другого приложения или средства разработки. Программирование объектов (ранее называемое программированием OLE) является функцией модели COM (Component Object Model, модель компонентных объектов).).
+TRANSPOSE		= ТРАНСП				##	Возвращает транспонированный массив.
+VLOOKUP			= ВПР					##	Ищет значение в первом столбце массива и возвращает значение из ячейки в найденной строке и указанном столбце.
+
+
+##
+##	Math and trigonometry functions				Математические и тригонометрические функции
+##
+ABS			= ABS					##	Возвращает модуль (абсолютную величину) числа.
+ACOS			= ACOS					##	Возвращает арккосинус числа.
+ACOSH			= ACOSH					##	Возвращает гиперболический арккосинус числа.
+ASIN			= ASIN					##	Возвращает арксинус числа.
+ASINH			= ASINH					##	Возвращает гиперболический арксинус числа.
+ATAN			= ATAN					##	Возвращает арктангенс числа.
+ATAN2			= ATAN2					##	Возвращает арктангенс для заданных координат x и y.
+ATANH			= ATANH					##	Возвращает гиперболический арктангенс числа.
+CEILING			= ОКРВВЕРХ				##	Округляет число до ближайшего целого или до ближайшего кратного указанному значению.
+COMBIN			= ЧИСЛКОМБ				##	Возвращает количество комбинаций для заданного числа объектов.
+COS			= COS					##	Возвращает косинус числа.
+COSH			= COSH					##	Возвращает гиперболический косинус числа.
+DEGREES			= ГРАДУСЫ				##	Преобразует радианы в градусы.
+EVEN			= ЧЁТН					##	Округляет число до ближайшего четного целого.
+EXP			= EXP					##	Возвращает число e, возведенное в указанную степень.
+FACT			= ФАКТР					##	Возвращает факториал числа.
+FACTDOUBLE		= ДВФАКТР				##	Возвращает двойной факториал числа.
+FLOOR			= ОКРВНИЗ				##	Округляет число до ближайшего меньшего по модулю значения.
+GCD			= НОД					##	Возвращает наибольший общий делитель.
+INT			= ЦЕЛОЕ					##	Округляет число до ближайшего меньшего целого.
+LCM			= НОК					##	Возвращает наименьшее общее кратное.
+LN			= LN					##	Возвращает натуральный логарифм числа.
+LOG			= LOG					##	Возвращает логарифм числа по заданному основанию.
+LOG10			= LOG10					##	Возвращает десятичный логарифм числа.
+MDETERM			= МОПРЕД				##	Возвращает определитель матрицы массива.
+MINVERSE		= МОБР					##	Возвращает обратную матрицу массива.
+MMULT			= МУМНОЖ				##	Возвращает произведение матриц двух массивов.
+MOD			= ОСТАТ					##	Возвращает остаток от деления.
+MROUND			= ОКРУГЛТ				##	Возвращает число, округленное с требуемой точностью.
+MULTINOMIAL		= МУЛЬТИНОМ				##	Возвращает мультиномиальный коэффициент множества чисел.
+ODD			= НЕЧЁТ					##	Округляет число до ближайшего нечетного целого.
+PI			= ПИ					##	Возвращает число пи.
+POWER			= СТЕПЕНЬ				##	Возвращает результат возведения числа в степень.
+PRODUCT			= ПРОИЗВЕД				##	Возвращает произведение аргументов.
+QUOTIENT		= ЧАСТНОЕ				##	Возвращает целую часть частного при делении.
+RADIANS			= РАДИАНЫ				##	Преобразует градусы в радианы.
+RAND			= СЛЧИС					##	Возвращает случайное число в интервале от 0 до 1.
+RANDBETWEEN		= СЛУЧМЕЖДУ				##	Возвращает случайное число в интервале между двумя заданными числами.
+ROMAN			= РИМСКОЕ				##	Преобразует арабские цифры в римские в виде текста.
+ROUND			= ОКРУГЛ				##	Округляет число до указанного количества десятичных разрядов.
+ROUNDDOWN		= ОКРУГЛВНИЗ				##	Округляет число до ближайшего меньшего по модулю значения.
+ROUNDUP			= ОКРУГЛВВЕРХ				##	Округляет число до ближайшего большего по модулю значения.
+SERIESSUM		= РЯД.СУММ				##	Возвращает сумму степенного ряда, вычисленную по формуле.
+SIGN			= ЗНАК					##	Возвращает знак числа.
+SIN			= SIN					##	Возвращает синус заданного угла.
+SINH			= SINH					##	Возвращает гиперболический синус числа.
+SQRT			= КОРЕНЬ				##	Возвращает положительное значение квадратного корня.
+SQRTPI			= КОРЕНЬПИ				##	Возвращает квадратный корень из значения выражения (число * ПИ).
+SUBTOTAL		= ПРОМЕЖУТОЧНЫЕ.ИТОГИ			##	Возвращает промежуточный итог в списке или базе данных.
+SUM			= СУММ					##	Суммирует аргументы.
+SUMIF			= СУММЕСЛИ				##	Суммирует ячейки, удовлетворяющие заданному условию.
+SUMIFS			= СУММЕСЛИМН				##	Суммирует диапазон ячеек, удовлетворяющих нескольким условиям.
+SUMPRODUCT		= СУММПРОИЗВ				##	Возвращает сумму произведений соответствующих элементов массивов.
+SUMSQ			= СУММКВ				##	Возвращает сумму квадратов аргументов.
+SUMX2MY2		= СУММРАЗНКВ				##	Возвращает сумму разностей квадратов соответствующих значений в двух массивах.
+SUMX2PY2		= СУММСУММКВ				##	Возвращает сумму сумм квадратов соответствующих элементов двух массивов.
+SUMXMY2			= СУММКВРАЗН				##	Возвращает сумму квадратов разностей соответствующих значений в двух массивах.
+TAN			= TAN					##	Возвращает тангенс числа.
+TANH			= TANH					##	Возвращает гиперболический тангенс числа.
+TRUNC			= ОТБР					##	Отбрасывает дробную часть числа.
+
+
+##
+##	Statistical functions					Статистические функции
+##
+AVEDEV			= СРОТКЛ				##	Возвращает среднее арифметическое абсолютных значений отклонений точек данных от среднего.
+AVERAGE			= СРЗНАЧ				##	Возвращает среднее арифметическое аргументов.
+AVERAGEA		= СРЗНАЧА				##	Возвращает среднее арифметическое аргументов, включая числа, текст и логические значения.
+AVERAGEIF		= СРЗНАЧЕСЛИ 				##	Возвращает среднее значение (среднее арифметическое) всех ячеек в диапазоне, которые удовлетворяют данному условию.
+AVERAGEIFS		= СРЗНАЧЕСЛИМН 				##	Возвращает среднее значение (среднее арифметическое) всех ячеек, которые удовлетворяют нескольким условиям.
+BETADIST		= БЕТАРАСП				##	Возвращает интегральную функцию бета-распределения.
+BETAINV			= БЕТАОБР				##	Возвращает обратную интегральную функцию указанного бета-распределения.
+BINOMDIST		= БИНОМРАСП				##	Возвращает отдельное значение биномиального распределения.
+CHIDIST			= ХИ2РАСП				##	Возвращает одностороннюю вероятность распределения хи-квадрат.
+CHIINV			= ХИ2ОБР				##	Возвращает обратное значение односторонней вероятности распределения хи-квадрат.
+CHITEST			= ХИ2ТЕСТ				##	Возвращает тест на независимость.
+CONFIDENCE		= ДОВЕРИТ				##	Возвращает доверительный интервал для среднего значения по генеральной совокупности.
+CORREL			= КОРРЕЛ				##	Возвращает коэффициент корреляции между двумя множествами данных.
+COUNT			= СЧЁТ					##	Подсчитывает количество чисел в списке аргументов.
+COUNTA			= СЧЁТЗ					##	Подсчитывает количество значений в списке аргументов.
+COUNTBLANK		= СЧИТАТЬПУСТОТЫ			##	Подсчитывает количество пустых ячеек в диапазоне
+COUNTIF			= СЧЁТЕСЛИ 				##	Подсчитывает количество ячеек в диапазоне, удовлетворяющих заданному условию
+COUNTIFS		= СЧЁТЕСЛИМН				##	Подсчитывает количество ячеек внутри диапазона, удовлетворяющих нескольким условиям.
+COVAR			= КОВАР					##	Возвращает ковариацию, среднее произведений парных отклонений
+CRITBINOM		= КРИТБИНОМ				##	Возвращает наименьшее значение, для которого интегральное биномиальное распределение меньше или равно заданному критерию.
+DEVSQ			= КВАДРОТКЛ				##	Возвращает сумму квадратов отклонений.
+EXPONDIST		= ЭКСПРАСП				##	Возвращает экспоненциальное распределение.
+FDIST			= FРАСП					##	Возвращает F-распределение вероятности.
+FINV			= FРАСПОБР				##	Возвращает обратное значение для F-распределения вероятности.
+FISHER			= ФИШЕР					##	Возвращает преобразование Фишера.
+FISHERINV		= ФИШЕРОБР				##	Возвращает обратное преобразование Фишера.
+FORECAST		= ПРЕДСКАЗ				##	Возвращает значение линейного тренда.
+FREQUENCY		= ЧАСТОТА				##	Возвращает распределение частот в виде вертикального массива.
+FTEST			= ФТЕСТ					##	Возвращает результат F-теста.
+GAMMADIST		= ГАММАРАСП				##	Возвращает гамма-распределение.
+GAMMAINV		= ГАММАОБР				##	Возвращает обратное гамма-распределение.
+GAMMALN			= ГАММАНЛОГ				##	Возвращает натуральный логарифм гамма функции, Γ(x).
+GEOMEAN			= СРГЕОМ				##	Возвращает среднее геометрическое.
+GROWTH			= РОСТ					##	Возвращает значения в соответствии с экспоненциальным трендом.
+HARMEAN			= СРГАРМ				##	Возвращает среднее гармоническое.
+HYPGEOMDIST		= ГИПЕРГЕОМЕТ				##	Возвращает гипергеометрическое распределение.
+INTERCEPT		= ОТРЕЗОК				##	Возвращает отрезок, отсекаемый на оси линией линейной регрессии.
+KURT			= ЭКСЦЕСС				##	Возвращает эксцесс множества данных.
+LARGE			= НАИБОЛЬШИЙ				##	Возвращает k-ое наибольшее значение в множестве данных.
+LINEST			= ЛИНЕЙН				##	Возвращает параметры линейного тренда.
+LOGEST			= ЛГРФПРИБЛ				##	Возвращает параметры экспоненциального тренда.
+LOGINV			= ЛОГНОРМОБР				##	Возвращает обратное логарифмическое нормальное распределение.
+LOGNORMDIST		= ЛОГНОРМРАСП				##	Возвращает интегральное логарифмическое нормальное распределение.
+MAX			= МАКС					##	Возвращает наибольшее значение в списке аргументов.
+MAXA			= МАКСА					##	Возвращает наибольшее значение в списке аргументов, включая числа, текст и логические значения.
+MEDIAN			= МЕДИАНА				##	Возвращает медиану заданных чисел.
+MIN			= МИН					##	Возвращает наименьшее значение в списке аргументов.
+MINA			= МИНА					##	Возвращает наименьшее значение в списке аргументов, включая числа, текст и логические значения.
+MODE			= МОДА					##	Возвращает значение моды множества данных.
+NEGBINOMDIST		= ОТРБИНОМРАСП				##	Возвращает отрицательное биномиальное распределение.
+NORMDIST		= НОРМРАСП				##	Возвращает нормальную функцию распределения.
+NORMINV			= НОРМОБР				##	Возвращает обратное нормальное распределение.
+NORMSDIST		= НОРМСТРАСП				##	Возвращает стандартное нормальное интегральное распределение.
+NORMSINV		= НОРМСТОБР				##	Возвращает обратное значение стандартного нормального распределения.
+PEARSON			= ПИРСОН				##	Возвращает коэффициент корреляции Пирсона.
+PERCENTILE		= ПЕРСЕНТИЛЬ				##	Возвращает k-ую персентиль для значений диапазона.
+PERCENTRANK		= ПРОЦЕНТРАНГ				##	Возвращает процентную норму значения в множестве данных.
+PERMUT			= ПЕРЕСТ				##	Возвращает количество перестановок для заданного числа объектов.
+POISSON			= ПУАССОН				##	Возвращает распределение Пуассона.
+PROB			= ВЕРОЯТНОСТЬ				##	Возвращает вероятность того, что значение из диапазона находится внутри заданных пределов.
+QUARTILE		= КВАРТИЛЬ				##	Возвращает квартиль множества данных.
+RANK			= РАНГ					##	Возвращает ранг числа в списке чисел.
+RSQ			= КВПИРСОН				##	Возвращает квадрат коэффициента корреляции Пирсона.
+SKEW			= СКОС					##	Возвращает асимметрию распределения.
+SLOPE			= НАКЛОН				##	Возвращает наклон линии линейной регрессии.
+SMALL			= НАИМЕНЬШИЙ				##	Возвращает k-ое наименьшее значение в множестве данных.
+STANDARDIZE		= НОРМАЛИЗАЦИЯ				##	Возвращает нормализованное значение.
+STDEV			= СТАНДОТКЛОН				##	Оценивает стандартное отклонение по выборке.
+STDEVA			= СТАНДОТКЛОНА				##	Оценивает стандартное отклонение по выборке, включая числа, текст и логические значения.
+STDEVP			= СТАНДОТКЛОНП				##	Вычисляет стандартное отклонение по генеральной совокупности.
+STDEVPA			= СТАНДОТКЛОНПА				##	Вычисляет стандартное отклонение по генеральной совокупности, включая числа, текст и логические значения.
+STEYX			= СТОШYX				##	Возвращает стандартную ошибку предсказанных значений y для каждого значения x в регрессии.
+TDIST			= СТЬЮДРАСП				##	Возвращает t-распределение Стьюдента.
+TINV			= СТЬЮДРАСПОБР				##	Возвращает обратное t-распределение Стьюдента.
+TREND			= ТЕНДЕНЦИЯ				##	Возвращает значения в соответствии с линейным трендом.
+TRIMMEAN		= УРЕЗСРЕДНЕЕ				##	Возвращает среднее внутренности множества данных.
+TTEST			= ТТЕСТ					##	Возвращает вероятность, соответствующую критерию Стьюдента.
+VAR			= ДИСП					##	Оценивает дисперсию по выборке.
+VARA			= ДИСПА					##	Оценивает дисперсию по выборке, включая числа, текст и логические значения.
+VARP			= ДИСПР					##	Вычисляет дисперсию для генеральной совокупности.
+VARPA			= ДИСПРА				##	Вычисляет дисперсию для генеральной совокупности, включая числа, текст и логические значения.
+WEIBULL			= ВЕЙБУЛЛ				##	Возвращает распределение Вейбулла.
+ZTEST			= ZТЕСТ					##	Возвращает двустороннее P-значение z-теста.
+
+
+##
+##	Text functions						Текстовые функции
+##
+ASC			= ASC					##	Для языков с двухбайтовыми наборами знаков (например, катакана) преобразует полноширинные (двухбайтовые) знаки в полуширинные (однобайтовые).
+BAHTTEXT		= БАТТЕКСТ				##	Преобразует число в текст, используя денежный формат ß (БАТ).
+CHAR			= СИМВОЛ				##	Возвращает знак с заданным кодом.
+CLEAN			= ПЕЧСИМВ				##	Удаляет все непечатаемые знаки из текста.
+CODE			= КОДСИМВ				##	Возвращает числовой код первого знака в текстовой строке.
+CONCATENATE		= СЦЕПИТЬ				##	Объединяет несколько текстовых элементов в один.
+DOLLAR			= РУБЛЬ					##	Преобразует число в текст, используя денежный формат.
+EXACT			= СОВПАД				##	Проверяет идентичность двух текстовых значений.
+FIND			= НАЙТИ					##	Ищет вхождения одного текстового значения в другом (с учетом регистра).
+FINDB			= НАЙТИБ				##	Ищет вхождения одного текстового значения в другом (с учетом регистра).
+FIXED			= ФИКСИРОВАННЫЙ				##	Форматирует число и преобразует его в текст с заданным числом десятичных знаков.
+JIS			= JIS					##	Для языков с двухбайтовыми наборами знаков (например, катакана) преобразует полуширинные (однобайтовые) знаки в текстовой строке в полноширинные (двухбайтовые).
+LEFT			= ЛЕВСИМВ				##	Возвращает крайние слева знаки текстового значения.
+LEFTB			= ЛЕВБ					##	Возвращает крайние слева знаки текстового значения.
+LEN			= ДЛСТР					##	Возвращает количество знаков в текстовой строке.
+LENB			= ДЛИНБ					##	Возвращает количество знаков в текстовой строке.
+LOWER			= СТРОЧН				##	Преобразует все буквы текста в строчные.
+MID			= ПСТР					##	Возвращает заданное число знаков из строки текста, начиная с указанной позиции.
+MIDB			= ПСТРБ					##	Возвращает заданное число знаков из строки текста, начиная с указанной позиции.
+PHONETIC		= PHONETIC				##	Извлекает фонетические (фуригана) знаки из текстовой строки.
+PROPER			= ПРОПНАЧ				##	Преобразует первую букву в каждом слове текста в прописную.
+REPLACE			= ЗАМЕНИТЬ				##	Заменяет знаки в тексте.
+REPLACEB		= ЗАМЕНИТЬБ				##	Заменяет знаки в тексте.
+REPT			= ПОВТОР				##	Повторяет текст заданное число раз.
+RIGHT			= ПРАВСИМВ				##	Возвращает крайние справа знаки текстовой строки.
+RIGHTB			= ПРАВБ					##	Возвращает крайние справа знаки текстовой строки.
+SEARCH			= ПОИСК					##	Ищет вхождения одного текстового значения в другом (без учета регистра).
+SEARCHB			= ПОИСКБ				##	Ищет вхождения одного текстового значения в другом (без учета регистра).
+SUBSTITUTE		= ПОДСТАВИТЬ				##	Заменяет в текстовой строке старый текст новым.
+T			= Т					##	Преобразует аргументы в текст.
+TEXT			= ТЕКСТ					##	Форматирует число и преобразует его в текст.
+TRIM			= СЖПРОБЕЛЫ				##	Удаляет из текста пробелы.
+UPPER			= ПРОПИСН				##	Преобразует все буквы текста в прописные.
+VALUE			= ЗНАЧЕН				##	Преобразует текстовый аргумент в число.

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/cs/functions

@@ -0,0 +1,520 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Ceština (Czech)
+##
+############################################################
+
+
+##
+## Funkce pro práci s datovými krychlemi (Cube Functions)
+##
+CUBEKPIMEMBER = CUBEKPIMEMBER
+CUBEMEMBER = CUBEMEMBER
+CUBEMEMBERPROPERTY = CUBEMEMBERPROPERTY
+CUBERANKEDMEMBER = CUBERANKEDMEMBER
+CUBESET = CUBESET
+CUBESETCOUNT = CUBESETCOUNT
+CUBEVALUE = CUBEVALUE
+
+##
+## Funkce databáze (Database Functions)
+##
+DAVERAGE = DPRŮMĚR
+DCOUNT = DPOČET
+DCOUNTA = DPOČET2
+DGET = DZÍSKAT
+DMAX = DMAX
+DMIN = DMIN
+DPRODUCT = DSOUČIN
+DSTDEV = DSMODCH.VÝBĚR
+DSTDEVP = DSMODCH
+DSUM = DSUMA
+DVAR = DVAR.VÝBĚR
+DVARP = DVAR
+
+##
+## Funkce data a času (Date & Time Functions)
+##
+DATE = DATUM
+DATEVALUE = DATUMHODN
+DAY = DEN
+DAYS = DAYS
+DAYS360 = ROK360
+EDATE = EDATE
+EOMONTH = EOMONTH
+HOUR = HODINA
+ISOWEEKNUM = ISOWEEKNUM
+MINUTE = MINUTA
+MONTH = MĚSÍC
+NETWORKDAYS = NETWORKDAYS
+NETWORKDAYS.INTL = NETWORKDAYS.INTL
+NOW = NYNÍ
+SECOND = SEKUNDA
+TIME = ČAS
+TIMEVALUE = ČASHODN
+TODAY = DNES
+WEEKDAY = DENTÝDNE
+WEEKNUM = WEEKNUM
+WORKDAY = WORKDAY
+WORKDAY.INTL = WORKDAY.INTL
+YEAR = ROK
+YEARFRAC = YEARFRAC
+
+##
+## Inženýrské funkce (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN2DEC
+BIN2HEX = BIN2HEX
+BIN2OCT = BIN2OCT
+BITAND = BITAND
+BITLSHIFT = BITLSHIFT
+BITOR = BITOR
+BITRSHIFT = BITRSHIFT
+BITXOR = BITXOR
+COMPLEX = COMPLEX
+CONVERT = CONVERT
+DEC2BIN = DEC2BIN
+DEC2HEX = DEC2HEX
+DEC2OCT = DEC2OCT
+DELTA = DELTA
+ERF = ERF
+ERF.PRECISE = ERF.PRECISE
+ERFC = ERFC
+ERFC.PRECISE = ERFC.PRECISE
+GESTEP = GESTEP
+HEX2BIN = HEX2BIN
+HEX2DEC = HEX2DEC
+HEX2OCT = HEX2OCT
+IMABS = IMABS
+IMAGINARY = IMAGINARY
+IMARGUMENT = IMARGUMENT
+IMCONJUGATE = IMCONJUGATE
+IMCOS = IMCOS
+IMCOSH = IMCOSH
+IMCOT = IMCOT
+IMCSC = IMCSC
+IMCSCH = IMCSCH
+IMDIV = IMDIV
+IMEXP = IMEXP
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMPOWER
+IMPRODUCT = IMPRODUCT
+IMREAL = IMREAL
+IMSEC = IMSEC
+IMSECH = IMSECH
+IMSIN = IMSIN
+IMSINH = IMSINH
+IMSQRT = IMSQRT
+IMSUB = IMSUB
+IMSUM = IMSUM
+IMTAN = IMTAN
+OCT2BIN = OCT2BIN
+OCT2DEC = OCT2DEC
+OCT2HEX = OCT2HEX
+
+##
+## Finanční funkce (Financial Functions)
+##
+ACCRINT = ACCRINT
+ACCRINTM = ACCRINTM
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = COUPDAYBS
+COUPDAYS = COUPDAYS
+COUPDAYSNC = COUPDAYSNC
+COUPNCD = COUPNCD
+COUPNUM = COUPNUM
+COUPPCD = COUPPCD
+CUMIPMT = CUMIPMT
+CUMPRINC = CUMPRINC
+DB = ODPIS.ZRYCH
+DDB = ODPIS.ZRYCH2
+DISC = DISC
+DOLLARDE = DOLLARDE
+DOLLARFR = DOLLARFR
+DURATION = DURATION
+EFFECT = EFFECT
+FV = BUDHODNOTA
+FVSCHEDULE = FVSCHEDULE
+INTRATE = INTRATE
+IPMT = PLATBA.ÚROK
+IRR = MÍRA.VÝNOSNOSTI
+ISPMT = ISPMT
+MDURATION = MDURATION
+MIRR = MOD.MÍRA.VÝNOSNOSTI
+NOMINAL = NOMINAL
+NPER = POČET.OBDOBÍ
+NPV = ČISTÁ.SOUČHODNOTA
+ODDFPRICE = ODDFPRICE
+ODDFYIELD = ODDFYIELD
+ODDLPRICE = ODDLPRICE
+ODDLYIELD = ODDLYIELD
+PDURATION = PDURATION
+PMT = PLATBA
+PPMT = PLATBA.ZÁKLAD
+PRICE = PRICE
+PRICEDISC = PRICEDISC
+PRICEMAT = PRICEMAT
+PV = SOUČHODNOTA
+RATE = ÚROKOVÁ.MÍRA
+RECEIVED = RECEIVED
+RRI = RRI
+SLN = ODPIS.LIN
+SYD = ODPIS.NELIN
+TBILLEQ = TBILLEQ
+TBILLPRICE = TBILLPRICE
+TBILLYIELD = TBILLYIELD
+VDB = ODPIS.ZA.INT
+XIRR = XIRR
+XNPV = XNPV
+YIELD = YIELD
+YIELDDISC = YIELDDISC
+YIELDMAT = YIELDMAT
+
+##
+## Informační funkce (Information Functions)
+##
+CELL = POLÍČKO
+ERROR.TYPE = CHYBA.TYP
+INFO = O.PROSTŘEDÍ
+ISBLANK = JE.PRÁZDNÉ
+ISERR = JE.CHYBA
+ISERROR = JE.CHYBHODN
+ISEVEN = ISEVEN
+ISFORMULA = ISFORMULA
+ISLOGICAL = JE.LOGHODN
+ISNA = JE.NEDEF
+ISNONTEXT = JE.NETEXT
+ISNUMBER = JE.ČISLO
+ISODD = ISODD
+ISREF = JE.ODKAZ
+ISTEXT = JE.TEXT
+N = N
+NA = NEDEF
+SHEET = SHEET
+SHEETS = SHEETS
+TYPE = TYP
+
+##
+## Logické funkce (Logical Functions)
+##
+AND = A
+FALSE = NEPRAVDA
+IF = KDYŽ
+IFERROR = IFERROR
+IFNA = IFNA
+IFS = IFS
+NOT = NE
+OR = NEBO
+SWITCH = SWITCH
+TRUE = PRAVDA
+XOR = XOR
+
+##
+## Vyhledávací funkce a funkce pro odkazy (Lookup & Reference Functions)
+##
+ADDRESS = ODKAZ
+AREAS = POČET.BLOKŮ
+CHOOSE = ZVOLIT
+COLUMN = SLOUPEC
+COLUMNS = SLOUPCE
+FORMULATEXT = FORMULATEXT
+GETPIVOTDATA = ZÍSKATKONTDATA
+HLOOKUP = VVYHLEDAT
+HYPERLINK = HYPERTEXTOVÝ.ODKAZ
+INDEX = INDEX
+INDIRECT = NEPŘÍMÝ.ODKAZ
+LOOKUP = VYHLEDAT
+MATCH = POZVYHLEDAT
+OFFSET = POSUN
+ROW = ŘÁDEK
+ROWS = ŘÁDKY
+RTD = RTD
+TRANSPOSE = TRANSPOZICE
+VLOOKUP = SVYHLEDAT
+
+##
+## Matematické a trigonometrické funkce (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ARCCOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGGREGATE
+ARABIC = ARABIC
+ASIN = ARCSIN
+ASINH = ARCSINH
+ATAN = ARCTG
+ATAN2 = ARCTG2
+ATANH = ARCTGH
+BASE = BASE
+CEILING.MATH = CEILING.MATH
+COMBIN = KOMBINACE
+COMBINA = COMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMAL
+DEGREES = DEGREES
+EVEN = ZAOKROUHLIT.NA.SUDÉ
+EXP = EXP
+FACT = FAKTORIÁL
+FACTDOUBLE = FACTDOUBLE
+FLOOR.MATH = FLOOR.MATH
+GCD = GCD
+INT = CELÁ.ČÁST
+LCM = LCM
+LN = LN
+LOG = LOGZ
+LOG10 = LOG
+MDETERM = DETERMINANT
+MINVERSE = INVERZE
+MMULT = SOUČIN.MATIC
+MOD = MOD
+MROUND = MROUND
+MULTINOMIAL = MULTINOMIAL
+MUNIT = MUNIT
+ODD = ZAOKROUHLIT.NA.LICHÉ
+PI = PI
+POWER = POWER
+PRODUCT = SOUČIN
+QUOTIENT = QUOTIENT
+RADIANS = RADIANS
+RAND = NÁHČÍSLO
+RANDBETWEEN = RANDBETWEEN
+ROMAN = ROMAN
+ROUND = ZAOKROUHLIT
+ROUNDDOWN = ROUNDDOWN
+ROUNDUP = ROUNDUP
+SEC = SEC
+SECH = SECH
+SERIESSUM = SERIESSUM
+SIGN = SIGN
+SIN = SIN
+SINH = SINH
+SQRT = ODMOCNINA
+SQRTPI = SQRTPI
+SUBTOTAL = SUBTOTAL
+SUM = SUMA
+SUMIF = SUMIF
+SUMIFS = SUMIFS
+SUMPRODUCT = SOUČIN.SKALÁRNÍ
+SUMSQ = SUMA.ČTVERCŮ
+SUMX2MY2 = SUMX2MY2
+SUMX2PY2 = SUMX2PY2
+SUMXMY2 = SUMXMY2
+TAN = TG
+TANH = TGH
+TRUNC = USEKNOUT
+
+##
+## Statistické funkce (Statistical Functions)
+##
+AVEDEV = PRŮMODCHYLKA
+AVERAGE = PRŮMĚR
+AVERAGEA = AVERAGEA
+AVERAGEIF = AVERAGEIF
+AVERAGEIFS = AVERAGEIFS
+BETA.DIST = BETA.DIST
+BETA.INV = BETA.INV
+BINOM.DIST = BINOM.DIST
+BINOM.DIST.RANGE = BINOM.DIST.RANGE
+BINOM.INV = BINOM.INV
+CHISQ.DIST = CHISQ.DIST
+CHISQ.DIST.RT = CHISQ.DIST.RT
+CHISQ.INV = CHISQ.INV
+CHISQ.INV.RT = CHISQ.INV.RT
+CHISQ.TEST = CHISQ.TEST
+CONFIDENCE.NORM = CONFIDENCE.NORM
+CONFIDENCE.T = CONFIDENCE.T
+CORREL = CORREL
+COUNT = POČET
+COUNTA = POČET2
+COUNTBLANK = COUNTBLANK
+COUNTIF = COUNTIF
+COUNTIFS = COUNTIFS
+COVARIANCE.P = COVARIANCE.P
+COVARIANCE.S = COVARIANCE.S
+DEVSQ = DEVSQ
+EXPON.DIST = EXPON.DIST
+F.DIST = F.DIST
+F.DIST.RT = F.DIST.RT
+F.INV = F.INV
+F.INV.RT = F.INV.RT
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = FORECAST.ETS
+FORECAST.ETS.CONFINT = FORECAST.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = FORECAST.ETS.SEASONALITY
+FORECAST.ETS.STAT = FORECAST.ETS.STAT
+FORECAST.LINEAR = FORECAST.LINEAR
+FREQUENCY = ČETNOSTI
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.DIST
+GAMMA.INV = GAMMA.INV
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.PRECISE
+GAUSS = GAUSS
+GEOMEAN = GEOMEAN
+GROWTH = LOGLINTREND
+HARMEAN = HARMEAN
+HYPGEOM.DIST = HYPGEOM.DIST
+INTERCEPT = INTERCEPT
+KURT = KURT
+LARGE = LARGE
+LINEST = LINREGRESE
+LOGEST = LOGLINREGRESE
+LOGNORM.DIST = LOGNORM.DIST
+LOGNORM.INV = LOGNORM.INV
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAXIFS
+MEDIAN = MEDIAN
+MIN = MIN
+MINA = MINA
+MINIFS = MINIFS
+MODE.MULT = MODE.MULT
+MODE.SNGL = MODE.SNGL
+NEGBINOM.DIST = NEGBINOM.DIST
+NORM.DIST = NORM.DIST
+NORM.INV = NORM.INV
+NORM.S.DIST = NORM.S.DIST
+NORM.S.INV = NORM.S.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIL.EXC
+PERCENTILE.INC = PERCENTIL.INC
+PERCENTRANK.EXC = PERCENTRANK.EXC
+PERCENTRANK.INC = PERCENTRANK.INC
+PERMUT = PERMUTACE
+PERMUTATIONA = PERMUTATIONA
+PHI = PHI
+POISSON.DIST = POISSON.DIST
+PROB = PROB
+QUARTILE.EXC = QUARTIL.EXC
+QUARTILE.INC = QUARTIL.INC
+RANK.AVG = RANK.AVG
+RANK.EQ = RANK.EQ
+RSQ = RKQ
+SKEW = SKEW
+SKEW.P = SKEW.P
+SLOPE = SLOPE
+SMALL = SMALL
+STANDARDIZE = STANDARDIZE
+STDEV.P = SMODCH.P
+STDEV.S = SMODCH.VÝBĚR.S
+STDEVA = STDEVA
+STDEVPA = STDEVPA
+STEYX = STEYX
+T.DIST = T.DIST
+T.DIST.2T = T.DIST.2T
+T.DIST.RT = T.DIST.RT
+T.INV = T.INV
+T.INV.2T = T.INV.2T
+T.TEST = T.TEST
+TREND = LINTREND
+TRIMMEAN = TRIMMEAN
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = WEIBULL.DIST
+Z.TEST = Z.TEST
+
+##
+## Textové funkce (Text Functions)
+##
+BAHTTEXT = BAHTTEXT
+CHAR = ZNAK
+CLEAN = VYČISTIT
+CODE = KÓD
+CONCAT = CONCAT
+DOLLAR = KČ
+EXACT = STEJNÉ
+FIND = NAJÍT
+FIXED = ZAOKROUHLIT.NA.TEXT
+LEFT = ZLEVA
+LEN = DÉLKA
+LOWER = MALÁ
+MID = ČÁST
+NUMBERVALUE = NUMBERVALUE
+PHONETIC = ZVUKOVÉ
+PROPER = VELKÁ2
+REPLACE = NAHRADIT
+REPT = OPAKOVAT
+RIGHT = ZPRAVA
+SEARCH = HLEDAT
+SUBSTITUTE = DOSADIT
+T = T
+TEXT = HODNOTA.NA.TEXT
+TEXTJOIN = TEXTJOIN
+TRIM = PROČISTIT
+UNICHAR = UNICHAR
+UNICODE = UNICODE
+UPPER = VELKÁ
+VALUE = HODNOTA
+
+##
+## Webové funkce (Web Functions)
+##
+ENCODEURL = ENCODEURL
+FILTERXML = FILTERXML
+WEBSERVICE = WEBSERVICE
+
+##
+## Funkce pro kompatibilitu (Compatibility Functions)
+##
+BETADIST = BETADIST
+BETAINV = BETAINV
+BINOMDIST = BINOMDIST
+CEILING = ZAOKR.NAHORU
+CHIDIST = CHIDIST
+CHIINV = CHIINV
+CHITEST = CHITEST
+CONCATENATE = CONCATENATE
+CONFIDENCE = CONFIDENCE
+COVAR = COVAR
+CRITBINOM = CRITBINOM
+EXPONDIST = EXPONDIST
+FDIST = FDIST
+FINV = FINV
+FLOOR = ZAOKR.DOLŮ
+FORECAST = FORECAST
+FTEST = FTEST
+GAMMADIST = GAMMADIST
+GAMMAINV = GAMMAINV
+HYPGEOMDIST = HYPGEOMDIST
+LOGINV = LOGINV
+LOGNORMDIST = LOGNORMDIST
+MODE = MODE
+NEGBINOMDIST = NEGBINOMDIST
+NORMDIST = NORMDIST
+NORMINV = NORMINV
+NORMSDIST = NORMSDIST
+NORMSINV = NORMSINV
+PERCENTILE = PERCENTIL
+PERCENTRANK = PERCENTRANK
+POISSON = POISSON
+QUARTILE = QUARTIL
+RANK = RANK
+STDEV = SMODCH.VÝBĚR
+STDEVP = SMODCH
+TDIST = TDIST
+TINV = TINV
+TTEST = TTEST
+VAR = VAR.VÝBĚR
+VARP = VAR
+WEIBULL = WEIBULL
+ZTEST = ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/da/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Dansk (Danish)
+##
+############################################################
+
+
+##
+## Kubefunktioner (Cube Functions)
+##
+CUBEKPIMEMBER = KUBE.KPI.MEDLEM
+CUBEMEMBER = KUBEMEDLEM
+CUBEMEMBERPROPERTY = KUBEMEDLEM.EGENSKAB
+CUBERANKEDMEMBER = KUBERANGERET.MEDLEM
+CUBESET = KUBESÆT
+CUBESETCOUNT = KUBESÆT.ANTAL
+CUBEVALUE = KUBEVÆRDI
+
+##
+## Databasefunktioner (Database Functions)
+##
+DAVERAGE = DMIDDEL
+DCOUNT = DTÆL
+DCOUNTA = DTÆLV
+DGET = DHENT
+DMAX = DMAKS
+DMIN = DMIN
+DPRODUCT = DPRODUKT
+DSTDEV = DSTDAFV
+DSTDEVP = DSTDAFVP
+DSUM = DSUM
+DVAR = DVARIANS
+DVARP = DVARIANSP
+
+##
+## Dato- og klokkeslætfunktioner (Date & Time Functions)
+##
+DATE = DATO
+DATEDIF = DATO.FORSKEL
+DATESTRING = DATOSTRENG
+DATEVALUE = DATOVÆRDI
+DAY = DAG
+DAYS = DAGE
+DAYS360 = DAGE360
+EDATE = EDATO
+EOMONTH = SLUT.PÅ.MÅNED
+HOUR = TIME
+ISOWEEKNUM = ISOUGE.NR
+MINUTE = MINUT
+MONTH = MÅNED
+NETWORKDAYS = ANTAL.ARBEJDSDAGE
+NETWORKDAYS.INTL = ANTAL.ARBEJDSDAGE.INTL
+NOW = NU
+SECOND = SEKUND
+THAIDAYOFWEEK = THAILANDSKUGEDAG
+THAIMONTHOFYEAR = THAILANDSKMÅNED
+THAIYEAR = THAILANDSKÅR
+TIME = TID
+TIMEVALUE = TIDSVÆRDI
+TODAY = IDAG
+WEEKDAY = UGEDAG
+WEEKNUM = UGE.NR
+WORKDAY = ARBEJDSDAG
+WORKDAY.INTL = ARBEJDSDAG.INTL
+YEAR = ÅR
+YEARFRAC = ÅR.BRØK
+
+##
+## Tekniske funktioner (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN.TIL.DEC
+BIN2HEX = BIN.TIL.HEX
+BIN2OCT = BIN.TIL.OKT
+BITAND = BITOG
+BITLSHIFT = BITLSKIFT
+BITOR = BITELLER
+BITRSHIFT = BITRSKIFT
+BITXOR = BITXELLER
+COMPLEX = KOMPLEKS
+CONVERT = KONVERTER
+DEC2BIN = DEC.TIL.BIN
+DEC2HEX = DEC.TIL.HEX
+DEC2OCT = DEC.TIL.OKT
+DELTA = DELTA
+ERF = FEJLFUNK
+ERF.PRECISE = ERF.PRECISE
+ERFC = FEJLFUNK.KOMP
+ERFC.PRECISE = ERFC.PRECISE
+GESTEP = GETRIN
+HEX2BIN = HEX.TIL.BIN
+HEX2DEC = HEX.TIL.DEC
+HEX2OCT = HEX.TIL.OKT
+IMABS = IMAGABS
+IMAGINARY = IMAGINÆR
+IMARGUMENT = IMAGARGUMENT
+IMCONJUGATE = IMAGKONJUGERE
+IMCOS = IMAGCOS
+IMCOSH = IMAGCOSH
+IMCOT = IMAGCOT
+IMCSC = IMAGCSC
+IMCSCH = IMAGCSCH
+IMDIV = IMAGDIV
+IMEXP = IMAGEKSP
+IMLN = IMAGLN
+IMLOG10 = IMAGLOG10
+IMLOG2 = IMAGLOG2
+IMPOWER = IMAGPOTENS
+IMPRODUCT = IMAGPRODUKT
+IMREAL = IMAGREELT
+IMSEC = IMAGSEC
+IMSECH = IMAGSECH
+IMSIN = IMAGSIN
+IMSINH = IMAGSINH
+IMSQRT = IMAGKVROD
+IMSUB = IMAGSUB
+IMSUM = IMAGSUM
+IMTAN = IMAGTAN
+OCT2BIN = OKT.TIL.BIN
+OCT2DEC = OKT.TIL.DEC
+OCT2HEX = OKT.TIL.HEX
+
+##
+## Finansielle funktioner (Financial Functions)
+##
+ACCRINT = PÅLØBRENTE
+ACCRINTM = PÅLØBRENTE.UDLØB
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = KUPONDAGE.SA
+COUPDAYS = KUPONDAGE.A
+COUPDAYSNC = KUPONDAGE.ANK
+COUPNCD = KUPONDAG.NÆSTE
+COUPNUM = KUPONBETALINGER
+COUPPCD = KUPONDAG.FORRIGE
+CUMIPMT = AKKUM.RENTE
+CUMPRINC = AKKUM.HOVEDSTOL
+DB = DB
+DDB = DSA
+DISC = DISKONTO
+DOLLARDE = KR.DECIMAL
+DOLLARFR = KR.BRØK
+DURATION = VARIGHED
+EFFECT = EFFEKTIV.RENTE
+FV = FV
+FVSCHEDULE = FVTABEL
+INTRATE = RENTEFOD
+IPMT = R.YDELSE
+IRR = IA
+ISPMT = ISPMT
+MDURATION = MVARIGHED
+MIRR = MIA
+NOMINAL = NOMINEL
+NPER = NPER
+NPV = NUTIDSVÆRDI
+ODDFPRICE = ULIGE.KURS.PÅLYDENDE
+ODDFYIELD = ULIGE.FØRSTE.AFKAST
+ODDLPRICE = ULIGE.SIDSTE.KURS
+ODDLYIELD = ULIGE.SIDSTE.AFKAST
+PDURATION = PVARIGHED
+PMT = YDELSE
+PPMT = H.YDELSE
+PRICE = KURS
+PRICEDISC = KURS.DISKONTO
+PRICEMAT = KURS.UDLØB
+PV = NV
+RATE = RENTE
+RECEIVED = MODTAGET.VED.UDLØB
+RRI = RRI
+SLN = LA
+SYD = ÅRSAFSKRIVNING
+TBILLEQ = STATSOBLIGATION
+TBILLPRICE = STATSOBLIGATION.KURS
+TBILLYIELD = STATSOBLIGATION.AFKAST
+VDB = VSA
+XIRR = INTERN.RENTE
+XNPV = NETTO.NUTIDSVÆRDI
+YIELD = AFKAST
+YIELDDISC = AFKAST.DISKONTO
+YIELDMAT = AFKAST.UDLØBSDATO
+
+##
+## Informationsfunktioner (Information Functions)
+##
+CELL = CELLE
+ERROR.TYPE = FEJLTYPE
+INFO = INFO
+ISBLANK = ER.TOM
+ISERR = ER.FJL
+ISERROR = ER.FEJL
+ISEVEN = ER.LIGE
+ISFORMULA = ER.FORMEL
+ISLOGICAL = ER.LOGISK
+ISNA = ER.IKKE.TILGÆNGELIG
+ISNONTEXT = ER.IKKE.TEKST
+ISNUMBER = ER.TAL
+ISODD = ER.ULIGE
+ISREF = ER.REFERENCE
+ISTEXT = ER.TEKST
+N = TAL
+NA = IKKE.TILGÆNGELIG
+SHEET = ARK
+SHEETS = ARK.FLERE
+TYPE = VÆRDITYPE
+
+##
+## Logiske funktioner (Logical Functions)
+##
+AND = OG
+FALSE = FALSK
+IF = HVIS
+IFERROR = HVIS.FEJL
+IFNA = HVISIT
+IFS = HVISER
+NOT = IKKE
+OR = ELLER
+SWITCH = SKIFT
+TRUE = SAND
+XOR = XELLER
+
+##
+## Opslags- og referencefunktioner (Lookup & Reference Functions)
+##
+ADDRESS = ADRESSE
+AREAS = OMRÅDER
+CHOOSE = VÆLG
+COLUMN = KOLONNE
+COLUMNS = KOLONNER
+FORMULATEXT = FORMELTEKST
+GETPIVOTDATA = GETPIVOTDATA
+HLOOKUP = VOPSLAG
+HYPERLINK = HYPERLINK
+INDEX = INDEKS
+INDIRECT = INDIREKTE
+LOOKUP = SLÅ.OP
+MATCH = SAMMENLIGN
+OFFSET = FORSKYDNING
+ROW = RÆKKE
+ROWS = RÆKKER
+RTD = RTD
+TRANSPOSE = TRANSPONER
+VLOOKUP = LOPSLAG
+
+##
+## Matematiske og trigonometriske funktioner (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ARCCOSH
+ACOT = ARCCOT
+ACOTH = ARCCOTH
+AGGREGATE = SAMLING
+ARABIC = ARABISK
+ASIN = ARCSIN
+ASINH = ARCSINH
+ATAN = ARCTAN
+ATAN2 = ARCTAN2
+ATANH = ARCTANH
+BASE = BASIS
+CEILING.MATH = LOFT.MAT
+CEILING.PRECISE = LOFT.PRECISE
+COMBIN = KOMBIN
+COMBINA = KOMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMAL
+DEGREES = GRADER
+ECMA.CEILING = ECMA.LOFT
+EVEN = LIGE
+EXP = EKSP
+FACT = FAKULTET
+FACTDOUBLE = DOBBELT.FAKULTET
+FLOOR.MATH = AFRUND.BUND.MAT
+FLOOR.PRECISE = AFRUND.GULV.PRECISE
+GCD = STØRSTE.FÆLLES.DIVISOR
+INT = HELTAL
+ISO.CEILING = ISO.LOFT
+LCM = MINDSTE.FÆLLES.MULTIPLUM
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = MINVERT
+MMULT = MPRODUKT
+MOD = REST
+MROUND = MAFRUND
+MULTINOMIAL = MULTINOMIAL
+MUNIT = MENHED
+ODD = ULIGE
+PI = PI
+POWER = POTENS
+PRODUCT = PRODUKT
+QUOTIENT = KVOTIENT
+RADIANS = RADIANER
+RAND = SLUMP
+RANDBETWEEN = SLUMPMELLEM
+ROMAN = ROMERTAL
+ROUND = AFRUND
+ROUNDBAHTDOWN = RUNDBAHTNED
+ROUNDBAHTUP = RUNDBAHTOP
+ROUNDDOWN = RUND.NED
+ROUNDUP = RUND.OP
+SEC = SEC
+SECH = SECH
+SERIESSUM = SERIESUM
+SIGN = FORTEGN
+SIN = SIN
+SINH = SINH
+SQRT = KVROD
+SQRTPI = KVRODPI
+SUBTOTAL = SUBTOTAL
+SUM = SUM
+SUMIF = SUM.HVIS
+SUMIFS = SUM.HVISER
+SUMPRODUCT = SUMPRODUKT
+SUMSQ = SUMKV
+SUMX2MY2 = SUMX2MY2
+SUMX2PY2 = SUMX2PY2
+SUMXMY2 = SUMXMY2
+TAN = TAN
+TANH = TANH
+TRUNC = AFKORT
+
+##
+## Statistiske funktioner (Statistical Functions)
+##
+AVEDEV = MAD
+AVERAGE = MIDDEL
+AVERAGEA = MIDDELV
+AVERAGEIF = MIDDEL.HVIS
+AVERAGEIFS = MIDDEL.HVISER
+BETA.DIST = BETA.FORDELING
+BETA.INV = BETA.INV
+BINOM.DIST = BINOMIAL.FORDELING
+BINOM.DIST.RANGE = BINOMIAL.DIST.INTERVAL
+BINOM.INV = BINOMIAL.INV
+CHISQ.DIST = CHI2.FORDELING
+CHISQ.DIST.RT = CHI2.FORD.RT
+CHISQ.INV = CHI2.INV
+CHISQ.INV.RT = CHI2.INV.RT
+CHISQ.TEST = CHI2.TEST
+CONFIDENCE.NORM = KONFIDENS.NORM
+CONFIDENCE.T = KONFIDENST
+CORREL = KORRELATION
+COUNT = TÆL
+COUNTA = TÆLV
+COUNTBLANK = ANTAL.BLANKE
+COUNTIF = TÆL.HVIS
+COUNTIFS = TÆL.HVISER
+COVARIANCE.P = KOVARIANS.P
+COVARIANCE.S = KOVARIANS.S
+DEVSQ = SAK
+EXPON.DIST = EKSP.FORDELING
+F.DIST = F.FORDELING
+F.DIST.RT = F.FORDELING.RT
+F.INV = F.INV
+F.INV.RT = F.INV.RT
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PROGNOSE.ETS
+FORECAST.ETS.CONFINT = PROGNOSE.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PROGNOSE.ETS.SÆSONUDSVING
+FORECAST.ETS.STAT = PROGNOSE.ETS.STAT
+FORECAST.LINEAR = PROGNOSE.LINEÆR
+FREQUENCY = FREKVENS
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.FORDELING
+GAMMA.INV = GAMMA.INV
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.PRECISE
+GAUSS = GAUSS
+GEOMEAN = GEOMIDDELVÆRDI
+GROWTH = FORØGELSE
+HARMEAN = HARMIDDELVÆRDI
+HYPGEOM.DIST = HYPGEO.FORDELING
+INTERCEPT = SKÆRING
+KURT = TOPSTEJL
+LARGE = STØRSTE
+LINEST = LINREGR
+LOGEST = LOGREGR
+LOGNORM.DIST = LOGNORM.FORDELING
+LOGNORM.INV = LOGNORM.INV
+MAX = MAKS
+MAXA = MAKSV
+MAXIFS = MAKSHVISER
+MEDIAN = MEDIAN
+MIN = MIN
+MINA = MINV
+MINIFS = MINHVISER
+MODE.MULT = HYPPIGST.FLERE
+MODE.SNGL = HYPPIGST.ENKELT
+NEGBINOM.DIST = NEGBINOM.FORDELING
+NORM.DIST = NORMAL.FORDELING
+NORM.INV = NORM.INV
+NORM.S.DIST = STANDARD.NORM.FORDELING
+NORM.S.INV = STANDARD.NORM.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = FRAKTIL.UDELAD
+PERCENTILE.INC = FRAKTIL.MEDTAG
+PERCENTRANK.EXC = PROCENTPLADS.UDELAD
+PERCENTRANK.INC = PROCENTPLADS.MEDTAG
+PERMUT = PERMUT
+PERMUTATIONA = PERMUTATIONA
+PHI = PHI
+POISSON.DIST = POISSON.FORDELING
+PROB = SANDSYNLIGHED
+QUARTILE.EXC = KVARTIL.UDELAD
+QUARTILE.INC = KVARTIL.MEDTAG
+RANK.AVG = PLADS.GNSN
+RANK.EQ = PLADS.LIGE
+RSQ = FORKLARINGSGRAD
+SKEW = SKÆVHED
+SKEW.P = SKÆVHED.P
+SLOPE = STIGNING
+SMALL = MINDSTE
+STANDARDIZE = STANDARDISER
+STDEV.P = STDAFV.P
+STDEV.S = STDAFV.S
+STDEVA = STDAFVV
+STDEVPA = STDAFVPV
+STEYX = STFYX
+T.DIST = T.FORDELING
+T.DIST.2T = T.FORDELING.2T
+T.DIST.RT = T.FORDELING.RT
+T.INV = T.INV
+T.INV.2T = T.INV.2T
+T.TEST = T.TEST
+TREND = TENDENS
+TRIMMEAN = TRIMMIDDELVÆRDI
+VAR.P = VARIANS.P
+VAR.S = VARIANS.S
+VARA = VARIANSV
+VARPA = VARIANSPV
+WEIBULL.DIST = WEIBULL.FORDELING
+Z.TEST = Z.TEST
+
+##
+## Tekstfunktioner (Text Functions)
+##
+BAHTTEXT = BAHTTEKST
+CHAR = TEGN
+CLEAN = RENS
+CODE = KODE
+CONCAT = CONCAT
+DOLLAR = KR
+EXACT = EKSAKT
+FIND = FIND
+FIXED = FAST
+ISTHAIDIGIT = ERTHAILANDSKCIFFER
+LEFT = VENSTRE
+LEN = LÆNGDE
+LOWER = SMÅ.BOGSTAVER
+MID = MIDT
+NUMBERSTRING = TALSTRENG
+NUMBERVALUE = TALVÆRDI
+PHONETIC = FONETISK
+PROPER = STORT.FORBOGSTAV
+REPLACE = ERSTAT
+REPT = GENTAG
+RIGHT = HØJRE
+SEARCH = SØG
+SUBSTITUTE = UDSKIFT
+T = T
+TEXT = TEKST
+TEXTJOIN = TEKST.KOMBINER
+THAIDIGIT = THAILANDSKCIFFER
+THAINUMSOUND = THAILANDSKNUMLYD
+THAINUMSTRING = THAILANDSKNUMSTRENG
+THAISTRINGLENGTH = THAILANDSKSTRENGLÆNGDE
+TRIM = FJERN.OVERFLØDIGE.BLANKE
+UNICHAR = UNICHAR
+UNICODE = UNICODE
+UPPER = STORE.BOGSTAVER
+VALUE = VÆRDI
+
+##
+## Webfunktioner (Web Functions)
+##
+ENCODEURL = KODNINGSURL
+FILTERXML = FILTRERXML
+WEBSERVICE = WEBTJENESTE
+
+##
+## Kompatibilitetsfunktioner (Compatibility Functions)
+##
+BETADIST = BETAFORDELING
+BETAINV = BETAINV
+BINOMDIST = BINOMIALFORDELING
+CEILING = AFRUND.LOFT
+CHIDIST = CHIFORDELING
+CHIINV = CHIINV
+CHITEST = CHITEST
+CONCATENATE = SAMMENKÆDNING
+CONFIDENCE = KONFIDENSINTERVAL
+COVAR = KOVARIANS
+CRITBINOM = KRITBINOM
+EXPONDIST = EKSPFORDELING
+FDIST = FFORDELING
+FINV = FINV
+FLOOR = AFRUND.GULV
+FORECAST = PROGNOSE
+FTEST = FTEST
+GAMMADIST = GAMMAFORDELING
+GAMMAINV = GAMMAINV
+HYPGEOMDIST = HYPGEOFORDELING
+LOGINV = LOGINV
+LOGNORMDIST = LOGNORMFORDELING
+MODE = HYPPIGST
+NEGBINOMDIST = NEGBINOMFORDELING
+NORMDIST = NORMFORDELING
+NORMINV = NORMINV
+NORMSDIST = STANDARDNORMFORDELING
+NORMSINV = STANDARDNORMINV
+PERCENTILE = FRAKTIL
+PERCENTRANK = PROCENTPLADS
+POISSON = POISSON
+QUARTILE = KVARTIL
+RANK = PLADS
+STDEV = STDAFV
+STDEVP = STDAFVP
+TDIST = TFORDELING
+TINV = TINV
+TTEST = TTEST
+VAR = VARIANS
+VARP = VARIANSP
+WEIBULL = WEIBULL
+ZTEST = ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/de/functions

@@ -0,0 +1,533 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Deutsch (German)
+##
+############################################################
+
+
+##
+## Cubefunktionen (Cube Functions)
+##
+CUBEKPIMEMBER = CUBEKPIELEMENT
+CUBEMEMBER = CUBEELEMENT
+CUBEMEMBERPROPERTY = CUBEELEMENTEIGENSCHAFT
+CUBERANKEDMEMBER = CUBERANGELEMENT
+CUBESET = CUBEMENGE
+CUBESETCOUNT = CUBEMENGENANZAHL
+CUBEVALUE = CUBEWERT
+
+##
+## Datenbankfunktionen (Database Functions)
+##
+DAVERAGE = DBMITTELWERT
+DCOUNT = DBANZAHL
+DCOUNTA = DBANZAHL2
+DGET = DBAUSZUG
+DMAX = DBMAX
+DMIN = DBMIN
+DPRODUCT = DBPRODUKT
+DSTDEV = DBSTDABW
+DSTDEVP = DBSTDABWN
+DSUM = DBSUMME
+DVAR = DBVARIANZ
+DVARP = DBVARIANZEN
+
+##
+## Datums- und Uhrzeitfunktionen (Date & Time Functions)
+##
+DATE = DATUM
+DATEVALUE = DATWERT
+DAY = TAG
+DAYS = TAGE
+DAYS360 = TAGE360
+EDATE = EDATUM
+EOMONTH = MONATSENDE
+HOUR = STUNDE
+ISOWEEKNUM = ISOKALENDERWOCHE
+MINUTE = MINUTE
+MONTH = MONAT
+NETWORKDAYS = NETTOARBEITSTAGE
+NETWORKDAYS.INTL = NETTOARBEITSTAGE.INTL
+NOW = JETZT
+SECOND = SEKUNDE
+THAIDAYOFWEEK = THAIWOCHENTAG
+THAIMONTHOFYEAR = THAIMONATDESJAHRES
+THAIYEAR = THAIJAHR
+TIME = ZEIT
+TIMEVALUE = ZEITWERT
+TODAY = HEUTE
+WEEKDAY = WOCHENTAG
+WEEKNUM = KALENDERWOCHE
+WORKDAY = ARBEITSTAG
+WORKDAY.INTL = ARBEITSTAG.INTL
+YEAR = JAHR
+YEARFRAC = BRTEILJAHRE
+
+##
+## Technische Funktionen (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BININDEZ
+BIN2HEX = BININHEX
+BIN2OCT = BININOKT
+BITAND = BITUND
+BITLSHIFT = BITLVERSCHIEB
+BITOR = BITODER
+BITRSHIFT = BITRVERSCHIEB
+BITXOR = BITXODER
+COMPLEX = KOMPLEXE
+CONVERT = UMWANDELN
+DEC2BIN = DEZINBIN
+DEC2HEX = DEZINHEX
+DEC2OCT = DEZINOKT
+DELTA = DELTA
+ERF = GAUSSFEHLER
+ERF.PRECISE = GAUSSF.GENAU
+ERFC = GAUSSFKOMPL
+ERFC.PRECISE = GAUSSFKOMPL.GENAU
+GESTEP = GGANZZAHL
+HEX2BIN = HEXINBIN
+HEX2DEC = HEXINDEZ
+HEX2OCT = HEXINOKT
+IMABS = IMABS
+IMAGINARY = IMAGINÄRTEIL
+IMARGUMENT = IMARGUMENT
+IMCONJUGATE = IMKONJUGIERTE
+IMCOS = IMCOS
+IMCOSH = IMCOSHYP
+IMCOT = IMCOT
+IMCSC = IMCOSEC
+IMCSCH = IMCOSECHYP
+IMDIV = IMDIV
+IMEXP = IMEXP
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMAPOTENZ
+IMPRODUCT = IMPRODUKT
+IMREAL = IMREALTEIL
+IMSEC = IMSEC
+IMSECH = IMSECHYP
+IMSIN = IMSIN
+IMSINH = IMSINHYP
+IMSQRT = IMWURZEL
+IMSUB = IMSUB
+IMSUM = IMSUMME
+IMTAN = IMTAN
+OCT2BIN = OKTINBIN
+OCT2DEC = OKTINDEZ
+OCT2HEX = OKTINHEX
+
+##
+## Finanzmathematische Funktionen (Financial Functions)
+##
+ACCRINT = AUFGELZINS
+ACCRINTM = AUFGELZINSF
+AMORDEGRC = AMORDEGRK
+AMORLINC = AMORLINEARK
+COUPDAYBS = ZINSTERMTAGVA
+COUPDAYS = ZINSTERMTAGE
+COUPDAYSNC = ZINSTERMTAGNZ
+COUPNCD = ZINSTERMNZ
+COUPNUM = ZINSTERMZAHL
+COUPPCD = ZINSTERMVZ
+CUMIPMT = KUMZINSZ
+CUMPRINC = KUMKAPITAL
+DB = GDA2
+DDB = GDA
+DISC = DISAGIO
+DOLLARDE = NOTIERUNGDEZ
+DOLLARFR = NOTIERUNGBRU
+DURATION = DURATION
+EFFECT = EFFEKTIV
+FV = ZW
+FVSCHEDULE = ZW2
+INTRATE = ZINSSATZ
+IPMT = ZINSZ
+IRR = IKV
+ISPMT = ISPMT
+MDURATION = MDURATION
+MIRR = QIKV
+NOMINAL = NOMINAL
+NPER = ZZR
+NPV = NBW
+ODDFPRICE = UNREGER.KURS
+ODDFYIELD = UNREGER.REND
+ODDLPRICE = UNREGLE.KURS
+ODDLYIELD = UNREGLE.REND
+PDURATION = PDURATION
+PMT = RMZ
+PPMT = KAPZ
+PRICE = KURS
+PRICEDISC = KURSDISAGIO
+PRICEMAT = KURSFÄLLIG
+PV = BW
+RATE = ZINS
+RECEIVED = AUSZAHLUNG
+RRI = ZSATZINVEST
+SLN = LIA
+SYD = DIA
+TBILLEQ = TBILLÄQUIV
+TBILLPRICE = TBILLKURS
+TBILLYIELD = TBILLRENDITE
+VDB = VDB
+XIRR = XINTZINSFUSS
+XNPV = XKAPITALWERT
+YIELD = RENDITE
+YIELDDISC = RENDITEDIS
+YIELDMAT = RENDITEFÄLL
+
+##
+## Informationsfunktionen (Information Functions)
+##
+CELL = ZELLE
+ERROR.TYPE = FEHLER.TYP
+INFO = INFO
+ISBLANK = ISTLEER
+ISERR = ISTFEHL
+ISERROR = ISTFEHLER
+ISEVEN = ISTGERADE
+ISFORMULA = ISTFORMEL
+ISLOGICAL = ISTLOG
+ISNA = ISTNV
+ISNONTEXT = ISTKTEXT
+ISNUMBER = ISTZAHL
+ISODD = ISTUNGERADE
+ISREF = ISTBEZUG
+ISTEXT = ISTTEXT
+N = N
+NA = NV
+SHEET = BLATT
+SHEETS = BLÄTTER
+TYPE = TYP
+
+##
+## Logische Funktionen (Logical Functions)
+##
+AND = UND
+FALSE = FALSCH
+IF = WENN
+IFERROR = WENNFEHLER
+IFNA = WENNNV
+IFS = WENNS
+NOT = NICHT
+OR = ODER
+SWITCH = ERSTERWERT
+TRUE = WAHR
+XOR = XODER
+
+##
+## Nachschlage- und Verweisfunktionen (Lookup & Reference Functions)
+##
+ADDRESS = ADRESSE
+AREAS = BEREICHE
+CHOOSE = WAHL
+COLUMN = SPALTE
+COLUMNS = SPALTEN
+FORMULATEXT = FORMELTEXT
+GETPIVOTDATA = PIVOTDATENZUORDNEN
+HLOOKUP = WVERWEIS
+HYPERLINK = HYPERLINK
+INDEX = INDEX
+INDIRECT = INDIREKT
+LOOKUP = VERWEIS
+MATCH = VERGLEICH
+OFFSET = BEREICH.VERSCHIEBEN
+ROW = ZEILE
+ROWS = ZEILEN
+RTD = RTD
+TRANSPOSE = MTRANS
+VLOOKUP = SVERWEIS
+
+##
+## Mathematische und trigonometrische Funktionen (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ARCCOSHYP
+ACOT = ARCCOT
+ACOTH = ARCCOTHYP
+AGGREGATE = AGGREGAT
+ARABIC = ARABISCH
+ASIN = ARCSIN
+ASINH = ARCSINHYP
+ATAN = ARCTAN
+ATAN2 = ARCTAN2
+ATANH = ARCTANHYP
+BASE = BASIS
+CEILING.MATH = OBERGRENZE.MATHEMATIK
+CEILING.PRECISE = OBERGRENZE.GENAU
+COMBIN = KOMBINATIONEN
+COMBINA = KOMBINATIONEN2
+COS = COS
+COSH = COSHYP
+COT = COT
+COTH = COTHYP
+CSC = COSEC
+CSCH = COSECHYP
+DECIMAL = DEZIMAL
+DEGREES = GRAD
+ECMA.CEILING = ECMA.OBERGRENZE
+EVEN = GERADE
+EXP = EXP
+FACT = FAKULTÄT
+FACTDOUBLE = ZWEIFAKULTÄT
+FLOOR.MATH = UNTERGRENZE.MATHEMATIK
+FLOOR.PRECISE = UNTERGRENZE.GENAU
+GCD = GGT
+INT = GANZZAHL
+ISO.CEILING = ISO.OBERGRENZE
+LCM = KGV
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDET
+MINVERSE = MINV
+MMULT = MMULT
+MOD = REST
+MROUND = VRUNDEN
+MULTINOMIAL = POLYNOMIAL
+MUNIT = MEINHEIT
+ODD = UNGERADE
+PI = PI
+POWER = POTENZ
+PRODUCT = PRODUKT
+QUOTIENT = QUOTIENT
+RADIANS = BOGENMASS
+RAND = ZUFALLSZAHL
+RANDBETWEEN = ZUFALLSBEREICH
+ROMAN = RÖMISCH
+ROUND = RUNDEN
+ROUNDBAHTDOWN = RUNDBAHTNED
+ROUNDBAHTUP = BAHTAUFRUNDEN
+ROUNDDOWN = ABRUNDEN
+ROUNDUP = AUFRUNDEN
+SEC = SEC
+SECH = SECHYP
+SERIESSUM = POTENZREIHE
+SIGN = VORZEICHEN
+SIN = SIN
+SINH = SINHYP
+SQRT = WURZEL
+SQRTPI = WURZELPI
+SUBTOTAL = TEILERGEBNIS
+SUM = SUMME
+SUMIF = SUMMEWENN
+SUMIFS = SUMMEWENNS
+SUMPRODUCT = SUMMENPRODUKT
+SUMSQ = QUADRATESUMME
+SUMX2MY2 = SUMMEX2MY2
+SUMX2PY2 = SUMMEX2PY2
+SUMXMY2 = SUMMEXMY2
+TAN = TAN
+TANH = TANHYP
+TRUNC = KÜRZEN
+
+##
+## Statistische Funktionen (Statistical Functions)
+##
+AVEDEV = MITTELABW
+AVERAGE = MITTELWERT
+AVERAGEA = MITTELWERTA
+AVERAGEIF = MITTELWERTWENN
+AVERAGEIFS = MITTELWERTWENNS
+BETA.DIST = BETA.VERT
+BETA.INV = BETA.INV
+BINOM.DIST = BINOM.VERT
+BINOM.DIST.RANGE = BINOM.VERT.BEREICH
+BINOM.INV = BINOM.INV
+CHISQ.DIST = CHIQU.VERT
+CHISQ.DIST.RT = CHIQU.VERT.RE
+CHISQ.INV = CHIQU.INV
+CHISQ.INV.RT = CHIQU.INV.RE
+CHISQ.TEST = CHIQU.TEST
+CONFIDENCE.NORM = KONFIDENZ.NORM
+CONFIDENCE.T = KONFIDENZ.T
+CORREL = KORREL
+COUNT = ANZAHL
+COUNTA = ANZAHL2
+COUNTBLANK = ANZAHLLEEREZELLEN
+COUNTIF = ZÄHLENWENN
+COUNTIFS = ZÄHLENWENNS
+COVARIANCE.P = KOVARIANZ.P
+COVARIANCE.S = KOVARIANZ.S
+DEVSQ = SUMQUADABW
+EXPON.DIST = EXPON.VERT
+F.DIST = F.VERT
+F.DIST.RT = F.VERT.RE
+F.INV = F.INV
+F.INV.RT = F.INV.RE
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PROGNOSE.ETS
+FORECAST.ETS.CONFINT = PROGNOSE.ETS.KONFINT
+FORECAST.ETS.SEASONALITY = PROGNOSE.ETS.SAISONALITÄT
+FORECAST.ETS.STAT = PROGNOSE.ETS.STAT
+FORECAST.LINEAR = PROGNOSE.LINEAR
+FREQUENCY = HÄUFIGKEIT
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.VERT
+GAMMA.INV = GAMMA.INV
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.GENAU
+GAUSS = GAUSS
+GEOMEAN = GEOMITTEL
+GROWTH = VARIATION
+HARMEAN = HARMITTEL
+HYPGEOM.DIST = HYPGEOM.VERT
+INTERCEPT = ACHSENABSCHNITT
+KURT = KURT
+LARGE = KGRÖSSTE
+LINEST = RGP
+LOGEST = RKP
+LOGNORM.DIST = LOGNORM.VERT
+LOGNORM.INV = LOGNORM.INV
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAXWENNS
+MEDIAN = MEDIAN
+MIN = MIN
+MINA = MINA
+MINIFS = MINWENNS
+MODE.MULT = MODUS.VIELF
+MODE.SNGL = MODUS.EINF
+NEGBINOM.DIST = NEGBINOM.VERT
+NORM.DIST = NORM.VERT
+NORM.INV = NORM.INV
+NORM.S.DIST = NORM.S.VERT
+NORM.S.INV = NORM.S.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = QUANTIL.EXKL
+PERCENTILE.INC = QUANTIL.INKL
+PERCENTRANK.EXC = QUANTILSRANG.EXKL
+PERCENTRANK.INC = QUANTILSRANG.INKL
+PERMUT = VARIATIONEN
+PERMUTATIONA = VARIATIONEN2
+PHI = PHI
+POISSON.DIST = POISSON.VERT
+PROB = WAHRSCHBEREICH
+QUARTILE.EXC = QUARTILE.EXKL
+QUARTILE.INC = QUARTILE.INKL
+RANK.AVG = RANG.MITTELW
+RANK.EQ = RANG.GLEICH
+RSQ = BESTIMMTHEITSMASS
+SKEW = SCHIEFE
+SKEW.P = SCHIEFE.P
+SLOPE = STEIGUNG
+SMALL = KKLEINSTE
+STANDARDIZE = STANDARDISIERUNG
+STDEV.P = STABW.N
+STDEV.S = STABW.S
+STDEVA = STABWA
+STDEVPA = STABWNA
+STEYX = STFEHLERYX
+T.DIST = T.VERT
+T.DIST.2T = T.VERT.2S
+T.DIST.RT = T.VERT.RE
+T.INV = T.INV
+T.INV.2T = T.INV.2S
+T.TEST = T.TEST
+TREND = TREND
+TRIMMEAN = GESTUTZTMITTEL
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARIANZA
+VARPA = VARIANZENA
+WEIBULL.DIST = WEIBULL.VERT
+Z.TEST = G.TEST
+
+##
+## Textfunktionen (Text Functions)
+##
+BAHTTEXT = BAHTTEXT
+CHAR = ZEICHEN
+CLEAN = SÄUBERN
+CODE = CODE
+CONCAT = TEXTKETTE
+DOLLAR = DM
+EXACT = IDENTISCH
+FIND = FINDEN
+FIXED = FEST
+ISTHAIDIGIT = ISTTHAIZAHLENWORT
+LEFT = LINKS
+LEN = LÄNGE
+LOWER = KLEIN
+MID = TEIL
+NUMBERVALUE = ZAHLENWERT
+PROPER = GROSS2
+REPLACE = ERSETZEN
+REPT = WIEDERHOLEN
+RIGHT = RECHTS
+SEARCH = SUCHEN
+SUBSTITUTE = WECHSELN
+T = T
+TEXT = TEXT
+TEXTJOIN = TEXTVERKETTEN
+THAIDIGIT = THAIZAHLENWORT
+THAINUMSOUND = THAIZAHLSOUND
+THAINUMSTRING = THAILANDSKNUMSTRENG
+THAISTRINGLENGTH = THAIZEICHENFOLGENLÄNGE
+TRIM = GLÄTTEN
+UNICHAR = UNIZEICHEN
+UNICODE = UNICODE
+UPPER = GROSS
+VALUE = WERT
+
+##
+## Webfunktionen (Web Functions)
+##
+ENCODEURL = URLCODIEREN
+FILTERXML = XMLFILTERN
+WEBSERVICE = WEBDIENST
+
+##
+## Kompatibilitätsfunktionen (Compatibility Functions)
+##
+BETADIST = BETAVERT
+BETAINV = BETAINV
+BINOMDIST = BINOMVERT
+CEILING = OBERGRENZE
+CHIDIST = CHIVERT
+CHIINV = CHIINV
+CHITEST = CHITEST
+CONCATENATE = VERKETTEN
+CONFIDENCE = KONFIDENZ
+COVAR = KOVAR
+CRITBINOM = KRITBINOM
+EXPONDIST = EXPONVERT
+FDIST = FVERT
+FINV = FINV
+FLOOR = UNTERGRENZE
+FORECAST = SCHÄTZER
+FTEST = FTEST
+GAMMADIST = GAMMAVERT
+GAMMAINV = GAMMAINV
+HYPGEOMDIST = HYPGEOMVERT
+LOGINV = LOGINV
+LOGNORMDIST = LOGNORMVERT
+MODE = MODALWERT
+NEGBINOMDIST = NEGBINOMVERT
+NORMDIST = NORMVERT
+NORMINV = NORMINV
+NORMSDIST = STANDNORMVERT
+NORMSINV = STANDNORMINV
+PERCENTILE = QUANTIL
+PERCENTRANK = QUANTILSRANG
+POISSON = POISSON
+QUARTILE = QUARTILE
+RANK = RANG
+STDEV = STABW
+STDEVP = STABWN
+TDIST = TVERT
+TINV = TINV
+TTEST = TTEST
+VAR = VARIANZ
+VARP = VARIANZEN
+WEIBULL = WEIBULL
+ZTEST = GTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/es/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Español (Spanish)
+##
+############################################################
+
+
+##
+## Funciones de cubo (Cube Functions)
+##
+CUBEKPIMEMBER = MIEMBROKPICUBO
+CUBEMEMBER = MIEMBROCUBO
+CUBEMEMBERPROPERTY = PROPIEDADMIEMBROCUBO
+CUBERANKEDMEMBER = MIEMBRORANGOCUBO
+CUBESET = CONJUNTOCUBO
+CUBESETCOUNT = RECUENTOCONJUNTOCUBO
+CUBEVALUE = VALORCUBO
+
+##
+## Funciones de base de datos (Database Functions)
+##
+DAVERAGE = BDPROMEDIO
+DCOUNT = BDCONTAR
+DCOUNTA = BDCONTARA
+DGET = BDEXTRAER
+DMAX = BDMAX
+DMIN = BDMIN
+DPRODUCT = BDPRODUCTO
+DSTDEV = BDDESVEST
+DSTDEVP = BDDESVESTP
+DSUM = BDSUMA
+DVAR = BDVAR
+DVARP = BDVARP
+
+##
+## Funciones de fecha y hora (Date & Time Functions)
+##
+DATE = FECHA
+DATEDIF = SIFECHA
+DATESTRING = CADENA.FECHA
+DATEVALUE = FECHANUMERO
+DAY = DIA
+DAYS = DIAS
+DAYS360 = DIAS360
+EDATE = FECHA.MES
+EOMONTH = FIN.MES
+HOUR = HORA
+ISOWEEKNUM = ISO.NUM.DE.SEMANA
+MINUTE = MINUTO
+MONTH = MES
+NETWORKDAYS = DIAS.LAB
+NETWORKDAYS.INTL = DIAS.LAB.INTL
+NOW = AHORA
+SECOND = SEGUNDO
+THAIDAYOFWEEK = DIASEMTAI
+THAIMONTHOFYEAR = MESAÑOTAI
+THAIYEAR = AÑOTAI
+TIME = NSHORA
+TIMEVALUE = HORANUMERO
+TODAY = HOY
+WEEKDAY = DIASEM
+WEEKNUM = NUM.DE.SEMANA
+WORKDAY = DIA.LAB
+WORKDAY.INTL = DIA.LAB.INTL
+YEAR = AÑO
+YEARFRAC = FRAC.AÑO
+
+##
+## Funciones de ingeniería (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN.A.DEC
+BIN2HEX = BIN.A.HEX
+BIN2OCT = BIN.A.OCT
+BITAND = BIT.Y
+BITLSHIFT = BIT.DESPLIZQDA
+BITOR = BIT.O
+BITRSHIFT = BIT.DESPLDCHA
+BITXOR = BIT.XO
+COMPLEX = COMPLEJO
+CONVERT = CONVERTIR
+DEC2BIN = DEC.A.BIN
+DEC2HEX = DEC.A.HEX
+DEC2OCT = DEC.A.OCT
+DELTA = DELTA
+ERF = FUN.ERROR
+ERF.PRECISE = FUN.ERROR.EXACTO
+ERFC = FUN.ERROR.COMPL
+ERFC.PRECISE = FUN.ERROR.COMPL.EXACTO
+GESTEP = MAYOR.O.IGUAL
+HEX2BIN = HEX.A.BIN
+HEX2DEC = HEX.A.DEC
+HEX2OCT = HEX.A.OCT
+IMABS = IM.ABS
+IMAGINARY = IMAGINARIO
+IMARGUMENT = IM.ANGULO
+IMCONJUGATE = IM.CONJUGADA
+IMCOS = IM.COS
+IMCOSH = IM.COSH
+IMCOT = IM.COT
+IMCSC = IM.CSC
+IMCSCH = IM.CSCH
+IMDIV = IM.DIV
+IMEXP = IM.EXP
+IMLN = IM.LN
+IMLOG10 = IM.LOG10
+IMLOG2 = IM.LOG2
+IMPOWER = IM.POT
+IMPRODUCT = IM.PRODUCT
+IMREAL = IM.REAL
+IMSEC = IM.SEC
+IMSECH = IM.SECH
+IMSIN = IM.SENO
+IMSINH = IM.SENOH
+IMSQRT = IM.RAIZ2
+IMSUB = IM.SUSTR
+IMSUM = IM.SUM
+IMTAN = IM.TAN
+OCT2BIN = OCT.A.BIN
+OCT2DEC = OCT.A.DEC
+OCT2HEX = OCT.A.HEX
+
+##
+## Funciones financieras (Financial Functions)
+##
+ACCRINT = INT.ACUM
+ACCRINTM = INT.ACUM.V
+AMORDEGRC = AMORTIZ.PROGRE
+AMORLINC = AMORTIZ.LIN
+COUPDAYBS = CUPON.DIAS.L1
+COUPDAYS = CUPON.DIAS
+COUPDAYSNC = CUPON.DIAS.L2
+COUPNCD = CUPON.FECHA.L2
+COUPNUM = CUPON.NUM
+COUPPCD = CUPON.FECHA.L1
+CUMIPMT = PAGO.INT.ENTRE
+CUMPRINC = PAGO.PRINC.ENTRE
+DB = DB
+DDB = DDB
+DISC = TASA.DESC
+DOLLARDE = MONEDA.DEC
+DOLLARFR = MONEDA.FRAC
+DURATION = DURACION
+EFFECT = INT.EFECTIVO
+FV = VF
+FVSCHEDULE = VF.PLAN
+INTRATE = TASA.INT
+IPMT = PAGOINT
+IRR = TIR
+ISPMT = INT.PAGO.DIR
+MDURATION = DURACION.MODIF
+MIRR = TIRM
+NOMINAL = TASA.NOMINAL
+NPER = NPER
+NPV = VNA
+ODDFPRICE = PRECIO.PER.IRREGULAR.1
+ODDFYIELD = RENDTO.PER.IRREGULAR.1
+ODDLPRICE = PRECIO.PER.IRREGULAR.2
+ODDLYIELD = RENDTO.PER.IRREGULAR.2
+PDURATION = P.DURACION
+PMT = PAGO
+PPMT = PAGOPRIN
+PRICE = PRECIO
+PRICEDISC = PRECIO.DESCUENTO
+PRICEMAT = PRECIO.VENCIMIENTO
+PV = VA
+RATE = TASA
+RECEIVED = CANTIDAD.RECIBIDA
+RRI = RRI
+SLN = SLN
+SYD = SYD
+TBILLEQ = LETRA.DE.TEST.EQV.A.BONO
+TBILLPRICE = LETRA.DE.TES.PRECIO
+TBILLYIELD = LETRA.DE.TES.RENDTO
+VDB = DVS
+XIRR = TIR.NO.PER
+XNPV = VNA.NO.PER
+YIELD = RENDTO
+YIELDDISC = RENDTO.DESC
+YIELDMAT = RENDTO.VENCTO
+
+##
+## Funciones de información (Information Functions)
+##
+CELL = CELDA
+ERROR.TYPE = TIPO.DE.ERROR
+INFO = INFO
+ISBLANK = ESBLANCO
+ISERR = ESERR
+ISERROR = ESERROR
+ISEVEN = ES.PAR
+ISFORMULA = ESFORMULA
+ISLOGICAL = ESLOGICO
+ISNA = ESNOD
+ISNONTEXT = ESNOTEXTO
+ISNUMBER = ESNUMERO
+ISODD = ES.IMPAR
+ISREF = ESREF
+ISTEXT = ESTEXTO
+N = N
+NA = NOD
+SHEET = HOJA
+SHEETS = HOJAS
+TYPE = TIPO
+
+##
+## Funciones lógicas (Logical Functions)
+##
+AND = Y
+FALSE = FALSO
+IF = SI
+IFERROR = SI.ERROR
+IFNA = SI.ND
+IFS = SI.CONJUNTO
+NOT = NO
+OR = O
+SWITCH = CAMBIAR
+TRUE = VERDADERO
+XOR = XO
+
+##
+## Funciones de búsqueda y referencia (Lookup & Reference Functions)
+##
+ADDRESS = DIRECCION
+AREAS = AREAS
+CHOOSE = ELEGIR
+COLUMN = COLUMNA
+COLUMNS = COLUMNAS
+FORMULATEXT = FORMULATEXTO
+GETPIVOTDATA = IMPORTARDATOSDINAMICOS
+HLOOKUP = BUSCARH
+HYPERLINK = HIPERVINCULO
+INDEX = INDICE
+INDIRECT = INDIRECTO
+LOOKUP = BUSCAR
+MATCH = COINCIDIR
+OFFSET = DESREF
+ROW = FILA
+ROWS = FILAS
+RTD = RDTR
+TRANSPOSE = TRANSPONER
+VLOOKUP = BUSCARV
+
+##
+## Funciones matemáticas y trigonométricas (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGREGAR
+ARABIC = NUMERO.ARABE
+ASIN = ASENO
+ASINH = ASENOH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = BASE
+CEILING.MATH = MULTIPLO.SUPERIOR.MAT
+CEILING.PRECISE = MULTIPLO.SUPERIOR.EXACTO
+COMBIN = COMBINAT
+COMBINA = COMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = CONV.DECIMAL
+DEGREES = GRADOS
+ECMA.CEILING = MULTIPLO.SUPERIOR.ECMA
+EVEN = REDONDEA.PAR
+EXP = EXP
+FACT = FACT
+FACTDOUBLE = FACT.DOBLE
+FLOOR.MATH = MULTIPLO.INFERIOR.MAT
+FLOOR.PRECISE = MULTIPLO.INFERIOR.EXACTO
+GCD = M.C.D
+INT = ENTERO
+ISO.CEILING = MULTIPLO.SUPERIOR.ISO
+LCM = M.C.M
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = MINVERSA
+MMULT = MMULT
+MOD = RESIDUO
+MROUND = REDOND.MULT
+MULTINOMIAL = MULTINOMIAL
+MUNIT = M.UNIDAD
+ODD = REDONDEA.IMPAR
+PI = PI
+POWER = POTENCIA
+PRODUCT = PRODUCTO
+QUOTIENT = COCIENTE
+RADIANS = RADIANES
+RAND = ALEATORIO
+RANDBETWEEN = ALEATORIO.ENTRE
+ROMAN = NUMERO.ROMANO
+ROUND = REDONDEAR
+ROUNDBAHTDOWN = REDONDEAR.BAHT.MAS
+ROUNDBAHTUP = REDONDEAR.BAHT.MENOS
+ROUNDDOWN = REDONDEAR.MENOS
+ROUNDUP = REDONDEAR.MAS
+SEC = SEC
+SECH = SECH
+SERIESSUM = SUMA.SERIES
+SIGN = SIGNO
+SIN = SENO
+SINH = SENOH
+SQRT = RAIZ
+SQRTPI = RAIZ2PI
+SUBTOTAL = SUBTOTALES
+SUM = SUMA
+SUMIF = SUMAR.SI
+SUMIFS = SUMAR.SI.CONJUNTO
+SUMPRODUCT = SUMAPRODUCTO
+SUMSQ = SUMA.CUADRADOS
+SUMX2MY2 = SUMAX2MENOSY2
+SUMX2PY2 = SUMAX2MASY2
+SUMXMY2 = SUMAXMENOSY2
+TAN = TAN
+TANH = TANH
+TRUNC = TRUNCAR
+
+##
+## Funciones estadísticas (Statistical Functions)
+##
+AVEDEV = DESVPROM
+AVERAGE = PROMEDIO
+AVERAGEA = PROMEDIOA
+AVERAGEIF = PROMEDIO.SI
+AVERAGEIFS = PROMEDIO.SI.CONJUNTO
+BETA.DIST = DISTR.BETA.N
+BETA.INV = INV.BETA.N
+BINOM.DIST = DISTR.BINOM.N
+BINOM.DIST.RANGE = DISTR.BINOM.SERIE
+BINOM.INV = INV.BINOM
+CHISQ.DIST = DISTR.CHICUAD
+CHISQ.DIST.RT = DISTR.CHICUAD.CD
+CHISQ.INV = INV.CHICUAD
+CHISQ.INV.RT = INV.CHICUAD.CD
+CHISQ.TEST = PRUEBA.CHICUAD
+CONFIDENCE.NORM = INTERVALO.CONFIANZA.NORM
+CONFIDENCE.T = INTERVALO.CONFIANZA.T
+CORREL = COEF.DE.CORREL
+COUNT = CONTAR
+COUNTA = CONTARA
+COUNTBLANK = CONTAR.BLANCO
+COUNTIF = CONTAR.SI
+COUNTIFS = CONTAR.SI.CONJUNTO
+COVARIANCE.P = COVARIANCE.P
+COVARIANCE.S = COVARIANZA.M
+DEVSQ = DESVIA2
+EXPON.DIST = DISTR.EXP.N
+F.DIST = DISTR.F.N
+F.DIST.RT = DISTR.F.CD
+F.INV = INV.F
+F.INV.RT = INV.F.CD
+F.TEST = PRUEBA.F.N
+FISHER = FISHER
+FISHERINV = PRUEBA.FISHER.INV
+FORECAST.ETS = PRONOSTICO.ETS
+FORECAST.ETS.CONFINT = PRONOSTICO.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PRONOSTICO.ETS.ESTACIONALIDAD
+FORECAST.ETS.STAT = PRONOSTICO.ETS.STAT
+FORECAST.LINEAR = PRONOSTICO.LINEAL
+FREQUENCY = FRECUENCIA
+GAMMA = GAMMA
+GAMMA.DIST = DISTR.GAMMA.N
+GAMMA.INV = INV.GAMMA
+GAMMALN = GAMMA.LN
+GAMMALN.PRECISE = GAMMA.LN.EXACTO
+GAUSS = GAUSS
+GEOMEAN = MEDIA.GEOM
+GROWTH = CRECIMIENTO
+HARMEAN = MEDIA.ARMO
+HYPGEOM.DIST = DISTR.HIPERGEOM.N
+INTERCEPT = INTERSECCION.EJE
+KURT = CURTOSIS
+LARGE = K.ESIMO.MAYOR
+LINEST = ESTIMACION.LINEAL
+LOGEST = ESTIMACION.LOGARITMICA
+LOGNORM.DIST = DISTR.LOGNORM
+LOGNORM.INV = INV.LOGNORM
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAX.SI.CONJUNTO
+MEDIAN = MEDIANA
+MIN = MIN
+MINA = MINA
+MINIFS = MIN.SI.CONJUNTO
+MODE.MULT = MODA.VARIOS
+MODE.SNGL = MODA.UNO
+NEGBINOM.DIST = NEGBINOM.DIST
+NORM.DIST = DISTR.NORM.N
+NORM.INV = INV.NORM
+NORM.S.DIST = DISTR.NORM.ESTAND.N
+NORM.S.INV = INV.NORM.ESTAND
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIL.EXC
+PERCENTILE.INC = PERCENTIL.INC
+PERCENTRANK.EXC = RANGO.PERCENTIL.EXC
+PERCENTRANK.INC = RANGO.PERCENTIL.INC
+PERMUT = PERMUTACIONES
+PERMUTATIONA = PERMUTACIONES.A
+PHI = FI
+POISSON.DIST = POISSON.DIST
+PROB = PROBABILIDAD
+QUARTILE.EXC = CUARTIL.EXC
+QUARTILE.INC = CUARTIL.INC
+RANK.AVG = JERARQUIA.MEDIA
+RANK.EQ = JERARQUIA.EQV
+RSQ = COEFICIENTE.R2
+SKEW = COEFICIENTE.ASIMETRIA
+SKEW.P = COEFICIENTE.ASIMETRIA.P
+SLOPE = PENDIENTE
+SMALL = K.ESIMO.MENOR
+STANDARDIZE = NORMALIZACION
+STDEV.P = DESVEST.P
+STDEV.S = DESVEST.M
+STDEVA = DESVESTA
+STDEVPA = DESVESTPA
+STEYX = ERROR.TIPICO.XY
+T.DIST = DISTR.T.N
+T.DIST.2T = DISTR.T.2C
+T.DIST.RT = DISTR.T.CD
+T.INV = INV.T
+T.INV.2T = INV.T.2C
+T.TEST = PRUEBA.T.N
+TREND = TENDENCIA
+TRIMMEAN = MEDIA.ACOTADA
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = DISTR.WEIBULL
+Z.TEST = PRUEBA.Z.N
+
+##
+## Funciones de texto (Text Functions)
+##
+BAHTTEXT = TEXTOBAHT
+CHAR = CARACTER
+CLEAN = LIMPIAR
+CODE = CODIGO
+CONCAT = CONCAT
+DOLLAR = MONEDA
+EXACT = IGUAL
+FIND = ENCONTRAR
+FIXED = DECIMAL
+ISTHAIDIGIT = ESDIGITOTAI
+LEFT = IZQUIERDA
+LEN = LARGO
+LOWER = MINUSC
+MID = EXTRAE
+NUMBERSTRING = CADENA.NUMERO
+NUMBERVALUE = VALOR.NUMERO
+PHONETIC = FONETICO
+PROPER = NOMPROPIO
+REPLACE = REEMPLAZAR
+REPT = REPETIR
+RIGHT = DERECHA
+SEARCH = HALLAR
+SUBSTITUTE = SUSTITUIR
+T = T
+TEXT = TEXTO
+TEXTJOIN = UNIRCADENAS
+THAIDIGIT = DIGITOTAI
+THAINUMSOUND = SONNUMTAI
+THAINUMSTRING = CADENANUMTAI
+THAISTRINGLENGTH = LONGCADENATAI
+TRIM = ESPACIOS
+UNICHAR = UNICAR
+UNICODE = UNICODE
+UPPER = MAYUSC
+VALUE = VALOR
+
+##
+## Funciones web (Web Functions)
+##
+ENCODEURL = URLCODIF
+FILTERXML = XMLFILTRO
+WEBSERVICE = SERVICIOWEB
+
+##
+## Funciones de compatibilidad (Compatibility Functions)
+##
+BETADIST = DISTR.BETA
+BETAINV = DISTR.BETA.INV
+BINOMDIST = DISTR.BINOM
+CEILING = MULTIPLO.SUPERIOR
+CHIDIST = DISTR.CHI
+CHIINV = PRUEBA.CHI.INV
+CHITEST = PRUEBA.CHI
+CONCATENATE = CONCATENAR
+CONFIDENCE = INTERVALO.CONFIANZA
+COVAR = COVAR
+CRITBINOM = BINOM.CRIT
+EXPONDIST = DISTR.EXP
+FDIST = DISTR.F
+FINV = DISTR.F.INV
+FLOOR = MULTIPLO.INFERIOR
+FORECAST = PRONOSTICO
+FTEST = PRUEBA.F
+GAMMADIST = DISTR.GAMMA
+GAMMAINV = DISTR.GAMMA.INV
+HYPGEOMDIST = DISTR.HIPERGEOM
+LOGINV = DISTR.LOG.INV
+LOGNORMDIST = DISTR.LOG.NORM
+MODE = MODA
+NEGBINOMDIST = NEGBINOMDIST
+NORMDIST = DISTR.NORM
+NORMINV = DISTR.NORM.INV
+NORMSDIST = DISTR.NORM.ESTAND
+NORMSINV = DISTR.NORM.ESTAND.INV
+PERCENTILE = PERCENTIL
+PERCENTRANK = RANGO.PERCENTIL
+POISSON = POISSON
+QUARTILE = CUARTIL
+RANK = JERARQUIA
+STDEV = DESVEST
+STDEVP = DESVESTP
+TDIST = DISTR.T
+TINV = DISTR.T.INV
+TTEST = PRUEBA.T
+VAR = VAR
+VARP = VARP
+WEIBULL = DIST.WEIBULL
+ZTEST = PRUEBA.Z

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/fi/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Suomi (Finnish)
+##
+############################################################
+
+
+##
+## Kuutiofunktiot (Cube Functions)
+##
+CUBEKPIMEMBER = KUUTIOKPIJÄSEN
+CUBEMEMBER = KUUTIONJÄSEN
+CUBEMEMBERPROPERTY = KUUTIONJÄSENENOMINAISUUS
+CUBERANKEDMEMBER = KUUTIONLUOKITELTUJÄSEN
+CUBESET = KUUTIOJOUKKO
+CUBESETCOUNT = KUUTIOJOUKKOJENMÄÄRÄ
+CUBEVALUE = KUUTIONARVO
+
+##
+## Tietokantafunktiot (Database Functions)
+##
+DAVERAGE = TKESKIARVO
+DCOUNT = TLASKE
+DCOUNTA = TLASKEA
+DGET = TNOUDA
+DMAX = TMAKS
+DMIN = TMIN
+DPRODUCT = TTULO
+DSTDEV = TKESKIHAJONTA
+DSTDEVP = TKESKIHAJONTAP
+DSUM = TSUMMA
+DVAR = TVARIANSSI
+DVARP = TVARIANSSIP
+
+##
+## Päivämäärä- ja aikafunktiot (Date & Time Functions)
+##
+DATE = PÄIVÄYS
+DATEDIF = PVMERO
+DATESTRING = PVMMERKKIJONO
+DATEVALUE = PÄIVÄYSARVO
+DAY = PÄIVÄ
+DAYS = PÄIVÄT
+DAYS360 = PÄIVÄT360
+EDATE = PÄIVÄ.KUUKAUSI
+EOMONTH = KUUKAUSI.LOPPU
+HOUR = TUNNIT
+ISOWEEKNUM = VIIKKO.ISO.NRO
+MINUTE = MINUUTIT
+MONTH = KUUKAUSI
+NETWORKDAYS = TYÖPÄIVÄT
+NETWORKDAYS.INTL = TYÖPÄIVÄT.KANSVÄL
+NOW = NYT
+SECOND = SEKUNNIT
+THAIDAYOFWEEK = THAI.VIIKONPÄIVÄ
+THAIMONTHOFYEAR = THAI.KUUKAUSI
+THAIYEAR = THAI.VUOSI
+TIME = AIKA
+TIMEVALUE = AIKA_ARVO
+TODAY = TÄMÄ.PÄIVÄ
+WEEKDAY = VIIKONPÄIVÄ
+WEEKNUM = VIIKKO.NRO
+WORKDAY = TYÖPÄIVÄ
+WORKDAY.INTL = TYÖPÄIVÄ.KANSVÄL
+YEAR = VUOSI
+YEARFRAC = VUOSI.OSA
+
+##
+## Tekniset funktiot (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BINDES
+BIN2HEX = BINHEKSA
+BIN2OCT = BINOKT
+BITAND = BITTI.JA
+BITLSHIFT = BITTI.SIIRTO.V
+BITOR = BITTI.TAI
+BITRSHIFT = BITTI.SIIRTO.O
+BITXOR = BITTI.EHDOTON.TAI
+COMPLEX = KOMPLEKSI
+CONVERT = MUUNNA
+DEC2BIN = DESBIN
+DEC2HEX = DESHEKSA
+DEC2OCT = DESOKT
+DELTA = SAMA.ARVO
+ERF = VIRHEFUNKTIO
+ERF.PRECISE = VIRHEFUNKTIO.TARKKA
+ERFC = VIRHEFUNKTIO.KOMPLEMENTTI
+ERFC.PRECISE = VIRHEFUNKTIO.KOMPLEMENTTI.TARKKA
+GESTEP = RAJA
+HEX2BIN = HEKSABIN
+HEX2DEC = HEKSADES
+HEX2OCT = HEKSAOKT
+IMABS = KOMPLEKSI.ABS
+IMAGINARY = KOMPLEKSI.IMAG
+IMARGUMENT = KOMPLEKSI.ARG
+IMCONJUGATE = KOMPLEKSI.KONJ
+IMCOS = KOMPLEKSI.COS
+IMCOSH = IMCOSH
+IMCOT = KOMPLEKSI.COT
+IMCSC = KOMPLEKSI.KOSEK
+IMCSCH = KOMPLEKSI.KOSEKH
+IMDIV = KOMPLEKSI.OSAM
+IMEXP = KOMPLEKSI.EKSP
+IMLN = KOMPLEKSI.LN
+IMLOG10 = KOMPLEKSI.LOG10
+IMLOG2 = KOMPLEKSI.LOG2
+IMPOWER = KOMPLEKSI.POT
+IMPRODUCT = KOMPLEKSI.TULO
+IMREAL = KOMPLEKSI.REAALI
+IMSEC = KOMPLEKSI.SEK
+IMSECH = KOMPLEKSI.SEKH
+IMSIN = KOMPLEKSI.SIN
+IMSINH = KOMPLEKSI.SINH
+IMSQRT = KOMPLEKSI.NELIÖJ
+IMSUB = KOMPLEKSI.EROTUS
+IMSUM = KOMPLEKSI.SUM
+IMTAN = KOMPLEKSI.TAN
+OCT2BIN = OKTBIN
+OCT2DEC = OKTDES
+OCT2HEX = OKTHEKSA
+
+##
+## Rahoitusfunktiot (Financial Functions)
+##
+ACCRINT = KERTYNYT.KORKO
+ACCRINTM = KERTYNYT.KORKO.LOPUSSA
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = KORKOPÄIVÄT.ALUSTA
+COUPDAYS = KORKOPÄIVÄT
+COUPDAYSNC = KORKOPÄIVÄT.SEURAAVA
+COUPNCD = KORKOPÄIVÄ.SEURAAVA
+COUPNUM = KORKOPÄIVÄ.JAKSOT
+COUPPCD = KORKOPÄIVÄ.EDELLINEN
+CUMIPMT = MAKSETTU.KORKO
+CUMPRINC = MAKSETTU.LYHENNYS
+DB = DB
+DDB = DDB
+DISC = DISKONTTOKORKO
+DOLLARDE = VALUUTTA.DES
+DOLLARFR = VALUUTTA.MURTO
+DURATION = KESTO
+EFFECT = KORKO.EFEKT
+FV = TULEVA.ARVO
+FVSCHEDULE = TULEVA.ARVO.ERIKORKO
+INTRATE = KORKO.ARVOPAPERI
+IPMT = IPMT
+IRR = SISÄINEN.KORKO
+ISPMT = ISPMT
+MDURATION = KESTO.MUUNN
+MIRR = MSISÄINEN
+NOMINAL = KORKO.VUOSI
+NPER = NJAKSO
+NPV = NNA
+ODDFPRICE = PARITON.ENS.NIMELLISARVO
+ODDFYIELD = PARITON.ENS.TUOTTO
+ODDLPRICE = PARITON.VIIM.NIMELLISARVO
+ODDLYIELD = PARITON.VIIM.TUOTTO
+PDURATION = KESTO.JAKSO
+PMT = MAKSU
+PPMT = PPMT
+PRICE = HINTA
+PRICEDISC = HINTA.DISK
+PRICEMAT = HINTA.LUNASTUS
+PV = NA
+RATE = KORKO
+RECEIVED = SAATU.HINTA
+RRI = TOT.ROI
+SLN = STP
+SYD = VUOSIPOISTO
+TBILLEQ = OBLIG.TUOTTOPROS
+TBILLPRICE = OBLIG.HINTA
+TBILLYIELD = OBLIG.TUOTTO
+VDB = VDB
+XIRR = SISÄINEN.KORKO.JAKSOTON
+XNPV = NNA.JAKSOTON
+YIELD = TUOTTO
+YIELDDISC = TUOTTO.DISK
+YIELDMAT = TUOTTO.ERÄP
+
+##
+## Tietofunktiot (Information Functions)
+##
+CELL = SOLU
+ERROR.TYPE = VIRHEEN.LAJI
+INFO = KUVAUS
+ISBLANK = ONTYHJÄ
+ISERR = ONVIRH
+ISERROR = ONVIRHE
+ISEVEN = ONPARILLINEN
+ISFORMULA = ONKAAVA
+ISLOGICAL = ONTOTUUS
+ISNA = ONPUUTTUU
+ISNONTEXT = ONEI_TEKSTI
+ISNUMBER = ONLUKU
+ISODD = ONPARITON
+ISREF = ONVIITT
+ISTEXT = ONTEKSTI
+N = N
+NA = PUUTTUU
+SHEET = TAULUKKO
+SHEETS = TAULUKOT
+TYPE = TYYPPI
+
+##
+## Loogiset funktiot (Logical Functions)
+##
+AND = JA
+FALSE = EPÄTOSI
+IF = JOS
+IFERROR = JOSVIRHE
+IFNA = JOSPUUTTUU
+IFS = JOSS
+NOT = EI
+OR = TAI
+SWITCH = MUUTA
+TRUE = TOSI
+XOR = EHDOTON.TAI
+
+##
+## Haku- ja viitefunktiot (Lookup & Reference Functions)
+##
+ADDRESS = OSOITE
+AREAS = ALUEET
+CHOOSE = VALITSE.INDEKSI
+COLUMN = SARAKE
+COLUMNS = SARAKKEET
+FORMULATEXT = KAAVA.TEKSTI
+GETPIVOTDATA = NOUDA.PIVOT.TIEDOT
+HLOOKUP = VHAKU
+HYPERLINK = HYPERLINKKI
+INDEX = INDEKSI
+INDIRECT = EPÄSUORA
+LOOKUP = HAKU
+MATCH = VASTINE
+OFFSET = SIIRTYMÄ
+ROW = RIVI
+ROWS = RIVIT
+RTD = RTD
+TRANSPOSE = TRANSPONOI
+VLOOKUP = PHAKU
+
+##
+## Matemaattiset ja trigonometriset funktiot (Math & Trig Functions)
+##
+ABS = ITSEISARVO
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = KOOSTE
+ARABIC = ARABIA
+ASIN = ASIN
+ASINH = ASINH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = PERUS
+CEILING.MATH = PYÖRISTÄ.KERR.YLÖS.MATEMAATTINEN
+CEILING.PRECISE = PYÖRISTÄ.KERR.YLÖS.TARKKA
+COMBIN = KOMBINAATIO
+COMBINA = KOMBINAATIOA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = KOSEK
+CSCH = KOSEKH
+DECIMAL = DESIMAALI
+DEGREES = ASTEET
+ECMA.CEILING = ECMA.PYÖRISTÄ.KERR.YLÖS
+EVEN = PARILLINEN
+EXP = EKSPONENTTI
+FACT = KERTOMA
+FACTDOUBLE = KERTOMA.OSA
+FLOOR.MATH = PYÖRISTÄ.KERR.ALAS.MATEMAATTINEN
+FLOOR.PRECISE = PYÖRISTÄ.KERR.ALAS.TARKKA
+GCD = SUURIN.YHT.TEKIJÄ
+INT = KOKONAISLUKU
+ISO.CEILING = ISO.PYÖRISTÄ.KERR.YLÖS
+LCM = PIENIN.YHT.JAETTAVA
+LN = LUONNLOG
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = MKÄÄNTEINEN
+MMULT = MKERRO
+MOD = JAKOJ
+MROUND = PYÖRISTÄ.KERR
+MULTINOMIAL = MULTINOMI
+MUNIT = YKSIKKÖM
+ODD = PARITON
+PI = PII
+POWER = POTENSSI
+PRODUCT = TULO
+QUOTIENT = OSAMÄÄRÄ
+RADIANS = RADIAANIT
+RAND = SATUNNAISLUKU
+RANDBETWEEN = SATUNNAISLUKU.VÄLILTÄ
+ROMAN = ROMAN
+ROUND = PYÖRISTÄ
+ROUNDBAHTDOWN = PYÖRISTÄ.BAHT.ALAS
+ROUNDBAHTUP = PYÖRISTÄ.BAHT.YLÖS
+ROUNDDOWN = PYÖRISTÄ.DES.ALAS
+ROUNDUP = PYÖRISTÄ.DES.YLÖS
+SEC = SEK
+SECH = SEKH
+SERIESSUM = SARJA.SUMMA
+SIGN = ETUMERKKI
+SIN = SIN
+SINH = SINH
+SQRT = NELIÖJUURI
+SQRTPI = NELIÖJUURI.PII
+SUBTOTAL = VÄLISUMMA
+SUM = SUMMA
+SUMIF = SUMMA.JOS
+SUMIFS = SUMMA.JOS.JOUKKO
+SUMPRODUCT = TULOJEN.SUMMA
+SUMSQ = NELIÖSUMMA
+SUMX2MY2 = NELIÖSUMMIEN.EROTUS
+SUMX2PY2 = NELIÖSUMMIEN.SUMMA
+SUMXMY2 = EROTUSTEN.NELIÖSUMMA
+TAN = TAN
+TANH = TANH
+TRUNC = KATKAISE
+
+##
+## Tilastolliset funktiot (Statistical Functions)
+##
+AVEDEV = KESKIPOIKKEAMA
+AVERAGE = KESKIARVO
+AVERAGEA = KESKIARVOA
+AVERAGEIF = KESKIARVO.JOS
+AVERAGEIFS = KESKIARVO.JOS.JOUKKO
+BETA.DIST = BEETA.JAKAUMA
+BETA.INV = BEETA.KÄÄNT
+BINOM.DIST = BINOMI.JAKAUMA
+BINOM.DIST.RANGE = BINOMI.JAKAUMA.ALUE
+BINOM.INV = BINOMIJAKAUMA.KÄÄNT
+CHISQ.DIST = CHINELIÖ.JAKAUMA
+CHISQ.DIST.RT = CHINELIÖ.JAKAUMA.OH
+CHISQ.INV = CHINELIÖ.KÄÄNT
+CHISQ.INV.RT = CHINELIÖ.KÄÄNT.OH
+CHISQ.TEST = CHINELIÖ.TESTI
+CONFIDENCE.NORM = LUOTTAMUSVÄLI.NORM
+CONFIDENCE.T = LUOTTAMUSVÄLI.T
+CORREL = KORRELAATIO
+COUNT = LASKE
+COUNTA = LASKE.A
+COUNTBLANK = LASKE.TYHJÄT
+COUNTIF = LASKE.JOS
+COUNTIFS = LASKE.JOS.JOUKKO
+COVARIANCE.P = KOVARIANSSI.P
+COVARIANCE.S = KOVARIANSSI.S
+DEVSQ = OIKAISTU.NELIÖSUMMA
+EXPON.DIST = EKSPONENTIAALI.JAKAUMA
+F.DIST = F.JAKAUMA
+F.DIST.RT = F.JAKAUMA.OH
+F.INV = F.KÄÄNT
+F.INV.RT = F.KÄÄNT.OH
+F.TEST = F.TESTI
+FISHER = FISHER
+FISHERINV = FISHER.KÄÄNT
+FORECAST.ETS = ENNUSTE.ETS
+FORECAST.ETS.CONFINT = ENNUSTE.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = ENNUSTE.ETS.KAUSIVAIHTELU
+FORECAST.ETS.STAT = ENNUSTE.ETS.STAT
+FORECAST.LINEAR = ENNUSTE.LINEAARINEN
+FREQUENCY = TAAJUUS
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.JAKAUMA
+GAMMA.INV = GAMMA.JAKAUMA.KÄÄNT
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.TARKKA
+GAUSS = GAUSS
+GEOMEAN = KESKIARVO.GEOM
+GROWTH = KASVU
+HARMEAN = KESKIARVO.HARM
+HYPGEOM.DIST = HYPERGEOM_JAKAUMA
+INTERCEPT = LEIKKAUSPISTE
+KURT = KURT
+LARGE = SUURI
+LINEST = LINREGR
+LOGEST = LOGREGR
+LOGNORM.DIST = LOGNORM_JAKAUMA
+LOGNORM.INV = LOGNORM.KÄÄNT
+MAX = MAKS
+MAXA = MAKSA
+MAXIFS = MAKS.JOS
+MEDIAN = MEDIAANI
+MIN = MIN
+MINA = MINA
+MINIFS = MIN.JOS
+MODE.MULT = MOODI.USEA
+MODE.SNGL = MOODI.YKSI
+NEGBINOM.DIST = BINOMI.JAKAUMA.NEG
+NORM.DIST = NORMAALI.JAKAUMA
+NORM.INV = NORMAALI.JAKAUMA.KÄÄNT
+NORM.S.DIST = NORM_JAKAUMA.NORMIT
+NORM.S.INV = NORM_JAKAUMA.KÄÄNT
+PEARSON = PEARSON
+PERCENTILE.EXC = PROSENTTIPISTE.ULK
+PERCENTILE.INC = PROSENTTIPISTE.SIS
+PERCENTRANK.EXC = PROSENTTIJÄRJESTYS.ULK
+PERCENTRANK.INC = PROSENTTIJÄRJESTYS.SIS
+PERMUT = PERMUTAATIO
+PERMUTATIONA = PERMUTAATIOA
+PHI = FII
+POISSON.DIST = POISSON.JAKAUMA
+PROB = TODENNÄKÖISYYS
+QUARTILE.EXC = NELJÄNNES.ULK
+QUARTILE.INC = NELJÄNNES.SIS
+RANK.AVG = ARVON.MUKAAN.KESKIARVO
+RANK.EQ = ARVON.MUKAAN.TASAN
+RSQ = PEARSON.NELIÖ
+SKEW = JAKAUMAN.VINOUS
+SKEW.P = JAKAUMAN.VINOUS.POP
+SLOPE = KULMAKERROIN
+SMALL = PIENI
+STANDARDIZE = NORMITA
+STDEV.P = KESKIHAJONTA.P
+STDEV.S = KESKIHAJONTA.S
+STDEVA = KESKIHAJONTAA
+STDEVPA = KESKIHAJONTAPA
+STEYX = KESKIVIRHE
+T.DIST = T.JAKAUMA
+T.DIST.2T = T.JAKAUMA.2S
+T.DIST.RT = T.JAKAUMA.OH
+T.INV = T.KÄÄNT
+T.INV.2T = T.KÄÄNT.2S
+T.TEST = T.TESTI
+TREND = SUUNTAUS
+TRIMMEAN = KESKIARVO.TASATTU
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = WEIBULL.JAKAUMA
+Z.TEST = Z.TESTI
+
+##
+## Tekstifunktiot (Text Functions)
+##
+BAHTTEXT = BAHTTEKSTI
+CHAR = MERKKI
+CLEAN = SIIVOA
+CODE = KOODI
+CONCAT = YHDISTÄ
+DOLLAR = VALUUTTA
+EXACT = VERTAA
+FIND = ETSI
+FIXED = KIINTEÄ
+ISTHAIDIGIT = ON.THAI.NUMERO
+LEFT = VASEN
+LEN = PITUUS
+LOWER = PIENET
+MID = POIMI.TEKSTI
+NUMBERSTRING = NROMERKKIJONO
+NUMBERVALUE = NROARVO
+PHONETIC = FONEETTINEN
+PROPER = ERISNIMI
+REPLACE = KORVAA
+REPT = TOISTA
+RIGHT = OIKEA
+SEARCH = KÄY.LÄPI
+SUBSTITUTE = VAIHDA
+T = T
+TEXT = TEKSTI
+TEXTJOIN = TEKSTI.YHDISTÄ
+THAIDIGIT = THAI.NUMERO
+THAINUMSOUND = THAI.LUKU.ÄÄNI
+THAINUMSTRING = THAI.LUKU.MERKKIJONO
+THAISTRINGLENGTH = THAI.MERKKIJONON.PITUUS
+TRIM = POISTA.VÄLIT
+UNICHAR = UNICODEMERKKI
+UNICODE = UNICODE
+UPPER = ISOT
+VALUE = ARVO
+
+##
+## Verkkofunktiot (Web Functions)
+##
+ENCODEURL = URLKOODAUS
+FILTERXML = SUODATA.XML
+WEBSERVICE = VERKKOPALVELU
+
+##
+## Yhteensopivuusfunktiot (Compatibility Functions)
+##
+BETADIST = BEETAJAKAUMA
+BETAINV = BEETAJAKAUMA.KÄÄNT
+BINOMDIST = BINOMIJAKAUMA
+CEILING = PYÖRISTÄ.KERR.YLÖS
+CHIDIST = CHIJAKAUMA
+CHIINV = CHIJAKAUMA.KÄÄNT
+CHITEST = CHITESTI
+CONCATENATE = KETJUTA
+CONFIDENCE = LUOTTAMUSVÄLI
+COVAR = KOVARIANSSI
+CRITBINOM = BINOMIJAKAUMA.KRIT
+EXPONDIST = EKSPONENTIAALIJAKAUMA
+FDIST = FJAKAUMA
+FINV = FJAKAUMA.KÄÄNT
+FLOOR = PYÖRISTÄ.KERR.ALAS
+FORECAST = ENNUSTE
+FTEST = FTESTI
+GAMMADIST = GAMMAJAKAUMA
+GAMMAINV = GAMMAJAKAUMA.KÄÄNT
+HYPGEOMDIST = HYPERGEOM.JAKAUMA
+LOGINV = LOGNORM.JAKAUMA.KÄÄNT
+LOGNORMDIST = LOGNORM.JAKAUMA
+MODE = MOODI
+NEGBINOMDIST = BINOMIJAKAUMA.NEG
+NORMDIST = NORM.JAKAUMA
+NORMINV = NORM.JAKAUMA.KÄÄNT
+NORMSDIST = NORM.JAKAUMA.NORMIT
+NORMSINV = NORM.JAKAUMA.NORMIT.KÄÄNT
+PERCENTILE = PROSENTTIPISTE
+PERCENTRANK = PROSENTTIJÄRJESTYS
+POISSON = POISSON
+QUARTILE = NELJÄNNES
+RANK = ARVON.MUKAAN
+STDEV = KESKIHAJONTA
+STDEVP = KESKIHAJONTAP
+TDIST = TJAKAUMA
+TINV = TJAKAUMA.KÄÄNT
+TTEST = TTESTI
+VAR = VAR
+VARP = VARP
+WEIBULL = WEIBULL
+ZTEST = ZTESTI

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/fr/functions

@@ -0,0 +1,524 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Français (French)
+##
+############################################################
+
+
+##
+## Fonctions Cube (Cube Functions)
+##
+CUBEKPIMEMBER = MEMBREKPICUBE
+CUBEMEMBER = MEMBRECUBE
+CUBEMEMBERPROPERTY = PROPRIETEMEMBRECUBE
+CUBERANKEDMEMBER = RANGMEMBRECUBE
+CUBESET = JEUCUBE
+CUBESETCOUNT = NBJEUCUBE
+CUBEVALUE = VALEURCUBE
+
+##
+## Fonctions de base de données (Database Functions)
+##
+DAVERAGE = BDMOYENNE
+DCOUNT = BDNB
+DCOUNTA = BDNBVAL
+DGET = BDLIRE
+DMAX = BDMAX
+DMIN = BDMIN
+DPRODUCT = BDPRODUIT
+DSTDEV = BDECARTYPE
+DSTDEVP = BDECARTYPEP
+DSUM = BDSOMME
+DVAR = BDVAR
+DVARP = BDVARP
+
+##
+## Fonctions de date et d’heure (Date & Time Functions)
+##
+DATE = DATE
+DATEVALUE = DATEVAL
+DAY = JOUR
+DAYS = JOURS
+DAYS360 = JOURS360
+EDATE = MOIS.DECALER
+EOMONTH = FIN.MOIS
+HOUR = HEURE
+ISOWEEKNUM = NO.SEMAINE.ISO
+MINUTE = MINUTE
+MONTH = MOIS
+NETWORKDAYS = NB.JOURS.OUVRES
+NETWORKDAYS.INTL = NB.JOURS.OUVRES.INTL
+NOW = MAINTENANT
+SECOND = SECONDE
+TIME = TEMPS
+TIMEVALUE = TEMPSVAL
+TODAY = AUJOURDHUI
+WEEKDAY = JOURSEM
+WEEKNUM = NO.SEMAINE
+WORKDAY = SERIE.JOUR.OUVRE
+WORKDAY.INTL = SERIE.JOUR.OUVRE.INTL
+YEAR = ANNEE
+YEARFRAC = FRACTION.ANNEE
+
+##
+## Fonctions d’ingénierie (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BINDEC
+BIN2HEX = BINHEX
+BIN2OCT = BINOCT
+BITAND = BITET
+BITLSHIFT = BITDECALG
+BITOR = BITOU
+BITRSHIFT = BITDECALD
+BITXOR = BITOUEXCLUSIF
+COMPLEX = COMPLEXE
+CONVERT = CONVERT
+DEC2BIN = DECBIN
+DEC2HEX = DECHEX
+DEC2OCT = DECOCT
+DELTA = DELTA
+ERF = ERF
+ERF.PRECISE = ERF.PRECIS
+ERFC = ERFC
+ERFC.PRECISE = ERFC.PRECIS
+GESTEP = SUP.SEUIL
+HEX2BIN = HEXBIN
+HEX2DEC = HEXDEC
+HEX2OCT = HEXOCT
+IMABS = COMPLEXE.MODULE
+IMAGINARY = COMPLEXE.IMAGINAIRE
+IMARGUMENT = COMPLEXE.ARGUMENT
+IMCONJUGATE = COMPLEXE.CONJUGUE
+IMCOS = COMPLEXE.COS
+IMCOSH = COMPLEXE.COSH
+IMCOT = COMPLEXE.COT
+IMCSC = COMPLEXE.CSC
+IMCSCH = COMPLEXE.CSCH
+IMDIV = COMPLEXE.DIV
+IMEXP = COMPLEXE.EXP
+IMLN = COMPLEXE.LN
+IMLOG10 = COMPLEXE.LOG10
+IMLOG2 = COMPLEXE.LOG2
+IMPOWER = COMPLEXE.PUISSANCE
+IMPRODUCT = COMPLEXE.PRODUIT
+IMREAL = COMPLEXE.REEL
+IMSEC = COMPLEXE.SEC
+IMSECH = COMPLEXE.SECH
+IMSIN = COMPLEXE.SIN
+IMSINH = COMPLEXE.SINH
+IMSQRT = COMPLEXE.RACINE
+IMSUB = COMPLEXE.DIFFERENCE
+IMSUM = COMPLEXE.SOMME
+IMTAN = COMPLEXE.TAN
+OCT2BIN = OCTBIN
+OCT2DEC = OCTDEC
+OCT2HEX = OCTHEX
+
+##
+## Fonctions financières (Financial Functions)
+##
+ACCRINT = INTERET.ACC
+ACCRINTM = INTERET.ACC.MAT
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = NB.JOURS.COUPON.PREC
+COUPDAYS = NB.JOURS.COUPONS
+COUPDAYSNC = NB.JOURS.COUPON.SUIV
+COUPNCD = DATE.COUPON.SUIV
+COUPNUM = NB.COUPONS
+COUPPCD = DATE.COUPON.PREC
+CUMIPMT = CUMUL.INTER
+CUMPRINC = CUMUL.PRINCPER
+DB = DB
+DDB = DDB
+DISC = TAUX.ESCOMPTE
+DOLLARDE = PRIX.DEC
+DOLLARFR = PRIX.FRAC
+DURATION = DUREE
+EFFECT = TAUX.EFFECTIF
+FV = VC
+FVSCHEDULE = VC.PAIEMENTS
+INTRATE = TAUX.INTERET
+IPMT = INTPER
+IRR = TRI
+ISPMT = ISPMT
+MDURATION = DUREE.MODIFIEE
+MIRR = TRIM
+NOMINAL = TAUX.NOMINAL
+NPER = NPM
+NPV = VAN
+ODDFPRICE = PRIX.PCOUPON.IRREG
+ODDFYIELD = REND.PCOUPON.IRREG
+ODDLPRICE = PRIX.DCOUPON.IRREG
+ODDLYIELD = REND.DCOUPON.IRREG
+PDURATION = PDUREE
+PMT = VPM
+PPMT = PRINCPER
+PRICE = PRIX.TITRE
+PRICEDISC = VALEUR.ENCAISSEMENT
+PRICEMAT = PRIX.TITRE.ECHEANCE
+PV = VA
+RATE = TAUX
+RECEIVED = VALEUR.NOMINALE
+RRI = TAUX.INT.EQUIV
+SLN = AMORLIN
+SYD = SYD
+TBILLEQ = TAUX.ESCOMPTE.R
+TBILLPRICE = PRIX.BON.TRESOR
+TBILLYIELD = RENDEMENT.BON.TRESOR
+VDB = VDB
+XIRR = TRI.PAIEMENTS
+XNPV = VAN.PAIEMENTS
+YIELD = RENDEMENT.TITRE
+YIELDDISC = RENDEMENT.SIMPLE
+YIELDMAT = RENDEMENT.TITRE.ECHEANCE
+
+##
+## Fonctions d’information (Information Functions)
+##
+CELL = CELLULE
+ERROR.TYPE = TYPE.ERREUR
+INFO = INFORMATIONS
+ISBLANK = ESTVIDE
+ISERR = ESTERR
+ISERROR = ESTERREUR
+ISEVEN = EST.PAIR
+ISFORMULA = ESTFORMULE
+ISLOGICAL = ESTLOGIQUE
+ISNA = ESTNA
+ISNONTEXT = ESTNONTEXTE
+ISNUMBER = ESTNUM
+ISODD = EST.IMPAIR
+ISREF = ESTREF
+ISTEXT = ESTTEXTE
+N = N
+NA = NA
+SHEET = FEUILLE
+SHEETS = FEUILLES
+TYPE = TYPE
+
+##
+## Fonctions logiques (Logical Functions)
+##
+AND = ET
+FALSE = FAUX
+IF = SI
+IFERROR = SIERREUR
+IFNA = SI.NON.DISP
+IFS = SI.CONDITIONS
+NOT = NON
+OR = OU
+SWITCH = SI.MULTIPLE
+TRUE = VRAI
+XOR = OUX
+
+##
+## Fonctions de recherche et de référence (Lookup & Reference Functions)
+##
+ADDRESS = ADRESSE
+AREAS = ZONES
+CHOOSE = CHOISIR
+COLUMN = COLONNE
+COLUMNS = COLONNES
+FORMULATEXT = FORMULETEXTE
+GETPIVOTDATA = LIREDONNEESTABCROISDYNAMIQUE
+HLOOKUP = RECHERCHEH
+HYPERLINK = LIEN_HYPERTEXTE
+INDEX = INDEX
+INDIRECT = INDIRECT
+LOOKUP = RECHERCHE
+MATCH = EQUIV
+OFFSET = DECALER
+ROW = LIGNE
+ROWS = LIGNES
+RTD = RTD
+TRANSPOSE = TRANSPOSE
+VLOOKUP = RECHERCHEV
+
+##
+## Fonctions mathématiques et trigonométriques (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGREGAT
+ARABIC = CHIFFRE.ARABE
+ASIN = ASIN
+ASINH = ASINH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = BASE
+CEILING.MATH = PLAFOND.MATH
+CEILING.PRECISE = PLAFOND.PRECIS
+COMBIN = COMBIN
+COMBINA = COMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMAL
+DEGREES = DEGRES
+ECMA.CEILING = ECMA.PLAFOND
+EVEN = PAIR
+EXP = EXP
+FACT = FACT
+FACTDOUBLE = FACTDOUBLE
+FLOOR.MATH = PLANCHER.MATH
+FLOOR.PRECISE = PLANCHER.PRECIS
+GCD = PGCD
+INT = ENT
+ISO.CEILING = ISO.PLAFOND
+LCM = PPCM
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = DETERMAT
+MINVERSE = INVERSEMAT
+MMULT = PRODUITMAT
+MOD = MOD
+MROUND = ARRONDI.AU.MULTIPLE
+MULTINOMIAL = MULTINOMIALE
+MUNIT = MATRICE.UNITAIRE
+ODD = IMPAIR
+PI = PI
+POWER = PUISSANCE
+PRODUCT = PRODUIT
+QUOTIENT = QUOTIENT
+RADIANS = RADIANS
+RAND = ALEA
+RANDBETWEEN = ALEA.ENTRE.BORNES
+ROMAN = ROMAIN
+ROUND = ARRONDI
+ROUNDDOWN = ARRONDI.INF
+ROUNDUP = ARRONDI.SUP
+SEC = SEC
+SECH = SECH
+SERIESSUM = SOMME.SERIES
+SIGN = SIGNE
+SIN = SIN
+SINH = SINH
+SQRT = RACINE
+SQRTPI = RACINE.PI
+SUBTOTAL = SOUS.TOTAL
+SUM = SOMME
+SUMIF = SOMME.SI
+SUMIFS = SOMME.SI.ENS
+SUMPRODUCT = SOMMEPROD
+SUMSQ = SOMME.CARRES
+SUMX2MY2 = SOMME.X2MY2
+SUMX2PY2 = SOMME.X2PY2
+SUMXMY2 = SOMME.XMY2
+TAN = TAN
+TANH = TANH
+TRUNC = TRONQUE
+
+##
+## Fonctions statistiques (Statistical Functions)
+##
+AVEDEV = ECART.MOYEN
+AVERAGE = MOYENNE
+AVERAGEA = AVERAGEA
+AVERAGEIF = MOYENNE.SI
+AVERAGEIFS = MOYENNE.SI.ENS
+BETA.DIST = LOI.BETA.N
+BETA.INV = BETA.INVERSE.N
+BINOM.DIST = LOI.BINOMIALE.N
+BINOM.DIST.RANGE = LOI.BINOMIALE.SERIE
+BINOM.INV = LOI.BINOMIALE.INVERSE
+CHISQ.DIST = LOI.KHIDEUX.N
+CHISQ.DIST.RT = LOI.KHIDEUX.DROITE
+CHISQ.INV = LOI.KHIDEUX.INVERSE
+CHISQ.INV.RT = LOI.KHIDEUX.INVERSE.DROITE
+CHISQ.TEST = CHISQ.TEST
+CONFIDENCE.NORM = INTERVALLE.CONFIANCE.NORMAL
+CONFIDENCE.T = INTERVALLE.CONFIANCE.STUDENT
+CORREL = COEFFICIENT.CORRELATION
+COUNT = NB
+COUNTA = NBVAL
+COUNTBLANK = NB.VIDE
+COUNTIF = NB.SI
+COUNTIFS = NB.SI.ENS
+COVARIANCE.P = COVARIANCE.PEARSON
+COVARIANCE.S = COVARIANCE.STANDARD
+DEVSQ = SOMME.CARRES.ECARTS
+EXPON.DIST = LOI.EXPONENTIELLE.N
+F.DIST = LOI.F.N
+F.DIST.RT = LOI.F.DROITE
+F.INV = INVERSE.LOI.F.N
+F.INV.RT = INVERSE.LOI.F.DROITE
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHER.INVERSE
+FORECAST.ETS = PREVISION.ETS
+FORECAST.ETS.CONFINT = PREVISION.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PREVISION.ETS.CARACTERESAISONNIER
+FORECAST.ETS.STAT = PREVISION.ETS.STAT
+FORECAST.LINEAR = PREVISION.LINEAIRE
+FREQUENCY = FREQUENCE
+GAMMA = GAMMA
+GAMMA.DIST = LOI.GAMMA.N
+GAMMA.INV = LOI.GAMMA.INVERSE.N
+GAMMALN = LNGAMMA
+GAMMALN.PRECISE = LNGAMMA.PRECIS
+GAUSS = GAUSS
+GEOMEAN = MOYENNE.GEOMETRIQUE
+GROWTH = CROISSANCE
+HARMEAN = MOYENNE.HARMONIQUE
+HYPGEOM.DIST = LOI.HYPERGEOMETRIQUE.N
+INTERCEPT = ORDONNEE.ORIGINE
+KURT = KURTOSIS
+LARGE = GRANDE.VALEUR
+LINEST = DROITEREG
+LOGEST = LOGREG
+LOGNORM.DIST = LOI.LOGNORMALE.N
+LOGNORM.INV = LOI.LOGNORMALE.INVERSE.N
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAX.SI
+MEDIAN = MEDIANE
+MIN = MIN
+MINA = MINA
+MINIFS = MIN.SI
+MODE.MULT = MODE.MULTIPLE
+MODE.SNGL = MODE.SIMPLE
+NEGBINOM.DIST = LOI.BINOMIALE.NEG.N
+NORM.DIST = LOI.NORMALE.N
+NORM.INV = LOI.NORMALE.INVERSE.N
+NORM.S.DIST = LOI.NORMALE.STANDARD.N
+NORM.S.INV = LOI.NORMALE.STANDARD.INVERSE.N
+PEARSON = PEARSON
+PERCENTILE.EXC = CENTILE.EXCLURE
+PERCENTILE.INC = CENTILE.INCLURE
+PERCENTRANK.EXC = RANG.POURCENTAGE.EXCLURE
+PERCENTRANK.INC = RANG.POURCENTAGE.INCLURE
+PERMUT = PERMUTATION
+PERMUTATIONA = PERMUTATIONA
+PHI = PHI
+POISSON.DIST = LOI.POISSON.N
+PROB = PROBABILITE
+QUARTILE.EXC = QUARTILE.EXCLURE
+QUARTILE.INC = QUARTILE.INCLURE
+RANK.AVG = MOYENNE.RANG
+RANK.EQ = EQUATION.RANG
+RSQ = COEFFICIENT.DETERMINATION
+SKEW = COEFFICIENT.ASYMETRIE
+SKEW.P = COEFFICIENT.ASYMETRIE.P
+SLOPE = PENTE
+SMALL = PETITE.VALEUR
+STANDARDIZE = CENTREE.REDUITE
+STDEV.P = ECARTYPE.PEARSON
+STDEV.S = ECARTYPE.STANDARD
+STDEVA = STDEVA
+STDEVPA = STDEVPA
+STEYX = ERREUR.TYPE.XY
+T.DIST = LOI.STUDENT.N
+T.DIST.2T = LOI.STUDENT.BILATERALE
+T.DIST.RT = LOI.STUDENT.DROITE
+T.INV = LOI.STUDENT.INVERSE.N
+T.INV.2T = LOI.STUDENT.INVERSE.BILATERALE
+T.TEST = T.TEST
+TREND = TENDANCE
+TRIMMEAN = MOYENNE.REDUITE
+VAR.P = VAR.P.N
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = LOI.WEIBULL.N
+Z.TEST = Z.TEST
+
+##
+## Fonctions de texte (Text Functions)
+##
+BAHTTEXT = BAHTTEXT
+CHAR = CAR
+CLEAN = EPURAGE
+CODE = CODE
+CONCAT = CONCAT
+DOLLAR = DEVISE
+EXACT = EXACT
+FIND = TROUVE
+FIXED = CTXT
+LEFT = GAUCHE
+LEN = NBCAR
+LOWER = MINUSCULE
+MID = STXT
+NUMBERVALUE = VALEURNOMBRE
+PHONETIC = PHONETIQUE
+PROPER = NOMPROPRE
+REPLACE = REMPLACER
+REPT = REPT
+RIGHT = DROITE
+SEARCH = CHERCHE
+SUBSTITUTE = SUBSTITUE
+T = T
+TEXT = TEXTE
+TEXTJOIN = JOINDRE.TEXTE
+TRIM = SUPPRESPACE
+UNICHAR = UNICAR
+UNICODE = UNICODE
+UPPER = MAJUSCULE
+VALUE = CNUM
+
+##
+## Fonctions web (Web Functions)
+##
+ENCODEURL = URLENCODAGE
+FILTERXML = FILTRE.XML
+WEBSERVICE = SERVICEWEB
+
+##
+## Fonctions de compatibilité (Compatibility Functions)
+##
+BETADIST = LOI.BETA
+BETAINV = BETA.INVERSE
+BINOMDIST = LOI.BINOMIALE
+CEILING = PLAFOND
+CHIDIST = LOI.KHIDEUX
+CHIINV = KHIDEUX.INVERSE
+CHITEST = TEST.KHIDEUX
+CONCATENATE = CONCATENER
+CONFIDENCE = INTERVALLE.CONFIANCE
+COVAR = COVARIANCE
+CRITBINOM = CRITERE.LOI.BINOMIALE
+EXPONDIST = LOI.EXPONENTIELLE
+FDIST = LOI.F
+FINV = INVERSE.LOI.F
+FLOOR = PLANCHER
+FORECAST = PREVISION
+FTEST = TEST.F
+GAMMADIST = LOI.GAMMA
+GAMMAINV = LOI.GAMMA.INVERSE
+HYPGEOMDIST = LOI.HYPERGEOMETRIQUE
+LOGINV = LOI.LOGNORMALE.INVERSE
+LOGNORMDIST = LOI.LOGNORMALE
+MODE = MODE
+NEGBINOMDIST = LOI.BINOMIALE.NEG
+NORMDIST = LOI.NORMALE
+NORMINV = LOI.NORMALE.INVERSE
+NORMSDIST = LOI.NORMALE.STANDARD
+NORMSINV = LOI.NORMALE.STANDARD.INVERSE
+PERCENTILE = CENTILE
+PERCENTRANK = RANG.POURCENTAGE
+POISSON = LOI.POISSON
+QUARTILE = QUARTILE
+RANK = RANG
+STDEV = ECARTYPE
+STDEVP = ECARTYPEP
+TDIST = LOI.STUDENT
+TINV = LOI.STUDENT.INVERSE
+TTEST = TEST.STUDENT
+VAR = VAR
+VARP = VAR.P
+WEIBULL = LOI.WEIBULL
+ZTEST = TEST.Z

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/hu/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Magyar (Hungarian)
+##
+############################################################
+
+
+##
+## Kockafüggvények (Cube Functions)
+##
+CUBEKPIMEMBER = KOCKA.FŐTELJMUT
+CUBEMEMBER = KOCKA.TAG
+CUBEMEMBERPROPERTY = KOCKA.TAG.TUL
+CUBERANKEDMEMBER = KOCKA.HALM.ELEM
+CUBESET = KOCKA.HALM
+CUBESETCOUNT = KOCKA.HALM.DB
+CUBEVALUE = KOCKA.ÉRTÉK
+
+##
+## Adatbázis-kezelő függvények (Database Functions)
+##
+DAVERAGE = AB.ÁTLAG
+DCOUNT = AB.DARAB
+DCOUNTA = AB.DARAB2
+DGET = AB.MEZŐ
+DMAX = AB.MAX
+DMIN = AB.MIN
+DPRODUCT = AB.SZORZAT
+DSTDEV = AB.SZÓRÁS
+DSTDEVP = AB.SZÓRÁS2
+DSUM = AB.SZUM
+DVAR = AB.VAR
+DVARP = AB.VAR2
+
+##
+## Dátumfüggvények (Date & Time Functions)
+##
+DATE = DÁTUM
+DATEDIF = DÁTUMTÓLIG
+DATESTRING = DÁTUMSZÖVEG
+DATEVALUE = DÁTUMÉRTÉK
+DAY = NAP
+DAYS = NAPOK
+DAYS360 = NAP360
+EDATE = KALK.DÁTUM
+EOMONTH = HÓNAP.UTOLSÓ.NAP
+HOUR = ÓRA
+ISOWEEKNUM = ISO.HÉT.SZÁMA
+MINUTE = PERCEK
+MONTH = HÓNAP
+NETWORKDAYS = ÖSSZ.MUNKANAP
+NETWORKDAYS.INTL = ÖSSZ.MUNKANAP.INTL
+NOW = MOST
+SECOND = MPERC
+THAIDAYOFWEEK = THAIHÉTNAPJA
+THAIMONTHOFYEAR = THAIHÓNAP
+THAIYEAR = THAIÉV
+TIME = IDŐ
+TIMEVALUE = IDŐÉRTÉK
+TODAY = MA
+WEEKDAY = HÉT.NAPJA
+WEEKNUM = HÉT.SZÁMA
+WORKDAY = KALK.MUNKANAP
+WORKDAY.INTL = KALK.MUNKANAP.INTL
+YEAR = ÉV
+YEARFRAC = TÖRTÉV
+
+##
+## Mérnöki függvények (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN.DEC
+BIN2HEX = BIN.HEX
+BIN2OCT = BIN.OKT
+BITAND = BIT.ÉS
+BITLSHIFT = BIT.BAL.ELTOL
+BITOR = BIT.VAGY
+BITRSHIFT = BIT.JOBB.ELTOL
+BITXOR = BIT.XVAGY
+COMPLEX = KOMPLEX
+CONVERT = KONVERTÁLÁS
+DEC2BIN = DEC.BIN
+DEC2HEX = DEC.HEX
+DEC2OCT = DEC.OKT
+DELTA = DELTA
+ERF = HIBAF
+ERF.PRECISE = HIBAF.PONTOS
+ERFC = HIBAF.KOMPLEMENTER
+ERFC.PRECISE = HIBAFKOMPLEMENTER.PONTOS
+GESTEP = KÜSZÖBNÉL.NAGYOBB
+HEX2BIN = HEX.BIN
+HEX2DEC = HEX.DEC
+HEX2OCT = HEX.OKT
+IMABS = KÉPZ.ABSZ
+IMAGINARY = KÉPZETES
+IMARGUMENT = KÉPZ.ARGUMENT
+IMCONJUGATE = KÉPZ.KONJUGÁLT
+IMCOS = KÉPZ.COS
+IMCOSH = KÉPZ.COSH
+IMCOT = KÉPZ.COT
+IMCSC = KÉPZ.CSC
+IMCSCH = KÉPZ.CSCH
+IMDIV = KÉPZ.HÁNYAD
+IMEXP = KÉPZ.EXP
+IMLN = KÉPZ.LN
+IMLOG10 = KÉPZ.LOG10
+IMLOG2 = KÉPZ.LOG2
+IMPOWER = KÉPZ.HATV
+IMPRODUCT = KÉPZ.SZORZAT
+IMREAL = KÉPZ.VALÓS
+IMSEC = KÉPZ.SEC
+IMSECH = KÉPZ.SECH
+IMSIN = KÉPZ.SIN
+IMSINH = KÉPZ.SINH
+IMSQRT = KÉPZ.GYÖK
+IMSUB = KÉPZ.KÜL
+IMSUM = KÉPZ.ÖSSZEG
+IMTAN = KÉPZ.TAN
+OCT2BIN = OKT.BIN
+OCT2DEC = OKT.DEC
+OCT2HEX = OKT.HEX
+
+##
+## Pénzügyi függvények (Financial Functions)
+##
+ACCRINT = IDŐSZAKI.KAMAT
+ACCRINTM = LEJÁRATI.KAMAT
+AMORDEGRC = ÉRTÉKCSÖKK.TÉNYEZŐVEL
+AMORLINC = ÉRTÉKCSÖKK
+COUPDAYBS = SZELVÉNYIDŐ.KEZDETTŐL
+COUPDAYS = SZELVÉNYIDŐ
+COUPDAYSNC = SZELVÉNYIDŐ.KIFIZETÉSTŐL
+COUPNCD = ELSŐ.SZELVÉNYDÁTUM
+COUPNUM = SZELVÉNYSZÁM
+COUPPCD = UTOLSÓ.SZELVÉNYDÁTUM
+CUMIPMT = ÖSSZES.KAMAT
+CUMPRINC = ÖSSZES.TŐKERÉSZ
+DB = KCS2
+DDB = KCSA
+DISC = LESZÁM
+DOLLARDE = FORINT.DEC
+DOLLARFR = FORINT.TÖRT
+DURATION = KAMATÉRZ
+EFFECT = TÉNYLEGES
+FV = JBÉ
+FVSCHEDULE = KJÉ
+INTRATE = KAMATRÁTA
+IPMT = RRÉSZLET
+IRR = BMR
+ISPMT = LRÉSZLETKAMAT
+MDURATION = MKAMATÉRZ
+MIRR = MEGTÉRÜLÉS
+NOMINAL = NÉVLEGES
+NPER = PER.SZÁM
+NPV = NMÉ
+ODDFPRICE = ELTÉRŐ.EÁR
+ODDFYIELD = ELTÉRŐ.EHOZAM
+ODDLPRICE = ELTÉRŐ.UÁR
+ODDLYIELD = ELTÉRŐ.UHOZAM
+PDURATION = KAMATÉRZ.PER
+PMT = RÉSZLET
+PPMT = PRÉSZLET
+PRICE = ÁR
+PRICEDISC = ÁR.LESZÁM
+PRICEMAT = ÁR.LEJÁRAT
+PV = MÉ
+RATE = RÁTA
+RECEIVED = KAPOTT
+RRI = MR
+SLN = LCSA
+SYD = ÉSZÖ
+TBILLEQ = KJEGY.EGYENÉRT
+TBILLPRICE = KJEGY.ÁR
+TBILLYIELD = KJEGY.HOZAM
+VDB = ÉCSRI
+XIRR = XBMR
+XNPV = XNJÉ
+YIELD = HOZAM
+YIELDDISC = HOZAM.LESZÁM
+YIELDMAT = HOZAM.LEJÁRAT
+
+##
+## Információs függvények (Information Functions)
+##
+CELL = CELLA
+ERROR.TYPE = HIBA.TÍPUS
+INFO = INFÓ
+ISBLANK = ÜRES
+ISERR = HIBA.E
+ISERROR = HIBÁS
+ISEVEN = PÁROSE
+ISFORMULA = KÉPLET
+ISLOGICAL = LOGIKAI
+ISNA = NINCS
+ISNONTEXT = NEM.SZÖVEG
+ISNUMBER = SZÁM
+ISODD = PÁRATLANE
+ISREF = HIVATKOZÁS
+ISTEXT = SZÖVEG.E
+N = S
+NA = HIÁNYZIK
+SHEET = LAP
+SHEETS = LAPOK
+TYPE = TÍPUS
+
+##
+## Logikai függvények (Logical Functions)
+##
+AND = ÉS
+FALSE = HAMIS
+IF = HA
+IFERROR = HAHIBA
+IFNA = HAHIÁNYZIK
+IFS = HAELSŐIGAZ
+NOT = NEM
+OR = VAGY
+SWITCH = ÁTVÁLT
+TRUE = IGAZ
+XOR = XVAGY
+
+##
+## Keresési és hivatkozási függvények (Lookup & Reference Functions)
+##
+ADDRESS = CÍM
+AREAS = TERÜLET
+CHOOSE = VÁLASZT
+COLUMN = OSZLOP
+COLUMNS = OSZLOPOK
+FORMULATEXT = KÉPLETSZÖVEG
+GETPIVOTDATA = KIMUTATÁSADATOT.VESZ
+HLOOKUP = VKERES
+HYPERLINK = HIPERHIVATKOZÁS
+INDEX = INDEX
+INDIRECT = INDIREKT
+LOOKUP = KERES
+MATCH = HOL.VAN
+OFFSET = ELTOLÁS
+ROW = SOR
+ROWS = SOROK
+RTD = VIA
+TRANSPOSE = TRANSZPONÁLÁS
+VLOOKUP = FKERES
+
+##
+## Matematikai és trigonometrikus függvények (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ACOSH
+ACOT = ARCCOT
+ACOTH = ARCCOTH
+AGGREGATE = ÖSSZESÍT
+ARABIC = ARAB
+ASIN = ARCSIN
+ASINH = ASINH
+ATAN = ARCTAN
+ATAN2 = ARCTAN2
+ATANH = ATANH
+BASE = ALAP
+CEILING.MATH = PLAFON.MAT
+CEILING.PRECISE = PLAFON.PONTOS
+COMBIN = KOMBINÁCIÓK
+COMBINA = KOMBINÁCIÓK.ISM
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = TIZEDES
+DEGREES = FOK
+ECMA.CEILING = ECMA.PLAFON
+EVEN = PÁROS
+EXP = KITEVŐ
+FACT = FAKT
+FACTDOUBLE = FAKTDUPLA
+FLOOR.MATH = PADLÓ.MAT
+FLOOR.PRECISE = PADLÓ.PONTOS
+GCD = LKO
+INT = INT
+ISO.CEILING = ISO.PLAFON
+LCM = LKT
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = INVERZ.MÁTRIX
+MMULT = MSZORZAT
+MOD = MARADÉK
+MROUND = TÖBBSZ.KEREKÍT
+MULTINOMIAL = SZORHÁNYFAKT
+MUNIT = MMÁTRIX
+ODD = PÁRATLAN
+PI = PI
+POWER = HATVÁNY
+PRODUCT = SZORZAT
+QUOTIENT = KVÓCIENS
+RADIANS = RADIÁN
+RAND = VÉL
+RANDBETWEEN = VÉLETLEN.KÖZÖTT
+ROMAN = RÓMAI
+ROUND = KEREKÍTÉS
+ROUNDBAHTDOWN = BAHTKEREK.LE
+ROUNDBAHTUP = BAHTKEREK.FEL
+ROUNDDOWN = KEREK.LE
+ROUNDUP = KEREK.FEL
+SEC = SEC
+SECH = SECH
+SERIESSUM = SORÖSSZEG
+SIGN = ELŐJEL
+SIN = SIN
+SINH = SINH
+SQRT = GYÖK
+SQRTPI = GYÖKPI
+SUBTOTAL = RÉSZÖSSZEG
+SUM = SZUM
+SUMIF = SZUMHA
+SUMIFS = SZUMHATÖBB
+SUMPRODUCT = SZORZATÖSSZEG
+SUMSQ = NÉGYZETÖSSZEG
+SUMX2MY2 = SZUMX2BŐLY2
+SUMX2PY2 = SZUMX2MEGY2
+SUMXMY2 = SZUMXBŐLY2
+TAN = TAN
+TANH = TANH
+TRUNC = CSONK
+
+##
+## Statisztikai függvények (Statistical Functions)
+##
+AVEDEV = ÁTL.ELTÉRÉS
+AVERAGE = ÁTLAG
+AVERAGEA = ÁTLAGA
+AVERAGEIF = ÁTLAGHA
+AVERAGEIFS = ÁTLAGHATÖBB
+BETA.DIST = BÉTA.ELOSZL
+BETA.INV = BÉTA.INVERZ
+BINOM.DIST = BINOM.ELOSZL
+BINOM.DIST.RANGE = BINOM.ELOSZL.TART
+BINOM.INV = BINOM.INVERZ
+CHISQ.DIST = KHINÉGYZET.ELOSZLÁS
+CHISQ.DIST.RT = KHINÉGYZET.ELOSZLÁS.JOBB
+CHISQ.INV = KHINÉGYZET.INVERZ
+CHISQ.INV.RT = KHINÉGYZET.INVERZ.JOBB
+CHISQ.TEST = KHINÉGYZET.PRÓBA
+CONFIDENCE.NORM = MEGBÍZHATÓSÁG.NORM
+CONFIDENCE.T = MEGBÍZHATÓSÁG.T
+CORREL = KORREL
+COUNT = DARAB
+COUNTA = DARAB2
+COUNTBLANK = DARABÜRES
+COUNTIF = DARABTELI
+COUNTIFS = DARABHATÖBB
+COVARIANCE.P = KOVARIANCIA.S
+COVARIANCE.S = KOVARIANCIA.M
+DEVSQ = SQ
+EXPON.DIST = EXP.ELOSZL
+F.DIST = F.ELOSZL
+F.DIST.RT = F.ELOSZLÁS.JOBB
+F.INV = F.INVERZ
+F.INV.RT = F.INVERZ.JOBB
+F.TEST = F.PRÓB
+FISHER = FISHER
+FISHERINV = INVERZ.FISHER
+FORECAST.ETS = ELŐREJELZÉS.ESIM
+FORECAST.ETS.CONFINT = ELŐREJELZÉS.ESIM.KONFINT
+FORECAST.ETS.SEASONALITY = ELŐREJELZÉS.ESIM.SZEZONALITÁS
+FORECAST.ETS.STAT = ELŐREJELZÉS.ESIM.STAT
+FORECAST.LINEAR = ELŐREJELZÉS.LINEÁRIS
+FREQUENCY = GYAKORISÁG
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.ELOSZL
+GAMMA.INV = GAMMA.INVERZ
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.PONTOS
+GAUSS = GAUSS
+GEOMEAN = MÉRTANI.KÖZÉP
+GROWTH = NÖV
+HARMEAN = HARM.KÖZÉP
+HYPGEOM.DIST = HIPGEOM.ELOSZLÁS
+INTERCEPT = METSZ
+KURT = CSÚCSOSSÁG
+LARGE = NAGY
+LINEST = LIN.ILL
+LOGEST = LOG.ILL
+LOGNORM.DIST = LOGNORM.ELOSZLÁS
+LOGNORM.INV = LOGNORM.INVERZ
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAXHA
+MEDIAN = MEDIÁN
+MIN = MIN
+MINA = MIN2
+MINIFS = MINHA
+MODE.MULT = MÓDUSZ.TÖBB
+MODE.SNGL = MÓDUSZ.EGY
+NEGBINOM.DIST = NEGBINOM.ELOSZLÁS
+NORM.DIST = NORM.ELOSZLÁS
+NORM.INV = NORM.INVERZ
+NORM.S.DIST = NORM.S.ELOSZLÁS
+NORM.S.INV = NORM.S.INVERZ
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTILIS.KIZÁR
+PERCENTILE.INC = PERCENTILIS.TARTALMAZ
+PERCENTRANK.EXC = SZÁZALÉKRANG.KIZÁR
+PERCENTRANK.INC = SZÁZALÉKRANG.TARTALMAZ
+PERMUT = VARIÁCIÓK
+PERMUTATIONA = VARIÁCIÓK.ISM
+PHI = FI
+POISSON.DIST = POISSON.ELOSZLÁS
+PROB = VALÓSZÍNŰSÉG
+QUARTILE.EXC = KVARTILIS.KIZÁR
+QUARTILE.INC = KVARTILIS.TARTALMAZ
+RANK.AVG = RANG.ÁTL
+RANK.EQ = RANG.EGY
+RSQ = RNÉGYZET
+SKEW = FERDESÉG
+SKEW.P = FERDESÉG.P
+SLOPE = MEREDEKSÉG
+SMALL = KICSI
+STANDARDIZE = NORMALIZÁLÁS
+STDEV.P = SZÓR.S
+STDEV.S = SZÓR.M
+STDEVA = SZÓRÁSA
+STDEVPA = SZÓRÁSPA
+STEYX = STHIBAYX
+T.DIST = T.ELOSZL
+T.DIST.2T = T.ELOSZLÁS.2SZ
+T.DIST.RT = T.ELOSZLÁS.JOBB
+T.INV = T.INVERZ
+T.INV.2T = T.INVERZ.2SZ
+T.TEST = T.PRÓB
+TREND = TREND
+TRIMMEAN = RÉSZÁTLAG
+VAR.P = VAR.S
+VAR.S = VAR.M
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = WEIBULL.ELOSZLÁS
+Z.TEST = Z.PRÓB
+
+##
+## Szövegműveletekhez használható függvények (Text Functions)
+##
+BAHTTEXT = BAHTSZÖVEG
+CHAR = KARAKTER
+CLEAN = TISZTÍT
+CODE = KÓD
+CONCAT = FŰZ
+DOLLAR = FORINT
+EXACT = AZONOS
+FIND = SZÖVEG.TALÁL
+FIXED = FIX
+ISTHAIDIGIT = ON.THAI.NUMERO
+LEFT = BAL
+LEN = HOSSZ
+LOWER = KISBETŰ
+MID = KÖZÉP
+NUMBERSTRING = SZÁM.BETŰVEL
+NUMBERVALUE = SZÁMÉRTÉK
+PHONETIC = FONETIKUS
+PROPER = TNÉV
+REPLACE = CSERE
+REPT = SOKSZOR
+RIGHT = JOBB
+SEARCH = SZÖVEG.KERES
+SUBSTITUTE = HELYETTE
+T = T
+TEXT = SZÖVEG
+TEXTJOIN = SZÖVEGÖSSZEFŰZÉS
+THAIDIGIT = THAISZÁM
+THAINUMSOUND = THAISZÁMHANG
+THAINUMSTRING = THAISZÁMKAR
+THAISTRINGLENGTH = THAIKARHOSSZ
+TRIM = KIMETSZ
+UNICHAR = UNIKARAKTER
+UNICODE = UNICODE
+UPPER = NAGYBETŰS
+VALUE = ÉRTÉK
+
+##
+## Webes függvények (Web Functions)
+##
+ENCODEURL = URL.KÓDOL
+FILTERXML = XMLSZŰRÉS
+WEBSERVICE = WEBSZOLGÁLTATÁS
+
+##
+## Kompatibilitási függvények (Compatibility Functions)
+##
+BETADIST = BÉTA.ELOSZLÁS
+BETAINV = INVERZ.BÉTA
+BINOMDIST = BINOM.ELOSZLÁS
+CEILING = PLAFON
+CHIDIST = KHI.ELOSZLÁS
+CHIINV = INVERZ.KHI
+CHITEST = KHI.PRÓBA
+CONCATENATE = ÖSSZEFŰZ
+CONFIDENCE = MEGBÍZHATÓSÁG
+COVAR = KOVAR
+CRITBINOM = KRITBINOM
+EXPONDIST = EXP.ELOSZLÁS
+FDIST = F.ELOSZLÁS
+FINV = INVERZ.F
+FLOOR = PADLÓ
+FORECAST = ELŐREJELZÉS
+FTEST = F.PRÓBA
+GAMMADIST = GAMMA.ELOSZLÁS
+GAMMAINV = INVERZ.GAMMA
+HYPGEOMDIST = HIPERGEOM.ELOSZLÁS
+LOGINV = INVERZ.LOG.ELOSZLÁS
+LOGNORMDIST = LOG.ELOSZLÁS
+MODE = MÓDUSZ
+NEGBINOMDIST = NEGBINOM.ELOSZL
+NORMDIST = NORM.ELOSZL
+NORMINV = INVERZ.NORM
+NORMSDIST = STNORMELOSZL
+NORMSINV = INVERZ.STNORM
+PERCENTILE = PERCENTILIS
+PERCENTRANK = SZÁZALÉKRANG
+POISSON = POISSON
+QUARTILE = KVARTILIS
+RANK = SORSZÁM
+STDEV = SZÓRÁS
+STDEVP = SZÓRÁSP
+TDIST = T.ELOSZLÁS
+TINV = INVERZ.T
+TTEST = T.PRÓBA
+VAR = VAR
+VARP = VARP
+WEIBULL = WEIBULL
+ZTEST = Z.PRÓBA

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/it/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Italiano (Italian)
+##
+############################################################
+
+
+##
+## Funzioni cubo (Cube Functions)
+##
+CUBEKPIMEMBER = MEMBRO.KPI.CUBO
+CUBEMEMBER = MEMBRO.CUBO
+CUBEMEMBERPROPERTY = PROPRIETÀ.MEMBRO.CUBO
+CUBERANKEDMEMBER = MEMBRO.CUBO.CON.RANGO
+CUBESET = SET.CUBO
+CUBESETCOUNT = CONTA.SET.CUBO
+CUBEVALUE = VALORE.CUBO
+
+##
+## Funzioni di database (Database Functions)
+##
+DAVERAGE = DB.MEDIA
+DCOUNT = DB.CONTA.NUMERI
+DCOUNTA = DB.CONTA.VALORI
+DGET = DB.VALORI
+DMAX = DB.MAX
+DMIN = DB.MIN
+DPRODUCT = DB.PRODOTTO
+DSTDEV = DB.DEV.ST
+DSTDEVP = DB.DEV.ST.POP
+DSUM = DB.SOMMA
+DVAR = DB.VAR
+DVARP = DB.VAR.POP
+
+##
+## Funzioni data e ora (Date & Time Functions)
+##
+DATE = DATA
+DATEDIF = DATA.DIFF
+DATESTRING = DATA.STRINGA
+DATEVALUE = DATA.VALORE
+DAY = GIORNO
+DAYS = GIORNI
+DAYS360 = GIORNO360
+EDATE = DATA.MESE
+EOMONTH = FINE.MESE
+HOUR = ORA
+ISOWEEKNUM = NUM.SETTIMANA.ISO
+MINUTE = MINUTO
+MONTH = MESE
+NETWORKDAYS = GIORNI.LAVORATIVI.TOT
+NETWORKDAYS.INTL = GIORNI.LAVORATIVI.TOT.INTL
+NOW = ADESSO
+SECOND = SECONDO
+THAIDAYOFWEEK = THAIGIORNODELLASETTIMANA
+THAIMONTHOFYEAR = THAIMESEDELLANNO
+THAIYEAR = THAIANNO
+TIME = ORARIO
+TIMEVALUE = ORARIO.VALORE
+TODAY = OGGI
+WEEKDAY = GIORNO.SETTIMANA
+WEEKNUM = NUM.SETTIMANA
+WORKDAY = GIORNO.LAVORATIVO
+WORKDAY.INTL = GIORNO.LAVORATIVO.INTL
+YEAR = ANNO
+YEARFRAC = FRAZIONE.ANNO
+
+##
+## Funzioni ingegneristiche (Engineering Functions)
+##
+BESSELI = BESSEL.I
+BESSELJ = BESSEL.J
+BESSELK = BESSEL.K
+BESSELY = BESSEL.Y
+BIN2DEC = BINARIO.DECIMALE
+BIN2HEX = BINARIO.HEX
+BIN2OCT = BINARIO.OCT
+BITAND = BITAND
+BITLSHIFT = BIT.SPOSTA.SX
+BITOR = BITOR
+BITRSHIFT = BIT.SPOSTA.DX
+BITXOR = BITXOR
+COMPLEX = COMPLESSO
+CONVERT = CONVERTI
+DEC2BIN = DECIMALE.BINARIO
+DEC2HEX = DECIMALE.HEX
+DEC2OCT = DECIMALE.OCT
+DELTA = DELTA
+ERF = FUNZ.ERRORE
+ERF.PRECISE = FUNZ.ERRORE.PRECISA
+ERFC = FUNZ.ERRORE.COMP
+ERFC.PRECISE = FUNZ.ERRORE.COMP.PRECISA
+GESTEP = SOGLIA
+HEX2BIN = HEX.BINARIO
+HEX2DEC = HEX.DECIMALE
+HEX2OCT = HEX.OCT
+IMABS = COMP.MODULO
+IMAGINARY = COMP.IMMAGINARIO
+IMARGUMENT = COMP.ARGOMENTO
+IMCONJUGATE = COMP.CONIUGATO
+IMCOS = COMP.COS
+IMCOSH = COMP.COSH
+IMCOT = COMP.COT
+IMCSC = COMP.CSC
+IMCSCH = COMP.CSCH
+IMDIV = COMP.DIV
+IMEXP = COMP.EXP
+IMLN = COMP.LN
+IMLOG10 = COMP.LOG10
+IMLOG2 = COMP.LOG2
+IMPOWER = COMP.POTENZA
+IMPRODUCT = COMP.PRODOTTO
+IMREAL = COMP.PARTE.REALE
+IMSEC = COMP.SEC
+IMSECH = COMP.SECH
+IMSIN = COMP.SEN
+IMSINH = COMP.SENH
+IMSQRT = COMP.RADQ
+IMSUB = COMP.DIFF
+IMSUM = COMP.SOMMA
+IMTAN = COMP.TAN
+OCT2BIN = OCT.BINARIO
+OCT2DEC = OCT.DECIMALE
+OCT2HEX = OCT.HEX
+
+##
+## Funzioni finanziarie (Financial Functions)
+##
+ACCRINT = INT.MATURATO.PER
+ACCRINTM = INT.MATURATO.SCAD
+AMORDEGRC = AMMORT.DEGR
+AMORLINC = AMMORT.PER
+COUPDAYBS = GIORNI.CED.INIZ.LIQ
+COUPDAYS = GIORNI.CED
+COUPDAYSNC = GIORNI.CED.NUOVA
+COUPNCD = DATA.CED.SUCC
+COUPNUM = NUM.CED
+COUPPCD = DATA.CED.PREC
+CUMIPMT = INT.CUMUL
+CUMPRINC = CAP.CUM
+DB = AMMORT.FISSO
+DDB = AMMORT
+DISC = TASSO.SCONTO
+DOLLARDE = VALUTA.DEC
+DOLLARFR = VALUTA.FRAZ
+DURATION = DURATA
+EFFECT = EFFETTIVO
+FV = VAL.FUT
+FVSCHEDULE = VAL.FUT.CAPITALE
+INTRATE = TASSO.INT
+IPMT = INTERESSI
+IRR = TIR.COST
+ISPMT = INTERESSE.RATA
+MDURATION = DURATA.M
+MIRR = TIR.VAR
+NOMINAL = NOMINALE
+NPER = NUM.RATE
+NPV = VAN
+ODDFPRICE = PREZZO.PRIMO.IRR
+ODDFYIELD = REND.PRIMO.IRR
+ODDLPRICE = PREZZO.ULTIMO.IRR
+ODDLYIELD = REND.ULTIMO.IRR
+PDURATION = DURATA.P
+PMT = RATA
+PPMT = P.RATA
+PRICE = PREZZO
+PRICEDISC = PREZZO.SCONT
+PRICEMAT = PREZZO.SCAD
+PV = VA
+RATE = TASSO
+RECEIVED = RICEV.SCAD
+RRI = RIT.INVEST.EFFETT
+SLN = AMMORT.COST
+SYD = AMMORT.ANNUO
+TBILLEQ = BOT.EQUIV
+TBILLPRICE = BOT.PREZZO
+TBILLYIELD = BOT.REND
+VDB = AMMORT.VAR
+XIRR = TIR.X
+XNPV = VAN.X
+YIELD = REND
+YIELDDISC = REND.TITOLI.SCONT
+YIELDMAT = REND.SCAD
+
+##
+## Funzioni relative alle informazioni (Information Functions)
+##
+CELL = CELLA
+ERROR.TYPE = ERRORE.TIPO
+INFO = AMBIENTE.INFO
+ISBLANK = VAL.VUOTO
+ISERR = VAL.ERR
+ISERROR = VAL.ERRORE
+ISEVEN = VAL.PARI
+ISFORMULA = VAL.FORMULA
+ISLOGICAL = VAL.LOGICO
+ISNA = VAL.NON.DISP
+ISNONTEXT = VAL.NON.TESTO
+ISNUMBER = VAL.NUMERO
+ISODD = VAL.DISPARI
+ISREF = VAL.RIF
+ISTEXT = VAL.TESTO
+N = NUM
+NA = NON.DISP
+SHEET = FOGLIO
+SHEETS = FOGLI
+TYPE = TIPO
+
+##
+## Funzioni logiche (Logical Functions)
+##
+AND = E
+FALSE = FALSO
+IF = SE
+IFERROR = SE.ERRORE
+IFNA = SE.NON.DISP.
+IFS = PIÙ.SE
+NOT = NON
+OR = O
+SWITCH = SWITCH
+TRUE = VERO
+XOR = XOR
+
+##
+## Funzioni di ricerca e di riferimento (Lookup & Reference Functions)
+##
+ADDRESS = INDIRIZZO
+AREAS = AREE
+CHOOSE = SCEGLI
+COLUMN = RIF.COLONNA
+COLUMNS = COLONNE
+FORMULATEXT = TESTO.FORMULA
+GETPIVOTDATA = INFO.DATI.TAB.PIVOT
+HLOOKUP = CERCA.ORIZZ
+HYPERLINK = COLLEG.IPERTESTUALE
+INDEX = INDICE
+INDIRECT = INDIRETTO
+LOOKUP = CERCA
+MATCH = CONFRONTA
+OFFSET = SCARTO
+ROW = RIF.RIGA
+ROWS = RIGHE
+RTD = DATITEMPOREALE
+TRANSPOSE = MATR.TRASPOSTA
+VLOOKUP = CERCA.VERT
+
+##
+## Funzioni matematiche e trigonometriche (Math & Trig Functions)
+##
+ABS = ASS
+ACOS = ARCCOS
+ACOSH = ARCCOSH
+ACOT = ARCCOT
+ACOTH = ARCCOTH
+AGGREGATE = AGGREGA
+ARABIC = ARABO
+ASIN = ARCSEN
+ASINH = ARCSENH
+ATAN = ARCTAN
+ATAN2 = ARCTAN.2
+ATANH = ARCTANH
+BASE = BASE
+CEILING.MATH = ARROTONDA.ECCESSO.MAT
+CEILING.PRECISE = ARROTONDA.ECCESSO.PRECISA
+COMBIN = COMBINAZIONE
+COMBINA = COMBINAZIONE.VALORI
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMALE
+DEGREES = GRADI
+ECMA.CEILING = ECMA.ARROTONDA.ECCESSO
+EVEN = PARI
+EXP = EXP
+FACT = FATTORIALE
+FACTDOUBLE = FATT.DOPPIO
+FLOOR.MATH = ARROTONDA.DIFETTO.MAT
+FLOOR.PRECISE = ARROTONDA.DIFETTO.PRECISA
+GCD = MCD
+INT = INT
+ISO.CEILING = ISO.ARROTONDA.ECCESSO
+LCM = MCM
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MATR.DETERM
+MINVERSE = MATR.INVERSA
+MMULT = MATR.PRODOTTO
+MOD = RESTO
+MROUND = ARROTONDA.MULTIPLO
+MULTINOMIAL = MULTINOMIALE
+MUNIT = MATR.UNIT
+ODD = DISPARI
+PI = PI.GRECO
+POWER = POTENZA
+PRODUCT = PRODOTTO
+QUOTIENT = QUOZIENTE
+RADIANS = RADIANTI
+RAND = CASUALE
+RANDBETWEEN = CASUALE.TRA
+ROMAN = ROMANO
+ROUND = ARROTONDA
+ROUNDBAHTDOWN = ARROTBAHTGIU
+ROUNDBAHTUP = ARROTBAHTSU
+ROUNDDOWN = ARROTONDA.PER.DIF
+ROUNDUP = ARROTONDA.PER.ECC
+SEC = SEC
+SECH = SECH
+SERIESSUM = SOMMA.SERIE
+SIGN = SEGNO
+SIN = SEN
+SINH = SENH
+SQRT = RADQ
+SQRTPI = RADQ.PI.GRECO
+SUBTOTAL = SUBTOTALE
+SUM = SOMMA
+SUMIF = SOMMA.SE
+SUMIFS = SOMMA.PIÙ.SE
+SUMPRODUCT = MATR.SOMMA.PRODOTTO
+SUMSQ = SOMMA.Q
+SUMX2MY2 = SOMMA.DIFF.Q
+SUMX2PY2 = SOMMA.SOMMA.Q
+SUMXMY2 = SOMMA.Q.DIFF
+TAN = TAN
+TANH = TANH
+TRUNC = TRONCA
+
+##
+## Funzioni statistiche (Statistical Functions)
+##
+AVEDEV = MEDIA.DEV
+AVERAGE = MEDIA
+AVERAGEA = MEDIA.VALORI
+AVERAGEIF = MEDIA.SE
+AVERAGEIFS = MEDIA.PIÙ.SE
+BETA.DIST = DISTRIB.BETA.N
+BETA.INV = INV.BETA.N
+BINOM.DIST = DISTRIB.BINOM.N
+BINOM.DIST.RANGE = INTERVALLO.DISTRIB.BINOM.N.
+BINOM.INV = INV.BINOM
+CHISQ.DIST = DISTRIB.CHI.QUAD
+CHISQ.DIST.RT = DISTRIB.CHI.QUAD.DS
+CHISQ.INV = INV.CHI.QUAD
+CHISQ.INV.RT = INV.CHI.QUAD.DS
+CHISQ.TEST = TEST.CHI.QUAD
+CONFIDENCE.NORM = CONFIDENZA.NORM
+CONFIDENCE.T = CONFIDENZA.T
+CORREL = CORRELAZIONE
+COUNT = CONTA.NUMERI
+COUNTA = CONTA.VALORI
+COUNTBLANK = CONTA.VUOTE
+COUNTIF = CONTA.SE
+COUNTIFS = CONTA.PIÙ.SE
+COVARIANCE.P = COVARIANZA.P
+COVARIANCE.S = COVARIANZA.C
+DEVSQ = DEV.Q
+EXPON.DIST = DISTRIB.EXP.N
+F.DIST = DISTRIBF
+F.DIST.RT = DISTRIB.F.DS
+F.INV = INVF
+F.INV.RT = INV.F.DS
+F.TEST = TESTF
+FISHER = FISHER
+FISHERINV = INV.FISHER
+FORECAST.ETS = PREVISIONE.ETS
+FORECAST.ETS.CONFINT = PREVISIONE.ETS.INTCONF
+FORECAST.ETS.SEASONALITY = PREVISIONE.ETS.STAGIONALITÀ
+FORECAST.ETS.STAT = PREVISIONE.ETS.STAT
+FORECAST.LINEAR = PREVISIONE.LINEARE
+FREQUENCY = FREQUENZA
+GAMMA = GAMMA
+GAMMA.DIST = DISTRIB.GAMMA.N
+GAMMA.INV = INV.GAMMA.N
+GAMMALN = LN.GAMMA
+GAMMALN.PRECISE = LN.GAMMA.PRECISA
+GAUSS = GAUSS
+GEOMEAN = MEDIA.GEOMETRICA
+GROWTH = CRESCITA
+HARMEAN = MEDIA.ARMONICA
+HYPGEOM.DIST = DISTRIB.IPERGEOM.N
+INTERCEPT = INTERCETTA
+KURT = CURTOSI
+LARGE = GRANDE
+LINEST = REGR.LIN
+LOGEST = REGR.LOG
+LOGNORM.DIST = DISTRIB.LOGNORM.N
+LOGNORM.INV = INV.LOGNORM.N
+MAX = MAX
+MAXA = MAX.VALORI
+MAXIFS = MAX.PIÙ.SE
+MEDIAN = MEDIANA
+MIN = MIN
+MINA = MIN.VALORI
+MINIFS = MIN.PIÙ.SE
+MODE.MULT = MODA.MULT
+MODE.SNGL = MODA.SNGL
+NEGBINOM.DIST = DISTRIB.BINOM.NEG.N
+NORM.DIST = DISTRIB.NORM.N
+NORM.INV = INV.NORM.N
+NORM.S.DIST = DISTRIB.NORM.ST.N
+NORM.S.INV = INV.NORM.S
+PEARSON = PEARSON
+PERCENTILE.EXC = ESC.PERCENTILE
+PERCENTILE.INC = INC.PERCENTILE
+PERCENTRANK.EXC = ESC.PERCENT.RANGO
+PERCENTRANK.INC = INC.PERCENT.RANGO
+PERMUT = PERMUTAZIONE
+PERMUTATIONA = PERMUTAZIONE.VALORI
+PHI = PHI
+POISSON.DIST = DISTRIB.POISSON
+PROB = PROBABILITÀ
+QUARTILE.EXC = ESC.QUARTILE
+QUARTILE.INC = INC.QUARTILE
+RANK.AVG = RANGO.MEDIA
+RANK.EQ = RANGO.UG
+RSQ = RQ
+SKEW = ASIMMETRIA
+SKEW.P = ASIMMETRIA.P
+SLOPE = PENDENZA
+SMALL = PICCOLO
+STANDARDIZE = NORMALIZZA
+STDEV.P = DEV.ST.P
+STDEV.S = DEV.ST.C
+STDEVA = DEV.ST.VALORI
+STDEVPA = DEV.ST.POP.VALORI
+STEYX = ERR.STD.YX
+T.DIST = DISTRIB.T.N
+T.DIST.2T = DISTRIB.T.2T
+T.DIST.RT = DISTRIB.T.DS
+T.INV = INVT
+T.INV.2T = INV.T.2T
+T.TEST = TESTT
+TREND = TENDENZA
+TRIMMEAN = MEDIA.TRONCATA
+VAR.P = VAR.P
+VAR.S = VAR.C
+VARA = VAR.VALORI
+VARPA = VAR.POP.VALORI
+WEIBULL.DIST = DISTRIB.WEIBULL
+Z.TEST = TESTZ
+
+##
+## Funzioni di testo (Text Functions)
+##
+BAHTTEXT = BAHTTESTO
+CHAR = CODICE.CARATT
+CLEAN = LIBERA
+CODE = CODICE
+CONCAT = CONCAT
+DOLLAR = VALUTA
+EXACT = IDENTICO
+FIND = TROVA
+FIXED = FISSO
+ISTHAIDIGIT = ÈTHAICIFRA
+LEFT = SINISTRA
+LEN = LUNGHEZZA
+LOWER = MINUSC
+MID = STRINGA.ESTRAI
+NUMBERSTRING = NUMERO.STRINGA
+NUMBERVALUE = NUMERO.VALORE
+PHONETIC = FURIGANA
+PROPER = MAIUSC.INIZ
+REPLACE = RIMPIAZZA
+REPT = RIPETI
+RIGHT = DESTRA
+SEARCH = RICERCA
+SUBSTITUTE = SOSTITUISCI
+T = T
+TEXT = TESTO
+TEXTJOIN = TESTO.UNISCI
+THAIDIGIT = THAICIFRA
+THAINUMSOUND = THAINUMSUONO
+THAINUMSTRING = THAISZÁMKAR
+THAISTRINGLENGTH = THAILUNGSTRINGA
+TRIM = ANNULLA.SPAZI
+UNICHAR = CARATT.UNI
+UNICODE = UNICODE
+UPPER = MAIUSC
+VALUE = VALORE
+
+##
+## Funzioni Web (Web Functions)
+##
+ENCODEURL = CODIFICA.URL
+FILTERXML = FILTRO.XML
+WEBSERVICE = SERVIZIO.WEB
+
+##
+## Funzioni di compatibilità (Compatibility Functions)
+##
+BETADIST = DISTRIB.BETA
+BETAINV = INV.BETA
+BINOMDIST = DISTRIB.BINOM
+CEILING = ARROTONDA.ECCESSO
+CHIDIST = DISTRIB.CHI
+CHIINV = INV.CHI
+CHITEST = TEST.CHI
+CONCATENATE = CONCATENA
+CONFIDENCE = CONFIDENZA
+COVAR = COVARIANZA
+CRITBINOM = CRIT.BINOM
+EXPONDIST = DISTRIB.EXP
+FDIST = DISTRIB.F
+FINV = INV.F
+FLOOR = ARROTONDA.DIFETTO
+FORECAST = PREVISIONE
+FTEST = TEST.F
+GAMMADIST = DISTRIB.GAMMA
+GAMMAINV = INV.GAMMA
+HYPGEOMDIST = DISTRIB.IPERGEOM
+LOGINV = INV.LOGNORM
+LOGNORMDIST = DISTRIB.LOGNORM
+MODE = MODA
+NEGBINOMDIST = DISTRIB.BINOM.NEG
+NORMDIST = DISTRIB.NORM
+NORMINV = INV.NORM
+NORMSDIST = DISTRIB.NORM.ST
+NORMSINV = INV.NORM.ST
+PERCENTILE = PERCENTILE
+PERCENTRANK = PERCENT.RANGO
+POISSON = POISSON
+QUARTILE = QUARTILE
+RANK = RANGO
+STDEV = DEV.ST
+STDEVP = DEV.ST.POP
+TDIST = DISTRIB.T
+TINV = INV.T
+TTEST = TEST.T
+VAR = VAR
+VARP = VAR.POP
+WEIBULL = WEIBULL
+ZTEST = TEST.Z

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/nb/functions

@@ -0,0 +1,538 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Norsk Bokmål (Norwegian Bokmål)
+##
+############################################################
+
+
+##
+## Kubefunksjoner (Cube Functions)
+##
+CUBEKPIMEMBER = KUBEKPIMEDLEM
+CUBEMEMBER = KUBEMEDLEM
+CUBEMEMBERPROPERTY = KUBEMEDLEMEGENSKAP
+CUBERANKEDMEMBER = KUBERANGERTMEDLEM
+CUBESET = KUBESETT
+CUBESETCOUNT = KUBESETTANTALL
+CUBEVALUE = KUBEVERDI
+
+##
+## Databasefunksjoner (Database Functions)
+##
+DAVERAGE = DGJENNOMSNITT
+DCOUNT = DANTALL
+DCOUNTA = DANTALLA
+DGET = DHENT
+DMAX = DMAKS
+DMIN = DMIN
+DPRODUCT = DPRODUKT
+DSTDEV = DSTDAV
+DSTDEVP = DSTDAVP
+DSUM = DSUMMER
+DVAR = DVARIANS
+DVARP = DVARIANSP
+
+##
+## Dato- og tidsfunksjoner (Date & Time Functions)
+##
+DATE = DATO
+DATEDIF = DATODIFF
+DATESTRING = DATOSTRENG
+DATEVALUE = DATOVERDI
+DAY = DAG
+DAYS = DAGER
+DAYS360 = DAGER360
+EDATE = DAG.ETTER
+EOMONTH = MÅNEDSSLUTT
+HOUR = TIME
+ISOWEEKNUM = ISOUKENR
+MINUTE = MINUTT
+MONTH = MÅNED
+NETWORKDAYS = NETT.ARBEIDSDAGER
+NETWORKDAYS.INTL = NETT.ARBEIDSDAGER.INTL
+NOW = NÅ
+SECOND = SEKUND
+THAIDAYOFWEEK = THAIUKEDAG
+THAIMONTHOFYEAR = THAIMÅNED
+THAIYEAR = THAIÅR
+TIME = TID
+TIMEVALUE = TIDSVERDI
+TODAY = IDAG
+WEEKDAY = UKEDAG
+WEEKNUM = UKENR
+WORKDAY = ARBEIDSDAG
+WORKDAY.INTL = ARBEIDSDAG.INTL
+YEAR = ÅR
+YEARFRAC = ÅRDEL
+
+##
+## Tekniske funksjoner (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BINTILDES
+BIN2HEX = BINTILHEKS
+BIN2OCT = BINTILOKT
+BITAND = BITOG
+BITLSHIFT = BITVFORSKYV
+BITOR = BITELLER
+BITRSHIFT = BITHFORSKYV
+BITXOR = BITEKSKLUSIVELLER
+COMPLEX = KOMPLEKS
+CONVERT = KONVERTER
+DEC2BIN = DESTILBIN
+DEC2HEX = DESTILHEKS
+DEC2OCT = DESTILOKT
+DELTA = DELTA
+ERF = FEILF
+ERF.PRECISE = FEILF.PRESIS
+ERFC = FEILFK
+ERFC.PRECISE = FEILFK.PRESIS
+GESTEP = GRENSEVERDI
+HEX2BIN = HEKSTILBIN
+HEX2DEC = HEKSTILDES
+HEX2OCT = HEKSTILOKT
+IMABS = IMABS
+IMAGINARY = IMAGINÆR
+IMARGUMENT = IMARGUMENT
+IMCONJUGATE = IMKONJUGERT
+IMCOS = IMCOS
+IMCOSH = IMCOSH
+IMCOT = IMCOT
+IMCSC = IMCSC
+IMCSCH = IMCSCH
+IMDIV = IMDIV
+IMEXP = IMEKSP
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMOPPHØY
+IMPRODUCT = IMPRODUKT
+IMREAL = IMREELL
+IMSEC = IMSEC
+IMSECH = IMSECH
+IMSIN = IMSIN
+IMSINH = IMSINH
+IMSQRT = IMROT
+IMSUB = IMSUB
+IMSUM = IMSUMMER
+IMTAN = IMTAN
+OCT2BIN = OKTTILBIN
+OCT2DEC = OKTTILDES
+OCT2HEX = OKTTILHEKS
+
+##
+## Økonomiske funksjoner (Financial Functions)
+##
+ACCRINT = PÅLØPT.PERIODISK.RENTE
+ACCRINTM = PÅLØPT.FORFALLSRENTE
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = OBLIG.DAGER.FF
+COUPDAYS = OBLIG.DAGER
+COUPDAYSNC = OBLIG.DAGER.NF
+COUPNCD = OBLIG.DAGER.EF
+COUPNUM = OBLIG.ANTALL
+COUPPCD = OBLIG.DAG.FORRIGE
+CUMIPMT = SAMLET.RENTE
+CUMPRINC = SAMLET.HOVEDSTOL
+DB = DAVSKR
+DDB = DEGRAVS
+DISC = DISKONTERT
+DOLLARDE = DOLLARDE
+DOLLARFR = DOLLARBR
+DURATION = VARIGHET
+EFFECT = EFFEKTIV.RENTE
+FV = SLUTTVERDI
+FVSCHEDULE = SVPLAN
+INTRATE = RENTESATS
+IPMT = RAVDRAG
+IRR = IR
+ISPMT = ER.AVDRAG
+MDURATION = MVARIGHET
+MIRR = MODIR
+NOMINAL = NOMINELL
+NPER = PERIODER
+NPV = NNV
+ODDFPRICE = AVVIKFP.PRIS
+ODDFYIELD = AVVIKFP.AVKASTNING
+ODDLPRICE = AVVIKSP.PRIS
+ODDLYIELD = AVVIKSP.AVKASTNING
+PDURATION = PVARIGHET
+PMT = AVDRAG
+PPMT = AMORT
+PRICE = PRIS
+PRICEDISC = PRIS.DISKONTERT
+PRICEMAT = PRIS.FORFALL
+PV = NÅVERDI
+RATE = RENTE
+RECEIVED = MOTTATT.AVKAST
+RRI = REALISERT.AVKASTNING
+SLN = LINAVS
+SYD = ÅRSAVS
+TBILLEQ = TBILLEKV
+TBILLPRICE = TBILLPRIS
+TBILLYIELD = TBILLAVKASTNING
+VDB = VERDIAVS
+XIRR = XIR
+XNPV = XNNV
+YIELD = AVKAST
+YIELDDISC = AVKAST.DISKONTERT
+YIELDMAT = AVKAST.FORFALL
+
+##
+## Informasjonsfunksjoner (Information Functions)
+##
+CELL = CELLE
+ERROR.TYPE = FEIL.TYPE
+INFO = INFO
+ISBLANK = ERTOM
+ISERR = ERF
+ISERROR = ERFEIL
+ISEVEN = ERPARTALL
+ISFORMULA = ERFORMEL
+ISLOGICAL = ERLOGISK
+ISNA = ERIT
+ISNONTEXT = ERIKKETEKST
+ISNUMBER = ERTALL
+ISODD = ERODDE
+ISREF = ERREF
+ISTEXT = ERTEKST
+N = N
+NA = IT
+SHEET = ARK
+SHEETS = ANTALL.ARK
+TYPE = VERDITYPE
+
+##
+## Logiske funksjoner (Logical Functions)
+##
+AND = OG
+FALSE = USANN
+IF = HVIS
+IFERROR = HVISFEIL
+IFNA = HVIS.IT
+IFS = HVIS.SETT
+NOT = IKKE
+OR = ELLER
+SWITCH = BRYTER
+TRUE = SANN
+XOR = EKSKLUSIVELLER
+
+##
+## Oppslag- og referansefunksjoner (Lookup & Reference Functions)
+##
+ADDRESS = ADRESSE
+AREAS = OMRÅDER
+CHOOSE = VELG
+COLUMN = KOLONNE
+COLUMNS = KOLONNER
+FORMULATEXT = FORMELTEKST
+GETPIVOTDATA = HENTPIVOTDATA
+HLOOKUP = FINN.KOLONNE
+HYPERLINK = HYPERKOBLING
+INDEX = INDEKS
+INDIRECT = INDIREKTE
+LOOKUP = SLÅ.OPP
+MATCH = SAMMENLIGNE
+OFFSET = FORSKYVNING
+ROW = RAD
+ROWS = RADER
+RTD = RTD
+TRANSPOSE = TRANSPONER
+VLOOKUP = FINN.RAD
+
+##
+## Matematikk- og trigonometrifunksjoner (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ARCCOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = MENGDE
+ARABIC = ARABISK
+ASIN = ARCSIN
+ASINH = ARCSINH
+ATAN = ARCTAN
+ATAN2 = ARCTAN2
+ATANH = ARCTANH
+BASE = GRUNNTALL
+CEILING.MATH = AVRUND.GJELDENDE.MULTIPLUM.OPP.MATEMATISK
+CEILING.PRECISE = AVRUND.GJELDENDE.MULTIPLUM.PRESIS
+COMBIN = KOMBINASJON
+COMBINA = KOMBINASJONA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DESIMAL
+DEGREES = GRADER
+ECMA.CEILING = ECMA.AVRUND.GJELDENDE.MULTIPLUM
+EVEN = AVRUND.TIL.PARTALL
+EXP = EKSP
+FACT = FAKULTET
+FACTDOUBLE = DOBBELFAKT
+FLOOR.MATH = AVRUND.GJELDENDE.MULTIPLUM.NED.MATEMATISK
+FLOOR.PRECISE = AVRUND.GJELDENDE.MULTIPLUM.NED.PRESIS
+GCD = SFF
+INT = HELTALL
+ISO.CEILING = ISO.AVRUND.GJELDENDE.MULTIPLUM
+LCM = MFM
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = MINVERS
+MMULT = MMULT
+MOD = REST
+MROUND = MRUND
+MULTINOMIAL = MULTINOMINELL
+MUNIT = MENHET
+ODD = AVRUND.TIL.ODDETALL
+PI = PI
+POWER = OPPHØYD.I
+PRODUCT = PRODUKT
+QUOTIENT = KVOTIENT
+RADIANS = RADIANER
+RAND = TILFELDIG
+RANDBETWEEN = TILFELDIGMELLOM
+ROMAN = ROMERTALL
+ROUND = AVRUND
+ROUNDBAHTDOWN = RUNDAVBAHTNEDOVER
+ROUNDBAHTUP = RUNDAVBAHTOPPOVER
+ROUNDDOWN = AVRUND.NED
+ROUNDUP = AVRUND.OPP
+SEC = SEC
+SECH = SECH
+SERIESSUM = SUMMER.REKKE
+SIGN = FORTEGN
+SIN = SIN
+SINH = SINH
+SQRT = ROT
+SQRTPI = ROTPI
+SUBTOTAL = DELSUM
+SUM = SUMMER
+SUMIF = SUMMERHVIS
+SUMIFS = SUMMER.HVIS.SETT
+SUMPRODUCT = SUMMERPRODUKT
+SUMSQ = SUMMERKVADRAT
+SUMX2MY2 = SUMMERX2MY2
+SUMX2PY2 = SUMMERX2PY2
+SUMXMY2 = SUMMERXMY2
+TAN = TAN
+TANH = TANH
+TRUNC = AVKORT
+
+##
+## Statistiske funksjoner (Statistical Functions)
+##
+AVEDEV = GJENNOMSNITTSAVVIK
+AVERAGE = GJENNOMSNITT
+AVERAGEA = GJENNOMSNITTA
+AVERAGEIF = GJENNOMSNITTHVIS
+AVERAGEIFS = GJENNOMSNITT.HVIS.SETT
+BETA.DIST = BETA.FORDELING.N
+BETA.INV = BETA.INV
+BINOM.DIST = BINOM.FORDELING.N
+BINOM.DIST.RANGE = BINOM.FORDELING.OMRÅDE
+BINOM.INV = BINOM.INV
+CHISQ.DIST = KJIKVADRAT.FORDELING
+CHISQ.DIST.RT = KJIKVADRAT.FORDELING.H
+CHISQ.INV = KJIKVADRAT.INV
+CHISQ.INV.RT = KJIKVADRAT.INV.H
+CHISQ.TEST = KJIKVADRAT.TEST
+CONFIDENCE.NORM = KONFIDENS.NORM
+CONFIDENCE.T = KONFIDENS.T
+CORREL = KORRELASJON
+COUNT = ANTALL
+COUNTA = ANTALLA
+COUNTBLANK = TELLBLANKE
+COUNTIF = ANTALL.HVIS
+COUNTIFS = ANTALL.HVIS.SETT
+COVARIANCE.P = KOVARIANS.P
+COVARIANCE.S = KOVARIANS.S
+DEVSQ = AVVIK.KVADRERT
+EXPON.DIST = EKSP.FORDELING.N
+F.DIST = F.FORDELING
+F.DIST.RT = F.FORDELING.H
+F.INV = F.INV
+F.INV.RT = F.INV.H
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PROGNOSE.ETS
+FORECAST.ETS.CONFINT = PROGNOSE.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PROGNOSE.ETS.SESONGAVHENGIGHET
+FORECAST.ETS.STAT = PROGNOSE.ETS.STAT
+FORECAST.LINEAR = PROGNOSE.LINEÆR
+FREQUENCY = FREKVENS
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.FORDELING
+GAMMA.INV = GAMMA.INV
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.PRESIS
+GAUSS = GAUSS
+GEOMEAN = GJENNOMSNITT.GEOMETRISK
+GROWTH = VEKST
+HARMEAN = GJENNOMSNITT.HARMONISK
+HYPGEOM.DIST = HYPGEOM.FORDELING.N
+INTERCEPT = SKJÆRINGSPUNKT
+KURT = KURT
+LARGE = N.STØRST
+LINEST = RETTLINJE
+LOGEST = KURVE
+LOGNORM.DIST = LOGNORM.FORDELING
+LOGNORM.INV = LOGNORM.INV
+MAX = STØRST
+MAXA = MAKSA
+MAXIFS = MAKS.HVIS.SETT
+MEDIAN = MEDIAN
+MIN = MIN
+MINA = MINA
+MINIFS = MIN.HVIS.SETT
+MODE.MULT = MODUS.MULT
+MODE.SNGL = MODUS.SNGL
+NEGBINOM.DIST = NEGBINOM.FORDELING.N
+NORM.DIST = NORM.FORDELING
+NORM.INV = NORM.INV
+NORM.S.DIST = NORM.S.FORDELING
+NORM.S.INV = NORM.S.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = PERSENTIL.EKS
+PERCENTILE.INC = PERSENTIL.INK
+PERCENTRANK.EXC = PROSENTDEL.EKS
+PERCENTRANK.INC = PROSENTDEL.INK
+PERMUT = PERMUTER
+PERMUTATIONA = PERMUTASJONA
+PHI = PHI
+POISSON.DIST = POISSON.FORDELING
+PROB = SANNSYNLIG
+QUARTILE.EXC = KVARTIL.EKS
+QUARTILE.INC = KVARTIL.INK
+RANK.AVG = RANG.GJSN
+RANK.EQ = RANG.EKV
+RSQ = RKVADRAT
+SKEW = SKJEVFORDELING
+SKEW.P = SKJEVFORDELING.P
+SLOPE = STIGNINGSTALL
+SMALL = N.MINST
+STANDARDIZE = NORMALISER
+STDEV.P = STDAV.P
+STDEV.S = STDAV.S
+STDEVA = STDAVVIKA
+STDEVPA = STDAVVIKPA
+STEYX = STANDARDFEIL
+T.DIST = T.FORDELING
+T.DIST.2T = T.FORDELING.2T
+T.DIST.RT = T.FORDELING.H
+T.INV = T.INV
+T.INV.2T = T.INV.2T
+T.TEST = T.TEST
+TREND = TREND
+TRIMMEAN = TRIMMET.GJENNOMSNITT
+VAR.P = VARIANS.P
+VAR.S = VARIANS.S
+VARA = VARIANSA
+VARPA = VARIANSPA
+WEIBULL.DIST = WEIBULL.DIST.N
+Z.TEST = Z.TEST
+
+##
+## Tekstfunksjoner (Text Functions)
+##
+ASC = STIGENDE
+BAHTTEXT = BAHTTEKST
+CHAR = TEGNKODE
+CLEAN = RENSK
+CODE = KODE
+CONCAT = KJED.SAMMEN
+DOLLAR = VALUTA
+EXACT = EKSAKT
+FIND = FINN
+FIXED = FASTSATT
+ISTHAIDIGIT = ERTHAISIFFER
+LEFT = VENSTRE
+LEN = LENGDE
+LOWER = SMÅ
+MID = DELTEKST
+NUMBERSTRING = TALLSTRENG
+NUMBERVALUE = TALLVERDI
+PHONETIC = FURIGANA
+PROPER = STOR.FORBOKSTAV
+REPLACE = ERSTATT
+REPT = GJENTA
+RIGHT = HØYRE
+SEARCH = SØK
+SUBSTITUTE = BYTT.UT
+T = T
+TEXT = TEKST
+TEXTJOIN = TEKST.KOMBINER
+THAIDIGIT = THAISIFFER
+THAINUMSOUND = THAINUMLYD
+THAINUMSTRING = THAINUMSTRENG
+THAISTRINGLENGTH = THAISTRENGLENGDE
+TRIM = TRIMME
+UNICHAR = UNICODETEGN
+UNICODE = UNICODE
+UPPER = STORE
+VALUE = VERDI
+
+##
+## Nettfunksjoner (Web Functions)
+##
+ENCODEURL = URL.KODE
+FILTERXML = FILTRERXML
+WEBSERVICE = NETTJENESTE
+
+##
+## Kompatibilitetsfunksjoner (Compatibility Functions)
+##
+BETADIST = BETA.FORDELING
+BETAINV = INVERS.BETA.FORDELING
+BINOMDIST = BINOM.FORDELING
+CEILING = AVRUND.GJELDENDE.MULTIPLUM
+CHIDIST = KJI.FORDELING
+CHIINV = INVERS.KJI.FORDELING
+CHITEST = KJI.TEST
+CONCATENATE = KJEDE.SAMMEN
+CONFIDENCE = KONFIDENS
+COVAR = KOVARIANS
+CRITBINOM = GRENSE.BINOM
+EXPONDIST = EKSP.FORDELING
+FDIST = FFORDELING
+FINV = FFORDELING.INVERS
+FLOOR = AVRUND.GJELDENDE.MULTIPLUM.NED
+FORECAST = PROGNOSE
+FTEST = FTEST
+GAMMADIST = GAMMAFORDELING
+GAMMAINV = GAMMAINV
+HYPGEOMDIST = HYPGEOM.FORDELING
+LOGINV = LOGINV
+LOGNORMDIST = LOGNORMFORD
+MODE = MODUS
+NEGBINOMDIST = NEGBINOM.FORDELING
+NORMDIST = NORMALFORDELING
+NORMINV = NORMINV
+NORMSDIST = NORMSFORDELING
+NORMSINV = NORMSINV
+PERCENTILE = PERSENTIL
+PERCENTRANK = PROSENTDEL
+POISSON = POISSON
+QUARTILE = KVARTIL
+RANK = RANG
+STDEV = STDAV
+STDEVP = STDAVP
+TDIST = TFORDELING
+TINV = TINV
+TTEST = TTEST
+VAR = VARIANS
+VARP = VARIANSP
+WEIBULL = WEIBULL.FORDELING
+ZTEST = ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/nl/functions

@@ -0,0 +1,536 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Nederlands (Dutch)
+##
+############################################################
+
+
+##
+## Kubusfuncties (Cube Functions)
+##
+CUBEKPIMEMBER = KUBUSKPILID
+CUBEMEMBER = KUBUSLID
+CUBEMEMBERPROPERTY = KUBUSLIDEIGENSCHAP
+CUBERANKEDMEMBER = KUBUSGERANGSCHIKTLID
+CUBESET = KUBUSSET
+CUBESETCOUNT = KUBUSSETAANTAL
+CUBEVALUE = KUBUSWAARDE
+
+##
+## Databasefuncties (Database Functions)
+##
+DAVERAGE = DBGEMIDDELDE
+DCOUNT = DBAANTAL
+DCOUNTA = DBAANTALC
+DGET = DBLEZEN
+DMAX = DBMAX
+DMIN = DBMIN
+DPRODUCT = DBPRODUCT
+DSTDEV = DBSTDEV
+DSTDEVP = DBSTDEVP
+DSUM = DBSOM
+DVAR = DBVAR
+DVARP = DBVARP
+
+##
+## Datum- en tijdfuncties (Date & Time Functions)
+##
+DATE = DATUM
+DATESTRING = DATUMNOTATIE
+DATEVALUE = DATUMWAARDE
+DAY = DAG
+DAYS = DAGEN
+DAYS360 = DAGEN360
+EDATE = ZELFDE.DAG
+EOMONTH = LAATSTE.DAG
+HOUR = UUR
+ISOWEEKNUM = ISO.WEEKNUMMER
+MINUTE = MINUUT
+MONTH = MAAND
+NETWORKDAYS = NETTO.WERKDAGEN
+NETWORKDAYS.INTL = NETWERKDAGEN.INTL
+NOW = NU
+SECOND = SECONDE
+THAIDAYOFWEEK = THAIS.WEEKDAG
+THAIMONTHOFYEAR = THAIS.MAAND.VAN.JAAR
+THAIYEAR = THAIS.JAAR
+TIME = TIJD
+TIMEVALUE = TIJDWAARDE
+TODAY = VANDAAG
+WEEKDAY = WEEKDAG
+WEEKNUM = WEEKNUMMER
+WORKDAY = WERKDAG
+WORKDAY.INTL = WERKDAG.INTL
+YEAR = JAAR
+YEARFRAC = JAAR.DEEL
+
+##
+## Technische functies (Engineering Functions)
+##
+BESSELI = BESSEL.I
+BESSELJ = BESSEL.J
+BESSELK = BESSEL.K
+BESSELY = BESSEL.Y
+BIN2DEC = BIN.N.DEC
+BIN2HEX = BIN.N.HEX
+BIN2OCT = BIN.N.OCT
+BITAND = BIT.EN
+BITLSHIFT = BIT.VERSCHUIF.LINKS
+BITOR = BIT.OF
+BITRSHIFT = BIT.VERSCHUIF.RECHTS
+BITXOR = BIT.EX.OF
+COMPLEX = COMPLEX
+CONVERT = CONVERTEREN
+DEC2BIN = DEC.N.BIN
+DEC2HEX = DEC.N.HEX
+DEC2OCT = DEC.N.OCT
+DELTA = DELTA
+ERF = FOUTFUNCTIE
+ERF.PRECISE = FOUTFUNCTIE.NAUWKEURIG
+ERFC = FOUT.COMPLEMENT
+ERFC.PRECISE = FOUT.COMPLEMENT.NAUWKEURIG
+GESTEP = GROTER.DAN
+HEX2BIN = HEX.N.BIN
+HEX2DEC = HEX.N.DEC
+HEX2OCT = HEX.N.OCT
+IMABS = C.ABS
+IMAGINARY = C.IM.DEEL
+IMARGUMENT = C.ARGUMENT
+IMCONJUGATE = C.TOEGEVOEGD
+IMCOS = C.COS
+IMCOSH = C.COSH
+IMCOT = C.COT
+IMCSC = C.COSEC
+IMCSCH = C.COSECH
+IMDIV = C.QUOTIENT
+IMEXP = C.EXP
+IMLN = C.LN
+IMLOG10 = C.LOG10
+IMLOG2 = C.LOG2
+IMPOWER = C.MACHT
+IMPRODUCT = C.PRODUCT
+IMREAL = C.REEEL.DEEL
+IMSEC = C.SEC
+IMSECH = C.SECH
+IMSIN = C.SIN
+IMSINH = C.SINH
+IMSQRT = C.WORTEL
+IMSUB = C.VERSCHIL
+IMSUM = C.SOM
+IMTAN = C.TAN
+OCT2BIN = OCT.N.BIN
+OCT2DEC = OCT.N.DEC
+OCT2HEX = OCT.N.HEX
+
+##
+## Financiële functies (Financial Functions)
+##
+ACCRINT = SAMENG.RENTE
+ACCRINTM = SAMENG.RENTE.V
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = COUP.DAGEN.BB
+COUPDAYS = COUP.DAGEN
+COUPDAYSNC = COUP.DAGEN.VV
+COUPNCD = COUP.DATUM.NB
+COUPNUM = COUP.AANTAL
+COUPPCD = COUP.DATUM.VB
+CUMIPMT = CUM.RENTE
+CUMPRINC = CUM.HOOFDSOM
+DB = DB
+DDB = DDB
+DISC = DISCONTO
+DOLLARDE = EURO.DE
+DOLLARFR = EURO.BR
+DURATION = DUUR
+EFFECT = EFFECT.RENTE
+FV = TW
+FVSCHEDULE = TOEK.WAARDE2
+INTRATE = RENTEPERCENTAGE
+IPMT = IBET
+IRR = IR
+ISPMT = ISBET
+MDURATION = AANG.DUUR
+MIRR = GIR
+NOMINAL = NOMINALE.RENTE
+NPER = NPER
+NPV = NHW
+ODDFPRICE = AFW.ET.PRIJS
+ODDFYIELD = AFW.ET.REND
+ODDLPRICE = AFW.LT.PRIJS
+ODDLYIELD = AFW.LT.REND
+PDURATION = PDUUR
+PMT = BET
+PPMT = PBET
+PRICE = PRIJS.NOM
+PRICEDISC = PRIJS.DISCONTO
+PRICEMAT = PRIJS.VERVALDAG
+PV = HW
+RATE = RENTE
+RECEIVED = OPBRENGST
+RRI = RRI
+SLN = LIN.AFSCHR
+SYD = SYD
+TBILLEQ = SCHATK.OBL
+TBILLPRICE = SCHATK.PRIJS
+TBILLYIELD = SCHATK.REND
+VDB = VDB
+XIRR = IR.SCHEMA
+XNPV = NHW2
+YIELD = RENDEMENT
+YIELDDISC = REND.DISCONTO
+YIELDMAT = REND.VERVAL
+
+##
+## Informatiefuncties (Information Functions)
+##
+CELL = CEL
+ERROR.TYPE = TYPE.FOUT
+INFO = INFO
+ISBLANK = ISLEEG
+ISERR = ISFOUT2
+ISERROR = ISFOUT
+ISEVEN = IS.EVEN
+ISFORMULA = ISFORMULE
+ISLOGICAL = ISLOGISCH
+ISNA = ISNB
+ISNONTEXT = ISGEENTEKST
+ISNUMBER = ISGETAL
+ISODD = IS.ONEVEN
+ISREF = ISVERWIJZING
+ISTEXT = ISTEKST
+N = N
+NA = NB
+SHEET = BLAD
+SHEETS = BLADEN
+TYPE = TYPE
+
+##
+## Logische functies (Logical Functions)
+##
+AND = EN
+FALSE = ONWAAR
+IF = ALS
+IFERROR = ALS.FOUT
+IFNA = ALS.NB
+IFS = ALS.VOORWAARDEN
+NOT = NIET
+OR = OF
+SWITCH = SCHAKELEN
+TRUE = WAAR
+XOR = EX.OF
+
+##
+## Zoek- en verwijzingsfuncties (Lookup & Reference Functions)
+##
+ADDRESS = ADRES
+AREAS = BEREIKEN
+CHOOSE = KIEZEN
+COLUMN = KOLOM
+COLUMNS = KOLOMMEN
+FORMULATEXT = FORMULETEKST
+GETPIVOTDATA = DRAAITABEL.OPHALEN
+HLOOKUP = HORIZ.ZOEKEN
+HYPERLINK = HYPERLINK
+INDEX = INDEX
+INDIRECT = INDIRECT
+LOOKUP = ZOEKEN
+MATCH = VERGELIJKEN
+OFFSET = VERSCHUIVING
+ROW = RIJ
+ROWS = RIJEN
+RTD = RTG
+TRANSPOSE = TRANSPONEREN
+VLOOKUP = VERT.ZOEKEN
+
+##
+## Wiskundige en trigonometrische functies (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = BOOGCOS
+ACOSH = BOOGCOSH
+ACOT = BOOGCOT
+ACOTH = BOOGCOTH
+AGGREGATE = AGGREGAAT
+ARABIC = ARABISCH
+ASIN = BOOGSIN
+ASINH = BOOGSINH
+ATAN = BOOGTAN
+ATAN2 = BOOGTAN2
+ATANH = BOOGTANH
+BASE = BASIS
+CEILING.MATH = AFRONDEN.BOVEN.WISK
+CEILING.PRECISE = AFRONDEN.BOVEN.NAUWKEURIG
+COMBIN = COMBINATIES
+COMBINA = COMBIN.A
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = COSEC
+CSCH = COSECH
+DECIMAL = DECIMAAL
+DEGREES = GRADEN
+ECMA.CEILING = ECMA.AFRONDEN.BOVEN
+EVEN = EVEN
+EXP = EXP
+FACT = FACULTEIT
+FACTDOUBLE = DUBBELE.FACULTEIT
+FLOOR.MATH = AFRONDEN.BENEDEN.WISK
+FLOOR.PRECISE = AFRONDEN.BENEDEN.NAUWKEURIG
+GCD = GGD
+INT = INTEGER
+ISO.CEILING = ISO.AFRONDEN.BOVEN
+LCM = KGV
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = DETERMINANTMAT
+MINVERSE = INVERSEMAT
+MMULT = PRODUCTMAT
+MOD = REST
+MROUND = AFRONDEN.N.VEELVOUD
+MULTINOMIAL = MULTINOMIAAL
+MUNIT = EENHEIDMAT
+ODD = ONEVEN
+PI = PI
+POWER = MACHT
+PRODUCT = PRODUCT
+QUOTIENT = QUOTIENT
+RADIANS = RADIALEN
+RAND = ASELECT
+RANDBETWEEN = ASELECTTUSSEN
+ROMAN = ROMEINS
+ROUND = AFRONDEN
+ROUNDBAHTDOWN = BAHT.AFR.NAAR.BENEDEN
+ROUNDBAHTUP = BAHT.AFR.NAAR.BOVEN
+ROUNDDOWN = AFRONDEN.NAAR.BENEDEN
+ROUNDUP = AFRONDEN.NAAR.BOVEN
+SEC = SEC
+SECH = SECH
+SERIESSUM = SOM.MACHTREEKS
+SIGN = POS.NEG
+SIN = SIN
+SINH = SINH
+SQRT = WORTEL
+SQRTPI = WORTEL.PI
+SUBTOTAL = SUBTOTAAL
+SUM = SOM
+SUMIF = SOM.ALS
+SUMIFS = SOMMEN.ALS
+SUMPRODUCT = SOMPRODUCT
+SUMSQ = KWADRATENSOM
+SUMX2MY2 = SOM.X2MINY2
+SUMX2PY2 = SOM.X2PLUSY2
+SUMXMY2 = SOM.XMINY.2
+TAN = TAN
+TANH = TANH
+TRUNC = GEHEEL
+
+##
+## Statistische functies (Statistical Functions)
+##
+AVEDEV = GEM.DEVIATIE
+AVERAGE = GEMIDDELDE
+AVERAGEA = GEMIDDELDEA
+AVERAGEIF = GEMIDDELDE.ALS
+AVERAGEIFS = GEMIDDELDEN.ALS
+BETA.DIST = BETA.VERD
+BETA.INV = BETA.INV
+BINOM.DIST = BINOM.VERD
+BINOM.DIST.RANGE = BINOM.VERD.BEREIK
+BINOM.INV = BINOMIALE.INV
+CHISQ.DIST = CHIKW.VERD
+CHISQ.DIST.RT = CHIKW.VERD.RECHTS
+CHISQ.INV = CHIKW.INV
+CHISQ.INV.RT = CHIKW.INV.RECHTS
+CHISQ.TEST = CHIKW.TEST
+CONFIDENCE.NORM = VERTROUWELIJKHEID.NORM
+CONFIDENCE.T = VERTROUWELIJKHEID.T
+CORREL = CORRELATIE
+COUNT = AANTAL
+COUNTA = AANTALARG
+COUNTBLANK = AANTAL.LEGE.CELLEN
+COUNTIF = AANTAL.ALS
+COUNTIFS = AANTALLEN.ALS
+COVARIANCE.P = COVARIANTIE.P
+COVARIANCE.S = COVARIANTIE.S
+DEVSQ = DEV.KWAD
+EXPON.DIST = EXPON.VERD.N
+F.DIST = F.VERD
+F.DIST.RT = F.VERD.RECHTS
+F.INV = F.INV
+F.INV.RT = F.INV.RECHTS
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHER.INV
+FORECAST.ETS = VOORSPELLEN.ETS
+FORECAST.ETS.CONFINT = VOORSPELLEN.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = VOORSPELLEN.ETS.SEASONALITY
+FORECAST.ETS.STAT = FORECAST.ETS.STAT
+FORECAST.LINEAR = VOORSPELLEN.LINEAR
+FREQUENCY = INTERVAL
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.VERD.N
+GAMMA.INV = GAMMA.INV.N
+GAMMALN = GAMMA.LN
+GAMMALN.PRECISE = GAMMA.LN.NAUWKEURIG
+GAUSS = GAUSS
+GEOMEAN = MEETK.GEM
+GROWTH = GROEI
+HARMEAN = HARM.GEM
+HYPGEOM.DIST = HYPGEOM.VERD
+INTERCEPT = SNIJPUNT
+KURT = KURTOSIS
+LARGE = GROOTSTE
+LINEST = LIJNSCH
+LOGEST = LOGSCH
+LOGNORM.DIST = LOGNORM.VERD
+LOGNORM.INV = LOGNORM.INV
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAX.ALS.VOORWAARDEN
+MEDIAN = MEDIAAN
+MIN = MIN
+MINA = MINA
+MINIFS = MIN.ALS.VOORWAARDEN
+MODE.MULT = MODUS.MEERV
+MODE.SNGL = MODUS.ENKELV
+NEGBINOM.DIST = NEGBINOM.VERD
+NORM.DIST = NORM.VERD.N
+NORM.INV = NORM.INV.N
+NORM.S.DIST = NORM.S.VERD
+NORM.S.INV = NORM.S.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIEL.EXC
+PERCENTILE.INC = PERCENTIEL.INC
+PERCENTRANK.EXC = PROCENTRANG.EXC
+PERCENTRANK.INC = PROCENTRANG.INC
+PERMUT = PERMUTATIES
+PERMUTATIONA = PERMUTATIE.A
+PHI = PHI
+POISSON.DIST = POISSON.VERD
+PROB = KANS
+QUARTILE.EXC = KWARTIEL.EXC
+QUARTILE.INC = KWARTIEL.INC
+RANK.AVG = RANG.GEMIDDELDE
+RANK.EQ = RANG.GELIJK
+RSQ = R.KWADRAAT
+SKEW = SCHEEFHEID
+SKEW.P = SCHEEFHEID.P
+SLOPE = RICHTING
+SMALL = KLEINSTE
+STANDARDIZE = NORMALISEREN
+STDEV.P = STDEV.P
+STDEV.S = STDEV.S
+STDEVA = STDEVA
+STDEVPA = STDEVPA
+STEYX = STAND.FOUT.YX
+T.DIST = T.DIST
+T.DIST.2T = T.VERD.2T
+T.DIST.RT = T.VERD.RECHTS
+T.INV = T.INV
+T.INV.2T = T.INV.2T
+T.TEST = T.TEST
+TREND = TREND
+TRIMMEAN = GETRIMD.GEM
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = WEIBULL.VERD
+Z.TEST = Z.TEST
+
+##
+## Tekstfuncties (Text Functions)
+##
+BAHTTEXT = BAHT.TEKST
+CHAR = TEKEN
+CLEAN = WISSEN.CONTROL
+CODE = CODE
+CONCAT = TEKST.SAMENV
+DOLLAR = EURO
+EXACT = GELIJK
+FIND = VIND.ALLES
+FIXED = VAST
+ISTHAIDIGIT = IS.THAIS.CIJFER
+LEFT = LINKS
+LEN = LENGTE
+LOWER = KLEINE.LETTERS
+MID = DEEL
+NUMBERSTRING = GETALNOTATIE
+NUMBERVALUE = NUMERIEKE.WAARDE
+PHONETIC = FONETISCH
+PROPER = BEGINLETTERS
+REPLACE = VERVANGEN
+REPT = HERHALING
+RIGHT = RECHTS
+SEARCH = VIND.SPEC
+SUBSTITUTE = SUBSTITUEREN
+T = T
+TEXT = TEKST
+TEXTJOIN = TEKST.COMBINEREN
+THAIDIGIT = THAIS.CIJFER
+THAINUMSOUND = THAIS.GETAL.GELUID
+THAINUMSTRING = THAIS.GETAL.REEKS
+THAISTRINGLENGTH = THAIS.REEKS.LENGTE
+TRIM = SPATIES.WISSEN
+UNICHAR = UNITEKEN
+UNICODE = UNICODE
+UPPER = HOOFDLETTERS
+VALUE = WAARDE
+
+##
+## Webfuncties (Web Functions)
+##
+ENCODEURL = URL.CODEREN
+FILTERXML = XML.FILTEREN
+WEBSERVICE = WEBSERVICE
+
+##
+## Compatibiliteitsfuncties (Compatibility Functions)
+##
+BETADIST = BETAVERD
+BETAINV = BETAINV
+BINOMDIST = BINOMIALE.VERD
+CEILING = AFRONDEN.BOVEN
+CHIDIST = CHI.KWADRAAT
+CHIINV = CHI.KWADRAAT.INV
+CHITEST = CHI.TOETS
+CONCATENATE = TEKST.SAMENVOEGEN
+CONFIDENCE = BETROUWBAARHEID
+COVAR = COVARIANTIE
+CRITBINOM = CRIT.BINOM
+EXPONDIST = EXPON.VERD
+FDIST = F.VERDELING
+FINV = F.INVERSE
+FLOOR = AFRONDEN.BENEDEN
+FORECAST = VOORSPELLEN
+FTEST = F.TOETS
+GAMMADIST = GAMMA.VERD
+GAMMAINV = GAMMA.INV
+HYPGEOMDIST = HYPERGEO.VERD
+LOGINV = LOG.NORM.INV
+LOGNORMDIST = LOG.NORM.VERD
+MODE = MODUS
+NEGBINOMDIST = NEG.BINOM.VERD
+NORMDIST = NORM.VERD
+NORMINV = NORM.INV
+NORMSDIST = STAND.NORM.VERD
+NORMSINV = STAND.NORM.INV
+PERCENTILE = PERCENTIEL
+PERCENTRANK = PERCENT.RANG
+POISSON = POISSON
+QUARTILE = KWARTIEL
+RANK = RANG
+STDEV = STDEV
+STDEVP = STDEVP
+TDIST = T.VERD
+TINV = TINV
+TTEST = T.TOETS
+VAR = VAR
+VARP = VARP
+WEIBULL = WEIBULL
+ZTEST = Z.TOETS

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/pl/functions

@@ -0,0 +1,536 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Jezyk polski (Polish)
+##
+############################################################
+
+
+##
+## Funkcje baz danych (Cube Functions)
+##
+CUBEKPIMEMBER = ELEMENT.KPI.MODUŁU
+CUBEMEMBER = ELEMENT.MODUŁU
+CUBEMEMBERPROPERTY = WŁAŚCIWOŚĆ.ELEMENTU.MODUŁU
+CUBERANKEDMEMBER = USZEREGOWANY.ELEMENT.MODUŁU
+CUBESET = ZESTAW.MODUŁÓW
+CUBESETCOUNT = LICZNIK.MODUŁÓW.ZESTAWU
+CUBEVALUE = WARTOŚĆ.MODUŁU
+
+##
+## Funkcje baz danych (Database Functions)
+##
+DAVERAGE = BD.ŚREDNIA
+DCOUNT = BD.ILE.REKORDÓW
+DCOUNTA = BD.ILE.REKORDÓW.A
+DGET = BD.POLE
+DMAX = BD.MAX
+DMIN = BD.MIN
+DPRODUCT = BD.ILOCZYN
+DSTDEV = BD.ODCH.STANDARD
+DSTDEVP = BD.ODCH.STANDARD.POPUL
+DSUM = BD.SUMA
+DVAR = BD.WARIANCJA
+DVARP = BD.WARIANCJA.POPUL
+
+##
+## Funkcje daty i godziny (Date & Time Functions)
+##
+DATE = DATA
+DATEDIF = DATA.RÓŻNICA
+DATESTRING = DATA.CIĄG.ZNAK
+DATEVALUE = DATA.WARTOŚĆ
+DAY = DZIEŃ
+DAYS = DNI
+DAYS360 = DNI.360
+EDATE = NR.SER.DATY
+EOMONTH = NR.SER.OST.DN.MIES
+HOUR = GODZINA
+ISOWEEKNUM = ISO.NUM.TYG
+MINUTE = MINUTA
+MONTH = MIESIĄC
+NETWORKDAYS = DNI.ROBOCZE
+NETWORKDAYS.INTL = DNI.ROBOCZE.NIESTAND
+NOW = TERAZ
+SECOND = SEKUNDA
+THAIDAYOFWEEK = TAJ.DZIEŃ.TYGODNIA
+THAIMONTHOFYEAR = TAJ.MIESIĄC.ROKU
+THAIYEAR = TAJ.ROK
+TIME = CZAS
+TIMEVALUE = CZAS.WARTOŚĆ
+TODAY = DZIŚ
+WEEKDAY = DZIEŃ.TYG
+WEEKNUM = NUM.TYG
+WORKDAY = DZIEŃ.ROBOCZY
+WORKDAY.INTL = DZIEŃ.ROBOCZY.NIESTAND
+YEAR = ROK
+YEARFRAC = CZĘŚĆ.ROKU
+
+##
+## Funkcje inżynierskie (Engineering Functions)
+##
+BESSELI = BESSEL.I
+BESSELJ = BESSEL.J
+BESSELK = BESSEL.K
+BESSELY = BESSEL.Y
+BIN2DEC = DWÓJK.NA.DZIES
+BIN2HEX = DWÓJK.NA.SZESN
+BIN2OCT = DWÓJK.NA.ÓSM
+BITAND = BITAND
+BITLSHIFT = BIT.PRZESUNIĘCIE.W.LEWO
+BITOR = BITOR
+BITRSHIFT = BIT.PRZESUNIĘCIE.W.PRAWO
+BITXOR = BITXOR
+COMPLEX = LICZBA.ZESP
+CONVERT = KONWERTUJ
+DEC2BIN = DZIES.NA.DWÓJK
+DEC2HEX = DZIES.NA.SZESN
+DEC2OCT = DZIES.NA.ÓSM
+DELTA = CZY.RÓWNE
+ERF = FUNKCJA.BŁ
+ERF.PRECISE = FUNKCJA.BŁ.DOKŁ
+ERFC = KOMP.FUNKCJA.BŁ
+ERFC.PRECISE = KOMP.FUNKCJA.BŁ.DOKŁ
+GESTEP = SPRAWDŹ.PRÓG
+HEX2BIN = SZESN.NA.DWÓJK
+HEX2DEC = SZESN.NA.DZIES
+HEX2OCT = SZESN.NA.ÓSM
+IMABS = MODUŁ.LICZBY.ZESP
+IMAGINARY = CZ.UROJ.LICZBY.ZESP
+IMARGUMENT = ARG.LICZBY.ZESP
+IMCONJUGATE = SPRZĘŻ.LICZBY.ZESP
+IMCOS = COS.LICZBY.ZESP
+IMCOSH = COSH.LICZBY.ZESP
+IMCOT = COT.LICZBY.ZESP
+IMCSC = CSC.LICZBY.ZESP
+IMCSCH = CSCH.LICZBY.ZESP
+IMDIV = ILORAZ.LICZB.ZESP
+IMEXP = EXP.LICZBY.ZESP
+IMLN = LN.LICZBY.ZESP
+IMLOG10 = LOG10.LICZBY.ZESP
+IMLOG2 = LOG2.LICZBY.ZESP
+IMPOWER = POTĘGA.LICZBY.ZESP
+IMPRODUCT = ILOCZYN.LICZB.ZESP
+IMREAL = CZ.RZECZ.LICZBY.ZESP
+IMSEC = SEC.LICZBY.ZESP
+IMSECH = SECH.LICZBY.ZESP
+IMSIN = SIN.LICZBY.ZESP
+IMSINH = SINH.LICZBY.ZESP
+IMSQRT = PIERWIASTEK.LICZBY.ZESP
+IMSUB = RÓŻN.LICZB.ZESP
+IMSUM = SUMA.LICZB.ZESP
+IMTAN = TAN.LICZBY.ZESP
+OCT2BIN = ÓSM.NA.DWÓJK
+OCT2DEC = ÓSM.NA.DZIES
+OCT2HEX = ÓSM.NA.SZESN
+
+##
+## Funkcje finansowe (Financial Functions)
+##
+ACCRINT = NAL.ODS
+ACCRINTM = NAL.ODS.WYKUP
+AMORDEGRC = AMORT.NIELIN
+AMORLINC = AMORT.LIN
+COUPDAYBS = WYPŁ.DNI.OD.POCZ
+COUPDAYS = WYPŁ.DNI
+COUPDAYSNC = WYPŁ.DNI.NAST
+COUPNCD = WYPŁ.DATA.NAST
+COUPNUM = WYPŁ.LICZBA
+COUPPCD = WYPŁ.DATA.POPRZ
+CUMIPMT = SPŁAC.ODS
+CUMPRINC = SPŁAC.KAPIT
+DB = DB
+DDB = DDB
+DISC = STOPA.DYSK
+DOLLARDE = CENA.DZIES
+DOLLARFR = CENA.UŁAM
+DURATION = ROCZ.PRZYCH
+EFFECT = EFEKTYWNA
+FV = FV
+FVSCHEDULE = WART.PRZYSZŁ.KAP
+INTRATE = STOPA.PROC
+IPMT = IPMT
+IRR = IRR
+ISPMT = ISPMT
+MDURATION = ROCZ.PRZYCH.M
+MIRR = MIRR
+NOMINAL = NOMINALNA
+NPER = NPER
+NPV = NPV
+ODDFPRICE = CENA.PIERW.OKR
+ODDFYIELD = RENT.PIERW.OKR
+ODDLPRICE = CENA.OST.OKR
+ODDLYIELD = RENT.OST.OKR
+PDURATION = O.CZAS.TRWANIA
+PMT = PMT
+PPMT = PPMT
+PRICE = CENA
+PRICEDISC = CENA.DYSK
+PRICEMAT = CENA.WYKUP
+PV = PV
+RATE = RATE
+RECEIVED = KWOTA.WYKUP
+RRI = RÓWNOW.STOPA.PROC
+SLN = SLN
+SYD = SYD
+TBILLEQ = RENT.EKW.BS
+TBILLPRICE = CENA.BS
+TBILLYIELD = RENT.BS
+VDB = VDB
+XIRR = XIRR
+XNPV = XNPV
+YIELD = RENTOWNOŚĆ
+YIELDDISC = RENT.DYSK
+YIELDMAT = RENT.WYKUP
+
+##
+## Funkcje informacyjne (Information Functions)
+##
+CELL = KOMÓRKA
+ERROR.TYPE = NR.BŁĘDU
+INFO = INFO
+ISBLANK = CZY.PUSTA
+ISERR = CZY.BŁ
+ISERROR = CZY.BŁĄD
+ISEVEN = CZY.PARZYSTE
+ISFORMULA = CZY.FORMUŁA
+ISLOGICAL = CZY.LOGICZNA
+ISNA = CZY.BRAK
+ISNONTEXT = CZY.NIE.TEKST
+ISNUMBER = CZY.LICZBA
+ISODD = CZY.NIEPARZYSTE
+ISREF = CZY.ADR
+ISTEXT = CZY.TEKST
+N = N
+NA = BRAK
+SHEET = ARKUSZ
+SHEETS = ARKUSZE
+TYPE = TYP
+
+##
+## Funkcje logiczne (Logical Functions)
+##
+AND = ORAZ
+FALSE = FAŁSZ
+IF = JEŻELI
+IFERROR = JEŻELI.BŁĄD
+IFNA = JEŻELI.ND
+IFS = WARUNKI
+NOT = NIE
+OR = LUB
+SWITCH = PRZEŁĄCZ
+TRUE = PRAWDA
+XOR = XOR
+
+##
+## Funkcje wyszukiwania i odwołań (Lookup & Reference Functions)
+##
+ADDRESS = ADRES
+AREAS = OBSZARY
+CHOOSE = WYBIERZ
+COLUMN = NR.KOLUMNY
+COLUMNS = LICZBA.KOLUMN
+FORMULATEXT = FORMUŁA.TEKST
+GETPIVOTDATA = WEŹDANETABELI
+HLOOKUP = WYSZUKAJ.POZIOMO
+HYPERLINK = HIPERŁĄCZE
+INDEX = INDEKS
+INDIRECT = ADR.POŚR
+LOOKUP = WYSZUKAJ
+MATCH = PODAJ.POZYCJĘ
+OFFSET = PRZESUNIĘCIE
+ROW = WIERSZ
+ROWS = ILE.WIERSZY
+RTD = DANE.CZASU.RZECZ
+TRANSPOSE = TRANSPONUJ
+VLOOKUP = WYSZUKAJ.PIONOWO
+
+##
+## Funkcje matematyczne i trygonometryczne (Math & Trig Functions)
+##
+ABS = MODUŁ.LICZBY
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGREGUJ
+ARABIC = ARABSKIE
+ASIN = ASIN
+ASINH = ASINH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = PODSTAWA
+CEILING.MATH = ZAOKR.W.GÓRĘ.MATEMATYCZNE
+CEILING.PRECISE = ZAOKR.W.GÓRĘ.DOKŁ
+COMBIN = KOMBINACJE
+COMBINA = KOMBINACJE.A
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DZIESIĘTNA
+DEGREES = STOPNIE
+ECMA.CEILING = ECMA.ZAOKR.W.GÓRĘ
+EVEN = ZAOKR.DO.PARZ
+EXP = EXP
+FACT = SILNIA
+FACTDOUBLE = SILNIA.DWUKR
+FLOOR.MATH = ZAOKR.W.DÓŁ.MATEMATYCZNE
+FLOOR.PRECISE = ZAOKR.W.DÓŁ.DOKŁ
+GCD = NAJW.WSP.DZIEL
+INT = ZAOKR.DO.CAŁK
+ISO.CEILING = ISO.ZAOKR.W.GÓRĘ
+LCM = NAJMN.WSP.WIEL
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = WYZNACZNIK.MACIERZY
+MINVERSE = MACIERZ.ODW
+MMULT = MACIERZ.ILOCZYN
+MOD = MOD
+MROUND = ZAOKR.DO.WIELOKR
+MULTINOMIAL = WIELOMIAN
+MUNIT = MACIERZ.JEDNOSTKOWA
+ODD = ZAOKR.DO.NPARZ
+PI = PI
+POWER = POTĘGA
+PRODUCT = ILOCZYN
+QUOTIENT = CZ.CAŁK.DZIELENIA
+RADIANS = RADIANY
+RAND = LOS
+RANDBETWEEN = LOS.ZAKR
+ROMAN = RZYMSKIE
+ROUND = ZAOKR
+ROUNDBAHTDOWN = ZAOKR.DÓŁ.BAT
+ROUNDBAHTUP = ZAOKR.GÓRA.BAT
+ROUNDDOWN = ZAOKR.DÓŁ
+ROUNDUP = ZAOKR.GÓRA
+SEC = SEC
+SECH = SECH
+SERIESSUM = SUMA.SZER.POT
+SIGN = ZNAK.LICZBY
+SIN = SIN
+SINH = SINH
+SQRT = PIERWIASTEK
+SQRTPI = PIERW.PI
+SUBTOTAL = SUMY.CZĘŚCIOWE
+SUM = SUMA
+SUMIF = SUMA.JEŻELI
+SUMIFS = SUMA.WARUNKÓW
+SUMPRODUCT = SUMA.ILOCZYNÓW
+SUMSQ = SUMA.KWADRATÓW
+SUMX2MY2 = SUMA.X2.M.Y2
+SUMX2PY2 = SUMA.X2.P.Y2
+SUMXMY2 = SUMA.XMY.2
+TAN = TAN
+TANH = TANH
+TRUNC = LICZBA.CAŁK
+
+##
+## Funkcje statystyczne (Statistical Functions)
+##
+AVEDEV = ODCH.ŚREDNIE
+AVERAGE = ŚREDNIA
+AVERAGEA = ŚREDNIA.A
+AVERAGEIF = ŚREDNIA.JEŻELI
+AVERAGEIFS = ŚREDNIA.WARUNKÓW
+BETA.DIST = ROZKŁ.BETA
+BETA.INV = ROZKŁ.BETA.ODWR
+BINOM.DIST = ROZKŁ.DWUM
+BINOM.DIST.RANGE = ROZKŁ.DWUM.ZAKRES
+BINOM.INV = ROZKŁ.DWUM.ODWR
+CHISQ.DIST = ROZKŁ.CHI
+CHISQ.DIST.RT = ROZKŁ.CHI.PS
+CHISQ.INV = ROZKŁ.CHI.ODWR
+CHISQ.INV.RT = ROZKŁ.CHI.ODWR.PS
+CHISQ.TEST = CHI.TEST
+CONFIDENCE.NORM = UFNOŚĆ.NORM
+CONFIDENCE.T = UFNOŚĆ.T
+CORREL = WSP.KORELACJI
+COUNT = ILE.LICZB
+COUNTA = ILE.NIEPUSTYCH
+COUNTBLANK = LICZ.PUSTE
+COUNTIF = LICZ.JEŻELI
+COUNTIFS = LICZ.WARUNKI
+COVARIANCE.P = KOWARIANCJA.POPUL
+COVARIANCE.S = KOWARIANCJA.PRÓBKI
+DEVSQ = ODCH.KWADRATOWE
+EXPON.DIST = ROZKŁ.EXP
+F.DIST = ROZKŁ.F
+F.DIST.RT = ROZKŁ.F.PS
+F.INV = ROZKŁ.F.ODWR
+F.INV.RT = ROZKŁ.F.ODWR.PS
+F.TEST = F.TEST
+FISHER = ROZKŁAD.FISHER
+FISHERINV = ROZKŁAD.FISHER.ODW
+FORECAST.ETS = REGLINX.ETS
+FORECAST.ETS.CONFINT = REGLINX.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = REGLINX.ETS.SEZONOWOŚĆ
+FORECAST.ETS.STAT = REGLINX.ETS.STATYSTYKA
+FORECAST.LINEAR = REGLINX.LINIOWA
+FREQUENCY = CZĘSTOŚĆ
+GAMMA = GAMMA
+GAMMA.DIST = ROZKŁ.GAMMA
+GAMMA.INV = ROZKŁ.GAMMA.ODWR
+GAMMALN = ROZKŁAD.LIN.GAMMA
+GAMMALN.PRECISE = ROZKŁAD.LIN.GAMMA.DOKŁ
+GAUSS = GAUSS
+GEOMEAN = ŚREDNIA.GEOMETRYCZNA
+GROWTH = REGEXPW
+HARMEAN = ŚREDNIA.HARMONICZNA
+HYPGEOM.DIST = ROZKŁ.HIPERGEOM
+INTERCEPT = ODCIĘTA
+KURT = KURTOZA
+LARGE = MAX.K
+LINEST = REGLINP
+LOGEST = REGEXPP
+LOGNORM.DIST = ROZKŁ.LOG
+LOGNORM.INV = ROZKŁ.LOG.ODWR
+MAX = MAX
+MAXA = MAX.A
+MAXIFS = MAKS.WARUNKÓW
+MEDIAN = MEDIANA
+MIN = MIN
+MINA = MIN.A
+MINIFS = MIN.WARUNKÓW
+MODE.MULT = WYST.NAJCZĘŚCIEJ.TABL
+MODE.SNGL = WYST.NAJCZĘŚCIEJ.WART
+NEGBINOM.DIST = ROZKŁ.DWUM.PRZEC
+NORM.DIST = ROZKŁ.NORMALNY
+NORM.INV = ROZKŁ.NORMALNY.ODWR
+NORM.S.DIST = ROZKŁ.NORMALNY.S
+NORM.S.INV = ROZKŁ.NORMALNY.S.ODWR
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTYL.PRZEDZ.OTW
+PERCENTILE.INC = PERCENTYL.PRZEDZ.ZAMK
+PERCENTRANK.EXC = PROC.POZ.PRZEDZ.OTW
+PERCENTRANK.INC = PROC.POZ.PRZEDZ.ZAMK
+PERMUT = PERMUTACJE
+PERMUTATIONA = PERMUTACJE.A
+PHI = PHI
+POISSON.DIST = ROZKŁ.POISSON
+PROB = PRAWDPD
+QUARTILE.EXC = KWARTYL.PRZEDZ.OTW
+QUARTILE.INC = KWARTYL.PRZEDZ.ZAMK
+RANK.AVG = POZYCJA.ŚR
+RANK.EQ = POZYCJA.NAJW
+RSQ = R.KWADRAT
+SKEW = SKOŚNOŚĆ
+SKEW.P = SKOŚNOŚĆ.P
+SLOPE = NACHYLENIE
+SMALL = MIN.K
+STANDARDIZE = NORMALIZUJ
+STDEV.P = ODCH.STAND.POPUL
+STDEV.S = ODCH.STANDARD.PRÓBKI
+STDEVA = ODCH.STANDARDOWE.A
+STDEVPA = ODCH.STANDARD.POPUL.A
+STEYX = REGBŁSTD
+T.DIST = ROZKŁ.T
+T.DIST.2T = ROZKŁ.T.DS
+T.DIST.RT = ROZKŁ.T.PS
+T.INV = ROZKŁ.T.ODWR
+T.INV.2T = ROZKŁ.T.ODWR.DS
+T.TEST = T.TEST
+TREND = REGLINW
+TRIMMEAN = ŚREDNIA.WEWN
+VAR.P = WARIANCJA.POP
+VAR.S = WARIANCJA.PRÓBKI
+VARA = WARIANCJA.A
+VARPA = WARIANCJA.POPUL.A
+WEIBULL.DIST = ROZKŁ.WEIBULL
+Z.TEST = Z.TEST
+
+##
+## Funkcje tekstowe (Text Functions)
+##
+BAHTTEXT = BAT.TEKST
+CHAR = ZNAK
+CLEAN = OCZYŚĆ
+CODE = KOD
+CONCAT = ZŁĄCZ.TEKST
+DOLLAR = KWOTA
+EXACT = PORÓWNAJ
+FIND = ZNAJDŹ
+FIXED = ZAOKR.DO.TEKST
+ISTHAIDIGIT = CZY.CYFRA.TAJ
+LEFT = LEWY
+LEN = DŁ
+LOWER = LITERY.MAŁE
+MID = FRAGMENT.TEKSTU
+NUMBERSTRING = LICZBA.CIĄG.ZNAK
+NUMBERVALUE = WARTOŚĆ.LICZBOWA
+PROPER = Z.WIELKIEJ.LITERY
+REPLACE = ZASTĄP
+REPT = POWT
+RIGHT = PRAWY
+SEARCH = SZUKAJ.TEKST
+SUBSTITUTE = PODSTAW
+T = T
+TEXT = TEKST
+TEXTJOIN = POŁĄCZ.TEKSTY
+THAIDIGIT = TAJ.CYFRA
+THAINUMSOUND = TAJ.DŹWIĘK.NUM
+THAINUMSTRING = TAJ.CIĄG.NUM
+THAISTRINGLENGTH = TAJ.DŁUGOŚĆ.CIĄGU
+TRIM = USUŃ.ZBĘDNE.ODSTĘPY
+UNICHAR = ZNAK.UNICODE
+UNICODE = UNICODE
+UPPER = LITERY.WIELKIE
+VALUE = WARTOŚĆ
+
+##
+## Funkcje sieci Web (Web Functions)
+##
+ENCODEURL = ENCODEURL
+FILTERXML = FILTERXML
+WEBSERVICE = WEBSERVICE
+
+##
+## Funkcje zgodności (Compatibility Functions)
+##
+BETADIST = ROZKŁAD.BETA
+BETAINV = ROZKŁAD.BETA.ODW
+BINOMDIST = ROZKŁAD.DWUM
+CEILING = ZAOKR.W.GÓRĘ
+CHIDIST = ROZKŁAD.CHI
+CHIINV = ROZKŁAD.CHI.ODW
+CHITEST = TEST.CHI
+CONCATENATE = ZŁĄCZ.TEKSTY
+CONFIDENCE = UFNOŚĆ
+COVAR = KOWARIANCJA
+CRITBINOM = PRÓG.ROZKŁAD.DWUM
+EXPONDIST = ROZKŁAD.EXP
+FDIST = ROZKŁAD.F
+FINV = ROZKŁAD.F.ODW
+FLOOR = ZAOKR.W.DÓŁ
+FORECAST = REGLINX
+FTEST = TEST.F
+GAMMADIST = ROZKŁAD.GAMMA
+GAMMAINV = ROZKŁAD.GAMMA.ODW
+HYPGEOMDIST = ROZKŁAD.HIPERGEOM
+LOGINV = ROZKŁAD.LOG.ODW
+LOGNORMDIST = ROZKŁAD.LOG
+MODE = WYST.NAJCZĘŚCIEJ
+NEGBINOMDIST = ROZKŁAD.DWUM.PRZEC
+NORMDIST = ROZKŁAD.NORMALNY
+NORMINV = ROZKŁAD.NORMALNY.ODW
+NORMSDIST = ROZKŁAD.NORMALNY.S
+NORMSINV = ROZKŁAD.NORMALNY.S.ODW
+PERCENTILE = PERCENTYL
+PERCENTRANK = PROCENT.POZYCJA
+POISSON = ROZKŁAD.POISSON
+QUARTILE = KWARTYL
+RANK = POZYCJA
+STDEV = ODCH.STANDARDOWE
+STDEVP = ODCH.STANDARD.POPUL
+TDIST = ROZKŁAD.T
+TINV = ROZKŁAD.T.ODW
+TTEST = TEST.T
+VAR = WARIANCJA
+VARP = WARIANCJA.POPUL
+WEIBULL = ROZKŁAD.WEIBULL
+ZTEST = TEST.Z

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/pt/br/functions

@@ -0,0 +1,527 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Português Brasileiro (Brazilian Portuguese)
+##
+############################################################
+
+
+##
+## Funções de cubo (Cube Functions)
+##
+CUBEKPIMEMBER = MEMBROKPICUBO
+CUBEMEMBER = MEMBROCUBO
+CUBEMEMBERPROPERTY = PROPRIEDADEMEMBROCUBO
+CUBERANKEDMEMBER = MEMBROCLASSIFICADOCUBO
+CUBESET = CONJUNTOCUBO
+CUBESETCOUNT = CONTAGEMCONJUNTOCUBO
+CUBEVALUE = VALORCUBO
+
+##
+## Funções de banco de dados (Database Functions)
+##
+DAVERAGE = BDMÉDIA
+DCOUNT = BDCONTAR
+DCOUNTA = BDCONTARA
+DGET = BDEXTRAIR
+DMAX = BDMÁX
+DMIN = BDMÍN
+DPRODUCT = BDMULTIPL
+DSTDEV = BDEST
+DSTDEVP = BDDESVPA
+DSUM = BDSOMA
+DVAR = BDVAREST
+DVARP = BDVARP
+
+##
+## Funções de data e hora (Date & Time Functions)
+##
+DATE = DATA
+DATEDIF = DATADIF
+DATESTRING = DATA.SÉRIE
+DATEVALUE = DATA.VALOR
+DAY = DIA
+DAYS = DIAS
+DAYS360 = DIAS360
+EDATE = DATAM
+EOMONTH = FIMMÊS
+HOUR = HORA
+ISOWEEKNUM = NÚMSEMANAISO
+MINUTE = MINUTO
+MONTH = MÊS
+NETWORKDAYS = DIATRABALHOTOTAL
+NETWORKDAYS.INTL = DIATRABALHOTOTAL.INTL
+NOW = AGORA
+SECOND = SEGUNDO
+TIME = TEMPO
+TIMEVALUE = VALOR.TEMPO
+TODAY = HOJE
+WEEKDAY = DIA.DA.SEMANA
+WEEKNUM = NÚMSEMANA
+WORKDAY = DIATRABALHO
+WORKDAY.INTL = DIATRABALHO.INTL
+YEAR = ANO
+YEARFRAC = FRAÇÃOANO
+
+##
+## Funções de engenharia (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BINADEC
+BIN2HEX = BINAHEX
+BIN2OCT = BINAOCT
+BITAND = BITAND
+BITLSHIFT = DESLOCESQBIT
+BITOR = BITOR
+BITRSHIFT = DESLOCDIRBIT
+BITXOR = BITXOR
+COMPLEX = COMPLEXO
+CONVERT = CONVERTER
+DEC2BIN = DECABIN
+DEC2HEX = DECAHEX
+DEC2OCT = DECAOCT
+DELTA = DELTA
+ERF = FUNERRO
+ERF.PRECISE = FUNERRO.PRECISO
+ERFC = FUNERROCOMPL
+ERFC.PRECISE = FUNERROCOMPL.PRECISO
+GESTEP = DEGRAU
+HEX2BIN = HEXABIN
+HEX2DEC = HEXADEC
+HEX2OCT = HEXAOCT
+IMABS = IMABS
+IMAGINARY = IMAGINÁRIO
+IMARGUMENT = IMARG
+IMCONJUGATE = IMCONJ
+IMCOS = IMCOS
+IMCOSH = IMCOSH
+IMCOT = IMCOT
+IMCSC = IMCOSEC
+IMCSCH = IMCOSECH
+IMDIV = IMDIV
+IMEXP = IMEXP
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMPOT
+IMPRODUCT = IMPROD
+IMREAL = IMREAL
+IMSEC = IMSEC
+IMSECH = IMSECH
+IMSIN = IMSENO
+IMSINH = IMSENH
+IMSQRT = IMRAIZ
+IMSUB = IMSUBTR
+IMSUM = IMSOMA
+IMTAN = IMTAN
+OCT2BIN = OCTABIN
+OCT2DEC = OCTADEC
+OCT2HEX = OCTAHEX
+
+##
+## Funções financeiras (Financial Functions)
+##
+ACCRINT = JUROSACUM
+ACCRINTM = JUROSACUMV
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = CUPDIASINLIQ
+COUPDAYS = CUPDIAS
+COUPDAYSNC = CUPDIASPRÓX
+COUPNCD = CUPDATAPRÓX
+COUPNUM = CUPNÚM
+COUPPCD = CUPDATAANT
+CUMIPMT = PGTOJURACUM
+CUMPRINC = PGTOCAPACUM
+DB = BD
+DDB = BDD
+DISC = DESC
+DOLLARDE = MOEDADEC
+DOLLARFR = MOEDAFRA
+DURATION = DURAÇÃO
+EFFECT = EFETIVA
+FV = VF
+FVSCHEDULE = VFPLANO
+INTRATE = TAXAJUROS
+IPMT = IPGTO
+IRR = TIR
+ISPMT = ÉPGTO
+MDURATION = MDURAÇÃO
+MIRR = MTIR
+NOMINAL = NOMINAL
+NPER = NPER
+NPV = VPL
+ODDFPRICE = PREÇOPRIMINC
+ODDFYIELD = LUCROPRIMINC
+ODDLPRICE = PREÇOÚLTINC
+ODDLYIELD = LUCROÚLTINC
+PDURATION = DURAÇÃOP
+PMT = PGTO
+PPMT = PPGTO
+PRICE = PREÇO
+PRICEDISC = PREÇODESC
+PRICEMAT = PREÇOVENC
+PV = VP
+RATE = TAXA
+RECEIVED = RECEBER
+RRI = TAXAJURO
+SLN = DPD
+SYD = SDA
+TBILLEQ = OTN
+TBILLPRICE = OTNVALOR
+TBILLYIELD = OTNLUCRO
+VDB = BDV
+XIRR = XTIR
+XNPV = XVPL
+YIELD = LUCRO
+YIELDDISC = LUCRODESC
+YIELDMAT = LUCROVENC
+
+##
+## Funções de informação (Information Functions)
+##
+CELL = CÉL
+ERROR.TYPE = TIPO.ERRO
+INFO = INFORMAÇÃO
+ISBLANK = ÉCÉL.VAZIA
+ISERR = ÉERRO
+ISERROR = ÉERROS
+ISEVEN = ÉPAR
+ISFORMULA = ÉFÓRMULA
+ISLOGICAL = ÉLÓGICO
+ISNA = É.NÃO.DISP
+ISNONTEXT = É.NÃO.TEXTO
+ISNUMBER = ÉNÚM
+ISODD = ÉIMPAR
+ISREF = ÉREF
+ISTEXT = ÉTEXTO
+N = N
+NA = NÃO.DISP
+SHEET = PLAN
+SHEETS = PLANS
+TYPE = TIPO
+
+##
+## Funções lógicas (Logical Functions)
+##
+AND = E
+FALSE = FALSO
+IF = SE
+IFERROR = SEERRO
+IFNA = SENÃODISP
+IFS = SES
+NOT = NÃO
+OR = OU
+SWITCH = PARÂMETRO
+TRUE = VERDADEIRO
+XOR = XOR
+
+##
+## Funções de pesquisa e referência (Lookup & Reference Functions)
+##
+ADDRESS = ENDEREÇO
+AREAS = ÁREAS
+CHOOSE = ESCOLHER
+COLUMN = COL
+COLUMNS = COLS
+FORMULATEXT = FÓRMULATEXTO
+GETPIVOTDATA = INFODADOSTABELADINÂMICA
+HLOOKUP = PROCH
+HYPERLINK = HIPERLINK
+INDEX = ÍNDICE
+INDIRECT = INDIRETO
+LOOKUP = PROC
+MATCH = CORRESP
+OFFSET = DESLOC
+ROW = LIN
+ROWS = LINS
+RTD = RTD
+TRANSPOSE = TRANSPOR
+VLOOKUP = PROCV
+
+##
+## Funções matemáticas e trigonométricas (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGREGAR
+ARABIC = ARÁBICO
+ASIN = ASEN
+ASINH = ASENH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = BASE
+CEILING.MATH = TETO.MAT
+CEILING.PRECISE = TETO.PRECISO
+COMBIN = COMBIN
+COMBINA = COMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = COSEC
+CSCH = COSECH
+DECIMAL = DECIMAL
+DEGREES = GRAUS
+ECMA.CEILING = ECMA.TETO
+EVEN = PAR
+EXP = EXP
+FACT = FATORIAL
+FACTDOUBLE = FATDUPLO
+FLOOR.MATH = ARREDMULTB.MAT
+FLOOR.PRECISE = ARREDMULTB.PRECISO
+GCD = MDC
+INT = INT
+ISO.CEILING = ISO.TETO
+LCM = MMC
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MATRIZ.DETERM
+MINVERSE = MATRIZ.INVERSO
+MMULT = MATRIZ.MULT
+MOD = MOD
+MROUND = MARRED
+MULTINOMIAL = MULTINOMIAL
+MUNIT = MUNIT
+ODD = ÍMPAR
+PI = PI
+POWER = POTÊNCIA
+PRODUCT = MULT
+QUOTIENT = QUOCIENTE
+RADIANS = RADIANOS
+RAND = ALEATÓRIO
+RANDBETWEEN = ALEATÓRIOENTRE
+ROMAN = ROMANO
+ROUND = ARRED
+ROUNDDOWN = ARREDONDAR.PARA.BAIXO
+ROUNDUP = ARREDONDAR.PARA.CIMA
+SEC = SEC
+SECH = SECH
+SERIESSUM = SOMASEQÜÊNCIA
+SIGN = SINAL
+SIN = SEN
+SINH = SENH
+SQRT = RAIZ
+SQRTPI = RAIZPI
+SUBTOTAL = SUBTOTAL
+SUM = SOMA
+SUMIF = SOMASE
+SUMIFS = SOMASES
+SUMPRODUCT = SOMARPRODUTO
+SUMSQ = SOMAQUAD
+SUMX2MY2 = SOMAX2DY2
+SUMX2PY2 = SOMAX2SY2
+SUMXMY2 = SOMAXMY2
+TAN = TAN
+TANH = TANH
+TRUNC = TRUNCAR
+
+##
+## Funções estatísticas (Statistical Functions)
+##
+AVEDEV = DESV.MÉDIO
+AVERAGE = MÉDIA
+AVERAGEA = MÉDIAA
+AVERAGEIF = MÉDIASE
+AVERAGEIFS = MÉDIASES
+BETA.DIST = DIST.BETA
+BETA.INV = INV.BETA
+BINOM.DIST = DISTR.BINOM
+BINOM.DIST.RANGE = INTERV.DISTR.BINOM
+BINOM.INV = INV.BINOM
+CHISQ.DIST = DIST.QUIQUA
+CHISQ.DIST.RT = DIST.QUIQUA.CD
+CHISQ.INV = INV.QUIQUA
+CHISQ.INV.RT = INV.QUIQUA.CD
+CHISQ.TEST = TESTE.QUIQUA
+CONFIDENCE.NORM = INT.CONFIANÇA.NORM
+CONFIDENCE.T = INT.CONFIANÇA.T
+CORREL = CORREL
+COUNT = CONT.NÚM
+COUNTA = CONT.VALORES
+COUNTBLANK = CONTAR.VAZIO
+COUNTIF = CONT.SE
+COUNTIFS = CONT.SES
+COVARIANCE.P = COVARIAÇÃO.P
+COVARIANCE.S = COVARIAÇÃO.S
+DEVSQ = DESVQ
+EXPON.DIST = DISTR.EXPON
+F.DIST = DIST.F
+F.DIST.RT = DIST.F.CD
+F.INV = INV.F
+F.INV.RT = INV.F.CD
+F.TEST = TESTE.F
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PREVISÃO.ETS
+FORECAST.ETS.CONFINT = PREVISÃO.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PREVISÃO.ETS.SAZONALIDADE
+FORECAST.ETS.STAT = PREVISÃO.ETS.STAT
+FORECAST.LINEAR = PREVISÃO.LINEAR
+FREQUENCY = FREQÜÊNCIA
+GAMMA = GAMA
+GAMMA.DIST = DIST.GAMA
+GAMMA.INV = INV.GAMA
+GAMMALN = LNGAMA
+GAMMALN.PRECISE = LNGAMA.PRECISO
+GAUSS = GAUSS
+GEOMEAN = MÉDIA.GEOMÉTRICA
+GROWTH = CRESCIMENTO
+HARMEAN = MÉDIA.HARMÔNICA
+HYPGEOM.DIST = DIST.HIPERGEOM.N
+INTERCEPT = INTERCEPÇÃO
+KURT = CURT
+LARGE = MAIOR
+LINEST = PROJ.LIN
+LOGEST = PROJ.LOG
+LOGNORM.DIST = DIST.LOGNORMAL.N
+LOGNORM.INV = INV.LOGNORMAL
+MAX = MÁXIMO
+MAXA = MÁXIMOA
+MAXIFS = MÁXIMOSES
+MEDIAN = MED
+MIN = MÍNIMO
+MINA = MÍNIMOA
+MINIFS = MÍNIMOSES
+MODE.MULT = MODO.MULT
+MODE.SNGL = MODO.ÚNICO
+NEGBINOM.DIST = DIST.BIN.NEG.N
+NORM.DIST = DIST.NORM.N
+NORM.INV = INV.NORM.N
+NORM.S.DIST = DIST.NORMP.N
+NORM.S.INV = INV.NORMP.N
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIL.EXC
+PERCENTILE.INC = PERCENTIL.INC
+PERCENTRANK.EXC = ORDEM.PORCENTUAL.EXC
+PERCENTRANK.INC = ORDEM.PORCENTUAL.INC
+PERMUT = PERMUT
+PERMUTATIONA = PERMUTAS
+PHI = PHI
+POISSON.DIST = DIST.POISSON
+PROB = PROB
+QUARTILE.EXC = QUARTIL.EXC
+QUARTILE.INC = QUARTIL.INC
+RANK.AVG = ORDEM.MÉD
+RANK.EQ = ORDEM.EQ
+RSQ = RQUAD
+SKEW = DISTORÇÃO
+SKEW.P = DISTORÇÃO.P
+SLOPE = INCLINAÇÃO
+SMALL = MENOR
+STANDARDIZE = PADRONIZAR
+STDEV.P = DESVPAD.P
+STDEV.S = DESVPAD.A
+STDEVA = DESVPADA
+STDEVPA = DESVPADPA
+STEYX = EPADYX
+T.DIST = DIST.T
+T.DIST.2T = DIST.T.BC
+T.DIST.RT = DIST.T.CD
+T.INV = INV.T
+T.INV.2T = INV.T.BC
+T.TEST = TESTE.T
+TREND = TENDÊNCIA
+TRIMMEAN = MÉDIA.INTERNA
+VAR.P = VAR.P
+VAR.S = VAR.A
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = DIST.WEIBULL
+Z.TEST = TESTE.Z
+
+##
+## Funções de texto (Text Functions)
+##
+BAHTTEXT = BAHTTEXT
+CHAR = CARACT
+CLEAN = TIRAR
+CODE = CÓDIGO
+CONCAT = CONCAT
+DOLLAR = MOEDA
+EXACT = EXATO
+FIND = PROCURAR
+FIXED = DEF.NÚM.DEC
+LEFT = ESQUERDA
+LEN = NÚM.CARACT
+LOWER = MINÚSCULA
+MID = EXT.TEXTO
+NUMBERSTRING = SEQÜÊNCIA.NÚMERO
+NUMBERVALUE = VALORNUMÉRICO
+PHONETIC = FONÉTICA
+PROPER = PRI.MAIÚSCULA
+REPLACE = MUDAR
+REPT = REPT
+RIGHT = DIREITA
+SEARCH = LOCALIZAR
+SUBSTITUTE = SUBSTITUIR
+T = T
+TEXT = TEXTO
+TEXTJOIN = UNIRTEXTO
+TRIM = ARRUMAR
+UNICHAR = CARACTUNICODE
+UNICODE = UNICODE
+UPPER = MAIÚSCULA
+VALUE = VALOR
+
+##
+## Funções da Web (Web Functions)
+##
+ENCODEURL = CODIFURL
+FILTERXML = FILTROXML
+WEBSERVICE = SERVIÇOWEB
+
+##
+## Funções de compatibilidade (Compatibility Functions)
+##
+BETADIST = DISTBETA
+BETAINV = BETA.ACUM.INV
+BINOMDIST = DISTRBINOM
+CEILING = TETO
+CHIDIST = DIST.QUI
+CHIINV = INV.QUI
+CHITEST = TESTE.QUI
+CONCATENATE = CONCATENAR
+CONFIDENCE = INT.CONFIANÇA
+COVAR = COVAR
+CRITBINOM = CRIT.BINOM
+EXPONDIST = DISTEXPON
+FDIST = DISTF
+FINV = INVF
+FLOOR = ARREDMULTB
+FORECAST = PREVISÃO
+FTEST = TESTEF
+GAMMADIST = DISTGAMA
+GAMMAINV = INVGAMA
+HYPGEOMDIST = DIST.HIPERGEOM
+LOGINV = INVLOG
+LOGNORMDIST = DIST.LOGNORMAL
+MODE = MODO
+NEGBINOMDIST = DIST.BIN.NEG
+NORMDIST = DISTNORM
+NORMINV = INV.NORM
+NORMSDIST = DISTNORMP
+NORMSINV = INV.NORMP
+PERCENTILE = PERCENTIL
+PERCENTRANK = ORDEM.PORCENTUAL
+POISSON = POISSON
+QUARTILE = QUARTIL
+RANK = ORDEM
+STDEV = DESVPAD
+STDEVP = DESVPADP
+TDIST = DISTT
+TINV = INVT
+TTEST = TESTET
+VAR = VAR
+VARP = VARP
+WEIBULL = WEIBULL
+ZTEST = TESTEZ

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/pt/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Português (Portuguese)
+##
+############################################################
+
+
+##
+## Funções de cubo (Cube Functions)
+##
+CUBEKPIMEMBER = MEMBROKPICUBO
+CUBEMEMBER = MEMBROCUBO
+CUBEMEMBERPROPERTY = PROPRIEDADEMEMBROCUBO
+CUBERANKEDMEMBER = MEMBROCLASSIFICADOCUBO
+CUBESET = CONJUNTOCUBO
+CUBESETCOUNT = CONTARCONJUNTOCUBO
+CUBEVALUE = VALORCUBO
+
+##
+## Funções de base de dados (Database Functions)
+##
+DAVERAGE = BDMÉDIA
+DCOUNT = BDCONTAR
+DCOUNTA = BDCONTAR.VAL
+DGET = BDOBTER
+DMAX = BDMÁX
+DMIN = BDMÍN
+DPRODUCT = BDMULTIPL
+DSTDEV = BDDESVPAD
+DSTDEVP = BDDESVPADP
+DSUM = BDSOMA
+DVAR = BDVAR
+DVARP = BDVARP
+
+##
+## Funções de data e hora (Date & Time Functions)
+##
+DATE = DATA
+DATEDIF = DATADIF
+DATESTRING = DATA.CADEIA
+DATEVALUE = DATA.VALOR
+DAY = DIA
+DAYS = DIAS
+DAYS360 = DIAS360
+EDATE = DATAM
+EOMONTH = FIMMÊS
+HOUR = HORA
+ISOWEEKNUM = NUMSEMANAISO
+MINUTE = MINUTO
+MONTH = MÊS
+NETWORKDAYS = DIATRABALHOTOTAL
+NETWORKDAYS.INTL = DIATRABALHOTOTAL.INTL
+NOW = AGORA
+SECOND = SEGUNDO
+THAIDAYOFWEEK = DIA.DA.SEMANA.TAILANDÊS
+THAIMONTHOFYEAR = MÊS.DO.ANO.TAILANDÊS
+THAIYEAR = ANO.TAILANDÊS
+TIME = TEMPO
+TIMEVALUE = VALOR.TEMPO
+TODAY = HOJE
+WEEKDAY = DIA.SEMANA
+WEEKNUM = NÚMSEMANA
+WORKDAY = DIATRABALHO
+WORKDAY.INTL = DIATRABALHO.INTL
+YEAR = ANO
+YEARFRAC = FRAÇÃOANO
+
+##
+## Funções de engenharia (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BINADEC
+BIN2HEX = BINAHEX
+BIN2OCT = BINAOCT
+BITAND = BIT.E
+BITLSHIFT = BITDESL.ESQ
+BITOR = BIT.OU
+BITRSHIFT = BITDESL.DIR
+BITXOR = BIT.XOU
+COMPLEX = COMPLEXO
+CONVERT = CONVERTER
+DEC2BIN = DECABIN
+DEC2HEX = DECAHEX
+DEC2OCT = DECAOCT
+DELTA = DELTA
+ERF = FUNCERRO
+ERF.PRECISE = FUNCERRO.PRECISO
+ERFC = FUNCERROCOMPL
+ERFC.PRECISE = FUNCERROCOMPL.PRECISO
+GESTEP = DEGRAU
+HEX2BIN = HEXABIN
+HEX2DEC = HEXADEC
+HEX2OCT = HEXAOCT
+IMABS = IMABS
+IMAGINARY = IMAGINÁRIO
+IMARGUMENT = IMARG
+IMCONJUGATE = IMCONJ
+IMCOS = IMCOS
+IMCOSH = IMCOSH
+IMCOT = IMCOT
+IMCSC = IMCSC
+IMCSCH = IMCSCH
+IMDIV = IMDIV
+IMEXP = IMEXP
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMPOT
+IMPRODUCT = IMPROD
+IMREAL = IMREAL
+IMSEC = IMSEC
+IMSECH = IMSECH
+IMSIN = IMSENO
+IMSINH = IMSENOH
+IMSQRT = IMRAIZ
+IMSUB = IMSUBTR
+IMSUM = IMSOMA
+IMTAN = IMTAN
+OCT2BIN = OCTABIN
+OCT2DEC = OCTADEC
+OCT2HEX = OCTAHEX
+
+##
+## Funções financeiras (Financial Functions)
+##
+ACCRINT = JUROSACUM
+ACCRINTM = JUROSACUMV
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = CUPDIASINLIQ
+COUPDAYS = CUPDIAS
+COUPDAYSNC = CUPDIASPRÓX
+COUPNCD = CUPDATAPRÓX
+COUPNUM = CUPNÚM
+COUPPCD = CUPDATAANT
+CUMIPMT = PGTOJURACUM
+CUMPRINC = PGTOCAPACUM
+DB = BD
+DDB = BDD
+DISC = DESC
+DOLLARDE = MOEDADEC
+DOLLARFR = MOEDAFRA
+DURATION = DURAÇÃO
+EFFECT = EFETIVA
+FV = VF
+FVSCHEDULE = VFPLANO
+INTRATE = TAXAJUROS
+IPMT = IPGTO
+IRR = TIR
+ISPMT = É.PGTO
+MDURATION = MDURAÇÃO
+MIRR = MTIR
+NOMINAL = NOMINAL
+NPER = NPER
+NPV = VAL
+ODDFPRICE = PREÇOPRIMINC
+ODDFYIELD = LUCROPRIMINC
+ODDLPRICE = PREÇOÚLTINC
+ODDLYIELD = LUCROÚLTINC
+PDURATION = PDURAÇÃO
+PMT = PGTO
+PPMT = PPGTO
+PRICE = PREÇO
+PRICEDISC = PREÇODESC
+PRICEMAT = PREÇOVENC
+PV = VA
+RATE = TAXA
+RECEIVED = RECEBER
+RRI = DEVOLVERTAXAJUROS
+SLN = AMORT
+SYD = AMORTD
+TBILLEQ = OTN
+TBILLPRICE = OTNVALOR
+TBILLYIELD = OTNLUCRO
+VDB = BDV
+XIRR = XTIR
+XNPV = XVAL
+YIELD = LUCRO
+YIELDDISC = LUCRODESC
+YIELDMAT = LUCROVENC
+
+##
+## Funções de informação (Information Functions)
+##
+CELL = CÉL
+ERROR.TYPE = TIPO.ERRO
+INFO = INFORMAÇÃO
+ISBLANK = É.CÉL.VAZIA
+ISERR = É.ERROS
+ISERROR = É.ERRO
+ISEVEN = ÉPAR
+ISFORMULA = É.FORMULA
+ISLOGICAL = É.LÓGICO
+ISNA = É.NÃO.DISP
+ISNONTEXT = É.NÃO.TEXTO
+ISNUMBER = É.NÚM
+ISODD = ÉÍMPAR
+ISREF = É.REF
+ISTEXT = É.TEXTO
+N = N
+NA = NÃO.DISP
+SHEET = FOLHA
+SHEETS = FOLHAS
+TYPE = TIPO
+
+##
+## Funções lógicas (Logical Functions)
+##
+AND = E
+FALSE = FALSO
+IF = SE
+IFERROR = SE.ERRO
+IFNA = SEND
+IFS = SE.S
+NOT = NÃO
+OR = OU
+SWITCH = PARÂMETRO
+TRUE = VERDADEIRO
+XOR = XOU
+
+##
+## Funções de pesquisa e referência (Lookup & Reference Functions)
+##
+ADDRESS = ENDEREÇO
+AREAS = ÁREAS
+CHOOSE = SELECIONAR
+COLUMN = COL
+COLUMNS = COLS
+FORMULATEXT = FÓRMULA.TEXTO
+GETPIVOTDATA = OBTERDADOSDIN
+HLOOKUP = PROCH
+HYPERLINK = HIPERLIGAÇÃO
+INDEX = ÍNDICE
+INDIRECT = INDIRETO
+LOOKUP = PROC
+MATCH = CORRESP
+OFFSET = DESLOCAMENTO
+ROW = LIN
+ROWS = LINS
+RTD = RTD
+TRANSPOSE = TRANSPOR
+VLOOKUP = PROCV
+
+##
+## Funções matemáticas e trigonométricas (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = AGREGAR
+ARABIC = ÁRABE
+ASIN = ASEN
+ASINH = ASENH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = BASE
+CEILING.MATH = ARRED.EXCESSO.MAT
+CEILING.PRECISE = ARRED.EXCESSO.PRECISO
+COMBIN = COMBIN
+COMBINA = COMBIN.R
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMAL
+DEGREES = GRAUS
+ECMA.CEILING = ARRED.EXCESSO.ECMA
+EVEN = PAR
+EXP = EXP
+FACT = FATORIAL
+FACTDOUBLE = FATDUPLO
+FLOOR.MATH = ARRED.DEFEITO.MAT
+FLOOR.PRECISE = ARRED.DEFEITO.PRECISO
+GCD = MDC
+INT = INT
+ISO.CEILING = ARRED.EXCESSO.ISO
+LCM = MMC
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MATRIZ.DETERM
+MINVERSE = MATRIZ.INVERSA
+MMULT = MATRIZ.MULT
+MOD = RESTO
+MROUND = MARRED
+MULTINOMIAL = POLINOMIAL
+MUNIT = UNIDM
+ODD = ÍMPAR
+PI = PI
+POWER = POTÊNCIA
+PRODUCT = PRODUTO
+QUOTIENT = QUOCIENTE
+RADIANS = RADIANOS
+RAND = ALEATÓRIO
+RANDBETWEEN = ALEATÓRIOENTRE
+ROMAN = ROMANO
+ROUND = ARRED
+ROUNDBAHTDOWN = ARREDOND.BAHT.BAIXO
+ROUNDBAHTUP = ARREDOND.BAHT.CIMA
+ROUNDDOWN = ARRED.PARA.BAIXO
+ROUNDUP = ARRED.PARA.CIMA
+SEC = SEC
+SECH = SECH
+SERIESSUM = SOMASÉRIE
+SIGN = SINAL
+SIN = SEN
+SINH = SENH
+SQRT = RAIZQ
+SQRTPI = RAIZPI
+SUBTOTAL = SUBTOTAL
+SUM = SOMA
+SUMIF = SOMA.SE
+SUMIFS = SOMA.SE.S
+SUMPRODUCT = SOMARPRODUTO
+SUMSQ = SOMARQUAD
+SUMX2MY2 = SOMAX2DY2
+SUMX2PY2 = SOMAX2SY2
+SUMXMY2 = SOMAXMY2
+TAN = TAN
+TANH = TANH
+TRUNC = TRUNCAR
+
+##
+## Funções estatísticas (Statistical Functions)
+##
+AVEDEV = DESV.MÉDIO
+AVERAGE = MÉDIA
+AVERAGEA = MÉDIAA
+AVERAGEIF = MÉDIA.SE
+AVERAGEIFS = MÉDIA.SE.S
+BETA.DIST = DIST.BETA
+BETA.INV = INV.BETA
+BINOM.DIST = DISTR.BINOM
+BINOM.DIST.RANGE = DIST.BINOM.INTERVALO
+BINOM.INV = INV.BINOM
+CHISQ.DIST = DIST.CHIQ
+CHISQ.DIST.RT = DIST.CHIQ.DIR
+CHISQ.INV = INV.CHIQ
+CHISQ.INV.RT = INV.CHIQ.DIR
+CHISQ.TEST = TESTE.CHIQ
+CONFIDENCE.NORM = INT.CONFIANÇA.NORM
+CONFIDENCE.T = INT.CONFIANÇA.T
+CORREL = CORREL
+COUNT = CONTAR
+COUNTA = CONTAR.VAL
+COUNTBLANK = CONTAR.VAZIO
+COUNTIF = CONTAR.SE
+COUNTIFS = CONTAR.SE.S
+COVARIANCE.P = COVARIÂNCIA.P
+COVARIANCE.S = COVARIÂNCIA.S
+DEVSQ = DESVQ
+EXPON.DIST = DIST.EXPON
+F.DIST = DIST.F
+F.DIST.RT = DIST.F.DIR
+F.INV = INV.F
+F.INV.RT = INV.F.DIR
+F.TEST = TESTE.F
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PREVISÃO.ETS
+FORECAST.ETS.CONFINT = PREVISÃO.ETS.CONFINT
+FORECAST.ETS.SEASONALITY = PREVISÃO.ETS.SAZONALIDADE
+FORECAST.ETS.STAT = PREVISÃO.ETS.ESTATÍSTICA
+FORECAST.LINEAR = PREVISÃO.LINEAR
+FREQUENCY = FREQUÊNCIA
+GAMMA = GAMA
+GAMMA.DIST = DIST.GAMA
+GAMMA.INV = INV.GAMA
+GAMMALN = LNGAMA
+GAMMALN.PRECISE = LNGAMA.PRECISO
+GAUSS = GAUSS
+GEOMEAN = MÉDIA.GEOMÉTRICA
+GROWTH = CRESCIMENTO
+HARMEAN = MÉDIA.HARMÓNICA
+HYPGEOM.DIST = DIST.HIPGEOM
+INTERCEPT = INTERCETAR
+KURT = CURT
+LARGE = MAIOR
+LINEST = PROJ.LIN
+LOGEST = PROJ.LOG
+LOGNORM.DIST = DIST.NORMLOG
+LOGNORM.INV = INV.NORMALLOG
+MAX = MÁXIMO
+MAXA = MÁXIMOA
+MAXIFS = MÁXIMO.SE.S
+MEDIAN = MED
+MIN = MÍNIMO
+MINA = MÍNIMOA
+MINIFS = MÍNIMO.SE.S
+MODE.MULT = MODO.MÚLT
+MODE.SNGL = MODO.SIMPLES
+NEGBINOM.DIST = DIST.BINOM.NEG
+NORM.DIST = DIST.NORMAL
+NORM.INV = INV.NORMAL
+NORM.S.DIST = DIST.S.NORM
+NORM.S.INV = INV.S.NORM
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIL.EXC
+PERCENTILE.INC = PERCENTIL.INC
+PERCENTRANK.EXC = ORDEM.PERCENTUAL.EXC
+PERCENTRANK.INC = ORDEM.PERCENTUAL.INC
+PERMUT = PERMUTAR
+PERMUTATIONA = PERMUTAR.R
+PHI = PHI
+POISSON.DIST = DIST.POISSON
+PROB = PROB
+QUARTILE.EXC = QUARTIL.EXC
+QUARTILE.INC = QUARTIL.INC
+RANK.AVG = ORDEM.MÉD
+RANK.EQ = ORDEM.EQ
+RSQ = RQUAD
+SKEW = DISTORÇÃO
+SKEW.P = DISTORÇÃO.P
+SLOPE = DECLIVE
+SMALL = MENOR
+STANDARDIZE = NORMALIZAR
+STDEV.P = DESVPAD.P
+STDEV.S = DESVPAD.S
+STDEVA = DESVPADA
+STDEVPA = DESVPADPA
+STEYX = EPADYX
+T.DIST = DIST.T
+T.DIST.2T = DIST.T.2C
+T.DIST.RT = DIST.T.DIR
+T.INV = INV.T
+T.INV.2T = INV.T.2C
+T.TEST = TESTE.T
+TREND = TENDÊNCIA
+TRIMMEAN = MÉDIA.INTERNA
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = DIST.WEIBULL
+Z.TEST = TESTE.Z
+
+##
+## Funções de texto (Text Functions)
+##
+BAHTTEXT = TEXTO.BAHT
+CHAR = CARÁT
+CLEAN = LIMPARB
+CODE = CÓDIGO
+CONCAT = CONCAT
+DOLLAR = MOEDA
+EXACT = EXATO
+FIND = LOCALIZAR
+FIXED = FIXA
+ISTHAIDIGIT = É.DÍGITO.TAILANDÊS
+LEFT = ESQUERDA
+LEN = NÚM.CARAT
+LOWER = MINÚSCULAS
+MID = SEG.TEXTO
+NUMBERSTRING = NÚMERO.CADEIA
+NUMBERVALUE = VALOR.NÚMERO
+PHONETIC = FONÉTICA
+PROPER = INICIAL.MAIÚSCULA
+REPLACE = SUBSTITUIR
+REPT = REPETIR
+RIGHT = DIREITA
+SEARCH = PROCURAR
+SUBSTITUTE = SUBST
+T = T
+TEXT = TEXTO
+TEXTJOIN = UNIRTEXTO
+THAIDIGIT = DÍGITO.TAILANDÊS
+THAINUMSOUND = SOM.NÚM.TAILANDÊS
+THAINUMSTRING = CADEIA.NÚM.TAILANDÊS
+THAISTRINGLENGTH = COMP.CADEIA.TAILANDÊS
+TRIM = COMPACTAR
+UNICHAR = UNICARÁT
+UNICODE = UNICODE
+UPPER = MAIÚSCULAS
+VALUE = VALOR
+
+##
+## Funções da Web (Web Functions)
+##
+ENCODEURL = CODIFICAÇÃOURL
+FILTERXML = FILTRARXML
+WEBSERVICE = SERVIÇOWEB
+
+##
+## Funções de compatibilidade (Compatibility Functions)
+##
+BETADIST = DISTBETA
+BETAINV = BETA.ACUM.INV
+BINOMDIST = DISTRBINOM
+CEILING = ARRED.EXCESSO
+CHIDIST = DIST.CHI
+CHIINV = INV.CHI
+CHITEST = TESTE.CHI
+CONCATENATE = CONCATENAR
+CONFIDENCE = INT.CONFIANÇA
+COVAR = COVAR
+CRITBINOM = CRIT.BINOM
+EXPONDIST = DISTEXPON
+FDIST = DISTF
+FINV = INVF
+FLOOR = ARRED.DEFEITO
+FORECAST = PREVISÃO
+FTEST = TESTEF
+GAMMADIST = DISTGAMA
+GAMMAINV = INVGAMA
+HYPGEOMDIST = DIST.HIPERGEOM
+LOGINV = INVLOG
+LOGNORMDIST = DIST.NORMALLOG
+MODE = MODA
+NEGBINOMDIST = DIST.BIN.NEG
+NORMDIST = DIST.NORM
+NORMINV = INV.NORM
+NORMSDIST = DIST.NORMP
+NORMSINV = INV.NORMP
+PERCENTILE = PERCENTIL
+PERCENTRANK = ORDEM.PERCENTUAL
+POISSON = POISSON
+QUARTILE = QUARTIL
+RANK = ORDEM
+STDEV = DESVPAD
+STDEVP = DESVPADP
+TDIST = DISTT
+TINV = INVT
+TTEST = TESTET
+VAR = VAR
+VARP = VARP
+WEIBULL = WEIBULL
+ZTEST = TESTEZ

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/ru/functions

@@ -0,0 +1,555 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## русский язык (Russian)
+##
+############################################################
+
+
+##
+## Функции кубов (Cube Functions)
+##
+CUBEKPIMEMBER = КУБЭЛЕМЕНТКИП
+CUBEMEMBER = КУБЭЛЕМЕНТ
+CUBEMEMBERPROPERTY = КУБСВОЙСТВОЭЛЕМЕНТА
+CUBERANKEDMEMBER = КУБПОРЭЛЕМЕНТ
+CUBESET = КУБМНОЖ
+CUBESETCOUNT = КУБЧИСЛОЭЛМНОЖ
+CUBEVALUE = КУБЗНАЧЕНИЕ
+
+##
+## Функции для работы с базами данных (Database Functions)
+##
+DAVERAGE = ДСРЗНАЧ
+DCOUNT = БСЧЁТ
+DCOUNTA = БСЧЁТА
+DGET = БИЗВЛЕЧЬ
+DMAX = ДМАКС
+DMIN = ДМИН
+DPRODUCT = БДПРОИЗВЕД
+DSTDEV = ДСТАНДОТКЛ
+DSTDEVP = ДСТАНДОТКЛП
+DSUM = БДСУММ
+DVAR = БДДИСП
+DVARP = БДДИСПП
+
+##
+## Функции даты и времени (Date & Time Functions)
+##
+DATE = ДАТА
+DATEDIF = РАЗНДАТ
+DATESTRING = СТРОКАДАННЫХ
+DATEVALUE = ДАТАЗНАЧ
+DAY = ДЕНЬ
+DAYS = ДНИ
+DAYS360 = ДНЕЙ360
+EDATE = ДАТАМЕС
+EOMONTH = КОНМЕСЯЦА
+HOUR = ЧАС
+ISOWEEKNUM = НОМНЕДЕЛИ.ISO
+MINUTE = МИНУТЫ
+MONTH = МЕСЯЦ
+NETWORKDAYS = ЧИСТРАБДНИ
+NETWORKDAYS.INTL = ЧИСТРАБДНИ.МЕЖД
+NOW = ТДАТА
+SECOND = СЕКУНДЫ
+THAIDAYOFWEEK = ТАЙДЕНЬНЕД
+THAIMONTHOFYEAR = ТАЙМЕСЯЦ
+THAIYEAR = ТАЙГОД
+TIME = ВРЕМЯ
+TIMEVALUE = ВРЕМЗНАЧ
+TODAY = СЕГОДНЯ
+WEEKDAY = ДЕНЬНЕД
+WEEKNUM = НОМНЕДЕЛИ
+WORKDAY = РАБДЕНЬ
+WORKDAY.INTL = РАБДЕНЬ.МЕЖД
+YEAR = ГОД
+YEARFRAC = ДОЛЯГОДА
+
+##
+## Инженерные функции (Engineering Functions)
+##
+BESSELI = БЕССЕЛЬ.I
+BESSELJ = БЕССЕЛЬ.J
+BESSELK = БЕССЕЛЬ.K
+BESSELY = БЕССЕЛЬ.Y
+BIN2DEC = ДВ.В.ДЕС
+BIN2HEX = ДВ.В.ШЕСТН
+BIN2OCT = ДВ.В.ВОСЬМ
+BITAND = БИТ.И
+BITLSHIFT = БИТ.СДВИГЛ
+BITOR = БИТ.ИЛИ
+BITRSHIFT = БИТ.СДВИГП
+BITXOR = БИТ.ИСКЛИЛИ
+COMPLEX = КОМПЛЕКСН
+CONVERT = ПРЕОБР
+DEC2BIN = ДЕС.В.ДВ
+DEC2HEX = ДЕС.В.ШЕСТН
+DEC2OCT = ДЕС.В.ВОСЬМ
+DELTA = ДЕЛЬТА
+ERF = ФОШ
+ERF.PRECISE = ФОШ.ТОЧН
+ERFC = ДФОШ
+ERFC.PRECISE = ДФОШ.ТОЧН
+GESTEP = ПОРОГ
+HEX2BIN = ШЕСТН.В.ДВ
+HEX2DEC = ШЕСТН.В.ДЕС
+HEX2OCT = ШЕСТН.В.ВОСЬМ
+IMABS = МНИМ.ABS
+IMAGINARY = МНИМ.ЧАСТЬ
+IMARGUMENT = МНИМ.АРГУМЕНТ
+IMCONJUGATE = МНИМ.СОПРЯЖ
+IMCOS = МНИМ.COS
+IMCOSH = МНИМ.COSH
+IMCOT = МНИМ.COT
+IMCSC = МНИМ.CSC
+IMCSCH = МНИМ.CSCH
+IMDIV = МНИМ.ДЕЛ
+IMEXP = МНИМ.EXP
+IMLN = МНИМ.LN
+IMLOG10 = МНИМ.LOG10
+IMLOG2 = МНИМ.LOG2
+IMPOWER = МНИМ.СТЕПЕНЬ
+IMPRODUCT = МНИМ.ПРОИЗВЕД
+IMREAL = МНИМ.ВЕЩ
+IMSEC = МНИМ.SEC
+IMSECH = МНИМ.SECH
+IMSIN = МНИМ.SIN
+IMSINH = МНИМ.SINH
+IMSQRT = МНИМ.КОРЕНЬ
+IMSUB = МНИМ.РАЗН
+IMSUM = МНИМ.СУММ
+IMTAN = МНИМ.TAN
+OCT2BIN = ВОСЬМ.В.ДВ
+OCT2DEC = ВОСЬМ.В.ДЕС
+OCT2HEX = ВОСЬМ.В.ШЕСТН
+
+##
+## Финансовые функции (Financial Functions)
+##
+ACCRINT = НАКОПДОХОД
+ACCRINTM = НАКОПДОХОДПОГАШ
+AMORDEGRC = АМОРУМ
+AMORLINC = АМОРУВ
+COUPDAYBS = ДНЕЙКУПОНДО
+COUPDAYS = ДНЕЙКУПОН
+COUPDAYSNC = ДНЕЙКУПОНПОСЛЕ
+COUPNCD = ДАТАКУПОНПОСЛЕ
+COUPNUM = ЧИСЛКУПОН
+COUPPCD = ДАТАКУПОНДО
+CUMIPMT = ОБЩПЛАТ
+CUMPRINC = ОБЩДОХОД
+DB = ФУО
+DDB = ДДОБ
+DISC = СКИДКА
+DOLLARDE = РУБЛЬ.ДЕС
+DOLLARFR = РУБЛЬ.ДРОБЬ
+DURATION = ДЛИТ
+EFFECT = ЭФФЕКТ
+FV = БС
+FVSCHEDULE = БЗРАСПИС
+INTRATE = ИНОРМА
+IPMT = ПРПЛТ
+IRR = ВСД
+ISPMT = ПРОЦПЛАТ
+MDURATION = МДЛИТ
+MIRR = МВСД
+NOMINAL = НОМИНАЛ
+NPER = КПЕР
+NPV = ЧПС
+ODDFPRICE = ЦЕНАПЕРВНЕРЕГ
+ODDFYIELD = ДОХОДПЕРВНЕРЕГ
+ODDLPRICE = ЦЕНАПОСЛНЕРЕГ
+ODDLYIELD = ДОХОДПОСЛНЕРЕГ
+PDURATION = ПДЛИТ
+PMT = ПЛТ
+PPMT = ОСПЛТ
+PRICE = ЦЕНА
+PRICEDISC = ЦЕНАСКИДКА
+PRICEMAT = ЦЕНАПОГАШ
+PV = ПС
+RATE = СТАВКА
+RECEIVED = ПОЛУЧЕНО
+RRI = ЭКВ.СТАВКА
+SLN = АПЛ
+SYD = АСЧ
+TBILLEQ = РАВНОКЧЕК
+TBILLPRICE = ЦЕНАКЧЕК
+TBILLYIELD = ДОХОДКЧЕК
+USDOLLAR = ДОЛЛСША
+VDB = ПУО
+XIRR = ЧИСТВНДОХ
+XNPV = ЧИСТНЗ
+YIELD = ДОХОД
+YIELDDISC = ДОХОДСКИДКА
+YIELDMAT = ДОХОДПОГАШ
+
+##
+## Информационные функции (Information Functions)
+##
+CELL = ЯЧЕЙКА
+ERROR.TYPE = ТИП.ОШИБКИ
+INFO = ИНФОРМ
+ISBLANK = ЕПУСТО
+ISERR = ЕОШ
+ISERROR = ЕОШИБКА
+ISEVEN = ЕЧЁТН
+ISFORMULA = ЕФОРМУЛА
+ISLOGICAL = ЕЛОГИЧ
+ISNA = ЕНД
+ISNONTEXT = ЕНЕТЕКСТ
+ISNUMBER = ЕЧИСЛО
+ISODD = ЕНЕЧЁТ
+ISREF = ЕССЫЛКА
+ISTEXT = ЕТЕКСТ
+N = Ч
+NA = НД
+SHEET = ЛИСТ
+SHEETS = ЛИСТЫ
+TYPE = ТИП
+
+##
+## Логические функции (Logical Functions)
+##
+AND = И
+FALSE = ЛОЖЬ
+IF = ЕСЛИ
+IFERROR = ЕСЛИОШИБКА
+IFNA = ЕСНД
+IFS = УСЛОВИЯ
+NOT = НЕ
+OR = ИЛИ
+SWITCH = ПЕРЕКЛЮЧ
+TRUE = ИСТИНА
+XOR = ИСКЛИЛИ
+
+##
+## Функции ссылки и поиска (Lookup & Reference Functions)
+##
+ADDRESS = АДРЕС
+AREAS = ОБЛАСТИ
+CHOOSE = ВЫБОР
+COLUMN = СТОЛБЕЦ
+COLUMNS = ЧИСЛСТОЛБ
+FILTER = ФИЛЬТР
+FORMULATEXT = Ф.ТЕКСТ
+GETPIVOTDATA = ПОЛУЧИТЬ.ДАННЫЕ.СВОДНОЙ.ТАБЛИЦЫ
+HLOOKUP = ГПР
+HYPERLINK = ГИПЕРССЫЛКА
+INDEX = ИНДЕКС
+INDIRECT = ДВССЫЛ
+LOOKUP = ПРОСМОТР
+MATCH = ПОИСКПОЗ
+OFFSET = СМЕЩ
+ROW = СТРОКА
+ROWS = ЧСТРОК
+RTD = ДРВ
+SORT = СОРТ
+SORTBY = СОРТПО
+TRANSPOSE = ТРАНСП
+UNIQUE = УНИК
+VLOOKUP = ВПР
+XLOOKUP = ПРОСМОТРX
+XMATCH = ПОИСКПОЗX
+
+##
+## Математические и тригонометрические функции (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = АГРЕГАТ
+ARABIC = АРАБСКОЕ
+ASIN = ASIN
+ASINH = ASINH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = ОСНОВАНИЕ
+CEILING.MATH = ОКРВВЕРХ.МАТ
+CEILING.PRECISE = ОКРВВЕРХ.ТОЧН
+COMBIN = ЧИСЛКОМБ
+COMBINA = ЧИСЛКОМБА
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = ДЕС
+DEGREES = ГРАДУСЫ
+ECMA.CEILING = ECMA.ОКРВВЕРХ
+EVEN = ЧЁТН
+EXP = EXP
+FACT = ФАКТР
+FACTDOUBLE = ДВФАКТР
+FLOOR.MATH = ОКРВНИЗ.МАТ
+FLOOR.PRECISE = ОКРВНИЗ.ТОЧН
+GCD = НОД
+INT = ЦЕЛОЕ
+ISO.CEILING = ISO.ОКРВВЕРХ
+LCM = НОК
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = МОПРЕД
+MINVERSE = МОБР
+MMULT = МУМНОЖ
+MOD = ОСТАТ
+MROUND = ОКРУГЛТ
+MULTINOMIAL = МУЛЬТИНОМ
+MUNIT = МЕДИН
+ODD = НЕЧЁТ
+PI = ПИ
+POWER = СТЕПЕНЬ
+PRODUCT = ПРОИЗВЕД
+QUOTIENT = ЧАСТНОЕ
+RADIANS = РАДИАНЫ
+RAND = СЛЧИС
+RANDARRAY = СЛУЧМАССИВ
+RANDBETWEEN = СЛУЧМЕЖДУ
+ROMAN = РИМСКОЕ
+ROUND = ОКРУГЛ
+ROUNDBAHTDOWN = ОКРУГЛБАТВНИЗ
+ROUNDBAHTUP = ОКРУГЛБАТВВЕРХ
+ROUNDDOWN = ОКРУГЛВНИЗ
+ROUNDUP = ОКРУГЛВВЕРХ
+SEC = SEC
+SECH = SECH
+SERIESSUM = РЯД.СУММ
+SEQUENCE = ПОСЛЕДОВ
+SIGN = ЗНАК
+SIN = SIN
+SINH = SINH
+SQRT = КОРЕНЬ
+SQRTPI = КОРЕНЬПИ
+SUBTOTAL = ПРОМЕЖУТОЧНЫЕ.ИТОГИ
+SUM = СУММ
+SUMIF = СУММЕСЛИ
+SUMIFS = СУММЕСЛИМН
+SUMPRODUCT = СУММПРОИЗВ
+SUMSQ = СУММКВ
+SUMX2MY2 = СУММРАЗНКВ
+SUMX2PY2 = СУММСУММКВ
+SUMXMY2 = СУММКВРАЗН
+TAN = TAN
+TANH = TANH
+TRUNC = ОТБР
+
+##
+## Статистические функции (Statistical Functions)
+##
+AVEDEV = СРОТКЛ
+AVERAGE = СРЗНАЧ
+AVERAGEA = СРЗНАЧА
+AVERAGEIF = СРЗНАЧЕСЛИ
+AVERAGEIFS = СРЗНАЧЕСЛИМН
+BETA.DIST = БЕТА.РАСП
+BETA.INV = БЕТА.ОБР
+BINOM.DIST = БИНОМ.РАСП
+BINOM.DIST.RANGE = БИНОМ.РАСП.ДИАП
+BINOM.INV = БИНОМ.ОБР
+CHISQ.DIST = ХИ2.РАСП
+CHISQ.DIST.RT = ХИ2.РАСП.ПХ
+CHISQ.INV = ХИ2.ОБР
+CHISQ.INV.RT = ХИ2.ОБР.ПХ
+CHISQ.TEST = ХИ2.ТЕСТ
+CONFIDENCE.NORM = ДОВЕРИТ.НОРМ
+CONFIDENCE.T = ДОВЕРИТ.СТЬЮДЕНТ
+CORREL = КОРРЕЛ
+COUNT = СЧЁТ
+COUNTA = СЧЁТЗ
+COUNTBLANK = СЧИТАТЬПУСТОТЫ
+COUNTIF = СЧЁТЕСЛИ
+COUNTIFS = СЧЁТЕСЛИМН
+COVARIANCE.P = КОВАРИАЦИЯ.Г
+COVARIANCE.S = КОВАРИАЦИЯ.В
+DEVSQ = КВАДРОТКЛ
+EXPON.DIST = ЭКСП.РАСП
+F.DIST = F.РАСП
+F.DIST.RT = F.РАСП.ПХ
+F.INV = F.ОБР
+F.INV.RT = F.ОБР.ПХ
+F.TEST = F.ТЕСТ
+FISHER = ФИШЕР
+FISHERINV = ФИШЕРОБР
+FORECAST.ETS = ПРЕДСКАЗ.ETS
+FORECAST.ETS.CONFINT = ПРЕДСКАЗ.ЕTS.ДОВИНТЕРВАЛ
+FORECAST.ETS.SEASONALITY = ПРЕДСКАЗ.ETS.СЕЗОННОСТЬ
+FORECAST.ETS.STAT = ПРЕДСКАЗ.ETS.СТАТ
+FORECAST.LINEAR = ПРЕДСКАЗ.ЛИНЕЙН
+FREQUENCY = ЧАСТОТА
+GAMMA = ГАММА
+GAMMA.DIST = ГАММА.РАСП
+GAMMA.INV = ГАММА.ОБР
+GAMMALN = ГАММАНЛОГ
+GAMMALN.PRECISE = ГАММАНЛОГ.ТОЧН
+GAUSS = ГАУСС
+GEOMEAN = СРГЕОМ
+GROWTH = РОСТ
+HARMEAN = СРГАРМ
+HYPGEOM.DIST = ГИПЕРГЕОМ.РАСП
+INTERCEPT = ОТРЕЗОК
+KURT = ЭКСЦЕСС
+LARGE = НАИБОЛЬШИЙ
+LINEST = ЛИНЕЙН
+LOGEST = ЛГРФПРИБЛ
+LOGNORM.DIST = ЛОГНОРМ.РАСП
+LOGNORM.INV = ЛОГНОРМ.ОБР
+MAX = МАКС
+MAXA = МАКСА
+MAXIFS = МАКСЕСЛИ
+MEDIAN = МЕДИАНА
+MIN = МИН
+MINA = МИНА
+MINIFS = МИНЕСЛИ
+MODE.MULT = МОДА.НСК
+MODE.SNGL = МОДА.ОДН
+NEGBINOM.DIST = ОТРБИНОМ.РАСП
+NORM.DIST = НОРМ.РАСП
+NORM.INV = НОРМ.ОБР
+NORM.S.DIST = НОРМ.СТ.РАСП
+NORM.S.INV = НОРМ.СТ.ОБР
+PEARSON = PEARSON
+PERCENTILE.EXC = ПРОЦЕНТИЛЬ.ИСКЛ
+PERCENTILE.INC = ПРОЦЕНТИЛЬ.ВКЛ
+PERCENTRANK.EXC = ПРОЦЕНТРАНГ.ИСКЛ
+PERCENTRANK.INC = ПРОЦЕНТРАНГ.ВКЛ
+PERMUT = ПЕРЕСТ
+PERMUTATIONA = ПЕРЕСТА
+PHI = ФИ
+POISSON.DIST = ПУАССОН.РАСП
+PROB = ВЕРОЯТНОСТЬ
+QUARTILE.EXC = КВАРТИЛЬ.ИСКЛ
+QUARTILE.INC = КВАРТИЛЬ.ВКЛ
+RANK.AVG = РАНГ.СР
+RANK.EQ = РАНГ.РВ
+RSQ = КВПИРСОН
+SKEW = СКОС
+SKEW.P = СКОС.Г
+SLOPE = НАКЛОН
+SMALL = НАИМЕНЬШИЙ
+STANDARDIZE = НОРМАЛИЗАЦИЯ
+STDEV.P = СТАНДОТКЛОН.Г
+STDEV.S = СТАНДОТКЛОН.В
+STDEVA = СТАНДОТКЛОНА
+STDEVPA = СТАНДОТКЛОНПА
+STEYX = СТОШYX
+T.DIST = СТЬЮДЕНТ.РАСП
+T.DIST.2T = СТЬЮДЕНТ.РАСП.2Х
+T.DIST.RT = СТЬЮДЕНТ.РАСП.ПХ
+T.INV = СТЬЮДЕНТ.ОБР
+T.INV.2T = СТЬЮДЕНТ.ОБР.2Х
+T.TEST = СТЬЮДЕНТ.ТЕСТ
+TREND = ТЕНДЕНЦИЯ
+TRIMMEAN = УРЕЗСРЕДНЕЕ
+VAR.P = ДИСП.Г
+VAR.S = ДИСП.В
+VARA = ДИСПА
+VARPA = ДИСПРА
+WEIBULL.DIST = ВЕЙБУЛЛ.РАСП
+Z.TEST = Z.ТЕСТ
+
+##
+## Текстовые функции (Text Functions)
+##
+ARRAYTOTEXT = МАССИВВТЕКСТ
+BAHTTEXT = БАТТЕКСТ
+CHAR = СИМВОЛ
+CLEAN = ПЕЧСИМВ
+CODE = КОДСИМВ
+CONCAT = СЦЕП
+DBCS = БДЦС
+DOLLAR = РУБЛЬ
+EXACT = СОВПАД
+FIND = НАЙТИ
+FINDB = НАЙТИБ
+FIXED = ФИКСИРОВАННЫЙ
+ISTHAIDIGIT = ЕТАЙЦИФРЫ
+LEFT = ЛЕВСИМВ
+LEFTB = ЛЕВБ
+LEN = ДЛСТР
+LENB = ДЛИНБ
+LOWER = СТРОЧН
+MID = ПСТР
+MIDB = ПСТРБ
+NUMBERSTRING = СТРОКАЧИСЕЛ
+NUMBERVALUE = ЧЗНАЧ
+PROPER = ПРОПНАЧ
+REPLACE = ЗАМЕНИТЬ
+REPLACEB = ЗАМЕНИТЬБ
+REPT = ПОВТОР
+RIGHT = ПРАВСИМВ
+RIGHTB = ПРАВБ
+SEARCH = ПОИСК
+SEARCHB = ПОИСКБ
+SUBSTITUTE = ПОДСТАВИТЬ
+T = Т
+TEXT = ТЕКСТ
+TEXTJOIN = ОБЪЕДИНИТЬ
+THAIDIGIT = ТАЙЦИФРА
+THAINUMSOUND = ТАЙЧИСЛОВЗВУК
+THAINUMSTRING = ТАЙЧИСЛОВСТРОКУ
+THAISTRINGLENGTH = ТАЙДЛИНАСТРОКИ
+TRIM = СЖПРОБЕЛЫ
+UNICHAR = ЮНИСИМВ
+UNICODE = UNICODE
+UPPER = ПРОПИСН
+VALUE = ЗНАЧЕН
+VALUETOTEXT = ЗНАЧЕНИЕВТЕКСТ
+
+##
+## Веб-функции (Web Functions)
+##
+ENCODEURL = КОДИР.URL
+FILTERXML = ФИЛЬТР.XML
+WEBSERVICE = ВЕБСЛУЖБА
+
+##
+## Функции совместимости (Compatibility Functions)
+##
+BETADIST = БЕТАРАСП
+BETAINV = БЕТАОБР
+BINOMDIST = БИНОМРАСП
+CEILING = ОКРВВЕРХ
+CHIDIST = ХИ2РАСП
+CHIINV = ХИ2ОБР
+CHITEST = ХИ2ТЕСТ
+CONCATENATE = СЦЕПИТЬ
+CONFIDENCE = ДОВЕРИТ
+COVAR = КОВАР
+CRITBINOM = КРИТБИНОМ
+EXPONDIST = ЭКСПРАСП
+FDIST = FРАСП
+FINV = FРАСПОБР
+FLOOR = ОКРВНИЗ
+FORECAST = ПРЕДСКАЗ
+FTEST = ФТЕСТ
+GAMMADIST = ГАММАРАСП
+GAMMAINV = ГАММАОБР
+HYPGEOMDIST = ГИПЕРГЕОМЕТ
+LOGINV = ЛОГНОРМОБР
+LOGNORMDIST = ЛОГНОРМРАСП
+MODE = МОДА
+NEGBINOMDIST = ОТРБИНОМРАСП
+NORMDIST = НОРМРАСП
+NORMINV = НОРМОБР
+NORMSDIST = НОРМСТРАСП
+NORMSINV = НОРМСТОБР
+PERCENTILE = ПЕРСЕНТИЛЬ
+PERCENTRANK = ПРОЦЕНТРАНГ
+POISSON = ПУАССОН
+QUARTILE = КВАРТИЛЬ
+RANK = РАНГ
+STDEV = СТАНДОТКЛОН
+STDEVP = СТАНДОТКЛОНП
+TDIST = СТЬЮДРАСП
+TINV = СТЬЮДРАСПОБР
+TTEST = ТТЕСТ
+VAR = ДИСП
+VARP = ДИСПР
+WEIBULL = ВЕЙБУЛЛ
+ZTEST = ZТЕСТ

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/sv/functions

@@ -0,0 +1,532 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Svenska (Swedish)
+##
+############################################################
+
+
+##
+## Kubfunktioner (Cube Functions)
+##
+CUBEKPIMEMBER = KUBKPIMEDLEM
+CUBEMEMBER = KUBMEDLEM
+CUBEMEMBERPROPERTY = KUBMEDLEMSEGENSKAP
+CUBERANKEDMEMBER = KUBRANGORDNADMEDLEM
+CUBESET = KUBUPPSÄTTNING
+CUBESETCOUNT = KUBUPPSÄTTNINGANTAL
+CUBEVALUE = KUBVÄRDE
+
+##
+## Databasfunktioner (Database Functions)
+##
+DAVERAGE = DMEDEL
+DCOUNT = DANTAL
+DCOUNTA = DANTALV
+DGET = DHÄMTA
+DMAX = DMAX
+DMIN = DMIN
+DPRODUCT = DPRODUKT
+DSTDEV = DSTDAV
+DSTDEVP = DSTDAVP
+DSUM = DSUMMA
+DVAR = DVARIANS
+DVARP = DVARIANSP
+
+##
+## Tid- och datumfunktioner (Date & Time Functions)
+##
+DATE = DATUM
+DATEVALUE = DATUMVÄRDE
+DAY = DAG
+DAYS = DAGAR
+DAYS360 = DAGAR360
+EDATE = EDATUM
+EOMONTH = SLUTMÅNAD
+HOUR = TIMME
+ISOWEEKNUM = ISOVECKONR
+MINUTE = MINUT
+MONTH = MÅNAD
+NETWORKDAYS = NETTOARBETSDAGAR
+NETWORKDAYS.INTL = NETTOARBETSDAGAR.INT
+NOW = NU
+SECOND = SEKUND
+THAIDAYOFWEEK = THAIVECKODAG
+THAIMONTHOFYEAR = THAIMÅNAD
+THAIYEAR = THAIÅR
+TIME = KLOCKSLAG
+TIMEVALUE = TIDVÄRDE
+TODAY = IDAG
+WEEKDAY = VECKODAG
+WEEKNUM = VECKONR
+WORKDAY = ARBETSDAGAR
+WORKDAY.INTL = ARBETSDAGAR.INT
+YEAR = ÅR
+YEARFRAC = ÅRDEL
+
+##
+## Tekniska funktioner (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN.TILL.DEC
+BIN2HEX = BIN.TILL.HEX
+BIN2OCT = BIN.TILL.OKT
+BITAND = BITOCH
+BITLSHIFT = BITVSKIFT
+BITOR = BITELLER
+BITRSHIFT = BITHSKIFT
+BITXOR = BITXELLER
+COMPLEX = KOMPLEX
+CONVERT = KONVERTERA
+DEC2BIN = DEC.TILL.BIN
+DEC2HEX = DEC.TILL.HEX
+DEC2OCT = DEC.TILL.OKT
+DELTA = DELTA
+ERF = FELF
+ERF.PRECISE = FELF.EXAKT
+ERFC = FELFK
+ERFC.PRECISE = FELFK.EXAKT
+GESTEP = SLSTEG
+HEX2BIN = HEX.TILL.BIN
+HEX2DEC = HEX.TILL.DEC
+HEX2OCT = HEX.TILL.OKT
+IMABS = IMABS
+IMAGINARY = IMAGINÄR
+IMARGUMENT = IMARGUMENT
+IMCONJUGATE = IMKONJUGAT
+IMCOS = IMCOS
+IMCOSH = IMCOSH
+IMCOT = IMCOT
+IMCSC = IMCSC
+IMCSCH = IMCSCH
+IMDIV = IMDIV
+IMEXP = IMEUPPHÖJT
+IMLN = IMLN
+IMLOG10 = IMLOG10
+IMLOG2 = IMLOG2
+IMPOWER = IMUPPHÖJT
+IMPRODUCT = IMPRODUKT
+IMREAL = IMREAL
+IMSEC = IMSEK
+IMSECH = IMSEKH
+IMSIN = IMSIN
+IMSINH = IMSINH
+IMSQRT = IMROT
+IMSUB = IMDIFF
+IMSUM = IMSUM
+IMTAN = IMTAN
+OCT2BIN = OKT.TILL.BIN
+OCT2DEC = OKT.TILL.DEC
+OCT2HEX = OKT.TILL.HEX
+
+##
+## Finansiella funktioner (Financial Functions)
+##
+ACCRINT = UPPLRÄNTA
+ACCRINTM = UPPLOBLRÄNTA
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = KUPDAGBB
+COUPDAYS = KUPDAGB
+COUPDAYSNC = KUPDAGNK
+COUPNCD = KUPNKD
+COUPNUM = KUPANT
+COUPPCD = KUPFKD
+CUMIPMT = KUMRÄNTA
+CUMPRINC = KUMPRIS
+DB = DB
+DDB = DEGAVSKR
+DISC = DISK
+DOLLARDE = DECTAL
+DOLLARFR = BRÅK
+DURATION = LÖPTID
+EFFECT = EFFRÄNTA
+FV = SLUTVÄRDE
+FVSCHEDULE = FÖRRÄNTNING
+INTRATE = ÅRSRÄNTA
+IPMT = RBETALNING
+IRR = IR
+ISPMT = RALÅN
+MDURATION = MLÖPTID
+MIRR = MODIR
+NOMINAL = NOMRÄNTA
+NPER = PERIODER
+NPV = NETNUVÄRDE
+ODDFPRICE = UDDAFPRIS
+ODDFYIELD = UDDAFAVKASTNING
+ODDLPRICE = UDDASPRIS
+ODDLYIELD = UDDASAVKASTNING
+PDURATION = PLÖPTID
+PMT = BETALNING
+PPMT = AMORT
+PRICE = PRIS
+PRICEDISC = PRISDISK
+PRICEMAT = PRISFÖRF
+PV = NUVÄRDE
+RATE = RÄNTA
+RECEIVED = BELOPP
+RRI = AVKPÅINVEST
+SLN = LINAVSKR
+SYD = ÅRSAVSKR
+TBILLEQ = SSVXEKV
+TBILLPRICE = SSVXPRIS
+TBILLYIELD = SSVXRÄNTA
+VDB = VDEGRAVSKR
+XIRR = XIRR
+XNPV = XNUVÄRDE
+YIELD = NOMAVK
+YIELDDISC = NOMAVKDISK
+YIELDMAT = NOMAVKFÖRF
+
+##
+## Informationsfunktioner (Information Functions)
+##
+CELL = CELL
+ERROR.TYPE = FEL.TYP
+INFO = INFO
+ISBLANK = ÄRTOM
+ISERR = ÄRF
+ISERROR = ÄRFEL
+ISEVEN = ÄRJÄMN
+ISFORMULA = ÄRFORMEL
+ISLOGICAL = ÄRLOGISK
+ISNA = ÄRSAKNAD
+ISNONTEXT = ÄREJTEXT
+ISNUMBER = ÄRTAL
+ISODD = ÄRUDDA
+ISREF = ÄRREF
+ISTEXT = ÄRTEXT
+N = N
+NA = SAKNAS
+SHEET = BLAD
+SHEETS = ANTALBLAD
+TYPE = VÄRDETYP
+
+##
+## Logiska funktioner (Logical Functions)
+##
+AND = OCH
+FALSE = FALSKT
+IF = OM
+IFERROR = OMFEL
+IFNA = OMSAKNAS
+IFS = IFS
+NOT = ICKE
+OR = ELLER
+SWITCH = VÄXLA
+TRUE = SANT
+XOR = XELLER
+
+##
+## Sök- och referensfunktioner (Lookup & Reference Functions)
+##
+ADDRESS = ADRESS
+AREAS = OMRÅDEN
+CHOOSE = VÄLJ
+COLUMN = KOLUMN
+COLUMNS = KOLUMNER
+FORMULATEXT = FORMELTEXT
+GETPIVOTDATA = HÄMTA.PIVOTDATA
+HLOOKUP = LETAKOLUMN
+HYPERLINK = HYPERLÄNK
+INDEX = INDEX
+INDIRECT = INDIREKT
+LOOKUP = LETAUPP
+MATCH = PASSA
+OFFSET = FÖRSKJUTNING
+ROW = RAD
+ROWS = RADER
+RTD = RTD
+TRANSPOSE = TRANSPONERA
+VLOOKUP = LETARAD
+
+##
+## Matematiska och trigonometriska funktioner (Math & Trig Functions)
+##
+ABS = ABS
+ACOS = ARCCOS
+ACOSH = ARCCOSH
+ACOT = ARCCOT
+ACOTH = ARCCOTH
+AGGREGATE = MÄNGD
+ARABIC = ARABISKA
+ASIN = ARCSIN
+ASINH = ARCSINH
+ATAN = ARCTAN
+ATAN2 = ARCTAN2
+ATANH = ARCTANH
+BASE = BAS
+CEILING.MATH = RUNDA.UPP.MATEMATISKT
+CEILING.PRECISE = RUNDA.UPP.EXAKT
+COMBIN = KOMBIN
+COMBINA = KOMBINA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = DECIMAL
+DEGREES = GRADER
+ECMA.CEILING = ECMA.RUNDA.UPP
+EVEN = JÄMN
+EXP = EXP
+FACT = FAKULTET
+FACTDOUBLE = DUBBELFAKULTET
+FLOOR.MATH = RUNDA.NER.MATEMATISKT
+FLOOR.PRECISE = RUNDA.NER.EXAKT
+GCD = SGD
+INT = HELTAL
+ISO.CEILING = ISO.RUNDA.UPP
+LCM = MGM
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = MDETERM
+MINVERSE = MINVERT
+MMULT = MMULT
+MOD = REST
+MROUND = MAVRUNDA
+MULTINOMIAL = MULTINOMIAL
+MUNIT = MENHET
+ODD = UDDA
+PI = PI
+POWER = UPPHÖJT.TILL
+PRODUCT = PRODUKT
+QUOTIENT = KVOT
+RADIANS = RADIANER
+RAND = SLUMP
+RANDBETWEEN = SLUMP.MELLAN
+ROMAN = ROMERSK
+ROUND = AVRUNDA
+ROUNDBAHTDOWN = AVRUNDABAHTNEDÅT
+ROUNDBAHTUP = AVRUNDABAHTUPPÅT
+ROUNDDOWN = AVRUNDA.NEDÅT
+ROUNDUP = AVRUNDA.UPPÅT
+SEC = SEK
+SECH = SEKH
+SERIESSUM = SERIESUMMA
+SIGN = TECKEN
+SIN = SIN
+SINH = SINH
+SQRT = ROT
+SQRTPI = ROTPI
+SUBTOTAL = DELSUMMA
+SUM = SUMMA
+SUMIF = SUMMA.OM
+SUMIFS = SUMMA.OMF
+SUMPRODUCT = PRODUKTSUMMA
+SUMSQ = KVADRATSUMMA
+SUMX2MY2 = SUMMAX2MY2
+SUMX2PY2 = SUMMAX2PY2
+SUMXMY2 = SUMMAXMY2
+TAN = TAN
+TANH = TANH
+TRUNC = AVKORTA
+
+##
+## Statistiska funktioner (Statistical Functions)
+##
+AVEDEV = MEDELAVV
+AVERAGE = MEDEL
+AVERAGEA = AVERAGEA
+AVERAGEIF = MEDEL.OM
+AVERAGEIFS = MEDEL.OMF
+BETA.DIST = BETA.FÖRD
+BETA.INV = BETA.INV
+BINOM.DIST = BINOM.FÖRD
+BINOM.DIST.RANGE = BINOM.FÖRD.INTERVALL
+BINOM.INV = BINOM.INV
+CHISQ.DIST = CHI2.FÖRD
+CHISQ.DIST.RT = CHI2.FÖRD.RT
+CHISQ.INV = CHI2.INV
+CHISQ.INV.RT = CHI2.INV.RT
+CHISQ.TEST = CHI2.TEST
+CONFIDENCE.NORM = KONFIDENS.NORM
+CONFIDENCE.T = KONFIDENS.T
+CORREL = KORREL
+COUNT = ANTAL
+COUNTA = ANTALV
+COUNTBLANK = ANTAL.TOMMA
+COUNTIF = ANTAL.OM
+COUNTIFS = ANTAL.OMF
+COVARIANCE.P = KOVARIANS.P
+COVARIANCE.S = KOVARIANS.S
+DEVSQ = KVADAVV
+EXPON.DIST = EXPON.FÖRD
+F.DIST = F.FÖRD
+F.DIST.RT = F.FÖRD.RT
+F.INV = F.INV
+F.INV.RT = F.INV.RT
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERINV
+FORECAST.ETS = PROGNOS.ETS
+FORECAST.ETS.CONFINT = PROGNOS.ETS.KONFINT
+FORECAST.ETS.SEASONALITY = PROGNOS.ETS.SÄSONGSBEROENDE
+FORECAST.ETS.STAT = PROGNOS.ETS.STAT
+FORECAST.LINEAR = PROGNOS.LINJÄR
+FREQUENCY = FREKVENS
+GAMMA = GAMMA
+GAMMA.DIST = GAMMA.FÖRD
+GAMMA.INV = GAMMA.INV
+GAMMALN = GAMMALN
+GAMMALN.PRECISE = GAMMALN.EXAKT
+GAUSS = GAUSS
+GEOMEAN = GEOMEDEL
+GROWTH = EXPTREND
+HARMEAN = HARMMEDEL
+HYPGEOM.DIST = HYPGEOM.FÖRD
+INTERCEPT = SKÄRNINGSPUNKT
+KURT = TOPPIGHET
+LARGE = STÖRSTA
+LINEST = REGR
+LOGEST = EXPREGR
+LOGNORM.DIST = LOGNORM.FÖRD
+LOGNORM.INV = LOGNORM.INV
+MAX = MAX
+MAXA = MAXA
+MAXIFS = MAXIFS
+MEDIAN = MEDIAN
+MIN = MIN
+MINA = MINA
+MINIFS = MINIFS
+MODE.MULT = TYPVÄRDE.FLERA
+MODE.SNGL = TYPVÄRDE.ETT
+NEGBINOM.DIST = NEGBINOM.FÖRD
+NORM.DIST = NORM.FÖRD
+NORM.INV = NORM.INV
+NORM.S.DIST = NORM.S.FÖRD
+NORM.S.INV = NORM.S.INV
+PEARSON = PEARSON
+PERCENTILE.EXC = PERCENTIL.EXK
+PERCENTILE.INC = PERCENTIL.INK
+PERCENTRANK.EXC = PROCENTRANG.EXK
+PERCENTRANK.INC = PROCENTRANG.INK
+PERMUT = PERMUT
+PERMUTATIONA = PERMUTATIONA
+PHI = PHI
+POISSON.DIST = POISSON.FÖRD
+PROB = SANNOLIKHET
+QUARTILE.EXC = KVARTIL.EXK
+QUARTILE.INC = KVARTIL.INK
+RANK.AVG = RANG.MED
+RANK.EQ = RANG.EKV
+RSQ = RKV
+SKEW = SNEDHET
+SKEW.P = SNEDHET.P
+SLOPE = LUTNING
+SMALL = MINSTA
+STANDARDIZE = STANDARDISERA
+STDEV.P = STDAV.P
+STDEV.S = STDAV.S
+STDEVA = STDEVA
+STDEVPA = STDEVPA
+STEYX = STDFELYX
+T.DIST = T.FÖRD
+T.DIST.2T = T.FÖRD.2T
+T.DIST.RT = T.FÖRD.RT
+T.INV = T.INV
+T.INV.2T = T.INV.2T
+T.TEST = T.TEST
+TREND = TREND
+TRIMMEAN = TRIMMEDEL
+VAR.P = VARIANS.P
+VAR.S = VARIANS.S
+VARA = VARA
+VARPA = VARPA
+WEIBULL.DIST = WEIBULL.FÖRD
+Z.TEST = Z.TEST
+
+##
+## Textfunktioner (Text Functions)
+##
+BAHTTEXT = BAHTTEXT
+CHAR = TECKENKOD
+CLEAN = STÄDA
+CODE = KOD
+CONCAT = SAMMAN
+DOLLAR = VALUTA
+EXACT = EXAKT
+FIND = HITTA
+FIXED = FASTTAL
+LEFT = VÄNSTER
+LEN = LÄNGD
+LOWER = GEMENER
+MID = EXTEXT
+NUMBERVALUE = TALVÄRDE
+PROPER = INITIAL
+REPLACE = ERSÄTT
+REPT = REP
+RIGHT = HÖGER
+SEARCH = SÖK
+SUBSTITUTE = BYT.UT
+T = T
+TEXT = TEXT
+TEXTJOIN = TEXTJOIN
+THAIDIGIT = THAISIFFRA
+THAINUMSOUND = THAITALLJUD
+THAINUMSTRING = THAITALSTRÄNG
+THAISTRINGLENGTH = THAISTRÄNGLÄNGD
+TRIM = RENSA
+UNICHAR = UNITECKENKOD
+UNICODE = UNICODE
+UPPER = VERSALER
+VALUE = TEXTNUM
+
+##
+## Webbfunktioner (Web Functions)
+##
+ENCODEURL = KODAWEBBADRESS
+FILTERXML = FILTRERAXML
+WEBSERVICE = WEBBTJÄNST
+
+##
+## Kompatibilitetsfunktioner (Compatibility Functions)
+##
+BETADIST = BETAFÖRD
+BETAINV = BETAINV
+BINOMDIST = BINOMFÖRD
+CEILING = RUNDA.UPP
+CHIDIST = CHI2FÖRD
+CHIINV = CHI2INV
+CHITEST = CHI2TEST
+CONCATENATE = SAMMANFOGA
+CONFIDENCE = KONFIDENS
+COVAR = KOVAR
+CRITBINOM = KRITBINOM
+EXPONDIST = EXPONFÖRD
+FDIST = FFÖRD
+FINV = FINV
+FLOOR = RUNDA.NER
+FORECAST = PREDIKTION
+FTEST = FTEST
+GAMMADIST = GAMMAFÖRD
+GAMMAINV = GAMMAINV
+HYPGEOMDIST = HYPGEOMFÖRD
+LOGINV = LOGINV
+LOGNORMDIST = LOGNORMFÖRD
+MODE = TYPVÄRDE
+NEGBINOMDIST = NEGBINOMFÖRD
+NORMDIST = NORMFÖRD
+NORMINV = NORMINV
+NORMSDIST = NORMSFÖRD
+NORMSINV = NORMSINV
+PERCENTILE = PERCENTIL
+PERCENTRANK = PROCENTRANG
+POISSON = POISSON
+QUARTILE = KVARTIL
+RANK = RANG
+STDEV = STDAV
+STDEVP = STDAVP
+TDIST = TFÖRD
+TINV = TINV
+TTEST = TTEST
+VAR = VARIANS
+VARP = VARIANSP
+WEIBULL = WEIBULL
+ZTEST = ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Calculation/locale/tr/functions

@@ -0,0 +1,537 @@
+############################################################
+##
+## PhpSpreadsheet - function name translations
+##
+## Türkçe (Turkish)
+##
+############################################################
+
+
+##
+## Küp işlevleri (Cube Functions)
+##
+CUBEKPIMEMBER = KÜPKPIÜYESİ
+CUBEMEMBER = KÜPÜYESİ
+CUBEMEMBERPROPERTY = KÜPÜYEÖZELLİĞİ
+CUBERANKEDMEMBER = DERECELİKÜPÜYESİ
+CUBESET = KÜPKÜMESİ
+CUBESETCOUNT = KÜPKÜMESAYISI
+CUBEVALUE = KÜPDEĞERİ
+
+##
+## Veritabanı işlevleri (Database Functions)
+##
+DAVERAGE = VSEÇORT
+DCOUNT = VSEÇSAY
+DCOUNTA = VSEÇSAYDOLU
+DGET = VAL
+DMAX = VSEÇMAK
+DMIN = VSEÇMİN
+DPRODUCT = VSEÇÇARP
+DSTDEV = VSEÇSTDSAPMA
+DSTDEVP = VSEÇSTDSAPMAS
+DSUM = VSEÇTOPLA
+DVAR = VSEÇVAR
+DVARP = VSEÇVARS
+
+##
+## Tarih ve saat işlevleri (Date & Time Functions)
+##
+DATE = TARİH
+DATEDIF = ETARİHLİ
+DATESTRING = TARİHDİZİ
+DATEVALUE = TARİHSAYISI
+DAY = GÜN
+DAYS = GÜNSAY
+DAYS360 = GÜN360
+EDATE = SERİTARİH
+EOMONTH = SERİAY
+HOUR = SAAT
+ISOWEEKNUM = ISOHAFTASAY
+MINUTE = DAKİKA
+MONTH = AY
+NETWORKDAYS = TAMİŞGÜNÜ
+NETWORKDAYS.INTL = TAMİŞGÜNÜ.ULUSL
+NOW = ŞİMDİ
+SECOND = SANİYE
+THAIDAYOFWEEK = TAYHAFTANINGÜNÜ
+THAIMONTHOFYEAR = TAYYILINAYI
+THAIYEAR = TAYYILI
+TIME = ZAMAN
+TIMEVALUE = ZAMANSAYISI
+TODAY = BUGÜN
+WEEKDAY = HAFTANINGÜNÜ
+WEEKNUM = HAFTASAY
+WORKDAY = İŞGÜNÜ
+WORKDAY.INTL = İŞGÜNÜ.ULUSL
+YEAR = YIL
+YEARFRAC = YILORAN
+
+##
+## Mühendislik işlevleri (Engineering Functions)
+##
+BESSELI = BESSELI
+BESSELJ = BESSELJ
+BESSELK = BESSELK
+BESSELY = BESSELY
+BIN2DEC = BIN2DEC
+BIN2HEX = BIN2HEX
+BIN2OCT = BIN2OCT
+BITAND = BİTVE
+BITLSHIFT = BİTSOLAKAYDIR
+BITOR = BİTVEYA
+BITRSHIFT = BİTSAĞAKAYDIR
+BITXOR = BİTÖZELVEYA
+COMPLEX = KARMAŞIK
+CONVERT = ÇEVİR
+DEC2BIN = DEC2BIN
+DEC2HEX = DEC2HEX
+DEC2OCT = DEC2OCT
+DELTA = DELTA
+ERF = HATAİŞLEV
+ERF.PRECISE = HATAİŞLEV.DUYARLI
+ERFC = TÜMHATAİŞLEV
+ERFC.PRECISE = TÜMHATAİŞLEV.DUYARLI
+GESTEP = BESINIR
+HEX2BIN = HEX2BIN
+HEX2DEC = HEX2DEC
+HEX2OCT = HEX2OCT
+IMABS = SANMUTLAK
+IMAGINARY = SANAL
+IMARGUMENT = SANBAĞ_DEĞİŞKEN
+IMCONJUGATE = SANEŞLENEK
+IMCOS = SANCOS
+IMCOSH = SANCOSH
+IMCOT = SANCOT
+IMCSC = SANCSC
+IMCSCH = SANCSCH
+IMDIV = SANBÖL
+IMEXP = SANÜS
+IMLN = SANLN
+IMLOG10 = SANLOG10
+IMLOG2 = SANLOG2
+IMPOWER = SANKUVVET
+IMPRODUCT = SANÇARP
+IMREAL = SANGERÇEK
+IMSEC = SANSEC
+IMSECH = SANSECH
+IMSIN = SANSIN
+IMSINH = SANSINH
+IMSQRT = SANKAREKÖK
+IMSUB = SANTOPLA
+IMSUM = SANÇIKAR
+IMTAN = SANTAN
+OCT2BIN = OCT2BIN
+OCT2DEC = OCT2DEC
+OCT2HEX = OCT2HEX
+
+##
+## Finansal işlevler (Financial Functions)
+##
+ACCRINT = GERÇEKFAİZ
+ACCRINTM = GERÇEKFAİZV
+AMORDEGRC = AMORDEGRC
+AMORLINC = AMORLINC
+COUPDAYBS = KUPONGÜNBD
+COUPDAYS = KUPONGÜN
+COUPDAYSNC = KUPONGÜNDSK
+COUPNCD = KUPONGÜNSKT
+COUPNUM = KUPONSAYI
+COUPPCD = KUPONGÜNÖKT
+CUMIPMT = TOPÖDENENFAİZ
+CUMPRINC = TOPANAPARA
+DB = AZALANBAKİYE
+DDB = ÇİFTAZALANBAKİYE
+DISC = İNDİRİM
+DOLLARDE = LİRAON
+DOLLARFR = LİRAKES
+DURATION = SÜRE
+EFFECT = ETKİN
+FV = GD
+FVSCHEDULE = GDPROGRAM
+INTRATE = FAİZORANI
+IPMT = FAİZTUTARI
+IRR = İÇ_VERİM_ORANI
+ISPMT = ISPMT
+MDURATION = MSÜRE
+MIRR = D_İÇ_VERİM_ORANI
+NOMINAL = NOMİNAL
+NPER = TAKSİT_SAYISI
+NPV = NBD
+ODDFPRICE = TEKYDEĞER
+ODDFYIELD = TEKYÖDEME
+ODDLPRICE = TEKSDEĞER
+ODDLYIELD = TEKSÖDEME
+PDURATION = PSÜRE
+PMT = DEVRESEL_ÖDEME
+PPMT = ANA_PARA_ÖDEMESİ
+PRICE = DEĞER
+PRICEDISC = DEĞERİND
+PRICEMAT = DEĞERVADE
+PV = BD
+RATE = FAİZ_ORANI
+RECEIVED = GETİRİ
+RRI = GERÇEKLEŞENYATIRIMGETİRİSİ
+SLN = DA
+SYD = YAT
+TBILLEQ = HTAHEŞ
+TBILLPRICE = HTAHDEĞER
+TBILLYIELD = HTAHÖDEME
+VDB = DAB
+XIRR = AİÇVERİMORANI
+XNPV = ANBD
+YIELD = ÖDEME
+YIELDDISC = ÖDEMEİND
+YIELDMAT = ÖDEMEVADE
+
+##
+## Bilgi işlevleri (Information Functions)
+##
+CELL = HÜCRE
+ERROR.TYPE = HATA.TİPİ
+INFO = BİLGİ
+ISBLANK = EBOŞSA
+ISERR = EHATA
+ISERROR = EHATALIYSA
+ISEVEN = ÇİFTMİ
+ISFORMULA = EFORMÜLSE
+ISLOGICAL = EMANTIKSALSA
+ISNA = EYOKSA
+ISNONTEXT = EMETİNDEĞİLSE
+ISNUMBER = ESAYIYSA
+ISODD = TEKMİ
+ISREF = EREFSE
+ISTEXT = EMETİNSE
+N = S
+NA = YOKSAY
+SHEET = SAYFA
+SHEETS = SAYFALAR
+TYPE = TÜR
+
+##
+## Mantıksal işlevler (Logical Functions)
+##
+AND = VE
+FALSE = YANLIŞ
+IF = EĞER
+IFERROR = EĞERHATA
+IFNA = EĞERYOKSA
+IFS = ÇOKEĞER
+NOT = DEĞİL
+OR = YADA
+SWITCH = İLKEŞLEŞEN
+TRUE = DOĞRU
+XOR = ÖZELVEYA
+
+##
+## Arama ve başvuru işlevleri (Lookup & Reference Functions)
+##
+ADDRESS = ADRES
+AREAS = ALANSAY
+CHOOSE = ELEMAN
+COLUMN = SÜTUN
+COLUMNS = SÜTUNSAY
+FORMULATEXT = FORMÜLMETNİ
+GETPIVOTDATA = ÖZETVERİAL
+HLOOKUP = YATAYARA
+HYPERLINK = KÖPRÜ
+INDEX = İNDİS
+INDIRECT = DOLAYLI
+LOOKUP = ARA
+MATCH = KAÇINCI
+OFFSET = KAYDIR
+ROW = SATIR
+ROWS = SATIRSAY
+RTD = GZV
+TRANSPOSE = DEVRİK_DÖNÜŞÜM
+VLOOKUP = DÜŞEYARA
+
+##
+## Matematik ve trigonometri işlevleri (Math & Trig Functions)
+##
+ABS = MUTLAK
+ACOS = ACOS
+ACOSH = ACOSH
+ACOT = ACOT
+ACOTH = ACOTH
+AGGREGATE = TOPLAMA
+ARABIC = ARAP
+ASIN = ASİN
+ASINH = ASİNH
+ATAN = ATAN
+ATAN2 = ATAN2
+ATANH = ATANH
+BASE = TABAN
+CEILING.MATH = TAVANAYUVARLA.MATEMATİK
+CEILING.PRECISE = TAVANAYUVARLA.DUYARLI
+COMBIN = KOMBİNASYON
+COMBINA = KOMBİNASYONA
+COS = COS
+COSH = COSH
+COT = COT
+COTH = COTH
+CSC = CSC
+CSCH = CSCH
+DECIMAL = ONDALIK
+DEGREES = DERECE
+ECMA.CEILING = ECMA.TAVAN
+EVEN = ÇİFT
+EXP = ÜS
+FACT = ÇARPINIM
+FACTDOUBLE = ÇİFTFAKTÖR
+FLOOR.MATH = TABANAYUVARLA.MATEMATİK
+FLOOR.PRECISE = TABANAYUVARLA.DUYARLI
+GCD = OBEB
+INT = TAMSAYI
+ISO.CEILING = ISO.TAVAN
+LCM = OKEK
+LN = LN
+LOG = LOG
+LOG10 = LOG10
+MDETERM = DETERMİNANT
+MINVERSE = DİZEY_TERS
+MMULT = DÇARP
+MOD = MOD
+MROUND = KYUVARLA
+MULTINOMIAL = ÇOKTERİMLİ
+MUNIT = BİRİMMATRİS
+ODD = TEK
+PI = Pİ
+POWER = KUVVET
+PRODUCT = ÇARPIM
+QUOTIENT = BÖLÜM
+RADIANS = RADYAN
+RAND = S_SAYI_ÜRET
+RANDBETWEEN = RASTGELEARADA
+ROMAN = ROMEN
+ROUND = YUVARLA
+ROUNDBAHTDOWN = BAHTAŞAĞIYUVARLA
+ROUNDBAHTUP = BAHTYUKARIYUVARLA
+ROUNDDOWN = AŞAĞIYUVARLA
+ROUNDUP = YUKARIYUVARLA
+SEC = SEC
+SECH = SECH
+SERIESSUM = SERİTOPLA
+SIGN = İŞARET
+SIN = SİN
+SINH = SİNH
+SQRT = KAREKÖK
+SQRTPI = KAREKÖKPİ
+SUBTOTAL = ALTTOPLAM
+SUM = TOPLA
+SUMIF = ETOPLA
+SUMIFS = ÇOKETOPLA
+SUMPRODUCT = TOPLA.ÇARPIM
+SUMSQ = TOPKARE
+SUMX2MY2 = TOPX2EY2
+SUMX2PY2 = TOPX2AY2
+SUMXMY2 = TOPXEY2
+TAN = TAN
+TANH = TANH
+TRUNC = NSAT
+
+##
+## İstatistik işlevleri (Statistical Functions)
+##
+AVEDEV = ORTSAP
+AVERAGE = ORTALAMA
+AVERAGEA = ORTALAMAA
+AVERAGEIF = EĞERORTALAMA
+AVERAGEIFS = ÇOKEĞERORTALAMA
+BETA.DIST = BETA.DAĞ
+BETA.INV = BETA.TERS
+BINOM.DIST = BİNOM.DAĞ
+BINOM.DIST.RANGE = BİNOM.DAĞ.ARALIK
+BINOM.INV = BİNOM.TERS
+CHISQ.DIST = KİKARE.DAĞ
+CHISQ.DIST.RT = KİKARE.DAĞ.SAĞK
+CHISQ.INV = KİKARE.TERS
+CHISQ.INV.RT = KİKARE.TERS.SAĞK
+CHISQ.TEST = KİKARE.TEST
+CONFIDENCE.NORM = GÜVENİLİRLİK.NORM
+CONFIDENCE.T = GÜVENİLİRLİK.T
+CORREL = KORELASYON
+COUNT = BAĞ_DEĞ_SAY
+COUNTA = BAĞ_DEĞ_DOLU_SAY
+COUNTBLANK = BOŞLUKSAY
+COUNTIF = EĞERSAY
+COUNTIFS = ÇOKEĞERSAY
+COVARIANCE.P = KOVARYANS.P
+COVARIANCE.S = KOVARYANS.S
+DEVSQ = SAPKARE
+EXPON.DIST = ÜSTEL.DAĞ
+F.DIST = F.DAĞ
+F.DIST.RT = F.DAĞ.SAĞK
+F.INV = F.TERS
+F.INV.RT = F.TERS.SAĞK
+F.TEST = F.TEST
+FISHER = FISHER
+FISHERINV = FISHERTERS
+FORECAST.ETS = TAHMİN.ETS
+FORECAST.ETS.CONFINT = TAHMİN.ETS.GVNARAL
+FORECAST.ETS.SEASONALITY = TAHMİN.ETS.MEVSİMSELLİK
+FORECAST.ETS.STAT = TAHMİN.ETS.İSTAT
+FORECAST.LINEAR = TAHMİN.DOĞRUSAL
+FREQUENCY = SIKLIK
+GAMMA = GAMA
+GAMMA.DIST = GAMA.DAĞ
+GAMMA.INV = GAMA.TERS
+GAMMALN = GAMALN
+GAMMALN.PRECISE = GAMALN.DUYARLI
+GAUSS = GAUSS
+GEOMEAN = GEOORT
+GROWTH = BÜYÜME
+HARMEAN = HARORT
+HYPGEOM.DIST = HİPERGEOM.DAĞ
+INTERCEPT = KESMENOKTASI
+KURT = BASIKLIK
+LARGE = BÜYÜK
+LINEST = DOT
+LOGEST = LOT
+LOGNORM.DIST = LOGNORM.DAĞ
+LOGNORM.INV = LOGNORM.TERS
+MAX = MAK
+MAXA = MAKA
+MAXIFS = ÇOKEĞERMAK
+MEDIAN = ORTANCA
+MIN = MİN
+MINA = MİNA
+MINIFS = ÇOKEĞERMİN
+MODE.MULT = ENÇOK_OLAN.ÇOK
+MODE.SNGL = ENÇOK_OLAN.TEK
+NEGBINOM.DIST = NEGBİNOM.DAĞ
+NORM.DIST = NORM.DAĞ
+NORM.INV = NORM.TERS
+NORM.S.DIST = NORM.S.DAĞ
+NORM.S.INV = NORM.S.TERS
+PEARSON = PEARSON
+PERCENTILE.EXC = YÜZDEBİRLİK.HRC
+PERCENTILE.INC = YÜZDEBİRLİK.DHL
+PERCENTRANK.EXC = YÜZDERANK.HRC
+PERCENTRANK.INC = YÜZDERANK.DHL
+PERMUT = PERMÜTASYON
+PERMUTATIONA = PERMÜTASYONA
+PHI = PHI
+POISSON.DIST = POISSON.DAĞ
+PROB = OLASILIK
+QUARTILE.EXC = DÖRTTEBİRLİK.HRC
+QUARTILE.INC = DÖRTTEBİRLİK.DHL
+RANK.AVG = RANK.ORT
+RANK.EQ = RANK.EŞİT
+RSQ = RKARE
+SKEW = ÇARPIKLIK
+SKEW.P = ÇARPIKLIK.P
+SLOPE = EĞİM
+SMALL = KÜÇÜK
+STANDARDIZE = STANDARTLAŞTIRMA
+STDEV.P = STDSAPMA.P
+STDEV.S = STDSAPMA.S
+STDEVA = STDSAPMAA
+STDEVPA = STDSAPMASA
+STEYX = STHYX
+T.DIST = T.DAĞ
+T.DIST.2T = T.DAĞ.2K
+T.DIST.RT = T.DAĞ.SAĞK
+T.INV = T.TERS
+T.INV.2T = T.TERS.2K
+T.TEST = T.TEST
+TREND = EĞİLİM
+TRIMMEAN = KIRPORTALAMA
+VAR.P = VAR.P
+VAR.S = VAR.S
+VARA = VARA
+VARPA = VARSA
+WEIBULL.DIST = WEIBULL.DAĞ
+Z.TEST = Z.TEST
+
+##
+## Metin işlevleri (Text Functions)
+##
+BAHTTEXT = BAHTMETİN
+CHAR = DAMGA
+CLEAN = TEMİZ
+CODE = KOD
+CONCAT = ARALIKBİRLEŞTİR
+DOLLAR = LİRA
+EXACT = ÖZDEŞ
+FIND = BUL
+FIXED = SAYIDÜZENLE
+ISTHAIDIGIT = TAYRAKAMIYSA
+LEFT = SOLDAN
+LEN = UZUNLUK
+LOWER = KÜÇÜKHARF
+MID = PARÇAAL
+NUMBERSTRING = SAYIDİZİ
+NUMBERVALUE = SAYIDEĞERİ
+PHONETIC = SES
+PROPER = YAZIM.DÜZENİ
+REPLACE = DEĞİŞTİR
+REPT = YİNELE
+RIGHT = SAĞDAN
+SEARCH = MBUL
+SUBSTITUTE = YERİNEKOY
+T = M
+TEXT = METNEÇEVİR
+TEXTJOIN = METİNBİRLEŞTİR
+THAIDIGIT = TAYRAKAM
+THAINUMSOUND = TAYSAYISES
+THAINUMSTRING = TAYSAYIDİZE
+THAISTRINGLENGTH = TAYDİZEUZUNLUĞU
+TRIM = KIRP
+UNICHAR = UNICODEKARAKTERİ
+UNICODE = UNICODE
+UPPER = BÜYÜKHARF
+VALUE = SAYIYAÇEVİR
+
+##
+## Metin işlevleri (Web Functions)
+##
+ENCODEURL = URLKODLA
+FILTERXML = XMLFİLTRELE
+WEBSERVICE = WEBHİZMETİ
+
+##
+## Uyumluluk işlevleri (Compatibility Functions)
+##
+BETADIST = BETADAĞ
+BETAINV = BETATERS
+BINOMDIST = BİNOMDAĞ
+CEILING = TAVANAYUVARLA
+CHIDIST = KİKAREDAĞ
+CHIINV = KİKARETERS
+CHITEST = KİKARETEST
+CONCATENATE = BİRLEŞTİR
+CONFIDENCE = GÜVENİRLİK
+COVAR = KOVARYANS
+CRITBINOM = KRİTİKBİNOM
+EXPONDIST = ÜSTELDAĞ
+FDIST = FDAĞ
+FINV = FTERS
+FLOOR = TABANAYUVARLA
+FORECAST = TAHMİN
+FTEST = FTEST
+GAMMADIST = GAMADAĞ
+GAMMAINV = GAMATERS
+HYPGEOMDIST = HİPERGEOMDAĞ
+LOGINV = LOGTERS
+LOGNORMDIST = LOGNORMDAĞ
+MODE = ENÇOK_OLAN
+NEGBINOMDIST = NEGBİNOMDAĞ
+NORMDIST = NORMDAĞ
+NORMINV = NORMTERS
+NORMSDIST = NORMSDAĞ
+NORMSINV = NORMSTERS
+PERCENTILE = YÜZDEBİRLİK
+PERCENTRANK = YÜZDERANK
+POISSON = POISSON
+QUARTILE = DÖRTTEBİRLİK
+RANK = RANK
+STDEV = STDSAPMA
+STDEVP = STDSAPMAS
+TDIST = TDAĞ
+TINV = TTERS
+TTEST = TTEST
+VAR = VAR
+VARP = VARS
+WEIBULL = WEIBULL
+ZTEST = ZTEST

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Cell/Hyperlink.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Cell;
+
+class Hyperlink
+{
+    /**
+     * URL to link the cell to.
+     *
+     * @var string
+     */
+    private $url;
+
+    /**
+     * Tooltip to display on the hyperlink.
+     *
+     * @var string
+     */
+    private $tooltip;
+
+    /**
+     * Create a new Hyperlink.
+     *
+     * @param string $url Url to link the cell to
+     * @param string $tooltip Tooltip to display on the hyperlink
+     */
+    public function __construct($url = '', $tooltip = '')
+    {
+        // Initialise member variables
+        $this->url = $url;
+        $this->tooltip = $tooltip;
+    }
+
+    /**
+     * Get URL.
+     *
+     * @return string
+     */
+    public function getUrl()
+    {
+        return $this->url;
+    }
+
+    /**
+     * Set URL.
+     *
+     * @param string $url
+     *
+     * @return $this
+     */
+    public function setUrl($url)
+    {
+        $this->url = $url;
+
+        return $this;
+    }
+
+    /**
+     * Get tooltip.
+     *
+     * @return string
+     */
+    public function getTooltip()
+    {
+        return $this->tooltip;
+    }
+
+    /**
+     * Set tooltip.
+     *
+     * @param string $tooltip
+     *
+     * @return $this
+     */
+    public function setTooltip($tooltip)
+    {
+        $this->tooltip = $tooltip;
+
+        return $this;
+    }
+
+    /**
+     * Is this hyperlink internal? (to another worksheet).
+     *
+     * @return bool
+     */
+    public function isInternal()
+    {
+        return strpos($this->url, 'sheet://') !== false;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTypeHyperlink()
+    {
+        return $this->isInternal() ? '' : 'External';
+    }
+
+    /**
+     * Get hash code.
+     *
+     * @return string Hash code
+     */
+    public function getHashCode()
+    {
+        return md5(
+            $this->url .
+            $this->tooltip .
+            __CLASS__
+        );
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Cell/IValueBinder.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Cell;
+
+interface IValueBinder
+{
+    /**
+     * Bind value to a cell.
+     *
+     * @param Cell $cell Cell to bind value to
+     * @param mixed $value Value to bind in cell
+     *
+     * @return bool
+     */
+    public function bindValue(Cell $cell, $value);
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Chart/Exception.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Chart;
+
+use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
+
+class Exception extends PhpSpreadsheetException
+{
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Chart/GridLines.php

@@ -0,0 +1,454 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Chart;
+
+/**
+ * Created by PhpStorm.
+ * User: Wiktor Trzonkowski
+ * Date: 7/2/14
+ * Time: 2:36 PM.
+ */
+class GridLines extends Properties
+{
+    /**
+     * Properties of Class:
+     * Object State (State for Minor Tick Mark) @var bool
+     * Line Properties @var  array of mixed
+     * Shadow Properties @var  array of mixed
+     * Glow Properties @var  array of mixed
+     * Soft Properties @var  array of mixed.
+     */
+    private $objectState = false;
+
+    private $lineProperties = [
+        'color' => [
+            'type' => self::EXCEL_COLOR_TYPE_STANDARD,
+            'value' => null,
+            'alpha' => 0,
+        ],
+        'style' => [
+            'width' => '9525',
+            'compound' => self::LINE_STYLE_COMPOUND_SIMPLE,
+            'dash' => self::LINE_STYLE_DASH_SOLID,
+            'cap' => self::LINE_STYLE_CAP_FLAT,
+            'join' => self::LINE_STYLE_JOIN_BEVEL,
+            'arrow' => [
+                'head' => [
+                    'type' => self::LINE_STYLE_ARROW_TYPE_NOARROW,
+                    'size' => self::LINE_STYLE_ARROW_SIZE_5,
+                ],
+                'end' => [
+                    'type' => self::LINE_STYLE_ARROW_TYPE_NOARROW,
+                    'size' => self::LINE_STYLE_ARROW_SIZE_8,
+                ],
+            ],
+        ],
+    ];
+
+    private $shadowProperties = [
+        'presets' => self::SHADOW_PRESETS_NOSHADOW,
+        'effect' => null,
+        'color' => [
+            'type' => self::EXCEL_COLOR_TYPE_STANDARD,
+            'value' => 'black',
+            'alpha' => 85,
+        ],
+        'size' => [
+            'sx' => null,
+            'sy' => null,
+            'kx' => null,
+        ],
+        'blur' => null,
+        'direction' => null,
+        'distance' => null,
+        'algn' => null,
+        'rotWithShape' => null,
+    ];
+
+    private $glowProperties = [
+        'size' => null,
+        'color' => [
+            'type' => self::EXCEL_COLOR_TYPE_STANDARD,
+            'value' => 'black',
+            'alpha' => 40,
+        ],
+    ];
+
+    private $softEdges = [
+        'size' => null,
+    ];
+
+    /**
+     * Get Object State.
+     *
+     * @return bool
+     */
+    public function getObjectState()
+    {
+        return $this->objectState;
+    }
+
+    /**
+     * Change Object State to True.
+     *
+     * @return $this
+     */
+    private function activateObject()
+    {
+        $this->objectState = true;
+
+        return $this;
+    }
+
+    /**
+     * Set Line Color Properties.
+     *
+     * @param string $value
+     * @param int $alpha
+     * @param string $colorType
+     */
+    public function setLineColorProperties($value, $alpha = 0, $colorType = self::EXCEL_COLOR_TYPE_STANDARD): void
+    {
+        $this->activateObject()
+            ->lineProperties['color'] = $this->setColorProperties(
+                $value,
+                $alpha,
+                $colorType
+            );
+    }
+
+    /**
+     * Set Line Color Properties.
+     *
+     * @param float $lineWidth
+     * @param string $compoundType
+     * @param string $dashType
+     * @param string $capType
+     * @param string $joinType
+     * @param string $headArrowType
+     * @param string $headArrowSize
+     * @param string $endArrowType
+     * @param string $endArrowSize
+     */
+    public function setLineStyleProperties($lineWidth = null, $compoundType = null, $dashType = null, $capType = null, $joinType = null, $headArrowType = null, $headArrowSize = null, $endArrowType = null, $endArrowSize = null): void
+    {
+        $this->activateObject();
+        ($lineWidth !== null)
+                ? $this->lineProperties['style']['width'] = $this->getExcelPointsWidth((float) $lineWidth)
+                : null;
+        ($compoundType !== null)
+                ? $this->lineProperties['style']['compound'] = (string) $compoundType
+                : null;
+        ($dashType !== null)
+                ? $this->lineProperties['style']['dash'] = (string) $dashType
+                : null;
+        ($capType !== null)
+                ? $this->lineProperties['style']['cap'] = (string) $capType
+                : null;
+        ($joinType !== null)
+                ? $this->lineProperties['style']['join'] = (string) $joinType
+                : null;
+        ($headArrowType !== null)
+                ? $this->lineProperties['style']['arrow']['head']['type'] = (string) $headArrowType
+                : null;
+        ($headArrowSize !== null)
+                ? $this->lineProperties['style']['arrow']['head']['size'] = (string) $headArrowSize
+                : null;
+        ($endArrowType !== null)
+                ? $this->lineProperties['style']['arrow']['end']['type'] = (string) $endArrowType
+                : null;
+        ($endArrowSize !== null)
+                ? $this->lineProperties['style']['arrow']['end']['size'] = (string) $endArrowSize
+                : null;
+    }
+
+    /**
+     * Get Line Color Property.
+     *
+     * @param string $propertyName
+     *
+     * @return string
+     */
+    public function getLineColorProperty($propertyName)
+    {
+        return $this->lineProperties['color'][$propertyName];
+    }
+
+    /**
+     * Get Line Style Property.
+     *
+     * @param array|string $elements
+     *
+     * @return string
+     */
+    public function getLineStyleProperty($elements)
+    {
+        return $this->getArrayElementsValue($this->lineProperties['style'], $elements);
+    }
+
+    /**
+     * Set Glow Properties.
+     *
+     * @param float $size
+     * @param string $colorValue
+     * @param int $colorAlpha
+     * @param string $colorType
+     */
+    public function setGlowProperties($size, $colorValue = null, $colorAlpha = null, $colorType = null): void
+    {
+        $this
+            ->activateObject()
+            ->setGlowSize($size)
+            ->setGlowColor($colorValue, $colorAlpha, $colorType);
+    }
+
+    /**
+     * Get Glow Color Property.
+     *
+     * @param string $propertyName
+     *
+     * @return string
+     */
+    public function getGlowColor($propertyName)
+    {
+        return $this->glowProperties['color'][$propertyName];
+    }
+
+    /**
+     * Get Glow Size.
+     *
+     * @return string
+     */
+    public function getGlowSize()
+    {
+        return $this->glowProperties['size'];
+    }
+
+    /**
+     * Set Glow Size.
+     *
+     * @param float $size
+     *
+     * @return $this
+     */
+    private function setGlowSize($size)
+    {
+        $this->glowProperties['size'] = $this->getExcelPointsWidth((float) $size);
+
+        return $this;
+    }
+
+    /**
+     * Set Glow Color.
+     *
+     * @param string $color
+     * @param int $alpha
+     * @param string $colorType
+     *
+     * @return $this
+     */
+    private function setGlowColor($color, $alpha, $colorType)
+    {
+        if ($color !== null) {
+            $this->glowProperties['color']['value'] = (string) $color;
+        }
+        if ($alpha !== null) {
+            $this->glowProperties['color']['alpha'] = $this->getTrueAlpha((int) $alpha);
+        }
+        if ($colorType !== null) {
+            $this->glowProperties['color']['type'] = (string) $colorType;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get Line Style Arrow Parameters.
+     *
+     * @param string $arrowSelector
+     * @param string $propertySelector
+     *
+     * @return string
+     */
+    public function getLineStyleArrowParameters($arrowSelector, $propertySelector)
+    {
+        return $this->getLineStyleArrowSize($this->lineProperties['style']['arrow'][$arrowSelector]['size'], $propertySelector);
+    }
+
+    /**
+     * Set Shadow Properties.
+     *
+     * @param int $presets
+     * @param string $colorValue
+     * @param string $colorType
+     * @param string $colorAlpha
+     * @param string $blur
+     * @param int $angle
+     * @param float $distance
+     */
+    public function setShadowProperties($presets, $colorValue = null, $colorType = null, $colorAlpha = null, $blur = null, $angle = null, $distance = null): void
+    {
+        $this->activateObject()
+            ->setShadowPresetsProperties((int) $presets)
+            ->setShadowColor(
+                $colorValue ?? $this->shadowProperties['color']['value'],
+                $colorAlpha === null ? (int) $this->shadowProperties['color']['alpha'] : $this->getTrueAlpha($colorAlpha),
+                $colorType ?? $this->shadowProperties['color']['type']
+            )
+            ->setShadowBlur((float) $blur)
+            ->setShadowAngle($angle)
+            ->setShadowDistance($distance);
+    }
+
+    /**
+     * Set Shadow Presets Properties.
+     *
+     * @param int $presets
+     *
+     * @return $this
+     */
+    private function setShadowPresetsProperties($presets)
+    {
+        $this->shadowProperties['presets'] = $presets;
+        $this->setShadowPropertiesMapValues($this->getShadowPresetsMap($presets));
+
+        return $this;
+    }
+
+    /**
+     * Set Shadow Properties Values.
+     *
+     * @param mixed $reference
+     *
+     * @return $this
+     */
+    private function setShadowPropertiesMapValues(array $propertiesMap, &$reference = null)
+    {
+        $base_reference = $reference;
+        foreach ($propertiesMap as $property_key => $property_val) {
+            if (is_array($property_val)) {
+                if ($reference === null) {
+                    $reference = &$this->shadowProperties[$property_key];
+                } else {
+                    $reference = &$reference[$property_key];
+                }
+                $this->setShadowPropertiesMapValues($property_val, $reference);
+            } else {
+                if ($base_reference === null) {
+                    $this->shadowProperties[$property_key] = $property_val;
+                } else {
+                    $reference[$property_key] = $property_val;
+                }
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Set Shadow Color.
+     *
+     * @param string $color
+     * @param int $alpha
+     * @param string $colorType
+     *
+     * @return $this
+     */
+    private function setShadowColor($color, $alpha, $colorType)
+    {
+        if ($color !== null) {
+            $this->shadowProperties['color']['value'] = (string) $color;
+        }
+        if ($alpha !== null) {
+            $this->shadowProperties['color']['alpha'] = $this->getTrueAlpha((int) $alpha);
+        }
+        if ($colorType !== null) {
+            $this->shadowProperties['color']['type'] = (string) $colorType;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Set Shadow Blur.
+     *
+     * @param float $blur
+     *
+     * @return $this
+     */
+    private function setShadowBlur($blur)
+    {
+        if ($blur !== null) {
+            $this->shadowProperties['blur'] = (string) $this->getExcelPointsWidth($blur);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Set Shadow Angle.
+     *
+     * @param int $angle
+     *
+     * @return $this
+     */
+    private function setShadowAngle($angle)
+    {
+        if ($angle !== null) {
+            $this->shadowProperties['direction'] = (string) $this->getExcelPointsAngle($angle);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Set Shadow Distance.
+     *
+     * @param float $distance
+     *
+     * @return $this
+     */
+    private function setShadowDistance($distance)
+    {
+        if ($distance !== null) {
+            $this->shadowProperties['distance'] = (string) $this->getExcelPointsWidth($distance);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get Shadow Property.
+     *
+     * @param string|string[] $elements
+     *
+     * @return string
+     */
+    public function getShadowProperty($elements)
+    {
+        return $this->getArrayElementsValue($this->shadowProperties, $elements);
+    }
+
+    /**
+     * Set Soft Edges Size.
+     *
+     * @param float $size
+     */
+    public function setSoftEdgesSize($size): void
+    {
+        if ($size !== null) {
+            $this->activateObject();
+            $this->softEdges['size'] = (string) $this->getExcelPointsWidth($size);
+        }
+    }
+
+    /**
+     * Get Soft Edges Size.
+     *
+     * @return string
+     */
+    public function getSoftEdgesSize()
+    {
+        return $this->softEdges['size'];
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Chart/Layout.php

@@ -0,0 +1,481 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Chart;
+
+class Layout
+{
+    /**
+     * layoutTarget.
+     *
+     * @var string
+     */
+    private $layoutTarget;
+
+    /**
+     * X Mode.
+     *
+     * @var string
+     */
+    private $xMode;
+
+    /**
+     * Y Mode.
+     *
+     * @var string
+     */
+    private $yMode;
+
+    /**
+     * X-Position.
+     *
+     * @var float
+     */
+    private $xPos;
+
+    /**
+     * Y-Position.
+     *
+     * @var float
+     */
+    private $yPos;
+
+    /**
+     * width.
+     *
+     * @var float
+     */
+    private $width;
+
+    /**
+     * height.
+     *
+     * @var float
+     */
+    private $height;
+
+    /**
+     * show legend key
+     * Specifies that legend keys should be shown in data labels.
+     *
+     * @var bool
+     */
+    private $showLegendKey;
+
+    /**
+     * show value
+     * Specifies that the value should be shown in a data label.
+     *
+     * @var bool
+     */
+    private $showVal;
+
+    /**
+     * show category name
+     * Specifies that the category name should be shown in the data label.
+     *
+     * @var bool
+     */
+    private $showCatName;
+
+    /**
+     * show data series name
+     * Specifies that the series name should be shown in the data label.
+     *
+     * @var bool
+     */
+    private $showSerName;
+
+    /**
+     * show percentage
+     * Specifies that the percentage should be shown in the data label.
+     *
+     * @var bool
+     */
+    private $showPercent;
+
+    /**
+     * show bubble size.
+     *
+     * @var bool
+     */
+    private $showBubbleSize;
+
+    /**
+     * show leader lines
+     * Specifies that leader lines should be shown for the data label.
+     *
+     * @var bool
+     */
+    private $showLeaderLines;
+
+    /**
+     * Create a new Layout.
+     */
+    public function __construct(array $layout = [])
+    {
+        if (isset($layout['layoutTarget'])) {
+            $this->layoutTarget = $layout['layoutTarget'];
+        }
+        if (isset($layout['xMode'])) {
+            $this->xMode = $layout['xMode'];
+        }
+        if (isset($layout['yMode'])) {
+            $this->yMode = $layout['yMode'];
+        }
+        if (isset($layout['x'])) {
+            $this->xPos = (float) $layout['x'];
+        }
+        if (isset($layout['y'])) {
+            $this->yPos = (float) $layout['y'];
+        }
+        if (isset($layout['w'])) {
+            $this->width = (float) $layout['w'];
+        }
+        if (isset($layout['h'])) {
+            $this->height = (float) $layout['h'];
+        }
+    }
+
+    /**
+     * Get Layout Target.
+     *
+     * @return string
+     */
+    public function getLayoutTarget()
+    {
+        return $this->layoutTarget;
+    }
+
+    /**
+     * Set Layout Target.
+     *
+     * @param string $target
+     *
+     * @return $this
+     */
+    public function setLayoutTarget($target)
+    {
+        $this->layoutTarget = $target;
+
+        return $this;
+    }
+
+    /**
+     * Get X-Mode.
+     *
+     * @return string
+     */
+    public function getXMode()
+    {
+        return $this->xMode;
+    }
+
+    /**
+     * Set X-Mode.
+     *
+     * @param string $mode
+     *
+     * @return $this
+     */
+    public function setXMode($mode)
+    {
+        $this->xMode = (string) $mode;
+
+        return $this;
+    }
+
+    /**
+     * Get Y-Mode.
+     *
+     * @return string
+     */
+    public function getYMode()
+    {
+        return $this->yMode;
+    }
+
+    /**
+     * Set Y-Mode.
+     *
+     * @param string $mode
+     *
+     * @return $this
+     */
+    public function setYMode($mode)
+    {
+        $this->yMode = (string) $mode;
+
+        return $this;
+    }
+
+    /**
+     * Get X-Position.
+     *
+     * @return number
+     */
+    public function getXPosition()
+    {
+        return $this->xPos;
+    }
+
+    /**
+     * Set X-Position.
+     *
+     * @param float $position
+     *
+     * @return $this
+     */
+    public function setXPosition($position)
+    {
+        $this->xPos = (float) $position;
+
+        return $this;
+    }
+
+    /**
+     * Get Y-Position.
+     *
+     * @return number
+     */
+    public function getYPosition()
+    {
+        return $this->yPos;
+    }
+
+    /**
+     * Set Y-Position.
+     *
+     * @param float $position
+     *
+     * @return $this
+     */
+    public function setYPosition($position)
+    {
+        $this->yPos = (float) $position;
+
+        return $this;
+    }
+
+    /**
+     * Get Width.
+     *
+     * @return number
+     */
+    public function getWidth()
+    {
+        return $this->width;
+    }
+
+    /**
+     * Set Width.
+     *
+     * @param float $width
+     *
+     * @return $this
+     */
+    public function setWidth($width)
+    {
+        $this->width = $width;
+
+        return $this;
+    }
+
+    /**
+     * Get Height.
+     *
+     * @return number
+     */
+    public function getHeight()
+    {
+        return $this->height;
+    }
+
+    /**
+     * Set Height.
+     *
+     * @param float $height
+     *
+     * @return $this
+     */
+    public function setHeight($height)
+    {
+        $this->height = $height;
+
+        return $this;
+    }
+
+    /**
+     * Get show legend key.
+     *
+     * @return bool
+     */
+    public function getShowLegendKey()
+    {
+        return $this->showLegendKey;
+    }
+
+    /**
+     * Set show legend key
+     * Specifies that legend keys should be shown in data labels.
+     *
+     * @param bool $showLegendKey Show legend key
+     *
+     * @return $this
+     */
+    public function setShowLegendKey($showLegendKey)
+    {
+        $this->showLegendKey = $showLegendKey;
+
+        return $this;
+    }
+
+    /**
+     * Get show value.
+     *
+     * @return bool
+     */
+    public function getShowVal()
+    {
+        return $this->showVal;
+    }
+
+    /**
+     * Set show val
+     * Specifies that the value should be shown in data labels.
+     *
+     * @param bool $showDataLabelValues Show val
+     *
+     * @return $this
+     */
+    public function setShowVal($showDataLabelValues)
+    {
+        $this->showVal = $showDataLabelValues;
+
+        return $this;
+    }
+
+    /**
+     * Get show category name.
+     *
+     * @return bool
+     */
+    public function getShowCatName()
+    {
+        return $this->showCatName;
+    }
+
+    /**
+     * Set show cat name
+     * Specifies that the category name should be shown in data labels.
+     *
+     * @param bool $showCategoryName Show cat name
+     *
+     * @return $this
+     */
+    public function setShowCatName($showCategoryName)
+    {
+        $this->showCatName = $showCategoryName;
+
+        return $this;
+    }
+
+    /**
+     * Get show data series name.
+     *
+     * @return bool
+     */
+    public function getShowSerName()
+    {
+        return $this->showSerName;
+    }
+
+    /**
+     * Set show ser name
+     * Specifies that the series name should be shown in data labels.
+     *
+     * @param bool $showSeriesName Show series name
+     *
+     * @return $this
+     */
+    public function setShowSerName($showSeriesName)
+    {
+        $this->showSerName = $showSeriesName;
+
+        return $this;
+    }
+
+    /**
+     * Get show percentage.
+     *
+     * @return bool
+     */
+    public function getShowPercent()
+    {
+        return $this->showPercent;
+    }
+
+    /**
+     * Set show percentage
+     * Specifies that the percentage should be shown in data labels.
+     *
+     * @param bool $showPercentage Show percentage
+     *
+     * @return $this
+     */
+    public function setShowPercent($showPercentage)
+    {
+        $this->showPercent = $showPercentage;
+
+        return $this;
+    }
+
+    /**
+     * Get show bubble size.
+     *
+     * @return bool
+     */
+    public function getShowBubbleSize()
+    {
+        return $this->showBubbleSize;
+    }
+
+    /**
+     * Set show bubble size
+     * Specifies that the bubble size should be shown in data labels.
+     *
+     * @param bool $showBubbleSize Show bubble size
+     *
+     * @return $this
+     */
+    public function setShowBubbleSize($showBubbleSize)
+    {
+        $this->showBubbleSize = $showBubbleSize;
+
+        return $this;
+    }
+
+    /**
+     * Get show leader lines.
+     *
+     * @return bool
+     */
+    public function getShowLeaderLines()
+    {
+        return $this->showLeaderLines;
+    }
+
+    /**
+     * Set show leader lines
+     * Specifies that leader lines should be shown in data labels.
+     *
+     * @param bool $showLeaderLines Show leader lines
+     *
+     * @return $this
+     */
+    public function setShowLeaderLines($showLeaderLines)
+    {
+        $this->showLeaderLines = $showLeaderLines;
+
+        return $this;
+    }
+}

vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Chart/Legend.php

@@ -0,0 +1,149 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Chart;
+
+class Legend
+{
+    /** Legend positions */
+    const XL_LEGEND_POSITION_BOTTOM = -4107; //    Below the chart.
+    const XL_LEGEND_POSITION_CORNER = 2; //    In the upper right-hand corner of the chart border.
+    const XL_LEGEND_POSITION_CUSTOM = -4161; //    A custom position.
+    const XL_LEGEND_POSITION_LEFT = -4131; //    Left of the chart.
+    const XL_LEGEND_POSITION_RIGHT = -4152; //    Right of the chart.
+    const XL_LEGEND_POSITION_TOP = -4160; //    Above the chart.
+
+    const POSITION_RIGHT = 'r';
+    const POSITION_LEFT = 'l';
+    const POSITION_BOTTOM = 'b';
+    const POSITION_TOP = 't';
+    const POSITION_TOPRIGHT = 'tr';
+
+    private static $positionXLref = [
+        self::XL_LEGEND_POSITION_BOTTOM => self::POSITION_BOTTOM,
+        self::XL_LEGEND_POSITION_CORNER => self::POSITION_TOPRIGHT,
+        self::XL_LEGEND_POSITION_CUSTOM => '??',
+        self::XL_LEGEND_POSITION_LEFT => self::POSITION_LEFT,
+        self::XL_LEGEND_POSITION_RIGHT => self::POSITION_RIGHT,
+        self::XL_LEGEND_POSITION_TOP => self::POSITION_TOP,
+    ];
+
+    /**
+     * Legend position.
+     *
+     * @var string
+     */
+    private $position = self::POSITION_RIGHT;
+
+    /**
+     * Allow overlay of other elements?
+     *
+     * @var bool
+     */
+    private $overlay = true;
+
+    /**
+     * Legend Layout.
+     *
+     * @var Layout
+     */
+    private $layout;
+
+    /**
+     * Create a new Legend.
+     *
+     * @param string $position
+     * @param bool $overlay
+     */
+    public function __construct($position = self::POSITION_RIGHT, ?Layout $layout = null, $overlay = false)
+    {
+        $this->setPosition($position);
+        $this->layout = $layout;
+        $this->setOverlay($overlay);
+    }
+
+    /**
+     * Get legend position as an excel string value.
+     *
+     * @return string
+     */
+    public function getPosition()
+    {
+        return $this->position;
+    }
+
+    /**
+     * Get legend position using an excel string value.
+     *
+     * @param string $position see self::POSITION_*
+     *
+     * @return bool
+     */
+    public function setPosition($position)
+    {
+        if (!in_array($position, self::$positionXLref)) {
+            return false;
+        }
+
+        $this->position = $position;
+
+        return true;
+    }
+
+    /**
+     * Get legend position as an Excel internal numeric value.
+     *
+     * @return int
+     */
+    public function getPositionXL()
+    {
+        return array_search($this->position, self::$positionXLref);
+    }
+
+    /**
+     * Set legend position using an Excel internal numeric value.
+     *
+     * @param int $positionXL see self::XL_LEGEND_POSITION_*
+     *
+     * @return bool
+     */
+    public function setPositionXL($positionXL)
+    {
+        if (!isset(self::$positionXLref[$positionXL])) {
+            return false;
+        }
+
+        $this->position = self::$positionXLref[$positionXL];
+
+        return true;
+    }
+
+    /**
+     * Get allow overlay of other elements?
+     *
+     * @return bool
+     */
+    public function getOverlay()
+    {
+        return $this->overlay;
+    }
+
+    /**
+     * Set allow overlay of other elements?
+     *
+     * @param bool $overlay
+     */
+    public function setOverlay($overlay): void
+    {
+        $this->overlay = $overlay;
+    }
+
+    /**
+     * Get Layout.
+     *
+     * @return Layout
+     */
+    public function getLayout()
+    {
+        return $this->layout;
+    }
+}