├── CHANGELOG.md
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── composer.json
└── src
    └── PhpSpreadsheet
        ├── Calculation
            ├── ArrayEnabled.php
            ├── BinaryComparison.php
            ├── Calculation.php
            ├── CalculationBase.php
            ├── CalculationLocale.php
            ├── Category.php
            ├── Database
            │   ├── DAverage.php
            │   ├── DCount.php
            │   ├── DCountA.php
            │   ├── DGet.php
            │   ├── DMax.php
            │   ├── DMin.php
            │   ├── DProduct.php
            │   ├── DStDev.php
            │   ├── DStDevP.php
            │   ├── DSum.php
            │   ├── DVar.php
            │   ├── DVarP.php
            │   └── DatabaseAbstract.php
            ├── DateTimeExcel
            │   ├── Constants.php
            │   ├── Current.php
            │   ├── Date.php
            │   ├── DateParts.php
            │   ├── DateValue.php
            │   ├── Days.php
            │   ├── Days360.php
            │   ├── Difference.php
            │   ├── Helpers.php
            │   ├── Month.php
            │   ├── NetworkDays.php
            │   ├── Time.php
            │   ├── TimeParts.php
            │   ├── TimeValue.php
            │   ├── Week.php
            │   ├── WorkDay.php
            │   └── YearFrac.php
            ├── Engine
            │   ├── ArrayArgumentHelper.php
            │   ├── ArrayArgumentProcessor.php
            │   ├── BranchPruner.php
            │   ├── CyclicReferenceStack.php
            │   ├── FormattedNumber.php
            │   ├── Logger.php
            │   └── Operands
            │   │   ├── Operand.php
            │   │   └── StructuredReference.php
            ├── Engineering
            │   ├── BesselI.php
            │   ├── BesselJ.php
            │   ├── BesselK.php
            │   ├── BesselY.php
            │   ├── BitWise.php
            │   ├── Compare.php
            │   ├── Complex.php
            │   ├── ComplexFunctions.php
            │   ├── ComplexOperations.php
            │   ├── Constants.php
            │   ├── ConvertBase.php
            │   ├── ConvertBinary.php
            │   ├── ConvertDecimal.php
            │   ├── ConvertHex.php
            │   ├── ConvertOctal.php
            │   ├── ConvertUOM.php
            │   ├── EngineeringValidations.php
            │   ├── Erf.php
            │   └── ErfC.php
            ├── Exception.php
            ├── ExceptionHandler.php
            ├── Financial
            │   ├── Amortization.php
            │   ├── CashFlow
            │   │   ├── CashFlowValidations.php
            │   │   ├── Constant
            │   │   │   ├── Periodic.php
            │   │   │   └── Periodic
            │   │   │   │   ├── Cumulative.php
            │   │   │   │   ├── Interest.php
            │   │   │   │   ├── InterestAndPrincipal.php
            │   │   │   │   └── Payments.php
            │   │   ├── Single.php
            │   │   └── Variable
            │   │   │   ├── NonPeriodic.php
            │   │   │   └── Periodic.php
            │   ├── Constants.php
            │   ├── Coupons.php
            │   ├── Depreciation.php
            │   ├── Dollar.php
            │   ├── FinancialValidations.php
            │   ├── Helpers.php
            │   ├── InterestRate.php
            │   ├── Securities
            │   │   ├── AccruedInterest.php
            │   │   ├── Price.php
            │   │   ├── Rates.php
            │   │   ├── SecurityValidations.php
            │   │   └── Yields.php
            │   └── TreasuryBill.php
            ├── FormulaParser.php
            ├── FormulaToken.php
            ├── FunctionArray.php
            ├── Functions.php
            ├── Information
            │   ├── ErrorValue.php
            │   ├── ExcelError.php
            │   └── Value.php
            ├── Internal
            │   ├── ExcelArrayPseudoFunctions.php
            │   ├── MakeMatrix.php
            │   └── WildcardMatch.php
            ├── Logical
            │   ├── Boolean.php
            │   ├── Conditional.php
            │   └── Operations.php
            ├── LookupRef
            │   ├── Address.php
            │   ├── ChooseRowsEtc.php
            │   ├── ExcelMatch.php
            │   ├── Filter.php
            │   ├── Formula.php
            │   ├── HLookup.php
            │   ├── Helpers.php
            │   ├── Hstack.php
            │   ├── Hyperlink.php
            │   ├── Indirect.php
            │   ├── Lookup.php
            │   ├── LookupBase.php
            │   ├── LookupRefValidations.php
            │   ├── Matrix.php
            │   ├── Offset.php
            │   ├── RowColumnInformation.php
            │   ├── Selection.php
            │   ├── Sort.php
            │   ├── TorowTocol.php
            │   ├── Unique.php
            │   ├── VLookup.php
            │   └── Vstack.php
            ├── MathTrig
            │   ├── Absolute.php
            │   ├── Angle.php
            │   ├── Arabic.php
            │   ├── Base.php
            │   ├── Ceiling.php
            │   ├── Combinations.php
            │   ├── Exp.php
            │   ├── Factorial.php
            │   ├── Floor.php
            │   ├── Gcd.php
            │   ├── Helpers.php
            │   ├── IntClass.php
            │   ├── Lcm.php
            │   ├── Logarithms.php
            │   ├── MatrixFunctions.php
            │   ├── Operations.php
            │   ├── Random.php
            │   ├── Roman.php
            │   ├── Round.php
            │   ├── SeriesSum.php
            │   ├── Sign.php
            │   ├── Sqrt.php
            │   ├── Subtotal.php
            │   ├── Sum.php
            │   ├── SumSquares.php
            │   ├── Trig
            │   │   ├── Cosecant.php
            │   │   ├── Cosine.php
            │   │   ├── Cotangent.php
            │   │   ├── Secant.php
            │   │   ├── Sine.php
            │   │   └── Tangent.php
            │   └── Trunc.php
            ├── Statistical
            │   ├── AggregateBase.php
            │   ├── Averages.php
            │   ├── Averages
            │   │   └── Mean.php
            │   ├── Conditional.php
            │   ├── Confidence.php
            │   ├── Counts.php
            │   ├── Deviations.php
            │   ├── Distributions
            │   │   ├── Beta.php
            │   │   ├── Binomial.php
            │   │   ├── ChiSquared.php
            │   │   ├── DistributionValidations.php
            │   │   ├── Exponential.php
            │   │   ├── F.php
            │   │   ├── Fisher.php
            │   │   ├── Gamma.php
            │   │   ├── GammaBase.php
            │   │   ├── HyperGeometric.php
            │   │   ├── LogNormal.php
            │   │   ├── NewtonRaphson.php
            │   │   ├── Normal.php
            │   │   ├── Poisson.php
            │   │   ├── StandardNormal.php
            │   │   ├── StudentT.php
            │   │   └── Weibull.php
            │   ├── MaxMinBase.php
            │   ├── Maximum.php
            │   ├── Minimum.php
            │   ├── Percentiles.php
            │   ├── Permutations.php
            │   ├── Size.php
            │   ├── StandardDeviations.php
            │   ├── Standardize.php
            │   ├── StatisticalValidations.php
            │   ├── Trends.php
            │   ├── VarianceBase.php
            │   └── Variances.php
            ├── TextData
            │   ├── CaseConvert.php
            │   ├── CharacterConvert.php
            │   ├── Concatenate.php
            │   ├── Extract.php
            │   ├── Format.php
            │   ├── Helpers.php
            │   ├── Replace.php
            │   ├── Search.php
            │   ├── Text.php
            │   └── Trim.php
            ├── Token
            │   └── Stack.php
            ├── Web
            │   └── Service.php
            └── locale
            │   ├── Translations.xlsx
            │   ├── bg
            │       ├── config
            │       └── functions
            │   ├── cs
            │       ├── config
            │       └── functions
            │   ├── da
            │       ├── config
            │       └── functions
            │   ├── de
            │       ├── config
            │       └── functions
            │   ├── en
            │       └── uk
            │       │   └── config
            │   ├── es
            │       ├── config
            │       └── functions
            │   ├── fi
            │       ├── config
            │       └── functions
            │   ├── fr
            │       ├── config
            │       └── functions
            │   ├── hu
            │       ├── config
            │       └── functions
            │   ├── it
            │       ├── config
            │       └── functions
            │   ├── nb
            │       ├── config
            │       └── functions
            │   ├── nl
            │       ├── config
            │       └── functions
            │   ├── pl
            │       ├── config
            │       └── functions
            │   ├── pt
            │       ├── br
            │       │   ├── config
            │       │   └── functions
            │       ├── config
            │       └── functions
            │   ├── ru
            │       ├── config
            │       └── functions
            │   ├── sv
            │       ├── config
            │       └── functions
            │   └── tr
            │       ├── config
            │       └── functions
        ├── Cell
            ├── AddressHelper.php
            ├── AddressRange.php
            ├── AdvancedValueBinder.php
            ├── Cell.php
            ├── CellAddress.php
            ├── CellRange.php
            ├── ColumnRange.php
            ├── Coordinate.php
            ├── DataType.php
            ├── DataValidation.php
            ├── DataValidator.php
            ├── DefaultValueBinder.php
            ├── Hyperlink.php
            ├── IValueBinder.php
            ├── IgnoredErrors.php
            ├── RowRange.php
            └── StringValueBinder.php
        ├── CellReferenceHelper.php
        ├── Chart
            ├── Axis.php
            ├── AxisText.php
            ├── Chart.php
            ├── ChartColor.php
            ├── DataSeries.php
            ├── DataSeriesValues.php
            ├── Exception.php
            ├── GridLines.php
            ├── Layout.php
            ├── Legend.php
            ├── PlotArea.php
            ├── Properties.php
            ├── Renderer
            │   ├── IRenderer.php
            │   ├── JpGraph.php
            │   ├── JpGraphRendererBase.php
            │   ├── MtJpGraphRenderer.php
            │   └── PHP Charting Libraries.txt
            ├── Title.php
            └── TrendLine.php
        ├── Collection
            ├── Cells.php
            ├── CellsFactory.php
            └── Memory
            │   ├── SimpleCache1.php
            │   └── SimpleCache3.php
        ├── Comment.php
        ├── DefinedName.php
        ├── Document
            ├── Properties.php
            └── Security.php
        ├── Exception.php
        ├── HashTable.php
        ├── Helper
            ├── Dimension.php
            ├── Downloader.php
            ├── Handler.php
            ├── Html.php
            ├── Sample.php
            ├── Size.php
            └── TextGrid.php
        ├── IComparable.php
        ├── IOFactory.php
        ├── NamedFormula.php
        ├── NamedRange.php
        ├── Reader
            ├── BaseReader.php
            ├── Csv.php
            ├── Csv
            │   └── Delimiter.php
            ├── DefaultReadFilter.php
            ├── Exception.php
            ├── Gnumeric.php
            ├── Gnumeric
            │   ├── PageSetup.php
            │   ├── Properties.php
            │   └── Styles.php
            ├── Html.php
            ├── IReadFilter.php
            ├── IReader.php
            ├── Ods.php
            ├── Ods
            │   ├── AutoFilter.php
            │   ├── BaseLoader.php
            │   ├── DefinedNames.php
            │   ├── FormulaTranslator.php
            │   ├── PageSettings.php
            │   └── Properties.php
            ├── Security
            │   └── XmlScanner.php
            ├── Slk.php
            ├── Xls.php
            ├── Xls
            │   ├── Biff5.php
            │   ├── Biff8.php
            │   ├── Color.php
            │   ├── Color
            │   │   ├── BIFF5.php
            │   │   ├── BIFF8.php
            │   │   └── BuiltIn.php
            │   ├── ConditionalFormatting.php
            │   ├── DataValidationHelper.php
            │   ├── ErrorCode.php
            │   ├── Escher.php
            │   ├── ListFunctions.php
            │   ├── LoadSpreadsheet.php
            │   ├── MD5.php
            │   ├── Mappings.php
            │   ├── RC4.php
            │   └── Style
            │   │   ├── Border.php
            │   │   ├── CellAlignment.php
            │   │   ├── CellFont.php
            │   │   └── FillPattern.php
            ├── XlsBase.php
            ├── Xlsx.php
            ├── Xlsx
            │   ├── AutoFilter.php
            │   ├── BaseParserClass.php
            │   ├── Chart.php
            │   ├── ColumnAndRowAttributes.php
            │   ├── ConditionalStyles.php
            │   ├── DataValidations.php
            │   ├── Hyperlinks.php
            │   ├── Namespaces.php
            │   ├── PageSetup.php
            │   ├── Properties.php
            │   ├── SharedFormula.php
            │   ├── SheetViewOptions.php
            │   ├── SheetViews.php
            │   ├── Styles.php
            │   ├── TableReader.php
            │   ├── Theme.php
            │   └── WorkbookView.php
            ├── Xml.php
            └── Xml
            │   ├── DataValidations.php
            │   ├── PageSettings.php
            │   ├── Properties.php
            │   ├── Style.php
            │   └── Style
            │       ├── Alignment.php
            │       ├── Border.php
            │       ├── Fill.php
            │       ├── Font.php
            │       ├── NumberFormat.php
            │       └── StyleBase.php
        ├── ReferenceHelper.php
        ├── RichText
            ├── ITextElement.php
            ├── RichText.php
            ├── Run.php
            └── TextElement.php
        ├── Settings.php
        ├── Shared
            ├── CodePage.php
            ├── Date.php
            ├── Drawing.php
            ├── Escher.php
            ├── Escher
            │   ├── DgContainer.php
            │   ├── DgContainer
            │   │   ├── SpgrContainer.php
            │   │   └── SpgrContainer
            │   │   │   └── SpContainer.php
            │   ├── DggContainer.php
            │   └── DggContainer
            │   │   ├── BstoreContainer.php
            │   │   └── BstoreContainer
            │   │       ├── BSE.php
            │   │       └── BSE
            │   │           └── Blip.php
            ├── File.php
            ├── Font.php
            ├── IntOrFloat.php
            ├── OLE.php
            ├── OLE
            │   ├── ChainedBlockStream.php
            │   ├── PPS.php
            │   └── PPS
            │   │   ├── File.php
            │   │   └── Root.php
            ├── OLERead.php
            ├── PasswordHasher.php
            ├── StringHelper.php
            ├── TimeZone.php
            ├── Trend
            │   ├── BestFit.php
            │   ├── ExponentialBestFit.php
            │   ├── LinearBestFit.php
            │   ├── LogarithmicBestFit.php
            │   ├── PolynomialBestFit.php
            │   ├── PowerBestFit.php
            │   └── Trend.php
            ├── XMLWriter.php
            └── Xls.php
        ├── Spreadsheet.php
        ├── Style
            ├── Alignment.php
            ├── Border.php
            ├── Borders.php
            ├── Color.php
            ├── Conditional.php
            ├── ConditionalFormatting
            │   ├── CellMatcher.php
            │   ├── CellStyleAssessor.php
            │   ├── ConditionalColorScale.php
            │   ├── ConditionalDataBar.php
            │   ├── ConditionalDataBarExtension.php
            │   ├── ConditionalFormatValueObject.php
            │   ├── ConditionalFormattingRuleExtension.php
            │   ├── StyleMerger.php
            │   ├── Wizard.php
            │   └── Wizard
            │   │   ├── Blanks.php
            │   │   ├── CellValue.php
            │   │   ├── DateValue.php
            │   │   ├── Duplicates.php
            │   │   ├── Errors.php
            │   │   ├── Expression.php
            │   │   ├── TextValue.php
            │   │   ├── WizardAbstract.php
            │   │   └── WizardInterface.php
            ├── Fill.php
            ├── Font.php
            ├── NumberFormat.php
            ├── NumberFormat
            │   ├── BaseFormatter.php
            │   ├── DateFormatter.php
            │   ├── Formatter.php
            │   ├── FractionFormatter.php
            │   ├── NumberFormatter.php
            │   ├── PercentageFormatter.php
            │   └── Wizard
            │   │   ├── Accounting.php
            │   │   ├── Currency.php
            │   │   ├── CurrencyBase.php
            │   │   ├── CurrencyNegative.php
            │   │   ├── Date.php
            │   │   ├── DateTime.php
            │   │   ├── DateTimeWizard.php
            │   │   ├── Duration.php
            │   │   ├── Locale.php
            │   │   ├── Number.php
            │   │   ├── NumberBase.php
            │   │   ├── Percentage.php
            │   │   ├── Scientific.php
            │   │   ├── Time.php
            │   │   └── Wizard.php
            ├── Protection.php
            ├── RgbTint.php
            ├── Style.php
            └── Supervisor.php
        ├── Theme.php
        ├── Worksheet
            ├── AutoFilter.php
            ├── AutoFilter
            │   ├── Column.php
            │   └── Column
            │   │   └── Rule.php
            ├── AutoFit.php
            ├── BaseDrawing.php
            ├── CellIterator.php
            ├── Column.php
            ├── ColumnCellIterator.php
            ├── ColumnDimension.php
            ├── ColumnIterator.php
            ├── Dimension.php
            ├── Drawing.php
            ├── Drawing
            │   └── Shadow.php
            ├── HeaderFooter.php
            ├── HeaderFooterDrawing.php
            ├── Iterator.php
            ├── MemoryDrawing.php
            ├── PageBreak.php
            ├── PageMargins.php
            ├── PageSetup.php
            ├── Pane.php
            ├── ProtectedRange.php
            ├── Protection.php
            ├── Row.php
            ├── RowCellIterator.php
            ├── RowDimension.php
            ├── RowIterator.php
            ├── SheetView.php
            ├── Table.php
            ├── Table
            │   ├── Column.php
            │   ├── TableDxfsStyle.php
            │   └── TableStyle.php
            ├── Validations.php
            └── Worksheet.php
        └── Writer
            ├── BaseWriter.php
            ├── Csv.php
            ├── Exception.php
            ├── Html.php
            ├── IWriter.php
            ├── Ods.php
            ├── Ods
                ├── AutoFilters.php
                ├── Cell
                │   ├── Comment.php
                │   └── Style.php
                ├── Content.php
                ├── Formula.php
                ├── Meta.php
                ├── MetaInf.php
                ├── Mimetype.php
                ├── NamedExpressions.php
                ├── Settings.php
                ├── Styles.php
                ├── Thumbnails.php
                └── WriterPart.php
            ├── Pdf.php
            ├── Pdf
                ├── Dompdf.php
                ├── Mpdf.php
                └── Tcpdf.php
            ├── Xls.php
            ├── Xls
                ├── BIFFwriter.php
                ├── CellDataValidation.php
                ├── ConditionalHelper.php
                ├── ErrorCode.php
                ├── Escher.php
                ├── Font.php
                ├── Parser.php
                ├── Style
                │   ├── CellAlignment.php
                │   ├── CellBorder.php
                │   └── CellFill.php
                ├── Workbook.php
                ├── Worksheet.php
                └── Xf.php
            ├── Xlsx.php
            ├── Xlsx
                ├── AutoFilter.php
                ├── Chart.php
                ├── Comments.php
                ├── ContentTypes.php
                ├── DefinedNames.php
                ├── DocProps.php
                ├── Drawing.php
                ├── FunctionPrefix.php
                ├── Metadata.php
                ├── Rels.php
                ├── RelsRibbon.php
                ├── RelsVBA.php
                ├── StringTable.php
                ├── Style.php
                ├── Table.php
                ├── Theme.php
                ├── Workbook.php
                ├── Worksheet.php
                └── WriterPart.php
            ├── ZipStream0.php
            ├── ZipStream2.php
            └── ZipStream3.php


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


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/CalculationBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation;
 4 | 
 5 | class CalculationBase
 6 | {
 7 |     /**
 8 |      * Get a list of all implemented functions as an array of function objects.
 9 |      *
10 |      * @return array<string, array{category: string, functionCall: string|string[], argumentCount: string, passCellReference?: bool, passByReference?: bool[], custom?: bool}>
11 |      */
12 |     public static function getFunctions(): array
13 |     {
14 |         return FunctionArray::$phpSpreadsheetFunctions;
15 |     }
16 | 
17 |     /**
18 |      * Get address of list of all implemented functions as an array of function objects.
19 |      *
20 |      * @return array<string, array<string, mixed>>
21 |      */
22 |     protected static function &getFunctionsAddress(): array
23 |     {
24 |         return FunctionArray::$phpSpreadsheetFunctions;
25 |     }
26 | 
27 |     /**
28 |      * @param array{category: string, functionCall: string|string[], argumentCount: string, passCellReference?: bool, passByReference?: bool[], custom?: bool} $value
29 |      */
30 |     public static function addFunction(string $key, array $value): bool
31 |     {
32 |         $key = strtoupper($key);
33 |         if (array_key_exists($key, FunctionArray::$phpSpreadsheetFunctions)) {
34 |             return false;
35 |         }
36 |         $value['custom'] = true;
37 |         FunctionArray::$phpSpreadsheetFunctions[$key] = $value;
38 | 
39 |         return true;
40 |     }
41 | 
42 |     public static function removeFunction(string $key): bool
43 |     {
44 |         $key = strtoupper($key);
45 |         if (array_key_exists($key, FunctionArray::$phpSpreadsheetFunctions)) {
46 |             if (FunctionArray::$phpSpreadsheetFunctions[$key]['custom'] ?? false) {
47 |                 unset(FunctionArray::$phpSpreadsheetFunctions[$key]);
48 | 
49 |                 return true;
50 |             }
51 |         }
52 | 
53 |         return false;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Category.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation;
 4 | 
 5 | abstract class Category
 6 | {
 7 |     // Function categories
 8 |     const CATEGORY_CUBE = 'Cube';
 9 |     const CATEGORY_DATABASE = 'Database';
10 |     const CATEGORY_DATE_AND_TIME = 'Date and Time';
11 |     const CATEGORY_ENGINEERING = 'Engineering';
12 |     const CATEGORY_FINANCIAL = 'Financial';
13 |     const CATEGORY_INFORMATION = 'Information';
14 |     const CATEGORY_LOGICAL = 'Logical';
15 |     const CATEGORY_LOOKUP_AND_REFERENCE = 'Lookup and Reference';
16 |     const CATEGORY_MATH_AND_TRIG = 'Math and Trig';
17 |     const CATEGORY_STATISTICAL = 'Statistical';
18 |     const CATEGORY_TEXT_AND_DATA = 'Text and Data';
19 |     const CATEGORY_WEB = 'Web';
20 |     const CATEGORY_UNCATEGORISED = 'Uncategorised';
21 |     const CATEGORY_MICROSOFT_INTERNAL = 'MS Internal';
22 | }
23 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Database/DAverage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Averages;
 7 | 
 8 | class DAverage extends DatabaseAbstract
 9 | {
10 |     /**
11 |      * DAVERAGE.
12 |      *
13 |      * Averages the values in a column of a list or database that match conditions you specify.
14 |      *
15 |      * Excel Function:
16 |      *        DAVERAGE(database,field,criteria)
17 |      *
18 |      * @param mixed[] $database The range of cells that makes up the list or database.
19 |      *                          A database is a list of related data in which rows of related
20 |      *                              information are records, and columns of data are fields. The
21 |      *                              first row of the list contains labels for each column.
22 |      * @param null|array<mixed>|int|string $field Indicates which column is used in the function. Enter the
23 |      *                              column label enclosed between double quotation marks, such as
24 |      *                              "Age" or "Yield," or a number (without quotation marks) that
25 |      *                              represents the position of the column within the list: 1 for
26 |      *                              the first column, 2 for the second column, and so on.
27 |      * @param mixed[][] $criteria The range of cells that contains the conditions you specify.
28 |      *                          You can use any range for the criteria argument, as long as it
29 |      *                              includes at least one column label and at least one cell below
30 |      *                              the column label in which you specify a condition for the
31 |      *                              column.
32 |      */
33 |     public static function evaluate(array $database, array|null|int|string $field, array $criteria): string|int|float
34 |     {
35 |         $field = self::fieldExtract($database, $field);
36 |         if ($field === null) {
37 |             return ExcelError::VALUE();
38 |         }
39 | 
40 |         return Averages::average(
41 |             self::getFilteredColumn($database, $field, $criteria)
42 |         );
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Database/DCountA.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Counts;
 7 | 
 8 | class DCountA extends DatabaseAbstract
 9 | {
10 |     /**
11 |      * DCOUNTA.
12 |      *
13 |      * Counts the nonblank cells in a column of a list or database that match conditions that you specify.
14 |      *
15 |      * Excel Function:
16 |      *        DCOUNTA(database,[field],criteria)
17 |      *
18 |      * @param mixed[] $database The range of cells that makes up the list or database.
19 |      *                                        A database is a list of related data in which rows of related
20 |      *                                        information are records, and columns of data are fields. The
21 |      *                                        first row of the list contains labels for each column.
22 |      * @param null|array<mixed>|int|string $field Indicates which column is used in the function. Enter the
23 |      *                                        column label enclosed between double quotation marks, such as
24 |      *                                        "Age" or "Yield," or a number (without quotation marks) that
25 |      *                                        represents the position of the column within the list: 1 for
26 |      *                                        the first column, 2 for the second column, and so on.
27 |      * @param mixed[][] $criteria The range of cells that contains the conditions you specify.
28 |      *                                        You can use any range for the criteria argument, as long as it
29 |      *                                        includes at least one column label and at least one cell below
30 |      *                                        the column label in which you specify a condition for the
31 |      *                                        column.
32 |      */
33 |     public static function evaluate(array $database, array|null|int|string $field, array $criteria): string|int
34 |     {
35 |         $field = self::fieldExtract($database, $field);
36 |         if ($field === null) {
37 |             return ExcelError::VALUE();
38 |         }
39 | 
40 |         return Counts::COUNTA(
41 |             self::getFilteredColumn($database, $field, $criteria)
42 |         );
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Database/DMax.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Statistical\Maximum;
 7 | 
 8 | class DMax extends DatabaseAbstract
 9 | {
10 |     /**
11 |      * DMAX.
12 |      *
13 |      * Returns the largest number in a column of a list or database that matches conditions you that
14 |      * specify.
15 |      *
16 |      * Excel Function:
17 |      *        DMAX(database,field,criteria)
18 |      *
19 |      * @param mixed[] $database The range of cells that makes up the list or database.
20 |      *                                        A database is a list of related data in which rows of related
21 |      *                                        information are records, and columns of data are fields. The
22 |      *                                        first row of the list contains labels for each column.
23 |      * @param null|array<mixed>|int|string $field Indicates which column is used in the function. Enter the
24 |      *                                        column label enclosed between double quotation marks, such as
25 |      *                                        "Age" or "Yield," or a number (without quotation marks) that
26 |      *                                        represents the position of the column within the list: 1 for
27 |      *                                        the first column, 2 for the second column, and so on.
28 |      * @param mixed[][] $criteria The range of cells that contains the conditions you specify.
29 |      *                                        You can use any range for the criteria argument, as long as it
30 |      *                                        includes at least one column label and at least one cell below
31 |      *                                        the column label in which you specify a condition for the
32 |      *                                        column.
33 |      */
34 |     public static function evaluate(array $database, array|null|int|string $field, array $criteria, bool $returnError = true): null|float|string
35 |     {
36 |         $field = self::fieldExtract($database, $field);
37 |         if ($field === null) {
38 |             return $returnError ? ExcelError::VALUE() : null;
39 |         }
40 | 
41 |         return Maximum::max(
42 |             self::getFilteredColumn($database, $field, $criteria)
43 |         );
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Database/DProduct.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 7 | 
 8 | class DProduct extends DatabaseAbstract
 9 | {
10 |     /**
11 |      * DPRODUCT.
12 |      *
13 |      * Multiplies the values in a column of a list or database that match conditions that you specify.
14 |      *
15 |      * Excel Function:
16 |      *        DPRODUCT(database,field,criteria)
17 |      *
18 |      * @param mixed[] $database The range of cells that makes up the list or database.
19 |      *                                        A database is a list of related data in which rows of related
20 |      *                                        information are records, and columns of data are fields. The
21 |      *                                        first row of the list contains labels for each column.
22 |      * @param null|array<mixed>|int|string $field Indicates which column is used in the function. Enter the
23 |      *                                        column label enclosed between double quotation marks, such as
24 |      *                                        "Age" or "Yield," or a number (without quotation marks) that
25 |      *                                        represents the position of the column within the list: 1 for
26 |      *                                        the first column, 2 for the second column, and so on.
27 |      * @param mixed[][] $criteria The range of cells that contains the conditions you specify.
28 |      *                                        You can use any range for the criteria argument, as long as it
29 |      *                                        includes at least one column label and at least one cell below
30 |      *                                        the column label in which you specify a condition for the
31 |      *                                        column.
32 |      */
33 |     public static function evaluate(array $database, array|null|int|string $field, array $criteria): string|float
34 |     {
35 |         $field = self::fieldExtract($database, $field);
36 |         if ($field === null) {
37 |             return ExcelError::VALUE();
38 |         }
39 | 
40 |         return MathTrig\Operations::product(
41 |             self::getFilteredColumn($database, $field, $criteria)
42 |         );
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Database/DSum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Database;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 7 | 
 8 | class DSum extends DatabaseAbstract
 9 | {
10 |     /**
11 |      * DSUM.
12 |      *
13 |      * Adds the numbers in a column of a list or database that match conditions that you specify.
14 |      *
15 |      * Excel Function:
16 |      *        DSUM(database,field,criteria)
17 |      *
18 |      * @param mixed[] $database The range of cells that makes up the list or database.
19 |      *                                        A database is a list of related data in which rows of related
20 |      *                                        information are records, and columns of data are fields. The
21 |      *                                        first row of the list contains labels for each column.
22 |      * @param null|array<mixed>|int|string $field Indicates which column is used in the function. Enter the
23 |      *                                        column label enclosed between double quotation marks, such as
24 |      *                                        "Age" or "Yield," or a number (without quotation marks) that
25 |      *                                        represents the position of the column within the list: 1 for
26 |      *                                        the first column, 2 for the second column, and so on.
27 |      * @param mixed[][] $criteria The range of cells that contains the conditions you specify.
28 |      *                                        You can use any range for the criteria argument, as long as it
29 |      *                                        includes at least one column label and at least one cell below
30 |      *                                        the column label in which you specify a condition for the
31 |      *                                        column.
32 |      */
33 |     public static function evaluate(array $database, array|null|int|string $field, array $criteria, bool $returnNull = false): null|float|string
34 |     {
35 |         $field = self::fieldExtract($database, $field);
36 |         if ($field === null) {
37 |             return $returnNull ? null : ExcelError::VALUE();
38 |         }
39 | 
40 |         return MathTrig\Sum::sumIgnoringStrings(
41 |             self::getFilteredColumn($database, $field, $criteria)
42 |         );
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/DateTimeExcel/Constants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
 4 | 
 5 | class Constants
 6 | {
 7 |     // Constants currently used by WeekNum; will eventually be used by WEEKDAY
 8 |     const STARTWEEK_SUNDAY = 1;
 9 |     const STARTWEEK_MONDAY = 2;
10 |     const STARTWEEK_MONDAY_ALT = 11;
11 |     const STARTWEEK_TUESDAY = 12;
12 |     const STARTWEEK_WEDNESDAY = 13;
13 |     const STARTWEEK_THURSDAY = 14;
14 |     const STARTWEEK_FRIDAY = 15;
15 |     const STARTWEEK_SATURDAY = 16;
16 |     const STARTWEEK_SUNDAY_ALT = 17;
17 |     const DOW_SUNDAY = 1;
18 |     const DOW_MONDAY = 2;
19 |     const DOW_TUESDAY = 3;
20 |     const DOW_WEDNESDAY = 4;
21 |     const DOW_THURSDAY = 5;
22 |     const DOW_FRIDAY = 6;
23 |     const DOW_SATURDAY = 7;
24 |     const STARTWEEK_MONDAY_ISO = 21;
25 | 
26 |     const METHODARR = [
27 |         self::STARTWEEK_SUNDAY => self::DOW_SUNDAY,
28 |         self::DOW_MONDAY,
29 |         self::STARTWEEK_MONDAY_ALT => self::DOW_MONDAY,
30 |         self::DOW_TUESDAY,
31 |         self::DOW_WEDNESDAY,
32 |         self::DOW_THURSDAY,
33 |         self::DOW_FRIDAY,
34 |         self::DOW_SATURDAY,
35 |         self::DOW_SUNDAY,
36 |         self::STARTWEEK_MONDAY_ISO => self::STARTWEEK_MONDAY_ISO,
37 |     ];
38 | }
39 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Engine/CyclicReferenceStack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Engine;
 4 | 
 5 | class CyclicReferenceStack
 6 | {
 7 |     /**
 8 |      * The call stack for calculated cells.
 9 |      *
10 |      * @var mixed[]
11 |      */
12 |     private array $stack = [];
13 | 
14 |     /**
15 |      * Return the number of entries on the stack.
16 |      */
17 |     public function count(): int
18 |     {
19 |         return count($this->stack);
20 |     }
21 | 
22 |     /**
23 |      * Push a new entry onto the stack.
24 |      */
25 |     public function push(mixed $value): void
26 |     {
27 |         $this->stack[$value] = $value;
28 |     }
29 | 
30 |     /**
31 |      * Pop the last entry from the stack.
32 |      */
33 |     public function pop(): mixed
34 |     {
35 |         return array_pop($this->stack);
36 |     }
37 | 
38 |     /**
39 |      * Test to see if a specified entry exists on the stack.
40 |      *
41 |      * @param mixed $value The value to test
42 |      */
43 |     public function onStack(mixed $value): bool
44 |     {
45 |         return isset($this->stack[$value]);
46 |     }
47 | 
48 |     /**
49 |      * Clear the stack.
50 |      */
51 |     public function clear(): void
52 |     {
53 |         $this->stack = [];
54 |     }
55 | 
56 |     /**
57 |      * Return an array of all entries on the stack.
58 |      *
59 |      * @return mixed[]
60 |      */
61 |     public function showStack(): array
62 |     {
63 |         return $this->stack;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Engine/Operands/Operand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Engine\Operands;
 4 | 
 5 | interface Operand
 6 | {
 7 |     /** @param string[] $matches */
 8 |     public static function fromParser(string $formula, int $index, array $matches): self;
 9 | 
10 |     public function value(): string;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Engineering/Constants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
 4 | 
 5 | class Constants
 6 | {
 7 |     /**
 8 |      * EULER.
 9 |      */
10 |     public const EULER = 2.71828182845904523536;
11 | }
12 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Engineering/ConvertBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 8 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 9 | use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
10 | 
11 | abstract class ConvertBase
12 | {
13 |     use ArrayEnabled;
14 | 
15 |     protected static function validateValue(mixed $value): string
16 |     {
17 |         if (is_bool($value)) {
18 |             if (Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_OPENOFFICE) {
19 |                 throw new Exception(ExcelError::VALUE());
20 |             }
21 |             $value = (int) $value;
22 |         }
23 | 
24 |         if (is_numeric($value)) {
25 |             if (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC) {
26 |                 $value = floor((float) $value);
27 |             }
28 |         }
29 | 
30 |         return strtoupper(StringHelper::convertToString($value));
31 |     }
32 | 
33 |     protected static function validatePlaces(mixed $places = null): ?int
34 |     {
35 |         if ($places === null) {
36 |             return $places;
37 |         }
38 | 
39 |         if (is_numeric($places)) {
40 |             if ($places < 0 || $places > 10) {
41 |                 throw new Exception(ExcelError::NAN());
42 |             }
43 | 
44 |             return (int) $places;
45 |         }
46 | 
47 |         throw new Exception(ExcelError::VALUE());
48 |     }
49 | 
50 |     /**
51 |      * Formats a number base string value with leading zeroes.
52 |      *
53 |      * @param string $value The "number" to pad
54 |      * @param ?int $places The length that we want to pad this value
55 |      *
56 |      * @return string The padded "number"
57 |      */
58 |     protected static function nbrConversionFormat(string $value, ?int $places): string
59 |     {
60 |         if ($places !== null) {
61 |             if (strlen($value) <= $places) {
62 |                 return substr(str_pad($value, $places, '0', STR_PAD_LEFT), -10);
63 |             }
64 | 
65 |             return ExcelError::NAN();
66 |         }
67 | 
68 |         return substr($value, -10);
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Engineering/EngineeringValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Engineering;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | 
 8 | class EngineeringValidations
 9 | {
10 |     public static function validateFloat(mixed $value): float
11 |     {
12 |         if (!is_numeric($value)) {
13 |             throw new Exception(ExcelError::VALUE());
14 |         }
15 | 
16 |         return (float) $value;
17 |     }
18 | 
19 |     public static function validateInt(mixed $value): int
20 |     {
21 |         if (!is_numeric($value)) {
22 |             throw new Exception(ExcelError::VALUE());
23 |         }
24 | 
25 |         return (int) floor((float) $value);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
 6 | 
 7 | class Exception extends PhpSpreadsheetException
 8 | {
 9 |     public const CALCULATION_ENGINE_PUSH_TO_STACK = 1;
10 | 
11 |     /**
12 |      * Error handler callback.
13 |      */
14 |     public static function errorHandlerCallback(int $code, string $string, string $file, int $line): void
15 |     {
16 |         $e = new self($string, $code);
17 |         $e->line = $line;
18 |         $e->file = $file;
19 | 
20 |         throw $e;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/ExceptionHandler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation;
 4 | 
 5 | class ExceptionHandler
 6 | {
 7 |     /**
 8 |      * Register errorhandler.
 9 |      */
10 |     public function __construct()
11 |     {
12 |         /** @var callable $callable */
13 |         $callable = [Exception::class, 'errorHandlerCallback'];
14 |         set_error_handler($callable, E_ALL);
15 |     }
16 | 
17 |     /**
18 |      * Unregister errorhandler.
19 |      */
20 |     public function __destruct()
21 |     {
22 |         restore_error_handler();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Financial/CashFlow/CashFlowValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Financial\FinancialValidations;
 8 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 9 | 
10 | class CashFlowValidations extends FinancialValidations
11 | {
12 |     public static function validateRate(mixed $rate): float
13 |     {
14 |         $rate = self::validateFloat($rate);
15 | 
16 |         return $rate;
17 |     }
18 | 
19 |     public static function validatePeriodType(mixed $type): int
20 |     {
21 |         $rate = self::validateInt($type);
22 |         if (
23 |             $type !== FinancialConstants::PAYMENT_END_OF_PERIOD
24 |             && $type !== FinancialConstants::PAYMENT_BEGINNING_OF_PERIOD
25 |         ) {
26 |             throw new Exception(ExcelError::NAN());
27 |         }
28 | 
29 |         return $rate;
30 |     }
31 | 
32 |     public static function validatePresentValue(mixed $presentValue): float
33 |     {
34 |         return self::validateFloat($presentValue);
35 |     }
36 | 
37 |     public static function validateFutureValue(mixed $futureValue): float
38 |     {
39 |         return self::validateFloat($futureValue);
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Financial/CashFlow/Constant/Periodic/InterestAndPrincipal.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\CashFlow\Constant\Periodic;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
 6 | 
 7 | class InterestAndPrincipal
 8 | {
 9 |     protected float $interest;
10 | 
11 |     protected float $principal;
12 | 
13 |     public function __construct(
14 |         float $rate = 0.0,
15 |         int $period = 0,
16 |         int $numberOfPeriods = 0,
17 |         float $presentValue = 0,
18 |         float $futureValue = 0,
19 |         int $type = FinancialConstants::PAYMENT_END_OF_PERIOD
20 |     ) {
21 |         $payment = Payments::annuity($rate, $numberOfPeriods, $presentValue, $futureValue, $type);
22 |         $capital = $presentValue;
23 |         $interest = 0.0;
24 |         $principal = 0.0;
25 |         for ($i = 1; $i <= $period; ++$i) {
26 |             $interest = ($type === FinancialConstants::PAYMENT_BEGINNING_OF_PERIOD && $i == 1) ? 0 : -$capital * $rate;
27 |             $principal = (float) $payment - $interest;
28 |             $capital += $principal;
29 |         }
30 | 
31 |         $this->interest = $interest;
32 |         $this->principal = $principal;
33 |     }
34 | 
35 |     public function interest(): float
36 |     {
37 |         return $this->interest;
38 |     }
39 | 
40 |     public function principal(): float
41 |     {
42 |         return $this->principal;
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Financial/Constants.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
 4 | 
 5 | class Constants
 6 | {
 7 |     public const BASIS_DAYS_PER_YEAR_NASD = 0;
 8 |     public const BASIS_DAYS_PER_YEAR_ACTUAL = 1;
 9 |     public const BASIS_DAYS_PER_YEAR_360 = 2;
10 |     public const BASIS_DAYS_PER_YEAR_365 = 3;
11 |     public const BASIS_DAYS_PER_YEAR_360_EUROPEAN = 4;
12 | 
13 |     public const FREQUENCY_ANNUAL = 1;
14 |     public const FREQUENCY_SEMI_ANNUAL = 2;
15 |     public const FREQUENCY_QUARTERLY = 4;
16 | 
17 |     public const PAYMENT_END_OF_PERIOD = 0;
18 |     public const PAYMENT_BEGINNING_OF_PERIOD = 1;
19 | }
20 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Financial/Helpers.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Financial;
 4 | 
 5 | use DateTimeInterface;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\DateTimeExcel;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Financial\Constants as FinancialConstants;
 8 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 9 | 
10 | class Helpers
11 | {
12 |     /**
13 |      * daysPerYear.
14 |      *
15 |      * Returns the number of days in a specified year, as defined by the "basis" value
16 |      *
17 |      * @param mixed $year The year against which we're testing, expect int|string
18 |      * @param int|string $basis The type of day count:
19 |      *                              0 or omitted US (NASD)   360
20 |      *                              1                        Actual (365 or 366 in a leap year)
21 |      *                              2                        360
22 |      *                              3                        365
23 |      *                              4                        European 360
24 |      *
25 |      * @return int|string Result, or a string containing an error
26 |      */
27 |     public static function daysPerYear(mixed $year, $basis = 0): string|int
28 |     {
29 |         if (!is_int($year) && !is_string($year)) {
30 |             return ExcelError::VALUE();
31 |         }
32 |         if (!is_numeric($basis)) {
33 |             return ExcelError::NAN();
34 |         }
35 | 
36 |         switch ($basis) {
37 |             case FinancialConstants::BASIS_DAYS_PER_YEAR_NASD:
38 |             case FinancialConstants::BASIS_DAYS_PER_YEAR_360:
39 |             case FinancialConstants::BASIS_DAYS_PER_YEAR_360_EUROPEAN:
40 |                 return 360;
41 |             case FinancialConstants::BASIS_DAYS_PER_YEAR_365:
42 |                 return 365;
43 |             case FinancialConstants::BASIS_DAYS_PER_YEAR_ACTUAL:
44 |                 return (DateTimeExcel\Helpers::isLeapYear($year)) ? 366 : 365;
45 |         }
46 | 
47 |         return ExcelError::NAN();
48 |     }
49 | 
50 |     /**
51 |      * isLastDayOfMonth.
52 |      *
53 |      * Returns a boolean TRUE/FALSE indicating if this date is the last date of the month
54 |      *
55 |      * @param DateTimeInterface $date The date for testing
56 |      */
57 |     public static function isLastDayOfMonth(DateTimeInterface $date): bool
58 |     {
59 |         return $date->format('d') === $date->format('t');
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Financial/Securities/SecurityValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Financial\Securities;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Financial\FinancialValidations;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class SecurityValidations extends FinancialValidations
10 | {
11 |     public static function validateIssueDate(mixed $issue): float
12 |     {
13 |         return self::validateDate($issue);
14 |     }
15 | 
16 |     public static function validateSecurityPeriod(mixed $settlement, mixed $maturity): void
17 |     {
18 |         if ($settlement >= $maturity) {
19 |             throw new Exception(ExcelError::NAN());
20 |         }
21 |     }
22 | 
23 |     public static function validateRedemption(mixed $redemption): float
24 |     {
25 |         $redemption = self::validateFloat($redemption);
26 |         if ($redemption <= 0.0) {
27 |             throw new Exception(ExcelError::NAN());
28 |         }
29 | 
30 |         return $redemption;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Internal/MakeMatrix.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Internal;
 4 | 
 5 | class MakeMatrix
 6 | {
 7 |     /**
 8 |      * @param mixed[] $args
 9 |      *
10 |      * @return mixed[]
11 |      */
12 |     public static function make(...$args): array
13 |     {
14 |         return $args;
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Internal/WildcardMatch.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Internal;
 4 | 
 5 | class WildcardMatch
 6 | {
 7 |     private const SEARCH_SET = [
 8 |         '~~', // convert double tilde to unprintable value
 9 |         '~\*', // convert tilde backslash asterisk to [*] (matches literal asterisk in regexp)
10 |         '\*', // convert backslash asterisk to .* (matches string of any length in regexp)
11 |         '~\?', // convert tilde backslash question to [?] (matches literal question mark in regexp)
12 |         '\?', // convert backslash question to . (matches one character in regexp)
13 |         "\x1c", // convert original double tilde to single tilde
14 |     ];
15 | 
16 |     private const REPLACEMENT_SET = [
17 |         "\x1c",
18 |         '[*]',
19 |         '.*',
20 |         '[?]',
21 |         '.',
22 |         '~',
23 |     ];
24 | 
25 |     public static function wildcard(string $wildcard): string
26 |     {
27 |         // Preg Escape the wildcard, but protecting the Excel * and ? search characters
28 |         return str_replace(self::SEARCH_SET, self::REPLACEMENT_SET, preg_quote($wildcard, '/'));
29 |     }
30 | 
31 |     public static function compare(?string $value, string $wildcard): bool
32 |     {
33 |         if ($value === '' || $value === null) {
34 |             return false;
35 |         }
36 | 
37 |         return (bool) preg_match("/^{$wildcard}\$/mui", $value);
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Logical/Boolean.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Logical;
 4 | 
 5 | class Boolean
 6 | {
 7 |     /**
 8 |      * TRUE.
 9 |      *
10 |      * Returns the boolean TRUE.
11 |      *
12 |      * Excel Function:
13 |      *        =TRUE()
14 |      *
15 |      * @return bool True
16 |      */
17 |     public static function true(): bool
18 |     {
19 |         return true;
20 |     }
21 | 
22 |     /**
23 |      * FALSE.
24 |      *
25 |      * Returns the boolean FALSE.
26 |      *
27 |      * Excel Function:
28 |      *        =FALSE()
29 |      *
30 |      * @return bool False
31 |      */
32 |     public static function false(): bool
33 |     {
34 |         return false;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/Formula.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | use PhpOffice\PhpSpreadsheet\Cell\Cell;
 8 | use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
 9 | 
10 | class Formula
11 | {
12 |     /**
13 |      * FORMULATEXT.
14 |      *
15 |      * @param mixed $cellReference The cell to check
16 |      * @param ?Cell $cell The current cell (containing this formula)
17 |      */
18 |     public static function text(mixed $cellReference = '', ?Cell $cell = null): string
19 |     {
20 |         if ($cell === null) {
21 |             return ExcelError::REF();
22 |         }
23 | 
24 |         $worksheet = null;
25 |         $cellReference = StringHelper::convertToString($cellReference);
26 |         if (1 === preg_match('/^' . Calculation::CALCULATION_REGEXP_CELLREF . '$/i', $cellReference, $matches)) {
27 |             $cellReference = $matches[6] . $matches[7];
28 |             $worksheetName = trim($matches[3], "'");
29 |             $worksheet = (!empty($worksheetName))
30 |                 ? $cell->getWorksheet()->getParentOrThrow()->getSheetByName($worksheetName)
31 |                 : $cell->getWorksheet();
32 |         }
33 | 
34 |         if (
35 |             $worksheet === null
36 |             || !$worksheet->cellExists($cellReference)
37 |             || !$worksheet->getCell($cellReference)->isFormula()
38 |         ) {
39 |             return ExcelError::NA();
40 |         }
41 | 
42 |         return $worksheet->getCell($cellReference)->getValueString();
43 |     }
44 | }
45 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/Hstack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | 
 8 | class Hstack
 9 | {
10 |     /**
11 |      * Excel function HSTACK.
12 |      *
13 |      * @return mixed[]|string
14 |      */
15 |     public static function hstack(mixed ...$inputData): array|string
16 |     {
17 |         $maxRow = 0;
18 |         foreach ($inputData as $matrix) {
19 |             if (!is_array($matrix)) {
20 |                 $count = 1;
21 |             } else {
22 |                 $count = count($matrix);
23 |             }
24 |             $maxRow = max($maxRow, $count);
25 |         }
26 |         /** @var mixed[] $inputData */
27 |         foreach ($inputData as &$matrix) {
28 |             if (!is_array($matrix)) {
29 |                 $matrix = [$matrix];
30 |             }
31 |             $rows = count($matrix);
32 |             $reset = reset($matrix);
33 |             $columns = is_array($reset) ? count($reset) : 1;
34 |             while ($maxRow > $rows) {
35 |                 $matrix[] = array_pad([], $columns, ExcelError::NA());
36 |                 ++$rows;
37 |             }
38 |         }
39 | 
40 |         $transpose = array_map(null, ...$inputData); //* @phpstan-ignore-line
41 |         $returnMatrix = [];
42 |         foreach ($transpose as $array) {
43 |             $returnMatrix[] = Functions::flattenArray($array);
44 |         }
45 | 
46 |         return $returnMatrix;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/Hyperlink.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | use PhpOffice\PhpSpreadsheet\Cell\Cell;
 8 | use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
 9 | 
10 | class Hyperlink
11 | {
12 |     /**
13 |      * HYPERLINK.
14 |      *
15 |      * Excel Function:
16 |      *        =HYPERLINK(linkURL, [displayName])
17 |      *
18 |      * @param mixed $linkURL Expect string. Value to check, is also the value returned when no error
19 |      * @param mixed $displayName Expect string. Value to return when testValue is an error condition
20 |      * @param ?Cell $cell The cell to set the hyperlink in
21 |      *
22 |      * @return string The value of $displayName (or $linkURL if $displayName was blank)
23 |      */
24 |     public static function set(mixed $linkURL = '', mixed $displayName = null, ?Cell $cell = null): string
25 |     {
26 |         $linkURL = ($linkURL === null) ? '' : StringHelper::convertToString(Functions::flattenSingleValue($linkURL));
27 |         $displayName = ($displayName === null) ? '' : Functions::flattenSingleValue($displayName);
28 | 
29 |         if ((!is_object($cell)) || (trim($linkURL) == '')) {
30 |             return ExcelError::REF();
31 |         }
32 | 
33 |         if (is_object($displayName)) {
34 |             $displayName = $linkURL;
35 |         }
36 |         $displayName = StringHelper::convertToString($displayName);
37 |         if (trim($displayName) === '') {
38 |             $displayName = $linkURL;
39 |         }
40 | 
41 |         $cell->getHyperlink()
42 |             ->setUrl($linkURL);
43 |         $cell->getHyperlink()->setTooltip($displayName);
44 | 
45 |         return $displayName;
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/LookupRefValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ErrorValue;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class LookupRefValidations
10 | {
11 |     public static function validateInt(mixed $value): int
12 |     {
13 |         if (!is_numeric($value)) {
14 |             if (is_string($value) && ErrorValue::isError($value)) {
15 |                 throw new Exception($value);
16 |             }
17 | 
18 |             throw new Exception(ExcelError::VALUE());
19 |         }
20 | 
21 |         return (int) floor((float) $value);
22 |     }
23 | 
24 |     public static function validatePositiveInt(mixed $value, bool $allowZero = true): int
25 |     {
26 |         $value = self::validateInt($value);
27 | 
28 |         if (($allowZero === false && $value <= 0) || $value < 0) {
29 |             throw new Exception(ExcelError::VALUE());
30 |         }
31 | 
32 |         return $value;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/Selection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class Selection
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * CHOOSE.
15 |      *
16 |      * Uses lookup_value to return a value from the list of value arguments.
17 |      * Use CHOOSE to select one of up to 254 values based on the lookup_value.
18 |      *
19 |      * Excel Function:
20 |      *        =CHOOSE(index_num, value1, [value2], ...)
21 |      *
22 |      * @param mixed $chosenEntry The entry to select from the list (indexed from 1)
23 |      * @param mixed ...$chooseArgs Data values
24 |      *
25 |      * @return mixed The selected value
26 |      */
27 |     public static function choose(mixed $chosenEntry, mixed ...$chooseArgs): mixed
28 |     {
29 |         if (is_array($chosenEntry)) {
30 |             return self::evaluateArrayArgumentsSubset([self::class, __FUNCTION__], 1, $chosenEntry, ...$chooseArgs);
31 |         }
32 | 
33 |         $entryCount = count($chooseArgs) - 1;
34 | 
35 |         if (is_numeric($chosenEntry)) {
36 |             --$chosenEntry;
37 |         } else {
38 |             return ExcelError::VALUE();
39 |         }
40 |         $chosenEntry = floor($chosenEntry);
41 |         if (($chosenEntry < 0) || ($chosenEntry > $entryCount)) {
42 |             return ExcelError::VALUE();
43 |         }
44 | 
45 |         if (is_array($chooseArgs[$chosenEntry])) {
46 |             return Functions::flattenArray($chooseArgs[$chosenEntry]);
47 |         }
48 | 
49 |         return $chooseArgs[$chosenEntry];
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/LookupRef/Vstack.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\LookupRef;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | 
 7 | class Vstack
 8 | {
 9 |     /**
10 |      * Excel function VSTACK.
11 |      *
12 |      * @return mixed[]
13 |      */
14 |     public static function vstack(mixed ...$inputData): array|string
15 |     {
16 |         $returnMatrix = [];
17 | 
18 |         $columns = 0;
19 |         foreach ($inputData as $matrix) {
20 |             if (!is_array($matrix)) {
21 |                 $count = 1;
22 |             } else {
23 |                 $count = count(reset($matrix)); //* @phpstan-ignore-line
24 |             }
25 |             $columns = max($columns, $count);
26 |         }
27 | 
28 |         foreach ($inputData as $matrix) {
29 |             if (!is_array($matrix)) {
30 |                 $matrix = [$matrix];
31 |             }
32 |             foreach ($matrix as $row) {
33 |                 if (!is_array($row)) {
34 |                     $row = [$row];
35 |                 }
36 |                 $returnMatrix[] = array_values(array_pad($row, $columns, ExcelError::NA()));
37 |             }
38 |         }
39 | 
40 |         return $returnMatrix;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Absolute.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class Absolute
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * ABS.
14 |      *
15 |      * Returns the result of builtin function abs after validating args.
16 |      *
17 |      * @param mixed $number Should be numeric, or can be an array of numbers
18 |      *
19 |      * @return array<mixed>|float|int|string rounded number
20 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
21 |      *            with the same dimensions
22 |      */
23 |     public static function evaluate(mixed $number): array|string|int|float
24 |     {
25 |         if (is_array($number)) {
26 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
27 |         }
28 | 
29 |         try {
30 |             $number = Helpers::validateNumericNullBool($number);
31 |         } catch (Exception $e) {
32 |             return $e->getMessage();
33 |         }
34 | 
35 |         return abs($number);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Angle.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class Angle
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * DEGREES.
14 |      *
15 |      * Returns the result of builtin function rad2deg after validating args.
16 |      *
17 |      * @param mixed $number Should be numeric, or can be an array of numbers
18 |      *
19 |      * @return array<mixed>|float|string Rounded number
20 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
21 |      *            with the same dimensions
22 |      */
23 |     public static function toDegrees(mixed $number): array|string|float
24 |     {
25 |         if (is_array($number)) {
26 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
27 |         }
28 | 
29 |         try {
30 |             $number = Helpers::validateNumericNullBool($number);
31 |         } catch (Exception $e) {
32 |             return $e->getMessage();
33 |         }
34 | 
35 |         return rad2deg($number);
36 |     }
37 | 
38 |     /**
39 |      * RADIANS.
40 |      *
41 |      * Returns the result of builtin function deg2rad after validating args.
42 |      *
43 |      * @param mixed $number Should be numeric, or can be an array of numbers
44 |      *
45 |      * @return array<mixed>|float|string Rounded number
46 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
47 |      *            with the same dimensions
48 |      */
49 |     public static function toRadians(mixed $number): array|string|float
50 |     {
51 |         if (is_array($number)) {
52 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
53 |         }
54 | 
55 |         try {
56 |             $number = Helpers::validateNumericNullBool($number);
57 |         } catch (Exception $e) {
58 |             return $e->getMessage();
59 |         }
60 | 
61 |         return deg2rad($number);
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Exp.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class Exp
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * EXP.
14 |      *
15 |      * Returns the result of builtin function exp after validating args.
16 |      *
17 |      * @param mixed $number Should be numeric, or can be an array of numbers
18 |      *
19 |      * @return array<mixed>|float|string Rounded number
20 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
21 |      *            with the same dimensions
22 |      */
23 |     public static function evaluate(mixed $number): array|string|float
24 |     {
25 |         if (is_array($number)) {
26 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
27 |         }
28 | 
29 |         try {
30 |             $number = Helpers::validateNumericNullBool($number);
31 |         } catch (Exception $e) {
32 |             return $e->getMessage();
33 |         }
34 | 
35 |         return exp($number);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Gcd.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class Gcd
10 | {
11 |     /**
12 |      * Recursively determine GCD.
13 |      *
14 |      * Returns the greatest common divisor of a series of numbers.
15 |      * The greatest common divisor is the largest integer that divides both
16 |      *        number1 and number2 without a remainder.
17 |      *
18 |      * Excel Function:
19 |      *        GCD(number1[,number2[, ...]])
20 |      */
21 |     private static function evaluateGCD(float|int $a, float|int $b): float|int
22 |     {
23 |         return $b ? self::evaluateGCD($b, $a % $b) : $a;
24 |     }
25 | 
26 |     /**
27 |      * GCD.
28 |      *
29 |      * Returns the greatest common divisor of a series of numbers.
30 |      * The greatest common divisor is the largest integer that divides both
31 |      *        number1 and number2 without a remainder.
32 |      *
33 |      * Excel Function:
34 |      *        GCD(number1[,number2[, ...]])
35 |      *
36 |      * @param mixed ...$args Data values
37 |      *
38 |      * @return float|int|string Greatest Common Divisor, or a string containing an error
39 |      */
40 |     public static function evaluate(mixed ...$args)
41 |     {
42 |         try {
43 |             $arrayArgs = [];
44 |             foreach (Functions::flattenArray($args) as $value1) {
45 |                 if ($value1 !== null) {
46 |                     $value = Helpers::validateNumericNullSubstitution($value1, 1);
47 |                     Helpers::validateNotNegative($value);
48 |                     $arrayArgs[] = (int) $value;
49 |                 }
50 |             }
51 |         } catch (Exception $e) {
52 |             return $e->getMessage();
53 |         }
54 | 
55 |         if (count($arrayArgs) <= 0) {
56 |             return ExcelError::VALUE();
57 |         }
58 |         $gcd = (int) array_pop($arrayArgs);
59 |         do {
60 |             $gcd = self::evaluateGCD($gcd, (int) array_pop($arrayArgs));
61 |         } while (!empty($arrayArgs));
62 | 
63 |         return $gcd;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/IntClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class IntClass
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * INT.
14 |      *
15 |      * Casts a floating point value to an integer
16 |      *
17 |      * Excel Function:
18 |      *        INT(number)
19 |      *
20 |      * @param array<mixed>|float $number Number to cast to an integer, or can be an array of numbers
21 |      *
22 |      * @return array<mixed>|int|string Integer value, or a string containing an error
23 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
24 |      *            with the same dimensions
25 |      */
26 |     public static function evaluate($number): array|string|int
27 |     {
28 |         if (is_array($number)) {
29 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
30 |         }
31 | 
32 |         try {
33 |             $number = Helpers::validateNumericNullBool($number);
34 |         } catch (Exception $e) {
35 |             return $e->getMessage();
36 |         }
37 | 
38 |         return (int) floor($number);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/SeriesSum.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 8 | 
 9 | class SeriesSum
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * SERIESSUM.
15 |      *
16 |      * Returns the sum of a power series
17 |      *
18 |      * @param mixed $x Input value
19 |      * @param mixed $n Initial power
20 |      * @param mixed $m Step
21 |      * @param mixed[] $args An array of coefficients for the Data Series
22 |      *
23 |      * @return array<mixed>|float|int|string The result, or a string containing an error
24 |      */
25 |     public static function evaluate(mixed $x, mixed $n, mixed $m, ...$args): array|string|float|int
26 |     {
27 |         if (is_array($x) || is_array($n) || is_array($m)) {
28 |             return self::evaluateArrayArgumentsSubset([self::class, __FUNCTION__], 3, $x, $n, $m, ...$args);
29 |         }
30 | 
31 |         try {
32 |             $x = Helpers::validateNumericNullSubstitution($x, 0);
33 |             $n = Helpers::validateNumericNullSubstitution($n, 0);
34 |             $m = Helpers::validateNumericNullSubstitution($m, 0);
35 | 
36 |             // Loop through arguments
37 |             $aArgs = Functions::flattenArray($args);
38 |             $returnValue = 0;
39 |             $i = 0;
40 |             foreach ($aArgs as $argx) {
41 |                 if ($argx !== null) {
42 |                     $arg = Helpers::validateNumericNullSubstitution($argx, 0);
43 |                     $returnValue += $arg * $x ** ($n + ($m * $i));
44 |                     ++$i;
45 |                 }
46 |             }
47 |         } catch (Exception $e) {
48 |             return $e->getMessage();
49 |         }
50 | 
51 |         return $returnValue;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Sign.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class Sign
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * SIGN.
14 |      *
15 |      * Determines the sign of a number. Returns 1 if the number is positive, zero (0)
16 |      *        if the number is 0, and -1 if the number is negative.
17 |      *
18 |      * @param array<mixed>|float $number Number to round, or can be an array of numbers
19 |      *
20 |      * @return array<mixed>|int|string sign value, or a string containing an error
21 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
22 |      *            with the same dimensions
23 |      */
24 |     public static function evaluate($number): array|string|int
25 |     {
26 |         if (is_array($number)) {
27 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
28 |         }
29 | 
30 |         try {
31 |             $number = Helpers::validateNumericNullBool($number);
32 |         } catch (Exception $e) {
33 |             return $e->getMessage();
34 |         }
35 | 
36 |         return Helpers::returnSign($number);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Sqrt.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | 
 8 | class Sqrt
 9 | {
10 |     use ArrayEnabled;
11 | 
12 |     /**
13 |      * SQRT.
14 |      *
15 |      * Returns the result of builtin function sqrt after validating args.
16 |      *
17 |      * @param mixed $number Should be numeric, or can be an array of numbers
18 |      *
19 |      * @return array<mixed>|float|string square root
20 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
21 |      *            with the same dimensions
22 |      */
23 |     public static function sqrt(mixed $number)
24 |     {
25 |         if (is_array($number)) {
26 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
27 |         }
28 | 
29 |         try {
30 |             $number = Helpers::validateNumericNullBool($number);
31 |         } catch (Exception $e) {
32 |             return $e->getMessage();
33 |         }
34 | 
35 |         return Helpers::numberOrNan(sqrt($number));
36 |     }
37 | 
38 |     /**
39 |      * SQRTPI.
40 |      *
41 |      * Returns the square root of (number * pi).
42 |      *
43 |      * @param array<mixed>|float $number Number, or can be an array of numbers
44 |      *
45 |      * @return array<mixed>|float|string Square Root of Number * Pi, or a string containing an error
46 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
47 |      *            with the same dimensions
48 |      */
49 |     public static function pi($number): array|string|float
50 |     {
51 |         if (is_array($number)) {
52 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $number);
53 |         }
54 | 
55 |         try {
56 |             $number = Helpers::validateNumericNullSubstitution($number, 0);
57 |             Helpers::validateNotNegative($number);
58 |         } catch (Exception $e) {
59 |             return $e->getMessage();
60 |         }
61 | 
62 |         return sqrt($number * M_PI);
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Trig/Cosecant.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig\Trig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\MathTrig\Helpers;
 8 | 
 9 | class Cosecant
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * CSC.
15 |      *
16 |      * Returns the cosecant of an angle.
17 |      *
18 |      * @param array<mixed>|float $angle Number, or can be an array of numbers
19 |      *
20 |      * @return array<mixed>|float|string The cosecant of the angle
21 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
22 |      *            with the same dimensions
23 |      */
24 |     public static function csc($angle)
25 |     {
26 |         if (is_array($angle)) {
27 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $angle);
28 |         }
29 | 
30 |         try {
31 |             $angle = Helpers::validateNumericNullBool($angle);
32 |         } catch (Exception $e) {
33 |             return $e->getMessage();
34 |         }
35 | 
36 |         return Helpers::verySmallDenominator(1.0, sin($angle));
37 |     }
38 | 
39 |     /**
40 |      * CSCH.
41 |      *
42 |      * Returns the hyperbolic cosecant of an angle.
43 |      *
44 |      * @param array<mixed>|float $angle Number, or can be an array of numbers
45 |      *
46 |      * @return array<mixed>|float|string The hyperbolic cosecant of the angle
47 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
48 |      *            with the same dimensions
49 |      */
50 |     public static function csch($angle)
51 |     {
52 |         if (is_array($angle)) {
53 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $angle);
54 |         }
55 | 
56 |         try {
57 |             $angle = Helpers::validateNumericNullBool($angle);
58 |         } catch (Exception $e) {
59 |             return $e->getMessage();
60 |         }
61 | 
62 |         return Helpers::verySmallDenominator(1.0, sinh($angle));
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Trig/Secant.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig\Trig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\MathTrig\Helpers;
 8 | 
 9 | class Secant
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * SEC.
15 |      *
16 |      * Returns the secant of an angle.
17 |      *
18 |      * @param array<mixed>|float $angle Number, or can be an array of numbers
19 |      *
20 |      * @return array<mixed>|float|string The secant of the angle
21 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
22 |      *            with the same dimensions
23 |      */
24 |     public static function sec($angle)
25 |     {
26 |         if (is_array($angle)) {
27 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $angle);
28 |         }
29 | 
30 |         try {
31 |             $angle = Helpers::validateNumericNullBool($angle);
32 |         } catch (Exception $e) {
33 |             return $e->getMessage();
34 |         }
35 | 
36 |         return Helpers::verySmallDenominator(1.0, cos($angle));
37 |     }
38 | 
39 |     /**
40 |      * SECH.
41 |      *
42 |      * Returns the hyperbolic secant of an angle.
43 |      *
44 |      * @param array<mixed>|float $angle Number, or can be an array of numbers
45 |      *
46 |      * @return array<mixed>|float|string The hyperbolic secant of the angle
47 |      *         If an array of numbers is passed as the argument, then the returned result will also be an array
48 |      *            with the same dimensions
49 |      */
50 |     public static function sech($angle)
51 |     {
52 |         if (is_array($angle)) {
53 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $angle);
54 |         }
55 | 
56 |         try {
57 |             $angle = Helpers::validateNumericNullBool($angle);
58 |         } catch (Exception $e) {
59 |             return $e->getMessage();
60 |         }
61 | 
62 |         return Helpers::verySmallDenominator(1.0, cosh($angle));
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/MathTrig/Trunc.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\MathTrig;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | 
 7 | class Trunc
 8 | {
 9 |     use ArrayEnabled;
10 | 
11 |     /**
12 |      * TRUNC.
13 |      *
14 |      * Truncates value to the number of fractional digits by number_digits.
15 |      * This will probably not be the precise result in the unlikely
16 |      * event that the number of digits to the left of the decimal
17 |      * plus the number of digits to the right exceeds PHP_FLOAT_DIG
18 |      * (or possibly that value minus 1).
19 |      * Excel is unlikely to do any better.
20 |      *
21 |      * @param null|array<mixed>|float|string $value Or can be an array of values
22 |      * @param array<mixed>|float|int|string $digits Or can be an array of values
23 |      *
24 |      * @return array<mixed>|float|string Truncated value, or a string containing an error
25 |      *         If an array of numbers is passed as an argument, then the returned result will also be an array
26 |      *            with the same dimensions
27 |      */
28 |     public static function evaluate(array|float|string|null $value = 0, array|float|int|string $digits = 0): array|float|string
29 |     {
30 |         if (is_array($value) || is_array($digits)) {
31 |             return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $digits);
32 |         }
33 | 
34 |         return Round::down($value, $digits);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/AggregateBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | 
 7 | abstract class AggregateBase
 8 | {
 9 |     /**
10 |      * MS Excel does not count Booleans if passed as cell values, but they are counted if passed as literals.
11 |      * OpenOffice Calc always counts Booleans.
12 |      * Gnumeric never counts Booleans.
13 |      */
14 |     protected static function testAcceptedBoolean(mixed $arg, mixed $k): mixed
15 |     {
16 |         if (!is_bool($arg)) {
17 |             return $arg;
18 |         }
19 |         if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_GNUMERIC) {
20 |             return $arg;
21 |         }
22 |         if (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
23 |             return (int) $arg;
24 |         }
25 |         if (!Functions::isCellValue($k)) {
26 |             return (int) $arg;
27 |         }
28 |         /*if (
29 |             (is_bool($arg)) &&
30 |             ((!Functions::isCellValue($k) && (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_EXCEL)) ||
31 |                 (Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE))
32 |         ) {
33 |             $arg = (int) $arg;
34 |         }*/
35 | 
36 |         return $arg;
37 |     }
38 | 
39 |     protected static function isAcceptedCountable(mixed $arg, mixed $k, bool $countNull = false): bool
40 |     {
41 |         if ($countNull && $arg === null && !Functions::isCellValue($k) && Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_GNUMERIC) {
42 |             return true;
43 |         }
44 |         if (!is_numeric($arg)) {
45 |             return false;
46 |         }
47 |         if (!is_string($arg)) {
48 |             return true;
49 |         }
50 |         if (!Functions::isCellValue($k) && Functions::getCompatibilityMode() === Functions::COMPATIBILITY_OPENOFFICE) {
51 |             return true;
52 |         }
53 |         if (!Functions::isCellValue($k) && Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_GNUMERIC) {
54 |             return true;
55 |         }
56 | 
57 |         return false;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/Confidence.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 8 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 9 | 
10 | class Confidence
11 | {
12 |     use ArrayEnabled;
13 | 
14 |     /**
15 |      * CONFIDENCE.
16 |      *
17 |      * Returns the confidence interval for a population mean
18 |      *
19 |      * @param mixed $alpha As a float
20 |      *                      Or can be an array of values
21 |      * @param mixed $stdDev Standard Deviation as a float
22 |      *                      Or can be an array of values
23 |      * @param mixed $size As an integer
24 |      *                      Or can be an array of values
25 |      *
26 |      * @return array<mixed>|float|string If an array of numbers is passed as an argument, then the returned result will also be an array
27 |      *            with the same dimensions
28 |      */
29 |     public static function CONFIDENCE(mixed $alpha, mixed $stdDev, mixed $size)
30 |     {
31 |         if (is_array($alpha) || is_array($stdDev) || is_array($size)) {
32 |             return self::evaluateArrayArguments([self::class, __FUNCTION__], $alpha, $stdDev, $size);
33 |         }
34 | 
35 |         try {
36 |             $alpha = StatisticalValidations::validateFloat($alpha);
37 |             $stdDev = StatisticalValidations::validateFloat($stdDev);
38 |             $size = StatisticalValidations::validateInt($size);
39 |         } catch (Exception $e) {
40 |             return $e->getMessage();
41 |         }
42 | 
43 |         if (($alpha <= 0) || ($alpha >= 1) || ($stdDev <= 0) || ($size < 1)) {
44 |             return ExcelError::NAN();
45 |         }
46 |         /** @var float $temp */
47 |         $temp = Distributions\StandardNormal::inverse(1 - $alpha / 2);
48 | 
49 |         /** @var float */
50 |         $result = Functions::scalar($temp * $stdDev / sqrt($size));
51 | 
52 |         return $result;
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/Distributions/DistributionValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Statistical\StatisticalValidations;
 8 | 
 9 | class DistributionValidations extends StatisticalValidations
10 | {
11 |     public static function validateProbability(mixed $probability): float
12 |     {
13 |         $probability = self::validateFloat($probability);
14 | 
15 |         if ($probability < 0.0 || $probability > 1.0) {
16 |             throw new Exception(ExcelError::NAN());
17 |         }
18 | 
19 |         return $probability;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/Distributions/Exponential.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class Exponential
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * EXPONDIST.
15 |      *
16 |      *    Returns the exponential distribution. Use EXPONDIST to model the time between events,
17 |      *        such as how long an automated bank teller takes to deliver cash. For example, you can
18 |      *        use EXPONDIST to determine the probability that the process takes at most 1 minute.
19 |      *
20 |      * @param mixed $value Float value for which we want the probability
21 |      *                      Or can be an array of values
22 |      * @param mixed $lambda The parameter value as a float
23 |      *                      Or can be an array of values
24 |      * @param mixed $cumulative Boolean value indicating if we want the cdf (true) or the pdf (false)
25 |      *                      Or can be an array of values
26 |      *
27 |      * @return array<mixed>|float|string If an array of numbers is passed as an argument, then the returned result will also be an array
28 |      *            with the same dimensions
29 |      */
30 |     public static function distribution(mixed $value, mixed $lambda, mixed $cumulative): array|string|float
31 |     {
32 |         if (is_array($value) || is_array($lambda) || is_array($cumulative)) {
33 |             return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $lambda, $cumulative);
34 |         }
35 | 
36 |         try {
37 |             $value = DistributionValidations::validateFloat($value);
38 |             $lambda = DistributionValidations::validateFloat($lambda);
39 |             $cumulative = DistributionValidations::validateBool($cumulative);
40 |         } catch (Exception $e) {
41 |             return $e->getMessage();
42 |         }
43 | 
44 |         if (($value < 0) || ($lambda < 0)) {
45 |             return ExcelError::NAN();
46 |         }
47 | 
48 |         if ($cumulative === true) {
49 |             return 1 - exp(0 - $value * $lambda);
50 |         }
51 | 
52 |         return $lambda * exp(0 - $value * $lambda);
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/Distributions/NewtonRaphson.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical\Distributions;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | 
 8 | class NewtonRaphson
 9 | {
10 |     private const MAX_ITERATIONS = 256;
11 | 
12 |     /** @var callable(float): mixed */
13 |     protected $callback;
14 | 
15 |     /** @param callable(float): mixed $callback */
16 |     public function __construct(callable $callback)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function execute(float $probability): string|int|float
22 |     {
23 |         $xLo = 100;
24 |         $xHi = 0;
25 | 
26 |         $dx = 1;
27 |         $x = $xNew = 1;
28 |         $i = 0;
29 | 
30 |         while ((abs($dx) > Functions::PRECISION) && ($i++ < self::MAX_ITERATIONS)) {
31 |             // Apply Newton-Raphson step
32 |             $result = call_user_func($this->callback, $x);
33 |             if (!is_float($result)) {
34 |                 return ExcelError::VALUE();
35 |             }
36 |             $error = $result - $probability;
37 | 
38 |             if ($error == 0.0) {
39 |                 $dx = 0;
40 |             } elseif ($error < 0.0) {
41 |                 $xLo = $x;
42 |             } else {
43 |                 $xHi = $x;
44 |             }
45 | 
46 |             // Avoid division by zero
47 |             if ($result != 0.0) {
48 |                 $dx = $error / $result;
49 |                 $xNew = $x - $dx;
50 |             }
51 | 
52 |             // If the NR fails to converge (which for example may be the
53 |             // case if the initial guess is too rough) we apply a bisection
54 |             // step to determine a more narrow interval around the root.
55 |             if (($xNew < $xLo) || ($xNew > $xHi) || ($result == 0.0)) {
56 |                 $xNew = ($xLo + $xHi) / 2;
57 |                 $dx = $xNew - $x;
58 |             }
59 |             $x = $xNew;
60 |         }
61 | 
62 |         if ($i == self::MAX_ITERATIONS) {
63 |             return ExcelError::NA();
64 |         }
65 | 
66 |         return $x;
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/MaxMinBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | abstract class MaxMinBase
 6 | {
 7 |     protected static function datatypeAdjustmentAllowStrings(int|float|string|bool $value): int|float
 8 |     {
 9 |         if (is_bool($value)) {
10 |             return (int) $value;
11 |         } elseif (is_string($value)) {
12 |             return 0;
13 |         }
14 | 
15 |         return $value;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/Standardize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 7 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 8 | 
 9 | class Standardize extends StatisticalValidations
10 | {
11 |     use ArrayEnabled;
12 | 
13 |     /**
14 |      * STANDARDIZE.
15 |      *
16 |      * Returns a normalized value from a distribution characterized by mean and standard_dev.
17 |      *
18 |      * @param array<mixed>|float $value Value to normalize
19 |      *                      Or can be an array of values
20 |      * @param array<mixed>|float $mean Mean Value
21 |      *                      Or can be an array of values
22 |      * @param array<mixed>|float $stdDev Standard Deviation
23 |      *                      Or can be an array of values
24 |      *
25 |      * @return array<mixed>|float|string Standardized value, or a string containing an error
26 |      *         If an array of numbers is passed as an argument, then the returned result will also be an array
27 |      *            with the same dimensions
28 |      */
29 |     public static function execute($value, $mean, $stdDev): array|string|float
30 |     {
31 |         if (is_array($value) || is_array($mean) || is_array($stdDev)) {
32 |             return self::evaluateArrayArguments([self::class, __FUNCTION__], $value, $mean, $stdDev);
33 |         }
34 | 
35 |         try {
36 |             $value = self::validateFloat($value);
37 |             $mean = self::validateFloat($mean);
38 |             $stdDev = self::validateFloat($stdDev);
39 |         } catch (Exception $e) {
40 |             return $e->getMessage();
41 |         }
42 | 
43 |         if ($stdDev <= 0) {
44 |             return ExcelError::NAN();
45 |         }
46 | 
47 |         return ($value - $mean) / $stdDev;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/StatisticalValidations.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Exception;
 6 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 7 | 
 8 | class StatisticalValidations
 9 | {
10 |     public static function validateFloat(mixed $value): float
11 |     {
12 |         if (!is_numeric($value)) {
13 |             throw new Exception(ExcelError::VALUE());
14 |         }
15 | 
16 |         return (float) $value;
17 |     }
18 | 
19 |     public static function validateInt(mixed $value): int
20 |     {
21 |         if (!is_numeric($value)) {
22 |             throw new Exception(ExcelError::VALUE());
23 |         }
24 | 
25 |         return (int) floor((float) $value);
26 |     }
27 | 
28 |     public static function validateBool(mixed $value): bool
29 |     {
30 |         if (!is_bool($value) && !is_numeric($value)) {
31 |             throw new Exception(ExcelError::VALUE());
32 |         }
33 | 
34 |         return (bool) $value;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Statistical/VarianceBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Statistical;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | 
 7 | abstract class VarianceBase
 8 | {
 9 |     protected static function datatypeAdjustmentAllowStrings(int|float|string|bool $value): int|float
10 |     {
11 |         if (is_bool($value)) {
12 |             return (int) $value;
13 |         } elseif (is_string($value)) {
14 |             return 0;
15 |         }
16 | 
17 |         return $value;
18 |     }
19 | 
20 |     protected static function datatypeAdjustmentBooleans(mixed $value): mixed
21 |     {
22 |         if (is_bool($value) && (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_OPENOFFICE)) {
23 |             return (int) $value;
24 |         }
25 | 
26 |         return $value;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/TextData/Trim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\TextData;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\ArrayEnabled;
 6 | 
 7 | class Trim
 8 | {
 9 |     use ArrayEnabled;
10 | 
11 |     /**
12 |      * CLEAN.
13 |      *
14 |      * @param mixed $stringValue String Value to check
15 |      *                              Or can be an array of values
16 |      *
17 |      * @return array<mixed>|string If an array of values is passed as the argument, then the returned result will also be an array
18 |      *            with the same dimensions
19 |      */
20 |     public static function nonPrintable(mixed $stringValue = '')
21 |     {
22 |         if (is_array($stringValue)) {
23 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $stringValue);
24 |         }
25 | 
26 |         $stringValue = Helpers::extractString($stringValue);
27 | 
28 |         return (string) preg_replace('/[\x00-\x1f]/', '', "$stringValue");
29 |     }
30 | 
31 |     /**
32 |      * TRIM.
33 |      *
34 |      * @param mixed $stringValue String Value to check
35 |      *                              Or can be an array of values
36 |      *
37 |      * @return array<mixed>|string If an array of values is passed as the argument, then the returned result will also be an array
38 |      *            with the same dimensions
39 |      */
40 |     public static function spaces(mixed $stringValue = ''): array|string
41 |     {
42 |         if (is_array($stringValue)) {
43 |             return self::evaluateSingleArgumentArray([self::class, __FUNCTION__], $stringValue);
44 |         }
45 | 
46 |         $stringValue = Helpers::extractString($stringValue);
47 | 
48 |         return trim(preg_replace('/ +/', ' ', trim("$stringValue", ' ')) ?? '', ' ');
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/Web/Service.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Calculation\Web;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;
 6 | use PhpOffice\PhpSpreadsheet\Settings;
 7 | use Psr\Http\Client\ClientExceptionInterface;
 8 | 
 9 | class Service
10 | {
11 |     /**
12 |      * WEBSERVICE.
13 |      *
14 |      * Returns data from a web service on the Internet or Intranet.
15 |      *
16 |      * Excel Function:
17 |      *        Webservice(url)
18 |      *
19 |      * @return string the output resulting from a call to the webservice
20 |      */
21 |     public static function webService(string $url): string
22 |     {
23 |         $url = trim($url);
24 |         if (strlen($url) > 2048) {
25 |             return ExcelError::VALUE(); // Invalid URL length
26 |         }
27 | 
28 |         if (!preg_match('/^http[s]?:\/\//', $url)) {
29 |             return ExcelError::VALUE(); // Invalid protocol
30 |         }
31 | 
32 |         // Get results from the webservice
33 |         $client = Settings::getHttpClient();
34 |         $requestFactory = Settings::getRequestFactory();
35 |         $request = $requestFactory->createRequest('GET', $url);
36 | 
37 |         try {
38 |             $response = $client->sendRequest($request);
39 |         } catch (ClientExceptionInterface) {
40 |             return ExcelError::VALUE(); // cURL error
41 |         }
42 | 
43 |         if ($response->getStatusCode() != 200) {
44 |             return ExcelError::VALUE(); // cURL error
45 |         }
46 | 
47 |         $output = $response->getBody()->getContents();
48 |         if (strlen($output) > 32767) {
49 |             return ExcelError::VALUE(); // Output not a string or too long
50 |         }
51 | 
52 |         return $output;
53 |     }
54 | 
55 |     /**
56 |      * URLENCODE.
57 |      *
58 |      * Returns data from a web service on the Internet or Intranet.
59 |      *
60 |      * Excel Function:
61 |      *        urlEncode(text)
62 |      *
63 |      * @return string the url encoded output
64 |      */
65 |     public static function urlEncode(mixed $text): string
66 |     {
67 |         if (!is_string($text)) {
68 |             return ExcelError::VALUE();
69 |         }
70 | 
71 |         return str_replace('+', '%20', urlencode($text));
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/Translations.xlsx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/PHPOffice/PhpSpreadsheet/44c3bd564b9913fac38bb1b565654d6bf7b5419a/src/PhpSpreadsheet/Calculation/locale/Translations.xlsx


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/bg/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## български (Bulgarian)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | ##
11 | ##  (For future use)
12 | ##
13 | currencySymbol = лв
14 | 
15 | ##
16 | ## Error Codes
17 | ##
18 | NULL = #ПРАЗНО!
19 | DIV0 = #ДЕЛ/0!
20 | VALUE = #СТОЙНОСТ!
21 | REF = #РЕФ!
22 | NAME = #ИМЕ?
23 | NUM = #ЧИСЛО!
24 | NA = #Н/Д
25 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/cs/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Ceština (Czech)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL
15 | DIV0 = #DĚLENÍ_NULOU!
16 | VALUE = #HODNOTA!
17 | REF = #ODKAZ!
18 | NAME = #NÁZEV?
19 | NUM = #ČÍSLO!
20 | NA = #NENÍ_K_DISPOZICI
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/da/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Dansk (Danish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #NUL!
15 | DIV0
16 | VALUE = #VÆRDI!
17 | REF = #REFERENCE!
18 | NAME = #NAVN?
19 | NUM
20 | NA = #I/T
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/de/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Deutsch (German)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL
15 | DIV0
16 | VALUE = #WERT!
17 | REF = #BEZUG!
18 | NAME
19 | NUM = #ZAHL!
20 | NA = #NV
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/en/uk/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## English-UK (English-UK)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ,
10 | ##
11 | ##  (For future use)
12 | ##
13 | currencySymbol = £
14 | 
15 | ##
16 | ## Error Codes
17 | ##
18 | NULL
19 | DIV0
20 | VALUE
21 | REF
22 | NAME
23 | NUM
24 | NA
25 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/es/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Español (Spanish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #¡NULO!
15 | DIV0 = #¡DIV/0!
16 | VALUE = #¡VALOR!
17 | REF = #¡REF!
18 | NAME = #¿NOMBRE?
19 | NUM = #¡NUM!
20 | NA
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/fi/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Suomi (Finnish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #TYHJÄ!
15 | DIV0 = #JAKO/0!
16 | VALUE = #ARVO!
17 | REF = #VIITTAUS!
18 | NAME = #NIMI?
19 | NUM = #LUKU!
20 | NA = #PUUTTUU!
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/fr/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Français (French)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #NUL!
15 | DIV0
16 | VALUE = #VALEUR!
17 | REF
18 | NAME = #NOM?
19 | NUM = #NOMBRE!
20 | NA
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/hu/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Magyar (Hungarian)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #NULLA!
15 | DIV0 = #ZÉRÓOSZTÓ!
16 | VALUE = #ÉRTÉK!
17 | REF = #HIV!
18 | NAME = #NÉV?
19 | NUM = #SZÁM!
20 | NA = #HIÁNYZIK
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/it/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Italiano (Italian)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL
15 | DIV0
16 | VALUE = #VALORE!
17 | REF = #RIF!
18 | NAME = #NOME?
19 | NUM
20 | NA = #N/D
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/nb/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Norsk Bokmål (Norwegian Bokmål)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL
15 | DIV0
16 | VALUE = #VERDI!
17 | REF
18 | NAME = #NAVN?
19 | NUM
20 | NA = #N/D
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/nl/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Nederlands (Dutch)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #LEEG!
15 | DIV0 = #DEEL/0!
16 | VALUE = #WAARDE!
17 | REF = #VERW!
18 | NAME = #NAAM?
19 | NUM = #GETAL!
20 | NA = #N/B
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/pl/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Jezyk polski (Polish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #ZERO!
15 | DIV0 = #DZIEL/0!
16 | VALUE = #ARG!
17 | REF = #ADR!
18 | NAME = #NAZWA?
19 | NUM = #LICZBA!
20 | NA = #N/D!
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/pt/br/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Português Brasileiro (Brazilian Portuguese)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #NULO!
15 | DIV0
16 | VALUE = #VALOR!
17 | REF
18 | NAME = #NOME?
19 | NUM = #NÚM!
20 | NA = #N/D
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/pt/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Português (Portuguese)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #NULO!
15 | DIV0
16 | VALUE = #VALOR!
17 | REF
18 | NAME = #NOME?
19 | NUM = #NÚM!
20 | NA = #N/D
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/ru/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## русский язык (Russian)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #ПУСТО!
15 | DIV0 = #ДЕЛ/0!
16 | VALUE = #ЗНАЧ!
17 | REF = #ССЫЛКА!
18 | NAME = #ИМЯ?
19 | NUM = #ЧИСЛО!
20 | NA = #Н/Д
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/sv/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Svenska (Swedish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #SKÄRNING!
15 | DIV0 = #DIVISION/0!
16 | VALUE = #VÄRDEFEL!
17 | REF = #REFERENS!
18 | NAME = #NAMN?
19 | NUM = #OGILTIGT!
20 | NA = #SAKNAS!
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Calculation/locale/tr/config:
--------------------------------------------------------------------------------
 1 | ############################################################
 2 | ##
 3 | ## PhpSpreadsheet - locale settings
 4 | ##
 5 | ## Türkçe (Turkish)
 6 | ##
 7 | ############################################################
 8 | 
 9 | ArgumentSeparator = ;
10 | 
11 | ##
12 | ## Error Codes
13 | ##
14 | NULL = #BOŞ!
15 | DIV0 = #SAYI/0!
16 | VALUE = #DEĞER!
17 | REF = #BAŞV!
18 | NAME = #AD?
19 | NUM = #SAYI!
20 | NA = #YOK
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Cell/AddressRange.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Cell;
 4 | 
 5 | /**
 6 |  * @template T
 7 |  */
 8 | interface AddressRange
 9 | {
10 |     public const MAX_ROW = 1048576;
11 | 
12 |     public const MAX_COLUMN = 'XFD';
13 | 
14 |     public const MAX_COLUMN_INT = 16384;
15 | 
16 |     /**
17 |      * @return T
18 |      */
19 |     public function from(): mixed;
20 | 
21 |     /**
22 |      * @return T
23 |      */
24 |     public function to(): mixed;
25 | 
26 |     public function __toString(): string;
27 | }
28 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Cell/Hyperlink.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Cell;
 4 | 
 5 | class Hyperlink
 6 | {
 7 |     /**
 8 |      * URL to link the cell to.
 9 |      */
10 |     private string $url;
11 | 
12 |     /**
13 |      * Tooltip to display on the hyperlink.
14 |      */
15 |     private string $tooltip;
16 | 
17 |     /**
18 |      * Create a new Hyperlink.
19 |      *
20 |      * @param string $url Url to link the cell to
21 |      * @param string $tooltip Tooltip to display on the hyperlink
22 |      */
23 |     public function __construct(string $url = '', string $tooltip = '')
24 |     {
25 |         // Initialise member variables
26 |         $this->url = $url;
27 |         $this->tooltip = $tooltip;
28 |     }
29 | 
30 |     /**
31 |      * Get URL.
32 |      */
33 |     public function getUrl(): string
34 |     {
35 |         return $this->url;
36 |     }
37 | 
38 |     /**
39 |      * Set URL.
40 |      *
41 |      * @return $this
42 |      */
43 |     public function setUrl(string $url): static
44 |     {
45 |         $this->url = $url;
46 | 
47 |         return $this;
48 |     }
49 | 
50 |     /**
51 |      * Get tooltip.
52 |      */
53 |     public function getTooltip(): string
54 |     {
55 |         return $this->tooltip;
56 |     }
57 | 
58 |     /**
59 |      * Set tooltip.
60 |      *
61 |      * @return $this
62 |      */
63 |     public function setTooltip(string $tooltip): static
64 |     {
65 |         $this->tooltip = $tooltip;
66 | 
67 |         return $this;
68 |     }
69 | 
70 |     /**
71 |      * Is this hyperlink internal? (to another worksheet or a cell in this worksheet).
72 |      */
73 |     public function isInternal(): bool
74 |     {
75 |         return str_starts_with($this->url, 'sheet://') || str_starts_with($this->url, '#');
76 |     }
77 | 
78 |     public function getTypeHyperlink(): string
79 |     {
80 |         return $this->isInternal() ? '' : 'External';
81 |     }
82 | 
83 |     /**
84 |      * Get hash code.
85 |      *
86 |      * @return string Hash code
87 |      */
88 |     public function getHashCode(): string
89 |     {
90 |         return md5(
91 |             $this->url
92 |             . $this->tooltip
93 |             . __CLASS__
94 |         );
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Cell/IValueBinder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Cell;
 4 | 
 5 | interface IValueBinder
 6 | {
 7 |     /**
 8 |      * Bind value to a cell.
 9 |      *
10 |      * @param Cell $cell Cell to bind value to
11 |      * @param mixed $value Value to bind in cell
12 |      */
13 |     public function bindValue(Cell $cell, mixed $value): bool;
14 | }
15 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Cell/IgnoredErrors.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Cell;
 4 | 
 5 | class IgnoredErrors
 6 | {
 7 |     private bool $numberStoredAsText = false;
 8 | 
 9 |     private bool $formula = false;
10 | 
11 |     private bool $formulaRange = false;
12 | 
13 |     private bool $twoDigitTextYear = false;
14 | 
15 |     private bool $evalError = false;
16 | 
17 |     public function setNumberStoredAsText(bool $value): self
18 |     {
19 |         $this->numberStoredAsText = $value;
20 | 
21 |         return $this;
22 |     }
23 | 
24 |     public function getNumberStoredAsText(): bool
25 |     {
26 |         return $this->numberStoredAsText;
27 |     }
28 | 
29 |     public function setFormula(bool $value): self
30 |     {
31 |         $this->formula = $value;
32 | 
33 |         return $this;
34 |     }
35 | 
36 |     public function getFormula(): bool
37 |     {
38 |         return $this->formula;
39 |     }
40 | 
41 |     public function setFormulaRange(bool $value): self
42 |     {
43 |         $this->formulaRange = $value;
44 | 
45 |         return $this;
46 |     }
47 | 
48 |     public function getFormulaRange(): bool
49 |     {
50 |         return $this->formulaRange;
51 |     }
52 | 
53 |     public function setTwoDigitTextYear(bool $value): self
54 |     {
55 |         $this->twoDigitTextYear = $value;
56 | 
57 |         return $this;
58 |     }
59 | 
60 |     public function getTwoDigitTextYear(): bool
61 |     {
62 |         return $this->twoDigitTextYear;
63 |     }
64 | 
65 |     public function setEvalError(bool $value): self
66 |     {
67 |         $this->evalError = $value;
68 | 
69 |         return $this;
70 |     }
71 | 
72 |     public function getEvalError(): bool
73 |     {
74 |         return $this->evalError;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/AxisText.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Font;
 6 | 
 7 | class AxisText extends Properties
 8 | {
 9 |     private ?int $rotation = null;
10 | 
11 |     private Font $font;
12 | 
13 |     public function __construct()
14 |     {
15 |         parent::__construct();
16 |         $this->font = new Font();
17 |         $this->font->setSize(null, true);
18 |     }
19 | 
20 |     public function setRotation(?int $rotation): self
21 |     {
22 |         $this->rotation = $rotation;
23 | 
24 |         return $this;
25 |     }
26 | 
27 |     public function getRotation(): ?int
28 |     {
29 |         return $this->rotation;
30 |     }
31 | 
32 |     public function getFillColorObject(): ChartColor
33 |     {
34 |         $fillColor = $this->font->getChartColor();
35 |         if ($fillColor === null) {
36 |             $fillColor = new ChartColor();
37 |             $this->font->setChartColorFromObject($fillColor);
38 |         }
39 | 
40 |         return $fillColor;
41 |     }
42 | 
43 |     public function getFont(): Font
44 |     {
45 |         return $this->font;
46 |     }
47 | 
48 |     public function setFont(Font $font): self
49 |     {
50 |         $this->font = $font;
51 | 
52 |         return $this;
53 |     }
54 | 
55 |     /**
56 |      * Implement PHP __clone to create a deep clone, not just a shallow copy.
57 |      */
58 |     public function __clone()
59 |     {
60 |         parent::__clone();
61 |         $this->font = clone $this->font;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
 6 | 
 7 | class Exception extends PhpSpreadsheetException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/GridLines.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart;
 4 | 
 5 | /**
 6 |  * Created by PhpStorm.
 7 |  * User: Wiktor Trzonkowski
 8 |  * Date: 7/2/14
 9 |  * Time: 2:36 PM.
10 |  */
11 | class GridLines extends Properties
12 | {
13 | }
14 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/Renderer/IRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart\Renderer;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Chart\Chart;
 6 | 
 7 | interface IRenderer
 8 | {
 9 |     /**
10 |      * IRenderer constructor.
11 |      */
12 |     public function __construct(Chart $chart);
13 | 
14 |     /**
15 |      * Render the chart to given file (or stream).
16 |      *
17 |      * @param ?string $filename Name of the file render to
18 |      *
19 |      * @return bool true on success
20 |      */
21 |     public function render(?string $filename): bool;
22 | }
23 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/Renderer/JpGraph.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart\Renderer;
 4 | 
 5 | /**
 6 |  * Jpgraph is not oficially maintained in Composer, so the version there
 7 |  * could be out of date. For that reason, all unit test requiring Jpgraph
 8 |  * are skipped. So, do not measure code coverage for this class till that
 9 |  * is fixed.
10 |  *
11 |  * This implementation uses abandoned package
12 |  * https://packagist.org/packages/jpgraph/jpgraph
13 |  *
14 |  * @codeCoverageIgnore
15 |  */
16 | class JpGraph extends JpGraphRendererBase
17 | {
18 |     protected static function init(): void
19 |     {
20 |         static $loaded = false;
21 |         if ($loaded) {
22 |             return;
23 |         }
24 | 
25 |         // JpGraph is no longer included with distribution, but user may install it.
26 |         // So Scrutinizer's complaint that it can't find it is reasonable, but unfixable.
27 |         \JpGraph\JpGraph::load();
28 |         \JpGraph\JpGraph::module('bar');
29 |         \JpGraph\JpGraph::module('contour');
30 |         \JpGraph\JpGraph::module('line');
31 |         \JpGraph\JpGraph::module('pie');
32 |         \JpGraph\JpGraph::module('pie3d');
33 |         \JpGraph\JpGraph::module('radar');
34 |         \JpGraph\JpGraph::module('regstat');
35 |         \JpGraph\JpGraph::module('scatter');
36 |         \JpGraph\JpGraph::module('stock');
37 | 
38 |         $loaded = true;
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/Renderer/MtJpGraphRenderer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Chart\Renderer;
 4 | 
 5 | use mitoteam\jpgraph\MtJpGraph;
 6 | 
 7 | /**
 8 |  * Jpgraph is not officially maintained by Composer at packagist.org.
 9 |  *
10 |  * This renderer implementation uses package
11 |  * https://packagist.org/packages/mitoteam/jpgraph
12 |  *
13 |  * This package is up to date for June 2023 and has PHP 8.2 support.
14 |  */
15 | class MtJpGraphRenderer extends JpGraphRendererBase
16 | {
17 |     protected static function init(): void
18 |     {
19 |         static $loaded = false;
20 |         if ($loaded) {
21 |             return;
22 |         }
23 | 
24 |         MtJpGraph::load([
25 |             'bar',
26 |             'contour',
27 |             'line',
28 |             'pie',
29 |             'pie3d',
30 |             'radar',
31 |             'regstat',
32 |             'scatter',
33 |             'stock',
34 |         ], true); // enable Extended mode
35 | 
36 |         $loaded = true;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Chart/Renderer/PHP Charting Libraries.txt:
--------------------------------------------------------------------------------
 1 | ChartDirector
 2 | 	https://www.advsofteng.com/cdphp.html
 3 | 
 4 | GraPHPite
 5 | 	http://graphpite.sourceforge.net/
 6 | 
 7 | JpGraph
 8 | 	https://jpgraph.net/
 9 | 	Used composer packages:
10 |         https://packagist.org/packages/jpgraph/jpgraph (\PhpOffice\PhpSpreadsheet\Chart\Renderer\JpGraph)
11 |         https://packagist.org/packages/mitoteam/jpgraph (\PhpOffice\PhpSpreadsheet\Chart\Renderer\MtJpGraphRenderer)
12 | 
13 | LibChart
14 | 	https://naku.dohcrew.com/libchart/pages/introduction/
15 | 
16 | pChart
17 | 	http://pchart.sourceforge.net/
18 | 
19 | TeeChart
20 | 	https://www.steema.com/
21 | 
22 | PHPGraphLib
23 |     http://www.ebrueggeman.com/phpgraphlib
24 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Collection/CellsFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Collection;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Settings;
 6 | use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
 7 | 
 8 | abstract class CellsFactory
 9 | {
10 |     /**
11 |      * Initialise the cache storage.
12 |      *
13 |      * @param Worksheet $worksheet Enable cell caching for this worksheet
14 |      *
15 |      * */
16 |     public static function getInstance(Worksheet $worksheet): Cells
17 |     {
18 |         return new Cells($worksheet, Settings::getCache());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Collection/Memory/SimpleCache1.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Collection\Memory;
 4 | 
 5 | use Psr\SimpleCache\CacheInterface;
 6 | 
 7 | /**
 8 |  * This is the default implementation for in-memory cell collection.
 9 |  *
10 |  * Alternative implementation should leverage off-memory, non-volatile storage
11 |  * to reduce overall memory usage.
12 |  *
13 |  * Either SimpleCache1 or SimpleCache3, but not both, may be used.
14 |  * For code coverage testing, it will always be SimpleCache3.
15 |  *
16 |  * @codeCoverageIgnore
17 |  */
18 | class SimpleCache1 implements CacheInterface
19 | {
20 |     /**
21 |      * @var array Cell Cache
22 |      */
23 |     private array $cache = [];
24 | 
25 |     public function clear(): bool
26 |     {
27 |         $this->cache = [];
28 | 
29 |         return true;
30 |     }
31 | 
32 |     public function delete($key): bool
33 |     {
34 |         unset($this->cache[$key]);
35 | 
36 |         return true;
37 |     }
38 | 
39 |     public function deleteMultiple($keys): bool
40 |     {
41 |         foreach ($keys as $key) {
42 |             $this->delete($key);
43 |         }
44 | 
45 |         return true;
46 |     }
47 | 
48 |     public function get($key, $default = null): mixed
49 |     {
50 |         if ($this->has($key)) {
51 |             return $this->cache[$key];
52 |         }
53 | 
54 |         return $default;
55 |     }
56 | 
57 |     public function getMultiple($keys, $default = null): iterable
58 |     {
59 |         $results = [];
60 |         foreach ($keys as $key) {
61 |             $results[$key] = $this->get($key, $default);
62 |         }
63 | 
64 |         return $results;
65 |     }
66 | 
67 |     public function has($key): bool
68 |     {
69 |         return array_key_exists($key, $this->cache);
70 |     }
71 | 
72 |     public function set($key, $value, $ttl = null): bool
73 |     {
74 |         $this->cache[$key] = $value;
75 | 
76 |         return true;
77 |     }
78 | 
79 |     public function setMultiple($values, $ttl = null): bool
80 |     {
81 |         foreach ($values as $key => $value) {
82 |             $this->set($key, $value);
83 |         }
84 | 
85 |         return true;
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Collection/Memory/SimpleCache3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Collection\Memory;
 4 | 
 5 | use DateInterval;
 6 | use Psr\SimpleCache\CacheInterface;
 7 | 
 8 | /**
 9 |  * This is the default implementation for in-memory cell collection.
10 |  *
11 |  * Alternative implementation should leverage off-memory, non-volatile storage
12 |  * to reduce overall memory usage.
13 |  */
14 | class SimpleCache3 implements CacheInterface
15 | {
16 |     private array $cache = [];
17 | 
18 |     public function clear(): bool
19 |     {
20 |         $this->cache = [];
21 | 
22 |         return true;
23 |     }
24 | 
25 |     public function delete(string $key): bool
26 |     {
27 |         unset($this->cache[$key]);
28 | 
29 |         return true;
30 |     }
31 | 
32 |     public function deleteMultiple(iterable $keys): bool
33 |     {
34 |         foreach ($keys as $key) {
35 |             $this->delete($key);
36 |         }
37 | 
38 |         return true;
39 |     }
40 | 
41 |     public function get(string $key, mixed $default = null): mixed
42 |     {
43 |         if ($this->has($key)) {
44 |             return $this->cache[$key];
45 |         }
46 | 
47 |         return $default;
48 |     }
49 | 
50 |     public function getMultiple(iterable $keys, mixed $default = null): iterable
51 |     {
52 |         $results = [];
53 |         foreach ($keys as $key) {
54 |             $results[$key] = $this->get($key, $default);
55 |         }
56 | 
57 |         return $results;
58 |     }
59 | 
60 |     public function has(string $key): bool
61 |     {
62 |         return array_key_exists($key, $this->cache);
63 |     }
64 | 
65 |     public function set(string $key, mixed $value, null|int|DateInterval $ttl = null): bool
66 |     {
67 |         $this->cache[$key] = $value;
68 | 
69 |         return true;
70 |     }
71 | 
72 |     public function setMultiple(iterable $values, null|int|DateInterval $ttl = null): bool
73 |     {
74 |         foreach ($values as $key => $value) {
75 |             $this->set($key, $value);
76 |         }
77 | 
78 |         return true;
79 |     }
80 | }
81 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet;
 4 | 
 5 | use RuntimeException;
 6 | 
 7 | class Exception extends RuntimeException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Helper/Handler.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Helper;
 4 | 
 5 | class Handler
 6 | {
 7 |     private static string $invalidHex = 'Y';
 8 | 
 9 |     // A bunch of methods to show that we continue
10 |     // to capture messages even using PhpUnit 10.
11 |     public static function suppressed(): bool
12 |     {
13 |         return @trigger_error('hello');
14 |     }
15 | 
16 |     public static function deprecated(): string
17 |     {
18 |         return (string) hexdec(self::$invalidHex);
19 |     }
20 | 
21 |     public static function notice(string $value): void
22 |     {
23 |         date_default_timezone_set($value);
24 |     }
25 | 
26 |     public static function warning(): bool
27 |     {
28 |         return file_get_contents(__FILE__ . 'noexist') !== false;
29 |     }
30 | 
31 |     public static function userDeprecated(): bool
32 |     {
33 |         return trigger_error('hello', E_USER_DEPRECATED);
34 |     }
35 | 
36 |     public static function userNotice(): bool
37 |     {
38 |         return trigger_error('userNotice', E_USER_NOTICE);
39 |     }
40 | 
41 |     public static function userWarning(): bool
42 |     {
43 |         return trigger_error('userWarning', E_USER_WARNING);
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Helper/Size.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Helper;
 4 | 
 5 | use Stringable;
 6 | 
 7 | class Size implements Stringable
 8 | {
 9 |     const REGEXP_SIZE_VALIDATION = '/^(?P<size>\d*\.?\d+)(?P<unit>pt|px|em)?$/i';
10 | 
11 |     protected bool $valid = false;
12 | 
13 |     protected string $size = '';
14 | 
15 |     protected string $unit = '';
16 | 
17 |     public function __construct(string $size)
18 |     {
19 |         if (1 === preg_match(self::REGEXP_SIZE_VALIDATION, $size, $matches)) {
20 |             $this->valid = true;
21 |             $this->size = $matches['size'];
22 |             $this->unit = $matches['unit'] ?? 'pt';
23 |         }
24 |     }
25 | 
26 |     public function valid(): bool
27 |     {
28 |         return $this->valid;
29 |     }
30 | 
31 |     public function size(): string
32 |     {
33 |         return $this->size;
34 |     }
35 | 
36 |     public function unit(): string
37 |     {
38 |         return $this->unit;
39 |     }
40 | 
41 |     public function __toString(): string
42 |     {
43 |         return $this->size . $this->unit;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/IComparable.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet;
 4 | 
 5 | interface IComparable
 6 | {
 7 |     /**
 8 |      * Get hash code.
 9 |      *
10 |      * @return string Hash code
11 |      */
12 |     public function getHashCode(): string;
13 | }
14 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/NamedFormula.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
 6 | 
 7 | class NamedFormula extends DefinedName
 8 | {
 9 |     /**
10 |      * Create a new Named Formula.
11 |      */
12 |     public function __construct(
13 |         string $name,
14 |         ?Worksheet $worksheet = null,
15 |         ?string $formula = null,
16 |         bool $localOnly = false,
17 |         ?Worksheet $scope = null
18 |     ) {
19 |         // Validate data
20 |         if (!isset($formula)) {
21 |             throw new Exception('You must specify a Formula value for a Named Formula');
22 |         }
23 |         parent::__construct($name, $worksheet, $formula, $localOnly, $scope);
24 |     }
25 | 
26 |     /**
27 |      * Get the formula value.
28 |      */
29 |     public function getFormula(): string
30 |     {
31 |         return $this->value;
32 |     }
33 | 
34 |     /**
35 |      * Set the formula value.
36 |      */
37 |     public function setFormula(string $formula): self
38 |     {
39 |         if (!empty($formula)) {
40 |             $this->value = $formula;
41 |         }
42 | 
43 |         return $this;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/NamedRange.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
 6 | use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
 7 | 
 8 | class NamedRange extends DefinedName
 9 | {
10 |     /**
11 |      * Create a new Named Range.
12 |      */
13 |     public function __construct(
14 |         string $name,
15 |         ?Worksheet $worksheet = null,
16 |         string $range = 'A1',
17 |         bool $localOnly = false,
18 |         ?Worksheet $scope = null
19 |     ) {
20 |         if ($worksheet === null && $scope === null) {
21 |             throw new Exception('You must specify a worksheet or a scope for a Named Range');
22 |         }
23 |         parent::__construct($name, $worksheet, $range, $localOnly, $scope);
24 |     }
25 | 
26 |     /**
27 |      * Get the range value.
28 |      */
29 |     public function getRange(): string
30 |     {
31 |         return $this->value;
32 |     }
33 | 
34 |     /**
35 |      * Set the range value.
36 |      */
37 |     public function setRange(string $range): self
38 |     {
39 |         if (!empty($range)) {
40 |             $this->value = $range;
41 |         }
42 | 
43 |         return $this;
44 |     }
45 | 
46 |     /** @return string[] */
47 |     public function getCellsInRange(): array
48 |     {
49 |         $range = $this->value;
50 |         if (str_starts_with($range, '=')) {
51 |             $range = substr($range, 1);
52 |         }
53 | 
54 |         return Coordinate::extractAllCellReferencesInRange($range);
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/DefaultReadFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader;
 4 | 
 5 | class DefaultReadFilter implements IReadFilter
 6 | {
 7 |     /**
 8 |      * Should this cell be read?
 9 |      *
10 |      * @param string $columnAddress Column address (as a string value like "A", or "IV")
11 |      * @param int $row Row number
12 |      * @param string $worksheetName Optional worksheet name
13 |      */
14 |     public function readCell(string $columnAddress, int $row, string $worksheetName = ''): bool
15 |     {
16 |         return true;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
 6 | 
 7 | class Exception extends PhpSpreadsheetException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/IReadFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader;
 4 | 
 5 | interface IReadFilter
 6 | {
 7 |     /**
 8 |      * Should this cell be read?
 9 |      *
10 |      * @param string $columnAddress Column address (as a string value like "A", or "IV")
11 |      * @param int $row Row number
12 |      * @param string $worksheetName Optional worksheet name
13 |      */
14 |     public function readCell(string $columnAddress, int $row, string $worksheetName = ''): bool;
15 | }
16 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Ods/AutoFilter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Ods;
 4 | 
 5 | use DOMElement;
 6 | use DOMNode;
 7 | 
 8 | class AutoFilter extends BaseLoader
 9 | {
10 |     public function read(DOMElement $workbookData): void
11 |     {
12 |         $this->readAutoFilters($workbookData);
13 |     }
14 | 
15 |     protected function readAutoFilters(DOMElement $workbookData): void
16 |     {
17 |         $databases = $workbookData->getElementsByTagNameNS($this->tableNs, 'database-ranges');
18 | 
19 |         foreach ($databases as $autofilters) {
20 |             foreach ($autofilters->childNodes as $autofilter) {
21 |                 $autofilterRange = $this->getAttributeValue($autofilter, 'target-range-address');
22 |                 if ($autofilterRange !== null) {
23 |                     $baseAddress = FormulaTranslator::convertToExcelAddressValue($autofilterRange);
24 |                     $this->spreadsheet->getActiveSheet()->setAutoFilter($baseAddress);
25 |                 }
26 |             }
27 |         }
28 |     }
29 | 
30 |     protected function getAttributeValue(?DOMNode $node, string $attributeName): ?string
31 |     {
32 |         if ($node !== null && $node->attributes !== null) {
33 |             $attribute = $node->attributes->getNamedItemNS(
34 |                 $this->tableNs,
35 |                 $attributeName
36 |             );
37 | 
38 |             if ($attribute !== null) {
39 |                 return $attribute->nodeValue;
40 |             }
41 |         }
42 | 
43 |         return null;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Ods/BaseLoader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Ods;
 4 | 
 5 | use DOMElement;
 6 | use PhpOffice\PhpSpreadsheet\Spreadsheet;
 7 | 
 8 | abstract class BaseLoader
 9 | {
10 |     protected Spreadsheet $spreadsheet;
11 | 
12 |     protected string $tableNs;
13 | 
14 |     public function __construct(Spreadsheet $spreadsheet, string $tableNs)
15 |     {
16 |         $this->spreadsheet = $spreadsheet;
17 |         $this->tableNs = $tableNs;
18 |     }
19 | 
20 |     abstract public function read(DOMElement $workbookData): void;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Biff5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
 6 | use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
 7 | use PhpOffice\PhpSpreadsheet\Reader\Xls;
 8 | 
 9 | class Biff5 extends Xls
10 | {
11 |     /**
12 |      * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'
13 |      * always fixed range
14 |      * section 2.5.14.
15 |      */
16 |     public static function readBIFF5CellRangeAddressFixed(string $subData): string
17 |     {
18 |         // offset: 0; size: 2; index to first row
19 |         $fr = self::getUInt2d($subData, 0) + 1;
20 | 
21 |         // offset: 2; size: 2; index to last row
22 |         $lr = self::getUInt2d($subData, 2) + 1;
23 | 
24 |         // offset: 4; size: 1; index to first column
25 |         $fc = ord($subData[4]);
26 | 
27 |         // offset: 5; size: 1; index to last column
28 |         $lc = ord($subData[5]);
29 | 
30 |         // check values
31 |         if ($fr > $lr || $fc > $lc) {
32 |             throw new ReaderException('Not a cell range address');
33 |         }
34 | 
35 |         // column index to letter
36 |         $fc = Coordinate::stringFromColumnIndex($fc + 1);
37 |         $lc = Coordinate::stringFromColumnIndex($lc + 1);
38 | 
39 |         if ($fr == $lr && $fc == $lc) {
40 |             return "$fc$fr";
41 |         }
42 | 
43 |         return "$fc$fr:$lc$lr";
44 |     }
45 | 
46 |     /**
47 |      * Read BIFF5 cell range address list
48 |      * section 2.5.15.
49 |      *
50 |      * @return array{size: int, cellRangeAddresses: string[]}
51 |      */
52 |     public static function readBIFF5CellRangeAddressList(string $subData): array
53 |     {
54 |         $cellRangeAddresses = [];
55 | 
56 |         // offset: 0; size: 2; number of the following cell range addresses
57 |         $nm = self::getUInt2d($subData, 0);
58 | 
59 |         $offset = 2;
60 |         // offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses
61 |         for ($i = 0; $i < $nm; ++$i) {
62 |             $cellRangeAddresses[] = self::readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));
63 |             $offset += 6;
64 |         }
65 | 
66 |         return [
67 |             'size' => 2 + 6 * $nm,
68 |             'cellRangeAddresses' => $cellRangeAddresses,
69 |         ];
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Color.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Reader\Xls;
 6 | 
 7 | class Color
 8 | {
 9 |     /**
10 |      * Read color.
11 |      *
12 |      * @param int $color Indexed color
13 |      * @param string[][] $palette Color palette
14 |      *
15 |      * @return string[] RGB color value, example: ['rgb' => 'FF0000']
16 |      */
17 |     public static function map(int $color, array $palette, int $version): array
18 |     {
19 |         if ($color <= 0x07 || $color >= 0x40) {
20 |             // special built-in color
21 |             return Color\BuiltIn::lookup($color);
22 |         } elseif (isset($palette[$color - 8])) {
23 |             // palette color, color index 0x08 maps to pallete index 0
24 |             return $palette[$color - 8];
25 |         }
26 | 
27 |         return ($version === Xls::XLS_BIFF8) ? Color\BIFF8::lookup($color) : Color\BIFF5::lookup($color);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Color/BIFF5.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
 4 | 
 5 | class BIFF5
 6 | {
 7 |     private const BIFF5_COLOR_MAP = [
 8 |         0x08 => '000000',
 9 |         0x09 => 'FFFFFF',
10 |         0x0A => 'FF0000',
11 |         0x0B => '00FF00',
12 |         0x0C => '0000FF',
13 |         0x0D => 'FFFF00',
14 |         0x0E => 'FF00FF',
15 |         0x0F => '00FFFF',
16 |         0x10 => '800000',
17 |         0x11 => '008000',
18 |         0x12 => '000080',
19 |         0x13 => '808000',
20 |         0x14 => '800080',
21 |         0x15 => '008080',
22 |         0x16 => 'C0C0C0',
23 |         0x17 => '808080',
24 |         0x18 => '8080FF',
25 |         0x19 => '802060',
26 |         0x1A => 'FFFFC0',
27 |         0x1B => 'A0E0F0',
28 |         0x1C => '600080',
29 |         0x1D => 'FF8080',
30 |         0x1E => '0080C0',
31 |         0x1F => 'C0C0FF',
32 |         0x20 => '000080',
33 |         0x21 => 'FF00FF',
34 |         0x22 => 'FFFF00',
35 |         0x23 => '00FFFF',
36 |         0x24 => '800080',
37 |         0x25 => '800000',
38 |         0x26 => '008080',
39 |         0x27 => '0000FF',
40 |         0x28 => '00CFFF',
41 |         0x29 => '69FFFF',
42 |         0x2A => 'E0FFE0',
43 |         0x2B => 'FFFF80',
44 |         0x2C => 'A6CAF0',
45 |         0x2D => 'DD9CB3',
46 |         0x2E => 'B38FEE',
47 |         0x2F => 'E3E3E3',
48 |         0x30 => '2A6FF9',
49 |         0x31 => '3FB8CD',
50 |         0x32 => '488436',
51 |         0x33 => '958C41',
52 |         0x34 => '8E5E42',
53 |         0x35 => 'A0627A',
54 |         0x36 => '624FAC',
55 |         0x37 => '969696',
56 |         0x38 => '1D2FBE',
57 |         0x39 => '286676',
58 |         0x3A => '004500',
59 |         0x3B => '453E01',
60 |         0x3C => '6A2813',
61 |         0x3D => '85396A',
62 |         0x3E => '4A3285',
63 |         0x3F => '424242',
64 |     ];
65 | 
66 |     /**
67 |      * Map color array from BIFF5 built-in color index.
68 |      *
69 |      * @return array{rgb: string}
70 |      */
71 |     public static function lookup(int $color): array
72 |     {
73 |         return ['rgb' => self::BIFF5_COLOR_MAP[$color] ?? '000000'];
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Color/BIFF8.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
 4 | 
 5 | class BIFF8
 6 | {
 7 |     private const BIFF8_COLOR_MAP = [
 8 |         0x08 => '000000',
 9 |         0x09 => 'FFFFFF',
10 |         0x0A => 'FF0000',
11 |         0x0B => '00FF00',
12 |         0x0C => '0000FF',
13 |         0x0D => 'FFFF00',
14 |         0x0E => 'FF00FF',
15 |         0x0F => '00FFFF',
16 |         0x10 => '800000',
17 |         0x11 => '008000',
18 |         0x12 => '000080',
19 |         0x13 => '808000',
20 |         0x14 => '800080',
21 |         0x15 => '008080',
22 |         0x16 => 'C0C0C0',
23 |         0x17 => '808080',
24 |         0x18 => '9999FF',
25 |         0x19 => '993366',
26 |         0x1A => 'FFFFCC',
27 |         0x1B => 'CCFFFF',
28 |         0x1C => '660066',
29 |         0x1D => 'FF8080',
30 |         0x1E => '0066CC',
31 |         0x1F => 'CCCCFF',
32 |         0x20 => '000080',
33 |         0x21 => 'FF00FF',
34 |         0x22 => 'FFFF00',
35 |         0x23 => '00FFFF',
36 |         0x24 => '800080',
37 |         0x25 => '800000',
38 |         0x26 => '008080',
39 |         0x27 => '0000FF',
40 |         0x28 => '00CCFF',
41 |         0x29 => 'CCFFFF',
42 |         0x2A => 'CCFFCC',
43 |         0x2B => 'FFFF99',
44 |         0x2C => '99CCFF',
45 |         0x2D => 'FF99CC',
46 |         0x2E => 'CC99FF',
47 |         0x2F => 'FFCC99',
48 |         0x30 => '3366FF',
49 |         0x31 => '33CCCC',
50 |         0x32 => '99CC00',
51 |         0x33 => 'FFCC00',
52 |         0x34 => 'FF9900',
53 |         0x35 => 'FF6600',
54 |         0x36 => '666699',
55 |         0x37 => '969696',
56 |         0x38 => '003366',
57 |         0x39 => '339966',
58 |         0x3A => '003300',
59 |         0x3B => '333300',
60 |         0x3C => '993300',
61 |         0x3D => '993366',
62 |         0x3E => '333399',
63 |         0x3F => '333333',
64 |     ];
65 | 
66 |     /**
67 |      * Map color array from BIFF8 built-in color index.
68 |      *
69 |      * @return array{rgb: string}
70 |      */
71 |     public static function lookup(int $color): array
72 |     {
73 |         return ['rgb' => self::BIFF8_COLOR_MAP[$color] ?? '000000'];
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Color/BuiltIn.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
 4 | 
 5 | class BuiltIn
 6 | {
 7 |     private const BUILTIN_COLOR_MAP = [
 8 |         0x00 => '000000',
 9 |         0x01 => 'FFFFFF',
10 |         0x02 => 'FF0000',
11 |         0x03 => '00FF00',
12 |         0x04 => '0000FF',
13 |         0x05 => 'FFFF00',
14 |         0x06 => 'FF00FF',
15 |         0x07 => '00FFFF',
16 |         0x40 => '000000', // system window text color
17 |         0x41 => 'FFFFFF', // system window background color
18 |     ];
19 | 
20 |     /**
21 |      * Map built-in color to RGB value.
22 |      *
23 |      * @param int $color Indexed color
24 |      *
25 |      * @return array{rgb: string}
26 |      */
27 |     public static function lookup(int $color): array
28 |     {
29 |         return ['rgb' => self::BUILTIN_COLOR_MAP[$color] ?? '000000'];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/ErrorCode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
 4 | 
 5 | class ErrorCode
 6 | {
 7 |     private const ERROR_CODE_MAP = [
 8 |         0x00 => '#NULL!',
 9 |         0x07 => '#DIV/0!',
10 |         0x0F => '#VALUE!',
11 |         0x17 => '#REF!',
12 |         0x1D => '#NAME?',
13 |         0x24 => '#NUM!',
14 |         0x2A => '#N/A',
15 |     ];
16 | 
17 |     /**
18 |      * Map error code, e.g. '#N/A'.
19 |      */
20 |     public static function lookup(int $code): string|bool
21 |     {
22 |         return self::ERROR_CODE_MAP[$code] ?? false;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/RC4.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
 4 | 
 5 | class RC4
 6 | {
 7 |     /** @var int[] */
 8 |     protected array $s = []; // Context
 9 | 
10 |     protected int $i = 0;
11 | 
12 |     protected int $j = 0;
13 | 
14 |     /**
15 |      * RC4 stream decryption/encryption constrcutor.
16 |      *
17 |      * @param string $key Encryption key/passphrase
18 |      */
19 |     public function __construct(string $key)
20 |     {
21 |         $len = strlen($key);
22 | 
23 |         for ($this->i = 0; $this->i < 256; ++$this->i) {
24 |             $this->s[$this->i] = $this->i;
25 |         }
26 | 
27 |         $this->j = 0;
28 |         for ($this->i = 0; $this->i < 256; ++$this->i) {
29 |             $this->j = ($this->j + $this->s[$this->i] + ord($key[$this->i % $len])) % 256;
30 |             $t = $this->s[$this->i];
31 |             $this->s[$this->i] = $this->s[$this->j];
32 |             $this->s[$this->j] = $t;
33 |         }
34 |         $this->i = $this->j = 0;
35 |     }
36 | 
37 |     /**
38 |      * Symmetric decryption/encryption function.
39 |      *
40 |      * @param string $data Data to encrypt/decrypt
41 |      */
42 |     public function RC4(string $data): string
43 |     {
44 |         $len = strlen($data);
45 |         for ($c = 0; $c < $len; ++$c) {
46 |             $this->i = ($this->i + 1) % 256;
47 |             $this->j = ($this->j + $this->s[$this->i]) % 256;
48 |             $t = $this->s[$this->i];
49 |             $this->s[$this->i] = $this->s[$this->j];
50 |             $this->s[$this->j] = $t;
51 | 
52 |             $t = ($this->s[$this->i] + $this->s[$this->j]) % 256;
53 | 
54 |             $data[$c] = chr(ord($data[$c]) ^ $this->s[$t]);
55 |         }
56 | 
57 |         return $data;
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Style/Border.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Border as StyleBorder;
 6 | 
 7 | class Border
 8 | {
 9 |     /**
10 |      * @var array<int, string>
11 |      */
12 |     protected static array $borderStyleMap = [
13 |         0x00 => StyleBorder::BORDER_NONE,
14 |         0x01 => StyleBorder::BORDER_THIN,
15 |         0x02 => StyleBorder::BORDER_MEDIUM,
16 |         0x03 => StyleBorder::BORDER_DASHED,
17 |         0x04 => StyleBorder::BORDER_DOTTED,
18 |         0x05 => StyleBorder::BORDER_THICK,
19 |         0x06 => StyleBorder::BORDER_DOUBLE,
20 |         0x07 => StyleBorder::BORDER_HAIR,
21 |         0x08 => StyleBorder::BORDER_MEDIUMDASHED,
22 |         0x09 => StyleBorder::BORDER_DASHDOT,
23 |         0x0A => StyleBorder::BORDER_MEDIUMDASHDOT,
24 |         0x0B => StyleBorder::BORDER_DASHDOTDOT,
25 |         0x0C => StyleBorder::BORDER_MEDIUMDASHDOTDOT,
26 |         0x0D => StyleBorder::BORDER_SLANTDASHDOT,
27 |     ];
28 | 
29 |     public static function lookup(int $index): string
30 |     {
31 |         return self::$borderStyleMap[$index] ?? StyleBorder::BORDER_NONE;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Style/CellAlignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Alignment;
 6 | 
 7 | class CellAlignment
 8 | {
 9 |     /**
10 |      * @var array<int, string>
11 |      */
12 |     protected static array $horizontalAlignmentMap = [
13 |         0 => Alignment::HORIZONTAL_GENERAL,
14 |         1 => Alignment::HORIZONTAL_LEFT,
15 |         2 => Alignment::HORIZONTAL_CENTER,
16 |         3 => Alignment::HORIZONTAL_RIGHT,
17 |         4 => Alignment::HORIZONTAL_FILL,
18 |         5 => Alignment::HORIZONTAL_JUSTIFY,
19 |         6 => Alignment::HORIZONTAL_CENTER_CONTINUOUS,
20 |     ];
21 | 
22 |     /**
23 |      * @var array<int, string>
24 |      */
25 |     protected static array $verticalAlignmentMap = [
26 |         0 => Alignment::VERTICAL_TOP,
27 |         1 => Alignment::VERTICAL_CENTER,
28 |         2 => Alignment::VERTICAL_BOTTOM,
29 |         3 => Alignment::VERTICAL_JUSTIFY,
30 |     ];
31 | 
32 |     public static function horizontal(Alignment $alignment, int $horizontal): void
33 |     {
34 |         if (array_key_exists($horizontal, self::$horizontalAlignmentMap)) {
35 |             $alignment->setHorizontal(self::$horizontalAlignmentMap[$horizontal]);
36 |         }
37 |     }
38 | 
39 |     public static function vertical(Alignment $alignment, int $vertical): void
40 |     {
41 |         if (array_key_exists($vertical, self::$verticalAlignmentMap)) {
42 |             $alignment->setVertical(self::$verticalAlignmentMap[$vertical]);
43 |         }
44 |     }
45 | 
46 |     public static function wrap(Alignment $alignment, int $wrap): void
47 |     {
48 |         $alignment->setWrapText((bool) $wrap);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Style/CellFont.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Font;
 6 | 
 7 | class CellFont
 8 | {
 9 |     public static function escapement(Font $font, int $escapement): void
10 |     {
11 |         switch ($escapement) {
12 |             case 0x0001:
13 |                 $font->setSuperscript(true);
14 | 
15 |                 break;
16 |             case 0x0002:
17 |                 $font->setSubscript(true);
18 | 
19 |                 break;
20 |         }
21 |     }
22 | 
23 |     /**
24 |      * @var array<int, string>
25 |      */
26 |     protected static array $underlineMap = [
27 |         0x01 => Font::UNDERLINE_SINGLE,
28 |         0x02 => Font::UNDERLINE_DOUBLE,
29 |         0x21 => Font::UNDERLINE_SINGLEACCOUNTING,
30 |         0x22 => Font::UNDERLINE_DOUBLEACCOUNTING,
31 |     ];
32 | 
33 |     public static function underline(Font $font, int $underline): void
34 |     {
35 |         if (array_key_exists($underline, self::$underlineMap)) {
36 |             $font->setUnderline(self::$underlineMap[$underline]);
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xls/Style/FillPattern.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Fill;
 6 | 
 7 | class FillPattern
 8 | {
 9 |     /**
10 |      * @var array<int, string>
11 |      */
12 |     protected static array $fillPatternMap = [
13 |         0x00 => Fill::FILL_NONE,
14 |         0x01 => Fill::FILL_SOLID,
15 |         0x02 => Fill::FILL_PATTERN_MEDIUMGRAY,
16 |         0x03 => Fill::FILL_PATTERN_DARKGRAY,
17 |         0x04 => Fill::FILL_PATTERN_LIGHTGRAY,
18 |         0x05 => Fill::FILL_PATTERN_DARKHORIZONTAL,
19 |         0x06 => Fill::FILL_PATTERN_DARKVERTICAL,
20 |         0x07 => Fill::FILL_PATTERN_DARKDOWN,
21 |         0x08 => Fill::FILL_PATTERN_DARKUP,
22 |         0x09 => Fill::FILL_PATTERN_DARKGRID,
23 |         0x0A => Fill::FILL_PATTERN_DARKTRELLIS,
24 |         0x0B => Fill::FILL_PATTERN_LIGHTHORIZONTAL,
25 |         0x0C => Fill::FILL_PATTERN_LIGHTVERTICAL,
26 |         0x0D => Fill::FILL_PATTERN_LIGHTDOWN,
27 |         0x0E => Fill::FILL_PATTERN_LIGHTUP,
28 |         0x0F => Fill::FILL_PATTERN_LIGHTGRID,
29 |         0x10 => Fill::FILL_PATTERN_LIGHTTRELLIS,
30 |         0x11 => Fill::FILL_PATTERN_GRAY125,
31 |         0x12 => Fill::FILL_PATTERN_GRAY0625,
32 |     ];
33 | 
34 |     /**
35 |      * Get fill pattern from index
36 |      * OpenOffice documentation: 2.5.12.
37 |      */
38 |     public static function lookup(int $index): string
39 |     {
40 |         return self::$fillPatternMap[$index] ?? Fill::FILL_NONE;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xlsx/BaseParserClass.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
 4 | 
 5 | use Stringable;
 6 | 
 7 | class BaseParserClass
 8 | {
 9 |     protected static function boolean(mixed $value): bool
10 |     {
11 |         if (is_object($value)) {
12 |             $value = ($value instanceof Stringable) ? ((string) $value) : 'true';
13 |         }
14 | 
15 |         if (is_numeric($value)) {
16 |             return (bool) $value;
17 |         }
18 | 
19 |         return $value === 'true' || $value === 'TRUE';
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xlsx/Hyperlinks.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
 6 | use PhpOffice\PhpSpreadsheet\Reader\Xlsx;
 7 | use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
 8 | use SimpleXMLElement;
 9 | 
10 | class Hyperlinks
11 | {
12 |     private Worksheet $worksheet;
13 | 
14 |     /** @var string[] */
15 |     private array $hyperlinks = [];
16 | 
17 |     public function __construct(Worksheet $workSheet)
18 |     {
19 |         $this->worksheet = $workSheet;
20 |     }
21 | 
22 |     public function readHyperlinks(SimpleXMLElement $relsWorksheet): void
23 |     {
24 |         foreach ($relsWorksheet->children(Namespaces::RELATIONSHIPS)->Relationship as $elementx) {
25 |             $element = Xlsx::getAttributes($elementx);
26 |             if ($element->Type == Namespaces::HYPERLINK) {
27 |                 $this->hyperlinks[(string) $element->Id] = (string) $element->Target;
28 |             }
29 |         }
30 |     }
31 | 
32 |     public function setHyperlinks(SimpleXMLElement $worksheetXml): void
33 |     {
34 |         foreach ($worksheetXml->children(Namespaces::MAIN)->hyperlink as $hyperlink) {
35 |             $this->setHyperlink($hyperlink, $this->worksheet);
36 |         }
37 |     }
38 | 
39 |     private function setHyperlink(SimpleXMLElement $hyperlink, Worksheet $worksheet): void
40 |     {
41 |         // Link url
42 |         $linkRel = Xlsx::getAttributes($hyperlink, Namespaces::SCHEMA_OFFICE_DOCUMENT);
43 | 
44 |         $attributes = Xlsx::getAttributes($hyperlink);
45 |         foreach (Coordinate::extractAllCellReferencesInRange($attributes->ref) as $cellReference) {
46 |             $cell = $worksheet->getCell($cellReference);
47 |             if (isset($linkRel['id'])) {
48 |                 $hyperlinkUrl = $this->hyperlinks[(string) $linkRel['id']] ?? '';
49 |                 if (isset($attributes['location'])) {
50 |                     $hyperlinkUrl .= '#' . (string) $attributes['location'];
51 |                 }
52 |                 $cell->getHyperlink()->setUrl($hyperlinkUrl);
53 |             } elseif (isset($attributes['location'])) {
54 |                 $cell->getHyperlink()->setUrl('sheet://' . (string) $attributes['location']);
55 |             }
56 | 
57 |             // Tooltip
58 |             if (isset($attributes['tooltip'])) {
59 |                 $cell->getHyperlink()->setTooltip((string) $attributes['tooltip']);
60 |             }
61 |         }
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xlsx/SharedFormula.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
 4 | 
 5 | class SharedFormula
 6 | {
 7 |     private string $master;
 8 | 
 9 |     private string $formula;
10 | 
11 |     public function __construct(string $master, string $formula)
12 |     {
13 |         $this->master = $master;
14 |         $this->formula = $formula;
15 |     }
16 | 
17 |     public function master(): string
18 |     {
19 |         return $this->master;
20 |     }
21 | 
22 |     public function formula(): string
23 |     {
24 |         return $this->formula;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xlsx/Theme.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
 4 | 
 5 | class Theme
 6 | {
 7 |     /**
 8 |      * Theme Name.
 9 |      */
10 |     private string $themeName;
11 | 
12 |     /**
13 |      * Colour Scheme Name.
14 |      */
15 |     private string $colourSchemeName;
16 | 
17 |     /**
18 |      * Colour Map.
19 |      *
20 |      * @var string[]
21 |      */
22 |     private array $colourMap;
23 | 
24 |     /**
25 |      * Create a new Theme.
26 |      *
27 |      * @param string[] $colourMap
28 |      */
29 |     public function __construct(string $themeName, string $colourSchemeName, array $colourMap)
30 |     {
31 |         // Initialise values
32 |         $this->themeName = $themeName;
33 |         $this->colourSchemeName = $colourSchemeName;
34 |         $this->colourMap = $colourMap;
35 |     }
36 | 
37 |     /**
38 |      * Not called by Reader, never accessible any other time.
39 |      *
40 |      * @codeCoverageIgnore
41 |      */
42 |     public function getThemeName(): string
43 |     {
44 |         return $this->themeName;
45 |     }
46 | 
47 |     /**
48 |      * Not called by Reader, never accessible any other time.
49 |      *
50 |      * @codeCoverageIgnore
51 |      */
52 |     public function getColourSchemeName(): string
53 |     {
54 |         return $this->colourSchemeName;
55 |     }
56 | 
57 |     /**
58 |      * Get colour Map Value by Position.
59 |      */
60 |     public function getColourByIndex(int $index): ?string
61 |     {
62 |         return $this->colourMap[$index] ?? null;
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xml/Style/Alignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xml\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Alignment as AlignmentStyles;
 6 | use SimpleXMLElement;
 7 | 
 8 | class Alignment extends StyleBase
 9 | {
10 |     protected const VERTICAL_ALIGNMENT_STYLES = [
11 |         AlignmentStyles::VERTICAL_BOTTOM,
12 |         AlignmentStyles::VERTICAL_TOP,
13 |         AlignmentStyles::VERTICAL_CENTER,
14 |         AlignmentStyles::VERTICAL_JUSTIFY,
15 |     ];
16 | 
17 |     protected const HORIZONTAL_ALIGNMENT_STYLES = [
18 |         AlignmentStyles::HORIZONTAL_GENERAL,
19 |         AlignmentStyles::HORIZONTAL_LEFT,
20 |         AlignmentStyles::HORIZONTAL_RIGHT,
21 |         AlignmentStyles::HORIZONTAL_CENTER,
22 |         AlignmentStyles::HORIZONTAL_CENTER_CONTINUOUS,
23 |         AlignmentStyles::HORIZONTAL_JUSTIFY,
24 |     ];
25 | 
26 |     /** @return mixed[] */
27 |     public function parseStyle(SimpleXMLElement $styleAttributes): array
28 |     {
29 |         $style = [];
30 | 
31 |         foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
32 |             $styleAttributeValue = (string) $styleAttributeValue;
33 |             switch ($styleAttributeKey) {
34 |                 case 'Vertical':
35 |                     if (self::identifyFixedStyleValue(self::VERTICAL_ALIGNMENT_STYLES, $styleAttributeValue)) {
36 |                         $style['alignment']['vertical'] = $styleAttributeValue;
37 |                     }
38 | 
39 |                     break;
40 |                 case 'Horizontal':
41 |                     if (self::identifyFixedStyleValue(self::HORIZONTAL_ALIGNMENT_STYLES, $styleAttributeValue)) {
42 |                         $style['alignment']['horizontal'] = $styleAttributeValue;
43 |                     }
44 | 
45 |                     break;
46 |                 case 'WrapText':
47 |                     $style['alignment']['wrapText'] = true;
48 | 
49 |                     break;
50 |                 case 'Rotate':
51 |                     $style['alignment']['textRotation'] = $styleAttributeValue;
52 | 
53 |                     break;
54 |                 case 'Indent':
55 |                     $style['alignment']['indent'] = $styleAttributeValue;
56 | 
57 |                     break;
58 |             }
59 |         }
60 | 
61 |         return $style;
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xml/Style/NumberFormat.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xml\Style;
 4 | 
 5 | use SimpleXMLElement;
 6 | 
 7 | class NumberFormat extends StyleBase
 8 | {
 9 |     /** @return mixed[] */
10 |     public function parseStyle(SimpleXMLElement $styleAttributes): array
11 |     {
12 |         $style = [];
13 | 
14 |         $fromFormats = ['\-', '\ '];
15 |         $toFormats = ['-', ' '];
16 | 
17 |         foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
18 |             $styleAttributeValue = str_replace($fromFormats, $toFormats, $styleAttributeValue);
19 | 
20 |             switch ($styleAttributeValue) {
21 |                 case 'Short Date':
22 |                     $styleAttributeValue = 'dd/mm/yyyy';
23 | 
24 |                     break;
25 |             }
26 | 
27 |             if ($styleAttributeValue > '') {
28 |                 $style['numberFormat']['formatCode'] = $styleAttributeValue;
29 |             }
30 |         }
31 | 
32 |         return $style;
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Reader/Xml/Style/StyleBase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Reader\Xml\Style;
 4 | 
 5 | use SimpleXMLElement;
 6 | 
 7 | abstract class StyleBase
 8 | {
 9 |     /** @param string[] $styleList */
10 |     protected static function identifyFixedStyleValue(array $styleList, string &$styleAttributeValue): bool
11 |     {
12 |         $returnValue = false;
13 | 
14 |         $styleAttributeValue = strtolower($styleAttributeValue);
15 |         foreach ($styleList as $style) {
16 |             if ($styleAttributeValue == strtolower($style)) {
17 |                 $styleAttributeValue = $style;
18 |                 $returnValue = true;
19 | 
20 |                 break;
21 |             }
22 |         }
23 | 
24 |         return $returnValue;
25 |     }
26 | 
27 |     protected static function getAttributes(?SimpleXMLElement $simple, string $node): SimpleXMLElement
28 |     {
29 |         return ($simple === null) ? new SimpleXMLElement('<xml></xml>') : ($simple->attributes($node) ?? new SimpleXMLElement('<xml></xml>'));
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/RichText/ITextElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\RichText;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Font;
 6 | 
 7 | interface ITextElement
 8 | {
 9 |     /**
10 |      * Get text.
11 |      */
12 |     public function getText(): string;
13 | 
14 |     /**
15 |      * Set text.
16 |      *
17 |      * @param string $text Text
18 |      *
19 |      * @return $this
20 |      */
21 |     public function setText(string $text): self;
22 | 
23 |     /**
24 |      * Get font.
25 |      */
26 |     public function getFont(): ?Font;
27 | 
28 |     /**
29 |      * Get hash code.
30 |      *
31 |      * @return string Hash code
32 |      */
33 |     public function getHashCode(): string;
34 | }
35 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/RichText/Run.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\RichText;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
 6 | use PhpOffice\PhpSpreadsheet\Style\Font;
 7 | 
 8 | class Run extends TextElement implements ITextElement
 9 | {
10 |     /**
11 |      * Font.
12 |      */
13 |     private ?Font $font;
14 | 
15 |     /**
16 |      * Create a new Run instance.
17 |      *
18 |      * @param string $text Text
19 |      */
20 |     public function __construct(string $text = '')
21 |     {
22 |         parent::__construct($text);
23 |         // Initialise variables
24 |         $this->font = new Font();
25 |     }
26 | 
27 |     /**
28 |      * Get font.
29 |      */
30 |     public function getFont(): ?Font
31 |     {
32 |         return $this->font;
33 |     }
34 | 
35 |     public function getFontOrThrow(): Font
36 |     {
37 |         if ($this->font === null) {
38 |             throw new SpreadsheetException('unexpected null font');
39 |         }
40 | 
41 |         return $this->font;
42 |     }
43 | 
44 |     /**
45 |      * Set font.
46 |      *
47 |      * @param ?Font $font Font
48 |      *
49 |      * @return $this
50 |      */
51 |     public function setFont(?Font $font = null): static
52 |     {
53 |         $this->font = $font;
54 | 
55 |         return $this;
56 |     }
57 | 
58 |     /**
59 |      * Get hash code.
60 |      *
61 |      * @return string Hash code
62 |      */
63 |     public function getHashCode(): string
64 |     {
65 |         return md5(
66 |             $this->getText()
67 |             . (($this->font === null) ? '' : $this->font->getHashCode())
68 |             . __CLASS__
69 |         );
70 |     }
71 | }
72 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/RichText/TextElement.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\RichText;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Font;
 6 | 
 7 | class TextElement implements ITextElement
 8 | {
 9 |     /**
10 |      * Text.
11 |      */
12 |     private string $text;
13 | 
14 |     /**
15 |      * Create a new TextElement instance.
16 |      *
17 |      * @param string $text Text
18 |      */
19 |     public function __construct(string $text = '')
20 |     {
21 |         // Initialise variables
22 |         $this->text = $text;
23 |     }
24 | 
25 |     /**
26 |      * Get text.
27 |      *
28 |      * @return string Text
29 |      */
30 |     public function getText(): string
31 |     {
32 |         return $this->text;
33 |     }
34 | 
35 |     /**
36 |      * Set text.
37 |      *
38 |      * @param string $text Text
39 |      *
40 |      * @return $this
41 |      */
42 |     public function setText(string $text): self
43 |     {
44 |         $this->text = $text;
45 | 
46 |         return $this;
47 |     }
48 | 
49 |     /**
50 |      * Get font. For this class, the return value is always null.
51 |      */
52 |     public function getFont(): ?Font
53 |     {
54 |         return null;
55 |     }
56 | 
57 |     /**
58 |      * Get hash code.
59 |      *
60 |      * @return string Hash code
61 |      */
62 |     public function getHashCode(): string
63 |     {
64 |         return md5(
65 |             $this->text
66 |             . __CLASS__
67 |         );
68 |     }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared;
 4 | 
 5 | class Escher
 6 | {
 7 |     /**
 8 |      * Drawing Group Container.
 9 |      */
10 |     private ?Escher\DggContainer $dggContainer = null;
11 | 
12 |     /**
13 |      * Drawing Container.
14 |      */
15 |     private ?Escher\DgContainer $dgContainer = null;
16 | 
17 |     /**
18 |      * Get Drawing Group Container.
19 |      */
20 |     public function getDggContainer(): ?Escher\DggContainer
21 |     {
22 |         return $this->dggContainer;
23 |     }
24 | 
25 |     /**
26 |      * Set Drawing Group Container.
27 |      */
28 |     public function setDggContainer(Escher\DggContainer $dggContainer): Escher\DggContainer
29 |     {
30 |         return $this->dggContainer = $dggContainer;
31 |     }
32 | 
33 |     /**
34 |      * Get Drawing Container.
35 |      */
36 |     public function getDgContainer(): ?Escher\DgContainer
37 |     {
38 |         return $this->dgContainer;
39 |     }
40 | 
41 |     /**
42 |      * Set Drawing Container.
43 |      */
44 |     public function setDgContainer(Escher\DgContainer $dgContainer): Escher\DgContainer
45 |     {
46 |         return $this->dgContainer = $dgContainer;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher/DgContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Escher;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as SpreadsheetException;
 6 | use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer\SpgrContainer;
 7 | 
 8 | class DgContainer
 9 | {
10 |     /**
11 |      * Drawing index, 1-based.
12 |      */
13 |     private ?int $dgId = null;
14 | 
15 |     /**
16 |      * Last shape index in this drawing.
17 |      */
18 |     private ?int $lastSpId = null;
19 | 
20 |     private ?SpgrContainer $spgrContainer = null;
21 | 
22 |     public function getDgId(): ?int
23 |     {
24 |         return $this->dgId;
25 |     }
26 | 
27 |     public function setDgId(int $value): void
28 |     {
29 |         $this->dgId = $value;
30 |     }
31 | 
32 |     public function getLastSpId(): ?int
33 |     {
34 |         return $this->lastSpId;
35 |     }
36 | 
37 |     public function setLastSpId(int $value): void
38 |     {
39 |         $this->lastSpId = $value;
40 |     }
41 | 
42 |     public function getSpgrContainer(): ?SpgrContainer
43 |     {
44 |         return $this->spgrContainer;
45 |     }
46 | 
47 |     public function getSpgrContainerOrThrow(): SpgrContainer
48 |     {
49 |         if ($this->spgrContainer !== null) {
50 |             return $this->spgrContainer;
51 |         }
52 | 
53 |         throw new SpreadsheetException('spgrContainer is unexpectedly null');
54 |     }
55 | 
56 |     public function setSpgrContainer(SpgrContainer $spgrContainer): SpgrContainer
57 |     {
58 |         return $this->spgrContainer = $spgrContainer;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher/DgContainer/SpgrContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer;
 4 | 
 5 | class SpgrContainer
 6 | {
 7 |     /**
 8 |      * Parent Shape Group Container.
 9 |      */
10 |     private ?self $parent = null;
11 | 
12 |     /**
13 |      * Shape Container collection.
14 |      *
15 |      * @var mixed[]
16 |      */
17 |     private array $children = [];
18 | 
19 |     /**
20 |      * Set parent Shape Group Container.
21 |      */
22 |     public function setParent(?self $parent): void
23 |     {
24 |         $this->parent = $parent;
25 |     }
26 | 
27 |     /**
28 |      * Get the parent Shape Group Container if any.
29 |      */
30 |     public function getParent(): ?self
31 |     {
32 |         return $this->parent;
33 |     }
34 | 
35 |     /**
36 |      * Add a child. This will be either spgrContainer or spContainer.
37 |      *
38 |      * @param SpgrContainer|SpgrContainer\SpContainer $child child to be added
39 |      */
40 |     public function addChild(mixed $child): void
41 |     {
42 |         $this->children[] = $child;
43 |         $child->setParent($this);
44 |     }
45 | 
46 |     /**
47 |      * Get collection of Shape Containers.
48 |      *
49 |      * @return mixed[]
50 |      */
51 |     public function getChildren(): array
52 |     {
53 |         return $this->children;
54 |     }
55 | 
56 |     /**
57 |      * Recursively get all spContainers within this spgrContainer.
58 |      *
59 |      * @return SpgrContainer\SpContainer[]
60 |      */
61 |     public function getAllSpContainers(): array
62 |     {
63 |         $allSpContainers = [];
64 | 
65 |         foreach ($this->children as $child) {
66 |             if ($child instanceof self) {
67 |                 $allSpContainers = array_merge($allSpContainers, $child->getAllSpContainers());
68 |             } else {
69 |                 $allSpContainers[] = $child;
70 |             }
71 |         }
72 |         /** @var SpgrContainer\SpContainer[] $allSpContainers */
73 | 
74 |         return $allSpContainers;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher/DggContainer/BstoreContainer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer;
 4 | 
 5 | class BstoreContainer
 6 | {
 7 |     /**
 8 |      * BLIP Store Entries. Each of them holds one BLIP (Big Large Image or Picture).
 9 |      *
10 |      * @var BstoreContainer\BSE[]
11 |      */
12 |     private array $BSECollection = [];
13 | 
14 |     /**
15 |      * Add a BLIP Store Entry.
16 |      */
17 |     public function addBSE(BstoreContainer\BSE $BSE): void
18 |     {
19 |         $this->BSECollection[] = $BSE;
20 |         $BSE->setParent($this);
21 |     }
22 | 
23 |     /**
24 |      * Get the collection of BLIP Store Entries.
25 |      *
26 |      * @return BstoreContainer\BSE[]
27 |      */
28 |     public function getBSECollection(): array
29 |     {
30 |         return $this->BSECollection;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher/DggContainer/BstoreContainer/BSE.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer;
 6 | 
 7 | class BSE
 8 | {
 9 |     const BLIPTYPE_ERROR = 0x00;
10 |     const BLIPTYPE_UNKNOWN = 0x01;
11 |     const BLIPTYPE_EMF = 0x02;
12 |     const BLIPTYPE_WMF = 0x03;
13 |     const BLIPTYPE_PICT = 0x04;
14 |     const BLIPTYPE_JPEG = 0x05;
15 |     const BLIPTYPE_PNG = 0x06;
16 |     const BLIPTYPE_DIB = 0x07;
17 |     const BLIPTYPE_TIFF = 0x11;
18 |     const BLIPTYPE_CMYKJPEG = 0x12;
19 | 
20 |     /**
21 |      * The parent BLIP Store Entry Container.
22 |      * Property is currently unused.
23 |      */
24 |     private BstoreContainer $parent;
25 | 
26 |     /**
27 |      * The BLIP (Big Large Image or Picture).
28 |      */
29 |     private ?BSE\Blip $blip = null;
30 | 
31 |     /**
32 |      * The BLIP type.
33 |      */
34 |     private int $blipType;
35 | 
36 |     /**
37 |      * Set parent BLIP Store Entry Container.
38 |      */
39 |     public function setParent(BstoreContainer $parent): void
40 |     {
41 |         $this->parent = $parent;
42 |     }
43 | 
44 |     public function getParent(): BstoreContainer
45 |     {
46 |         return $this->parent;
47 |     }
48 | 
49 |     /**
50 |      * Get the BLIP.
51 |      */
52 |     public function getBlip(): ?BSE\Blip
53 |     {
54 |         return $this->blip;
55 |     }
56 | 
57 |     /**
58 |      * Set the BLIP.
59 |      */
60 |     public function setBlip(BSE\Blip $blip): void
61 |     {
62 |         $this->blip = $blip;
63 |         $blip->setParent($this);
64 |     }
65 | 
66 |     /**
67 |      * Get the BLIP type.
68 |      */
69 |     public function getBlipType(): int
70 |     {
71 |         return $this->blipType;
72 |     }
73 | 
74 |     /**
75 |      * Set the BLIP type.
76 |      */
77 |     public function setBlipType(int $blipType): void
78 |     {
79 |         $this->blipType = $blipType;
80 |     }
81 | }
82 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Escher/DggContainer/BstoreContainer/BSE/Blip.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE;
 6 | 
 7 | class Blip
 8 | {
 9 |     /**
10 |      * The parent BSE.
11 |      */
12 |     private BSE $parent;
13 | 
14 |     /**
15 |      * Raw image data.
16 |      */
17 |     private string $data;
18 | 
19 |     /**
20 |      * Get the raw image data.
21 |      */
22 |     public function getData(): string
23 |     {
24 |         return $this->data;
25 |     }
26 | 
27 |     /**
28 |      * Set the raw image data.
29 |      */
30 |     public function setData(string $data): void
31 |     {
32 |         $this->data = $data;
33 |     }
34 | 
35 |     /**
36 |      * Set parent BSE.
37 |      */
38 |     public function setParent(BSE $parent): void
39 |     {
40 |         $this->parent = $parent;
41 |     }
42 | 
43 |     /**
44 |      * Get parent BSE.
45 |      */
46 |     public function getParent(): BSE
47 |     {
48 |         return $this->parent;
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/IntOrFloat.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared;
 4 | 
 5 | class IntOrFloat
 6 | {
 7 |     /**
 8 |      * Help some functions with large results operate correctly on 32-bit,
 9 |      * by returning result as int when possible, float otherwise.
10 |      */
11 |     public static function evaluate(float|int $value): float|int
12 |     {
13 |         $iValue = (int) $value;
14 | 
15 |         return ($value == $iValue) ? $iValue : $value;
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/OLE/PPS/File.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\OLE\PPS;
 4 | 
 5 | // vim: set expandtab tabstop=4 shiftwidth=4:
 6 | // +----------------------------------------------------------------------+
 7 | // | PHP Version 4                                                        |
 8 | // +----------------------------------------------------------------------+
 9 | // | Copyright (c) 1997-2002 The PHP Group                                |
10 | // +----------------------------------------------------------------------+
11 | // | This source file is subject to version 2.02 of the PHP license,      |
12 | // | that is bundled with this package in the file LICENSE, and is        |
13 | // | available at through the world-wide-web at                           |
14 | // | http://www.php.net/license/2_02.txt.                                 |
15 | // | If you did not receive a copy of the PHP license and are unable to   |
16 | // | obtain it through the world-wide-web, please send a note to          |
17 | // | license@php.net so we can mail you a copy immediately.               |
18 | // +----------------------------------------------------------------------+
19 | // | Author: Xavier Noguer <xnoguer@php.net>                              |
20 | // | Based on OLE::Storage_Lite by Kawai, Takanori                        |
21 | // +----------------------------------------------------------------------+
22 | //
23 | use PhpOffice\PhpSpreadsheet\Shared\OLE;
24 | use PhpOffice\PhpSpreadsheet\Shared\OLE\PPS;
25 | 
26 | /**
27 |  * Class for creating File PPS's for OLE containers.
28 |  *
29 |  * @author   Xavier Noguer <xnoguer@php.net>
30 |  */
31 | class File extends PPS
32 | {
33 |     /**
34 |      * The constructor.
35 |      *
36 |      * @param string $name The name of the file (in Unicode)
37 |      *
38 |      * @see OLE::ascToUcs()
39 |      */
40 |     public function __construct(string $name)
41 |     {
42 |         parent::__construct(null, $name, OLE::OLE_PPS_TYPE_FILE, null, null, null, null, null, '', []);
43 |     }
44 | 
45 |     /**
46 |      * Initialization method. Has to be called right after OLE_PPS_File().
47 |      */
48 |     public function init(): bool
49 |     {
50 |         return true;
51 |     }
52 | 
53 |     /**
54 |      * Append data to PPS.
55 |      *
56 |      * @param string $data The data to append
57 |      */
58 |     public function append(string $data): void
59 |     {
60 |         $this->_data .= $data;
61 |     }
62 | }
63 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Shared/Trend/LinearBestFit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Shared\Trend;
 4 | 
 5 | class LinearBestFit extends BestFit
 6 | {
 7 |     /**
 8 |      * Algorithm type to use for best-fit
 9 |      * (Name of this Trend class).
10 |      */
11 |     protected string $bestFitType = 'linear';
12 | 
13 |     /**
14 |      * Return the Y-Value for a specified value of X.
15 |      *
16 |      * @param float $xValue X-Value
17 |      *
18 |      * @return float Y-Value
19 |      */
20 |     public function getValueOfYForX(float $xValue): float
21 |     {
22 |         return $this->getIntersect() + $this->getSlope() * $xValue;
23 |     }
24 | 
25 |     /**
26 |      * Return the X-Value for a specified value of Y.
27 |      *
28 |      * @param float $yValue Y-Value
29 |      *
30 |      * @return float X-Value
31 |      */
32 |     public function getValueOfXForY(float $yValue): float
33 |     {
34 |         return ($yValue - $this->getIntersect()) / $this->getSlope();
35 |     }
36 | 
37 |     /**
38 |      * Return the Equation of the best-fit line.
39 |      *
40 |      * @param int $dp Number of places of decimal precision to display
41 |      */
42 |     public function getEquation(int $dp = 0): string
43 |     {
44 |         $slope = $this->getSlope($dp);
45 |         $intersect = $this->getIntersect($dp);
46 | 
47 |         return 'Y = ' . $intersect . ' + ' . $slope . ' * X';
48 |     }
49 | 
50 |     /**
51 |      * Execute the regression and calculate the goodness of fit for a set of X and Y data values.
52 |      *
53 |      * @param float[] $yValues The set of Y-values for this regression
54 |      * @param float[] $xValues The set of X-values for this regression
55 |      */
56 |     private function linearRegression(array $yValues, array $xValues, bool $const): void
57 |     {
58 |         $this->leastSquareFit($yValues, $xValues, $const);
59 |     }
60 | 
61 |     /**
62 |      * Define the regression and calculate the goodness of fit for a set of X and Y data values.
63 |      *
64 |      * @param float[] $yValues The set of Y-values for this regression
65 |      * @param float[] $xValues The set of X-values for this regression
66 |      */
67 |     public function __construct(array $yValues, array $xValues = [], bool $const = true)
68 |     {
69 |         parent::__construct($yValues, $xValues);
70 | 
71 |         if (!$this->error) {
72 |             $this->linearRegression($yValues, $xValues, (bool) $const);
73 |         }
74 |     }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/ConditionalFormatting/CellStyleAssessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\Cell;
 6 | use PhpOffice\PhpSpreadsheet\Style\Conditional;
 7 | use PhpOffice\PhpSpreadsheet\Style\Style;
 8 | 
 9 | class CellStyleAssessor
10 | {
11 |     protected CellMatcher $cellMatcher;
12 | 
13 |     protected StyleMerger $styleMerger;
14 | 
15 |     protected Cell $cell;
16 | 
17 |     public function __construct(Cell $cell, string $conditionalRange)
18 |     {
19 |         $this->cell = $cell;
20 |         $this->cellMatcher = new CellMatcher($cell, $conditionalRange);
21 |         $this->styleMerger = new StyleMerger($cell->getStyle());
22 |     }
23 | 
24 |     /**
25 |      * @param Conditional[] $conditionalStyles
26 |      */
27 |     public function matchConditions(array $conditionalStyles = []): Style
28 |     {
29 |         foreach ($conditionalStyles as $conditional) {
30 |             if ($this->cellMatcher->evaluateConditional($conditional) === true) {
31 |                 // Merging the conditional style into the base style goes in here
32 |                 $this->styleMerger->mergeStyle($conditional->getStyle($this->cell->getValue()));
33 |                 if ($conditional->getStopIfTrue() === true) {
34 |                     break;
35 |                 }
36 |             }
37 |         }
38 | 
39 |         return $this->styleMerger->getStyle();
40 |     }
41 | 
42 |     /**
43 |      * @param Conditional[] $conditionalStyles
44 |      */
45 |     public function matchConditionsReturnNullIfNoneMatched(array $conditionalStyles, string $cellData, bool $stopAtFirstMatch = false): ?Style
46 |     {
47 |         $matched = false;
48 |         $value = (float) $cellData;
49 |         foreach ($conditionalStyles as $conditional) {
50 |             if ($this->cellMatcher->evaluateConditional($conditional) === true) {
51 |                 $matched = true;
52 |                 // Merging the conditional style into the base style goes in here
53 |                 $this->styleMerger->mergeStyle($conditional->getStyle($value));
54 |                 if ($conditional->getStopIfTrue() === true || $stopAtFirstMatch) {
55 |                     break;
56 |                 }
57 |             }
58 |         }
59 |         if ($matched) {
60 |             return $this->styleMerger->getStyle();
61 |         }
62 | 
63 |         return null;
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/ConditionalFormatting/ConditionalDataBar.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting;
 4 | 
 5 | class ConditionalDataBar
 6 | {
 7 |     private ?bool $showValue = null;
 8 | 
 9 |     private ?ConditionalFormatValueObject $minimumConditionalFormatValueObject = null;
10 | 
11 |     private ?ConditionalFormatValueObject $maximumConditionalFormatValueObject = null;
12 | 
13 |     private string $color = '';
14 | 
15 |     private ?ConditionalFormattingRuleExtension $conditionalFormattingRuleExt = null;
16 | 
17 |     public function getShowValue(): ?bool
18 |     {
19 |         return $this->showValue;
20 |     }
21 | 
22 |     public function setShowValue(bool $showValue): self
23 |     {
24 |         $this->showValue = $showValue;
25 | 
26 |         return $this;
27 |     }
28 | 
29 |     public function getMinimumConditionalFormatValueObject(): ?ConditionalFormatValueObject
30 |     {
31 |         return $this->minimumConditionalFormatValueObject;
32 |     }
33 | 
34 |     public function setMinimumConditionalFormatValueObject(ConditionalFormatValueObject $minimumConditionalFormatValueObject): self
35 |     {
36 |         $this->minimumConditionalFormatValueObject = $minimumConditionalFormatValueObject;
37 | 
38 |         return $this;
39 |     }
40 | 
41 |     public function getMaximumConditionalFormatValueObject(): ?ConditionalFormatValueObject
42 |     {
43 |         return $this->maximumConditionalFormatValueObject;
44 |     }
45 | 
46 |     public function setMaximumConditionalFormatValueObject(ConditionalFormatValueObject $maximumConditionalFormatValueObject): self
47 |     {
48 |         $this->maximumConditionalFormatValueObject = $maximumConditionalFormatValueObject;
49 | 
50 |         return $this;
51 |     }
52 | 
53 |     public function getColor(): string
54 |     {
55 |         return $this->color;
56 |     }
57 | 
58 |     public function setColor(string $color): self
59 |     {
60 |         $this->color = $color;
61 | 
62 |         return $this;
63 |     }
64 | 
65 |     public function getConditionalFormattingRuleExt(): ?ConditionalFormattingRuleExtension
66 |     {
67 |         return $this->conditionalFormattingRuleExt;
68 |     }
69 | 
70 |     public function setConditionalFormattingRuleExt(ConditionalFormattingRuleExtension $conditionalFormattingRuleExt): self
71 |     {
72 |         $this->conditionalFormattingRuleExt = $conditionalFormattingRuleExt;
73 | 
74 |         return $this;
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/ConditionalFormatting/ConditionalFormatValueObject.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting;
 4 | 
 5 | class ConditionalFormatValueObject
 6 | {
 7 |     private string $type;
 8 | 
 9 |     private null|float|int|string $value;
10 | 
11 |     private ?string $cellFormula;
12 | 
13 |     public function __construct(string $type, null|float|int|string $value = null, ?string $cellFormula = null)
14 |     {
15 |         $this->type = $type;
16 |         $this->value = $value;
17 |         $this->cellFormula = $cellFormula;
18 |     }
19 | 
20 |     public function getType(): string
21 |     {
22 |         return $this->type;
23 |     }
24 | 
25 |     public function setType(string $type): self
26 |     {
27 |         $this->type = $type;
28 | 
29 |         return $this;
30 |     }
31 | 
32 |     public function getValue(): null|float|int|string
33 |     {
34 |         return $this->value;
35 |     }
36 | 
37 |     public function setValue(null|float|int|string $value): self
38 |     {
39 |         $this->value = $value;
40 | 
41 |         return $this;
42 |     }
43 | 
44 |     public function getCellFormula(): ?string
45 |     {
46 |         return $this->cellFormula;
47 |     }
48 | 
49 |     public function setCellFormula(?string $cellFormula): self
50 |     {
51 |         $this->cellFormula = $cellFormula;
52 | 
53 |         return $this;
54 |     }
55 | }
56 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/ConditionalFormatting/Wizard/WizardInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\Wizard;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Conditional;
 6 | use PhpOffice\PhpSpreadsheet\Style\Style;
 7 | 
 8 | interface WizardInterface
 9 | {
10 |     public function getCellRange(): string;
11 | 
12 |     public function setCellRange(string $cellRange): void;
13 | 
14 |     public function getStyle(): Style;
15 | 
16 |     public function setStyle(Style $style): void;
17 | 
18 |     public function getStopIfTrue(): bool;
19 | 
20 |     public function setStopIfTrue(bool $stopIfTrue): void;
21 | 
22 |     public function getConditional(): Conditional;
23 | 
24 |     public static function fromConditional(Conditional $conditional, string $cellRange = 'A1'): self;
25 | }
26 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/BaseFormatter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
 6 | 
 7 | abstract class BaseFormatter
 8 | {
 9 |     protected static function stripQuotes(string $format): string
10 |     {
11 |         // Some non-number strings are quoted, so we'll get rid of the quotes, likewise any positional * symbols
12 |         return str_replace(['"', '*'], '', $format);
13 |     }
14 | 
15 |     protected static function adjustSeparators(string $value): string
16 |     {
17 |         $thousandsSeparator = StringHelper::getThousandsSeparator();
18 |         $decimalSeparator = StringHelper::getDecimalSeparator();
19 |         if ($thousandsSeparator !== ',' || $decimalSeparator !== '.') {
20 |             $value = str_replace(['.', ',', "\u{fffd}"], ["\u{fffd}", $thousandsSeparator, $decimalSeparator], $value);
21 |         }
22 | 
23 |         return $value;
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/PercentageFormatter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
 6 | 
 7 | class PercentageFormatter extends BaseFormatter
 8 | {
 9 |     /** @param float|int $value */
10 |     public static function format($value, string $format): string
11 |     {
12 |         if ($format === NumberFormat::FORMAT_PERCENTAGE) {
13 |             return round((100 * $value), 0) . '%';
14 |         }
15 | 
16 |         $value *= 100;
17 |         $format = self::stripQuotes($format);
18 | 
19 |         [, $vDecimals] = explode('.', ((string) $value) . '.');
20 |         $vDecimalCount = strlen(rtrim($vDecimals, '0'));
21 | 
22 |         $format = str_replace('%', '%%', $format);
23 |         $wholePartSize = strlen((string) floor(abs($value)));
24 |         $decimalPartSize = 0;
25 |         $placeHolders = '';
26 |         // Number of decimals
27 |         if (preg_match('/\.([?0]+)/u', $format, $matches)) {
28 |             $decimalPartSize = strlen($matches[1]);
29 |             $vMinDecimalCount = strlen(rtrim($matches[1], '?'));
30 |             $decimalPartSize = min(max($vMinDecimalCount, $vDecimalCount), $decimalPartSize);
31 |             $placeHolders = str_repeat(' ', strlen($matches[1]) - $decimalPartSize);
32 |         }
33 |         // Number of digits to display before the decimal
34 |         if (preg_match('/([#0,]+)\.?/u', $format, $matches)) {
35 |             $firstZero = preg_replace('/^[#,]*/', '', $matches[1]) ?? '';
36 |             $wholePartSize = max($wholePartSize, strlen($firstZero));
37 |         }
38 | 
39 |         $wholePartSize += $decimalPartSize + (int) ($decimalPartSize > 0);
40 |         $replacement = "0{$wholePartSize}.{$decimalPartSize}";
41 |         $mask = (string) preg_replace('/[#0,]+\.?[?#0,]*/ui', "%{$replacement}F{$placeHolders}", $format);
42 | 
43 |         /** @var float $valueFloat */
44 |         $valueFloat = $value;
45 | 
46 |         return self::adjustSeparators(sprintf($mask, round($valueFloat, $decimalPartSize)));
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Accounting.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use NumberFormatter;
 6 | use PhpOffice\PhpSpreadsheet\Exception;
 7 | 
 8 | class Accounting extends CurrencyBase
 9 | {
10 |     protected ?bool $overrideSpacing = true;
11 | 
12 |     protected ?CurrencyNegative $overrideNegative = CurrencyNegative::parentheses;
13 | 
14 |     /**
15 |      * @throws Exception if the Intl extension and ICU version don't support Accounting formats
16 |      */
17 |     protected function getLocaleFormat(): string
18 |     {
19 |         if (self::icuVersion() < 53.0) {
20 |             // @codeCoverageIgnoreStart
21 |             throw new Exception('The Intl extension does not support Accounting Formats without ICU 53');
22 |             // @codeCoverageIgnoreEnd
23 |         }
24 | 
25 |         // Scrutinizer does not recognize CURRENCY_ACCOUNTING
26 |         $formatter = new Locale($this->fullLocale, NumberFormatter::CURRENCY_ACCOUNTING);
27 |         $mask = $formatter->format($this->stripLeadingRLM);
28 |         if ($this->decimals === 0) {
29 |             $mask = (string) preg_replace('/\.0+/miu', '', $mask);
30 |         }
31 | 
32 |         return str_replace('¤', $this->formatCurrencyCode(), $mask);
33 |     }
34 | 
35 |     public static function icuVersion(): float
36 |     {
37 |         [$major, $minor] = explode('.', INTL_ICU_VERSION);
38 | 
39 |         return (float) "{$major}.{$minor}";
40 |     }
41 | 
42 |     private function formatCurrencyCode(): string
43 |     {
44 |         if ($this->locale === null) {
45 |             return $this->currencyCode . '*';
46 |         }
47 | 
48 |         return "[\${$this->currencyCode}-{$this->locale}]";
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Currency.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | class Currency extends CurrencyBase
 6 | {
 7 |     protected ?bool $overrideSpacing = false;
 8 | 
 9 |     protected ?CurrencyNegative $overrideNegative = null;
10 | }
11 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/CurrencyNegative.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | enum CurrencyNegative
 6 | {
 7 |     case minus;
 8 |     case redMinus;
 9 |     case parentheses;
10 |     case redParentheses;
11 | 
12 |     public function start(): string
13 |     {
14 |         return match ($this) {
15 |             self::minus, self::redMinus => '-',
16 |             self::parentheses, self::redParentheses => '\(',
17 |         };
18 |     }
19 | 
20 |     public function end(): string
21 |     {
22 |         return match ($this) {
23 |             self::minus, self::redMinus => '',
24 |             self::parentheses, self::redParentheses => '\)',
25 |         };
26 |     }
27 | 
28 |     public function color(): string
29 |     {
30 |         return match ($this) {
31 |             self::redParentheses, self::redMinus => '[Red]',
32 |             self::parentheses, self::minus => '',
33 |         };
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/DateTime.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | class DateTime extends DateTimeWizard
 6 | {
 7 |     /**
 8 |      * @var string[]
 9 |      */
10 |     protected array $separators;
11 | 
12 |     /**
13 |      * @var array<DateTimeWizard|string>
14 |      */
15 |     protected array $formatBlocks;
16 | 
17 |     /**
18 |      * @param null|string|string[] $separators
19 |      *          If you want to use only a single format block, then pass a null as the separator argument
20 |      * @param DateTimeWizard|string ...$formatBlocks
21 |      */
22 |     public function __construct($separators, ...$formatBlocks)
23 |     {
24 |         $this->separators = $this->padSeparatorArray(
25 |             is_array($separators) ? $separators : [$separators], //* @phpstan-ignore-line
26 |             count($formatBlocks) - 1
27 |         );
28 |         $this->formatBlocks = array_map([$this, 'mapFormatBlocks'], $formatBlocks);
29 |     }
30 | 
31 |     private function mapFormatBlocks(DateTimeWizard|string $value): string
32 |     {
33 |         // Any date masking codes are returned as lower case values
34 |         if ($value instanceof DateTimeWizard) {
35 |             return $value->__toString();
36 |         }
37 | 
38 |         // Wrap any string literals in quotes, so that they're clearly defined as string literals
39 |         return $this->wrapLiteral($value);
40 |     }
41 | 
42 |     public function format(): string
43 |     {
44 |         return implode('', array_map([$this, 'intersperse'], $this->formatBlocks, $this->separators));
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/DateTimeWizard.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use Stringable;
 6 | 
 7 | abstract class DateTimeWizard implements Stringable, Wizard
 8 | {
 9 |     protected const NO_ESCAPING_NEEDED = "$+-/():!^&'~{}<>= ";
10 | 
11 |     /**
12 |      * @param string[] $separators
13 |      *
14 |      * @return string[]
15 |      */
16 |     protected function padSeparatorArray(array $separators, int $count): array
17 |     {
18 |         $lastSeparator = (string) array_pop($separators);
19 | 
20 |         return $separators + array_fill(0, $count, $lastSeparator);
21 |     }
22 | 
23 |     protected function escapeSingleCharacter(string $value): string
24 |     {
25 |         if (str_contains(self::NO_ESCAPING_NEEDED, $value)) {
26 |             return $value;
27 |         }
28 | 
29 |         return "\\{$value}";
30 |     }
31 | 
32 |     protected function wrapLiteral(string $value): string
33 |     {
34 |         if (mb_strlen($value, 'UTF-8') === 1) {
35 |             return $this->escapeSingleCharacter($value);
36 |         }
37 | 
38 |         // Wrap any other string literals in quotes, so that they're clearly defined as string literals
39 |         return '"' . str_replace('"', '""', $value) . '"';
40 |     }
41 | 
42 |     protected function intersperse(string $formatBlock, ?string $separator): string
43 |     {
44 |         return "{$formatBlock}{$separator}";
45 |     }
46 | 
47 |     public function __toString(): string
48 |     {
49 |         return $this->format();
50 |     }
51 | }
52 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Locale.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use NumberFormatter;
 6 | use PhpOffice\PhpSpreadsheet\Exception;
 7 | 
 8 | final class Locale
 9 | {
10 |     /**
11 |      * Language code: ISO-639 2 character, alpha.
12 |      * Optional script code: ISO-15924 4 alpha.
13 |      * Optional country code: ISO-3166-1, 2 character alpha.
14 |      * Separated by underscores or dashes.
15 |      */
16 |     public const STRUCTURE = '/^(?P<language>[a-z]{2})([-_](?P<script>[a-z]{4}))?([-_](?P<country>[a-z]{2}))?$/i';
17 | 
18 |     private NumberFormatter $formatter;
19 | 
20 |     public function __construct(?string $locale, int $style)
21 |     {
22 |         if (class_exists(NumberFormatter::class) === false) {
23 |             throw new Exception();
24 |         }
25 | 
26 |         $formatterLocale = str_replace('-', '_', $locale ?? '');
27 |         $this->formatter = new NumberFormatter($formatterLocale, $style);
28 |         if ($this->formatter->getLocale() !== $formatterLocale) {
29 |             throw new Exception("Unable to read locale data for '{$locale}'");
30 |         }
31 |     }
32 | 
33 |     public function format(bool $stripRlm = true): string
34 |     {
35 |         $str = $this->formatter->getPattern();
36 | 
37 |         return ($stripRlm && str_starts_with($str, "\xe2\x80\x8f")) ? substr($str, 3) : $str;
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Number.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception;
 6 | 
 7 | class Number extends NumberBase implements Wizard
 8 | {
 9 |     public const WITH_THOUSANDS_SEPARATOR = true;
10 | 
11 |     public const WITHOUT_THOUSANDS_SEPARATOR = false;
12 | 
13 |     protected bool $thousandsSeparator = true;
14 | 
15 |     /**
16 |      * @param int $decimals number of decimal places to display, in the range 0-30
17 |      * @param bool $thousandsSeparator indicator whether the thousands separator should be used, or not
18 |      * @param ?string $locale Set the locale for the number format; or leave as the default null.
19 |      *          Locale has no effect for Number Format values, and is retained here only for compatibility
20 |      *              with the other Wizards.
21 |      *          If provided, Locale values must be a valid formatted locale string (e.g. 'en-GB', 'fr', uz-Arab-AF).
22 |      *
23 |      * @throws Exception If a provided locale code is not a valid format
24 |      */
25 |     public function __construct(
26 |         int $decimals = 2,
27 |         bool $thousandsSeparator = self::WITH_THOUSANDS_SEPARATOR,
28 |         ?string $locale = null
29 |     ) {
30 |         $this->setDecimals($decimals);
31 |         $this->setThousandsSeparator($thousandsSeparator);
32 |         $this->setLocale($locale);
33 |     }
34 | 
35 |     public function setThousandsSeparator(bool $thousandsSeparator = self::WITH_THOUSANDS_SEPARATOR): void
36 |     {
37 |         $this->thousandsSeparator = $thousandsSeparator;
38 |     }
39 | 
40 |     /**
41 |      * As MS Excel cannot easily handle Lakh, which is the only locale-specific Number format variant,
42 |      *       we don't use locale with Numbers.
43 |      */
44 |     protected function getLocaleFormat(): string
45 |     {
46 |         return $this->format();
47 |     }
48 | 
49 |     public function format(): string
50 |     {
51 |         return sprintf(
52 |             '%s0%s',
53 |             $this->thousandsSeparator ? '#,##' : null,
54 |             $this->decimals > 0 ? '.' . str_repeat('0', $this->decimals) : null
55 |         );
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Percentage.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use NumberFormatter;
 6 | use PhpOffice\PhpSpreadsheet\Exception;
 7 | 
 8 | class Percentage extends NumberBase implements Wizard
 9 | {
10 |     /**
11 |      * @param int $decimals number of decimal places to display, in the range 0-30
12 |      * @param ?string $locale Set the locale for the percentage format; or leave as the default null.
13 |      *          If provided, Locale values must be a valid formatted locale string (e.g. 'en-GB', 'fr', uz-Arab-AF).
14 |      *
15 |      * @throws Exception If a provided locale code is not a valid format
16 |      */
17 |     public function __construct(int $decimals = 2, ?string $locale = null)
18 |     {
19 |         $this->setDecimals($decimals);
20 |         $this->setLocale($locale);
21 |     }
22 | 
23 |     protected function getLocaleFormat(): string
24 |     {
25 |         $formatter = new Locale($this->fullLocale, NumberFormatter::PERCENT);
26 | 
27 |         return $this->decimals > 0
28 |             ? str_replace('0', '0.' . str_repeat('0', $this->decimals), $formatter->format())
29 |             : $formatter->format();
30 |     }
31 | 
32 |     public function format(): string
33 |     {
34 |         if ($this->localeFormat !== null) {
35 |             return $this->localeFormat;
36 |         }
37 | 
38 |         return sprintf('0%s%%', $this->decimals > 0 ? '.' . str_repeat('0', $this->decimals) : null);
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Scientific.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception;
 6 | 
 7 | class Scientific extends NumberBase implements Wizard
 8 | {
 9 |     /**
10 |      * @param int $decimals number of decimal places to display, in the range 0-30
11 |      * @param ?string $locale Set the locale for the scientific format; or leave as the default null.
12 |      *          Locale has no effect for Scientific Format values, and is retained here for compatibility
13 |      *              with the other Wizards.
14 |      *          If provided, Locale values must be a valid formatted locale string (e.g. 'en-GB', 'fr', uz-Arab-AF).
15 |      *
16 |      * @throws Exception If a provided locale code is not a valid format
17 |      */
18 |     public function __construct(int $decimals = 2, ?string $locale = null)
19 |     {
20 |         $this->setDecimals($decimals);
21 |         $this->setLocale($locale);
22 |     }
23 | 
24 |     protected function getLocaleFormat(): string
25 |     {
26 |         return $this->format();
27 |     }
28 | 
29 |     public function format(): string
30 |     {
31 |         return sprintf('0%sE+00', $this->decimals > 0 ? '.' . str_repeat('0', $this->decimals) : null);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Wizard.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
4 | 
5 | interface Wizard
6 | {
7 |     public function format(): string;
8 | }
9 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/AutoFit.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\CellAddress;
 6 | use PhpOffice\PhpSpreadsheet\Cell\CellRange;
 7 | use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
 8 | 
 9 | class AutoFit
10 | {
11 |     protected Worksheet $worksheet;
12 | 
13 |     public function __construct(Worksheet $worksheet)
14 |     {
15 |         $this->worksheet = $worksheet;
16 |     }
17 | 
18 |     /** @return mixed[] */
19 |     public function getAutoFilterIndentRanges(): array
20 |     {
21 |         $autoFilterIndentRanges = [];
22 |         $autoFilterIndentRanges[] = $this->getAutoFilterIndentRange($this->worksheet->getAutoFilter());
23 | 
24 |         foreach ($this->worksheet->getTableCollection() as $table) {
25 |             if ($table->getShowHeaderRow() === true && $table->getAllowFilter() === true) {
26 |                 $autoFilter = $table->getAutoFilter();
27 |                 $autoFilterIndentRanges[] = $this->getAutoFilterIndentRange($autoFilter);
28 |             }
29 |         }
30 | 
31 |         return array_filter($autoFilterIndentRanges);
32 |     }
33 | 
34 |     private function getAutoFilterIndentRange(AutoFilter $autoFilter): ?string
35 |     {
36 |         $autoFilterRange = $autoFilter->getRange();
37 |         $autoFilterIndentRange = null;
38 | 
39 |         if (!empty($autoFilterRange)) {
40 |             $autoFilterRangeBoundaries = Coordinate::rangeBoundaries($autoFilterRange);
41 |             $autoFilterIndentRange = (string) new CellRange(
42 |                 CellAddress::fromColumnAndRow($autoFilterRangeBoundaries[0][0], $autoFilterRangeBoundaries[0][1]),
43 |                 CellAddress::fromColumnAndRow($autoFilterRangeBoundaries[1][0], $autoFilterRangeBoundaries[0][1])
44 |             );
45 |         }
46 | 
47 |         return $autoFilterIndentRange;
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/CellIterator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | use Iterator as NativeIterator;
 6 | use PhpOffice\PhpSpreadsheet\Cell\Cell;
 7 | use PhpOffice\PhpSpreadsheet\Collection\Cells;
 8 | 
 9 | /**
10 |  * @template TKey
11 |  *
12 |  * @implements NativeIterator<TKey, Cell>
13 |  */
14 | abstract class CellIterator implements NativeIterator
15 | {
16 |     public const TREAT_NULL_VALUE_AS_EMPTY_CELL = 1;
17 | 
18 |     public const TREAT_EMPTY_STRING_AS_EMPTY_CELL = 2;
19 | 
20 |     public const IF_NOT_EXISTS_RETURN_NULL = false;
21 | 
22 |     public const IF_NOT_EXISTS_CREATE_NEW = true;
23 | 
24 |     /**
25 |      * Worksheet to iterate.
26 |      */
27 |     protected Worksheet $worksheet;
28 | 
29 |     /**
30 |      * Cell Collection to iterate.
31 |      */
32 |     protected Cells $cellCollection;
33 | 
34 |     /**
35 |      * Iterate only existing cells.
36 |      */
37 |     protected bool $onlyExistingCells = false;
38 | 
39 |     /**
40 |      * If iterating all cells, and a cell doesn't exist, identifies whether a new cell should be created,
41 |      *    or if the iterator should return a null value.
42 |      */
43 |     protected bool $ifNotExists = self::IF_NOT_EXISTS_CREATE_NEW;
44 | 
45 |     /**
46 |      * Destructor.
47 |      */
48 |     public function __destruct()
49 |     {
50 |         unset($this->worksheet, $this->cellCollection);
51 |     }
52 | 
53 |     public function getIfNotExists(): bool
54 |     {
55 |         return $this->ifNotExists;
56 |     }
57 | 
58 |     public function setIfNotExists(bool $ifNotExists = self::IF_NOT_EXISTS_CREATE_NEW): void
59 |     {
60 |         $this->ifNotExists = $ifNotExists;
61 |     }
62 | 
63 |     /**
64 |      * Get loop only existing cells.
65 |      */
66 |     public function getIterateOnlyExistingCells(): bool
67 |     {
68 |         return $this->onlyExistingCells;
69 |     }
70 | 
71 |     /**
72 |      * Validate start/end values for 'IterateOnlyExistingCells' mode, and adjust if necessary.
73 |      */
74 |     abstract protected function adjustForExistingOnlyRange(): void;
75 | 
76 |     /**
77 |      * Set the iterator to loop only existing cells.
78 |      */
79 |     public function setIterateOnlyExistingCells(bool $value): void
80 |     {
81 |         $this->onlyExistingCells = (bool) $value;
82 | 
83 |         $this->adjustForExistingOnlyRange();
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/HeaderFooterDrawing.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | class HeaderFooterDrawing extends Drawing
 6 | {
 7 |     /**
 8 |      * Get hash code.
 9 |      *
10 |      * @return string Hash code
11 |      */
12 |     public function getHashCode(): string
13 |     {
14 |         return md5(
15 |             $this->getPath()
16 |             . $this->name
17 |             . $this->offsetX
18 |             . $this->offsetY
19 |             . $this->width
20 |             . $this->height
21 |             . __CLASS__
22 |         );
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/Iterator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Spreadsheet;
 6 | 
 7 | /**
 8 |  * @implements \Iterator<int, Worksheet>
 9 |  */
10 | class Iterator implements \Iterator
11 | {
12 |     /**
13 |      * Spreadsheet to iterate.
14 |      */
15 |     private Spreadsheet $subject;
16 | 
17 |     /**
18 |      * Current iterator position.
19 |      */
20 |     private int $position = 0;
21 | 
22 |     /**
23 |      * Create a new worksheet iterator.
24 |      */
25 |     public function __construct(Spreadsheet $subject)
26 |     {
27 |         // Set subject
28 |         $this->subject = $subject;
29 |     }
30 | 
31 |     /**
32 |      * Rewind iterator.
33 |      */
34 |     public function rewind(): void
35 |     {
36 |         $this->position = 0;
37 |     }
38 | 
39 |     /**
40 |      * Current Worksheet.
41 |      */
42 |     public function current(): Worksheet
43 |     {
44 |         return $this->subject->getSheet($this->position);
45 |     }
46 | 
47 |     /**
48 |      * Current key.
49 |      */
50 |     public function key(): int
51 |     {
52 |         return $this->position;
53 |     }
54 | 
55 |     /**
56 |      * Next value.
57 |      */
58 |     public function next(): void
59 |     {
60 |         ++$this->position;
61 |     }
62 | 
63 |     /**
64 |      * Are there more Worksheet instances available?
65 |      */
66 |     public function valid(): bool
67 |     {
68 |         return $this->position < $this->subject->getSheetCount() && $this->position >= 0;
69 |     }
70 | }
71 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/PageBreak.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 6 | use PhpOffice\PhpSpreadsheet\Cell\CellAddress;
 7 | use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
 8 | 
 9 | class PageBreak
10 | {
11 |     private int $breakType;
12 | 
13 |     private string $coordinate;
14 | 
15 |     private int $maxColOrRow;
16 | 
17 |     /**
18 |      * @param array{0: int, 1: int}|CellAddress|string $coordinate
19 |      */
20 |     public function __construct(int $breakType, CellAddress|string|array $coordinate, int $maxColOrRow = -1)
21 |     {
22 |         $coordinate = Functions::trimSheetFromCellReference(Validations::validateCellAddress($coordinate));
23 |         $this->breakType = $breakType;
24 |         $this->coordinate = $coordinate;
25 |         $this->maxColOrRow = $maxColOrRow;
26 |     }
27 | 
28 |     public function getBreakType(): int
29 |     {
30 |         return $this->breakType;
31 |     }
32 | 
33 |     public function getCoordinate(): string
34 |     {
35 |         return $this->coordinate;
36 |     }
37 | 
38 |     public function getMaxColOrRow(): int
39 |     {
40 |         return $this->maxColOrRow;
41 |     }
42 | 
43 |     public function getColumnInt(): int
44 |     {
45 |         return Coordinate::indexesFromString($this->coordinate)[0];
46 |     }
47 | 
48 |     public function getRow(): int
49 |     {
50 |         return Coordinate::indexesFromString($this->coordinate)[1];
51 |     }
52 | 
53 |     public function getColumnString(): string
54 |     {
55 |         return Coordinate::indexesFromString($this->coordinate)[2];
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/Pane.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | class Pane
 6 | {
 7 |     private string $sqref;
 8 | 
 9 |     private string $activeCell;
10 | 
11 |     private string $position;
12 | 
13 |     public function __construct(string $position, string $sqref = '', string $activeCell = '')
14 |     {
15 |         $this->sqref = $sqref;
16 |         $this->activeCell = $activeCell;
17 |         $this->position = $position;
18 |     }
19 | 
20 |     public function getPosition(): string
21 |     {
22 |         return $this->position;
23 |     }
24 | 
25 |     public function getSqref(): string
26 |     {
27 |         return $this->sqref;
28 |     }
29 | 
30 |     public function setSqref(string $sqref): self
31 |     {
32 |         $this->sqref = $sqref;
33 | 
34 |         return $this;
35 |     }
36 | 
37 |     public function getActiveCell(): string
38 |     {
39 |         return $this->activeCell;
40 |     }
41 | 
42 |     public function setActiveCell(string $activeCell): self
43 |     {
44 |         $this->activeCell = $activeCell;
45 | 
46 |         return $this;
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Worksheet/ProtectedRange.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Worksheet;
 4 | 
 5 | class ProtectedRange
 6 | {
 7 |     private string $name = '';
 8 | 
 9 |     private string $password = '';
10 | 
11 |     private string $sqref;
12 | 
13 |     private string $securityDescriptor = '';
14 | 
15 |     /**
16 |      * No setters aside from constructor.
17 |      */
18 |     public function __construct(string $sqref, string $password = '', string $name = '', string $securityDescriptor = '')
19 |     {
20 |         $this->sqref = $sqref;
21 |         $this->name = $name;
22 |         $this->password = $password;
23 |         $this->securityDescriptor = $securityDescriptor;
24 |     }
25 | 
26 |     public function getSqref(): string
27 |     {
28 |         return $this->sqref;
29 |     }
30 | 
31 |     public function getName(): string
32 |     {
33 |         return $this->name ?: ('p' . md5($this->sqref));
34 |     }
35 | 
36 |     public function getPassword(): string
37 |     {
38 |         return $this->password;
39 |     }
40 | 
41 |     public function getSecurityDescriptor(): string
42 |     {
43 |         return $this->securityDescriptor;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Exception.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
 6 | 
 7 | class Exception extends PhpSpreadsheetException
 8 | {
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Ods/AutoFilters.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
 6 | use PhpOffice\PhpSpreadsheet\Spreadsheet;
 7 | use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter;
 8 | use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
 9 | 
10 | class AutoFilters
11 | {
12 |     private XMLWriter $objWriter;
13 | 
14 |     private Spreadsheet $spreadsheet;
15 | 
16 |     public function __construct(XMLWriter $objWriter, Spreadsheet $spreadsheet)
17 |     {
18 |         $this->objWriter = $objWriter;
19 |         $this->spreadsheet = $spreadsheet;
20 |     }
21 | 
22 |     public function write(): void
23 |     {
24 |         $wrapperWritten = false;
25 |         $sheetCount = $this->spreadsheet->getSheetCount();
26 |         for ($i = 0; $i < $sheetCount; ++$i) {
27 |             $worksheet = $this->spreadsheet->getSheet($i);
28 |             $autofilter = $worksheet->getAutoFilter();
29 |             if (!empty($autofilter->getRange())) {
30 |                 if ($wrapperWritten === false) {
31 |                     $this->objWriter->startElement('table:database-ranges');
32 |                     $wrapperWritten = true;
33 |                 }
34 |                 $this->objWriter->startElement('table:database-range');
35 |                 $this->objWriter->writeAttribute('table:orientation', 'column');
36 |                 $this->objWriter->writeAttribute('table:display-filter-buttons', 'true');
37 |                 $this->objWriter->writeAttribute(
38 |                     'table:target-range-address',
39 |                     $this->formatRange($worksheet, $autofilter)
40 |                 );
41 |                 $this->objWriter->endElement();
42 |             }
43 |         }
44 | 
45 |         if ($wrapperWritten === true) {
46 |             $this->objWriter->endElement();
47 |         }
48 |     }
49 | 
50 |     protected function formatRange(Worksheet $worksheet, AutoFilter $autofilter): string
51 |     {
52 |         $title = $worksheet->getTitle();
53 |         $range = $autofilter->getRange();
54 | 
55 |         return "'{$title}'.{$range}";
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Ods/Cell/Comment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Ods\Cell;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Cell\Cell;
 6 | use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
 7 | 
 8 | /**
 9 |  * @author     Alexander Pervakov <frost-nzcr4@jagmort.com>
10 |  */
11 | class Comment
12 | {
13 |     public static function write(XMLWriter $objWriter, Cell $cell): void
14 |     {
15 |         $comments = $cell->getWorksheet()->getComments();
16 |         if (!isset($comments[$cell->getCoordinate()])) {
17 |             return;
18 |         }
19 |         $comment = $comments[$cell->getCoordinate()];
20 | 
21 |         $objWriter->startElement('office:annotation');
22 |         $objWriter->writeAttribute('svg:width', $comment->getWidth());
23 |         $objWriter->writeAttribute('svg:height', $comment->getHeight());
24 |         $objWriter->writeAttribute('svg:x', $comment->getMarginLeft());
25 |         $objWriter->writeAttribute('svg:y', $comment->getMarginTop());
26 |         $objWriter->writeElement('dc:creator', $comment->getAuthor());
27 | 
28 |         $objWriter->startElement('text:p');
29 |         $text = $comment->getText()->getPlainText();
30 |         $textElements = explode("\n", $text);
31 |         $newLineOwed = false;
32 |         foreach ($textElements as $textSegment) {
33 |             if ($newLineOwed) {
34 |                 $objWriter->writeElement('text:line-break');
35 |             }
36 |             $newLineOwed = true;
37 |             if ($textSegment !== '') {
38 |                 $objWriter->writeElement('text:span', $textSegment);
39 |             }
40 |         }
41 |         $objWriter->endElement(); // text:p
42 | 
43 |         $objWriter->endElement();
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Ods/Mimetype.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
 4 | 
 5 | class Mimetype extends WriterPart
 6 | {
 7 |     /**
 8 |      * Write mimetype to plain text format.
 9 |      *
10 |      * @return string XML Output
11 |      */
12 |     public function write(): string
13 |     {
14 |         return 'application/vnd.oasis.opendocument.spreadsheet';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Ods/Thumbnails.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
 4 | 
 5 | class Thumbnails extends WriterPart
 6 | {
 7 |     /**
 8 |      * Write Thumbnails/thumbnail.png to PNG format.
 9 |      *
10 |      * @return string XML Output
11 |      */
12 |     public function write(): string
13 |     {
14 |         return '';
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Ods/WriterPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Writer\Ods;
 6 | 
 7 | abstract class WriterPart
 8 | {
 9 |     /**
10 |      * Parent Ods object.
11 |      */
12 |     private Ods $parentWriter;
13 | 
14 |     /**
15 |      * Get Ods writer.
16 |      */
17 |     public function getParentWriter(): Ods
18 |     {
19 |         return $this->parentWriter;
20 |     }
21 | 
22 |     /**
23 |      * Set parent Ods writer.
24 |      */
25 |     public function __construct(Ods $writer)
26 |     {
27 |         $this->parentWriter = $writer;
28 |     }
29 | 
30 |     abstract public function write(): string;
31 | }
32 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Pdf/Dompdf.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Pdf;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
 6 | use PhpOffice\PhpSpreadsheet\Writer\Pdf;
 7 | 
 8 | class Dompdf extends Pdf
 9 | {
10 |     /**
11 |      * embed images, or link to images.
12 |      */
13 |     protected bool $embedImages = true;
14 | 
15 |     /**
16 |      * Gets the implementation of external PDF library that should be used.
17 |      *
18 |      * @return \Dompdf\Dompdf implementation
19 |      */
20 |     protected function createExternalWriterInstance(): \Dompdf\Dompdf
21 |     {
22 |         return new \Dompdf\Dompdf();
23 |     }
24 | 
25 |     /**
26 |      * Save Spreadsheet to file.
27 |      *
28 |      * @param string $filename Name of the file to save as
29 |      */
30 |     public function save($filename, int $flags = 0): void
31 |     {
32 |         $fileHandle = parent::prepareForSave($filename);
33 | 
34 |         //  Check for paper size and page orientation
35 |         $setup = $this->spreadsheet->getSheet($this->getSheetIndex() ?? 0)->getPageSetup();
36 |         $orientation = $this->getOrientation() ?? $setup->getOrientation();
37 |         $orientation = ($orientation === PageSetup::ORIENTATION_LANDSCAPE) ? 'L' : 'P';
38 |         $printPaperSize = $this->getPaperSize() ?? $setup->getPaperSize();
39 |         $paperSize = self::$paperSizes[$printPaperSize] ?? self::$paperSizes[PageSetup::getPaperSizeDefault()] ?? 'LETTER';
40 |         if (is_array($paperSize) && count($paperSize) === 2) {
41 |             $paperSize = [0.0, 0.0, $paperSize[0], $paperSize[1]];
42 |         }
43 | 
44 |         $orientation = ($orientation == 'L') ? 'landscape' : 'portrait';
45 | 
46 |         //  Create PDF
47 |         $pdf = $this->createExternalWriterInstance();
48 |         $pdf->setPaper($paperSize, $orientation);
49 | 
50 |         $pdf->loadHtml($this->generateHTMLAll());
51 |         $pdf->render();
52 | 
53 |         //  Write to file
54 |         fwrite($fileHandle, $pdf->output() ?? '');
55 | 
56 |         parent::restoreStateAfterSave();
57 |     }
58 | }
59 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xls/ConditionalHelper.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xls;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
 6 | use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
 7 | use PhpOffice\PhpSpreadsheet\Style\ConditionalFormatting\Wizard;
 8 | 
 9 | class ConditionalHelper
10 | {
11 |     /**
12 |      * Formula parser.
13 |      */
14 |     protected Parser $parser;
15 | 
16 |     protected mixed $condition;
17 | 
18 |     protected string $cellRange;
19 | 
20 |     protected ?string $tokens = null;
21 | 
22 |     protected int $size;
23 | 
24 |     public function __construct(Parser $parser)
25 |     {
26 |         $this->parser = $parser;
27 |     }
28 | 
29 |     public function processCondition(mixed $condition, string $cellRange): void
30 |     {
31 |         $this->condition = $condition;
32 |         $this->cellRange = $cellRange;
33 | 
34 |         if (is_int($condition) && $condition >= 0 && $condition <= 65535) {
35 |             $this->size = 3;
36 |             $this->tokens = pack('Cv', 0x1E, $condition);
37 |         } else {
38 |             try {
39 |                 $formula = Wizard\WizardAbstract::reverseAdjustCellRef(StringHelper::convertToString($condition), $cellRange);
40 |                 $this->parser->parse($formula);
41 |                 $this->tokens = $this->parser->toReversePolish();
42 |                 $this->size = strlen($this->tokens ?? '');
43 |             } catch (PhpSpreadsheetException) {
44 |                 // In the event of a parser error with a formula value, we set the expression to ptgInt + 0
45 |                 $this->tokens = pack('Cv', 0x1E, 0);
46 |                 $this->size = 3;
47 |             }
48 |         }
49 |     }
50 | 
51 |     public function tokens(): ?string
52 |     {
53 |         return $this->tokens;
54 |     }
55 | 
56 |     public function size(): int
57 |     {
58 |         return $this->size;
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xls/ErrorCode.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xls;
 4 | 
 5 | class ErrorCode
 6 | {
 7 |     /**
 8 |      * @var array<string, int>
 9 |      */
10 |     protected static array $errorCodeMap = [
11 |         '#NULL!' => 0x00,
12 |         '#DIV/0!' => 0x07,
13 |         '#VALUE!' => 0x0F,
14 |         '#REF!' => 0x17,
15 |         '#NAME?' => 0x1D,
16 |         '#NUM!' => 0x24,
17 |         '#N/A' => 0x2A,
18 |     ];
19 | 
20 |     public static function error(string $errorCode): int
21 |     {
22 |         if (array_key_exists($errorCode, self::$errorCodeMap)) {
23 |             return self::$errorCodeMap[$errorCode];
24 |         }
25 | 
26 |         return 0;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xls/Style/CellAlignment.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Alignment;
 6 | 
 7 | class CellAlignment
 8 | {
 9 |     /**
10 |      * @var array<string, int>
11 |      */
12 |     private static array $horizontalMap = [
13 |         Alignment::HORIZONTAL_GENERAL => 0,
14 |         Alignment::HORIZONTAL_LEFT => 1,
15 |         Alignment::HORIZONTAL_RIGHT => 3,
16 |         Alignment::HORIZONTAL_CENTER => 2,
17 |         Alignment::HORIZONTAL_CENTER_CONTINUOUS => 6,
18 |         Alignment::HORIZONTAL_JUSTIFY => 5,
19 |     ];
20 | 
21 |     /**
22 |      * @var array<string, int>
23 |      */
24 |     private static array $verticalMap = [
25 |         Alignment::VERTICAL_BOTTOM => 2,
26 |         Alignment::VERTICAL_TOP => 0,
27 |         Alignment::VERTICAL_CENTER => 1,
28 |         Alignment::VERTICAL_JUSTIFY => 3,
29 |     ];
30 | 
31 |     public static function horizontal(Alignment $alignment): int
32 |     {
33 |         $horizontalAlignment = $alignment->getHorizontal();
34 | 
35 |         if (is_string($horizontalAlignment) && array_key_exists($horizontalAlignment, self::$horizontalMap)) {
36 |             return self::$horizontalMap[$horizontalAlignment];
37 |         }
38 | 
39 |         return self::$horizontalMap[Alignment::HORIZONTAL_GENERAL];
40 |     }
41 | 
42 |     public static function wrap(Alignment $alignment): int
43 |     {
44 |         $wrap = $alignment->getWrapText();
45 | 
46 |         return ($wrap === true) ? 1 : 0;
47 |     }
48 | 
49 |     public static function vertical(Alignment $alignment): int
50 |     {
51 |         $verticalAlignment = $alignment->getVertical();
52 | 
53 |         if (is_string($verticalAlignment) && array_key_exists($verticalAlignment, self::$verticalMap)) {
54 |             return self::$verticalMap[$verticalAlignment];
55 |         }
56 | 
57 |         return self::$verticalMap[Alignment::VERTICAL_BOTTOM];
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xls/Style/CellBorder.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Border;
 6 | 
 7 | class CellBorder
 8 | {
 9 |     /**
10 |      * @var array<string, int>
11 |      */
12 |     protected static array $styleMap = [
13 |         Border::BORDER_NONE => 0x00,
14 |         Border::BORDER_THIN => 0x01,
15 |         Border::BORDER_MEDIUM => 0x02,
16 |         Border::BORDER_DASHED => 0x03,
17 |         Border::BORDER_DOTTED => 0x04,
18 |         Border::BORDER_THICK => 0x05,
19 |         Border::BORDER_DOUBLE => 0x06,
20 |         Border::BORDER_HAIR => 0x07,
21 |         Border::BORDER_MEDIUMDASHED => 0x08,
22 |         Border::BORDER_DASHDOT => 0x09,
23 |         Border::BORDER_MEDIUMDASHDOT => 0x0A,
24 |         Border::BORDER_DASHDOTDOT => 0x0B,
25 |         Border::BORDER_MEDIUMDASHDOTDOT => 0x0C,
26 |         Border::BORDER_SLANTDASHDOT => 0x0D,
27 |         Border::BORDER_OMIT => 0x00,
28 |     ];
29 | 
30 |     public static function style(Border $border): int
31 |     {
32 |         $borderStyle = $border->getBorderStyle();
33 | 
34 |         if (array_key_exists($borderStyle, self::$styleMap)) {
35 |             return self::$styleMap[$borderStyle];
36 |         }
37 | 
38 |         return self::$styleMap[Border::BORDER_NONE];
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xls/Style/CellFill.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xls\Style;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Style\Fill;
 6 | 
 7 | class CellFill
 8 | {
 9 |     /**
10 |      * @var array<string, int>
11 |      */
12 |     protected static array $fillStyleMap = [
13 |         Fill::FILL_NONE => 0x00,
14 |         Fill::FILL_SOLID => 0x01,
15 |         Fill::FILL_PATTERN_MEDIUMGRAY => 0x02,
16 |         Fill::FILL_PATTERN_DARKGRAY => 0x03,
17 |         Fill::FILL_PATTERN_LIGHTGRAY => 0x04,
18 |         Fill::FILL_PATTERN_DARKHORIZONTAL => 0x05,
19 |         Fill::FILL_PATTERN_DARKVERTICAL => 0x06,
20 |         Fill::FILL_PATTERN_DARKDOWN => 0x07,
21 |         Fill::FILL_PATTERN_DARKUP => 0x08,
22 |         Fill::FILL_PATTERN_DARKGRID => 0x09,
23 |         Fill::FILL_PATTERN_DARKTRELLIS => 0x0A,
24 |         Fill::FILL_PATTERN_LIGHTHORIZONTAL => 0x0B,
25 |         Fill::FILL_PATTERN_LIGHTVERTICAL => 0x0C,
26 |         Fill::FILL_PATTERN_LIGHTDOWN => 0x0D,
27 |         Fill::FILL_PATTERN_LIGHTUP => 0x0E,
28 |         Fill::FILL_PATTERN_LIGHTGRID => 0x0F,
29 |         Fill::FILL_PATTERN_LIGHTTRELLIS => 0x10,
30 |         Fill::FILL_PATTERN_GRAY125 => 0x11,
31 |         Fill::FILL_PATTERN_GRAY0625 => 0x12,
32 |         Fill::FILL_GRADIENT_LINEAR => 0x00, // does not exist in BIFF8
33 |         Fill::FILL_GRADIENT_PATH => 0x00,   // does not exist in BIFF8
34 |     ];
35 | 
36 |     public static function style(Fill $fill): int
37 |     {
38 |         $fillStyle = $fill->getFillType();
39 | 
40 |         if (is_string($fillStyle) && array_key_exists($fillStyle, self::$fillStyleMap)) {
41 |             return self::$fillStyleMap[$fillStyle];
42 |         }
43 | 
44 |         return self::$fillStyleMap[Fill::FILL_NONE];
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xlsx/RelsRibbon.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xlsx;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Namespaces;
 6 | use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
 7 | use PhpOffice\PhpSpreadsheet\Spreadsheet;
 8 | 
 9 | class RelsRibbon extends WriterPart
10 | {
11 |     /**
12 |      * Write relationships for additional objects of custom UI (ribbon).
13 |      *
14 |      * @return string XML Output
15 |      */
16 |     public function writeRibbonRelationships(Spreadsheet $spreadsheet): string
17 |     {
18 |         // Create XML writer
19 |         $objWriter = null;
20 |         if ($this->getParentWriter()->getUseDiskCaching()) {
21 |             $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
22 |         } else {
23 |             $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
24 |         }
25 | 
26 |         // XML header
27 |         $objWriter->startDocument('1.0', 'UTF-8', 'yes');
28 | 
29 |         // Relationships
30 |         $objWriter->startElement('Relationships');
31 |         $objWriter->writeAttribute('xmlns', Namespaces::RELATIONSHIPS);
32 |         $localRels = $spreadsheet->getRibbonBinObjects('names');
33 |         if (is_array($localRels)) {
34 |             foreach ($localRels as $aId => $aTarget) {
35 |                 $objWriter->startElement('Relationship');
36 |                 $objWriter->writeAttribute('Id', $aId);
37 |                 $objWriter->writeAttribute('Type', Namespaces::IMAGE);
38 |                 /** @var string $aTarget */
39 |                 $objWriter->writeAttribute('Target', $aTarget);
40 |                 $objWriter->endElement();
41 |             }
42 |         }
43 |         $objWriter->endElement();
44 | 
45 |         return $objWriter->getData();
46 |     }
47 | }
48 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xlsx/RelsVBA.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xlsx;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Namespaces;
 6 | use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
 7 | 
 8 | class RelsVBA extends WriterPart
 9 | {
10 |     /**
11 |      * Write relationships for a signed VBA Project.
12 |      *
13 |      * @return string XML Output
14 |      */
15 |     public function writeVBARelationships(): string
16 |     {
17 |         // Create XML writer
18 |         $objWriter = null;
19 |         if ($this->getParentWriter()->getUseDiskCaching()) {
20 |             $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
21 |         } else {
22 |             $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
23 |         }
24 | 
25 |         // XML header
26 |         $objWriter->startDocument('1.0', 'UTF-8', 'yes');
27 | 
28 |         // Relationships
29 |         $objWriter->startElement('Relationships');
30 |         $objWriter->writeAttribute('xmlns', Namespaces::RELATIONSHIPS);
31 |         $objWriter->startElement('Relationship');
32 |         $objWriter->writeAttribute('Id', 'rId1');
33 |         $objWriter->writeAttribute('Type', Namespaces::VBA_SIGNATURE);
34 |         $objWriter->writeAttribute('Target', 'vbaProjectSignature.bin');
35 |         $objWriter->endElement();
36 |         $objWriter->endElement();
37 | 
38 |         return $objWriter->getData();
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/Xlsx/WriterPart.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer\Xlsx;
 4 | 
 5 | use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
 6 | 
 7 | abstract class WriterPart
 8 | {
 9 |     /**
10 |      * Parent Xlsx object.
11 |      */
12 |     private Xlsx $parentWriter;
13 | 
14 |     /**
15 |      * Get parent Xlsx object.
16 |      */
17 |     public function getParentWriter(): Xlsx
18 |     {
19 |         return $this->parentWriter;
20 |     }
21 | 
22 |     /**
23 |      * Set parent Xlsx object.
24 |      */
25 |     public function __construct(Xlsx $writer)
26 |     {
27 |         $this->parentWriter = $writer;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/ZipStream0.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer;
 4 | 
 5 | use ZipStream\Option\Archive;
 6 | use ZipStream\ZipStream;
 7 | 
 8 | class ZipStream0
 9 | {
10 |     /**
11 |      * @param resource $fileHandle
12 |      */
13 |     public static function newZipStream($fileHandle): ZipStream
14 |     {
15 |         return class_exists(Archive::class) ? ZipStream2::newZipStream($fileHandle) : ZipStream3::newZipStream($fileHandle);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/ZipStream2.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer;
 4 | 
 5 | use ZipStream\Option\Archive;
 6 | use ZipStream\ZipStream;
 7 | 
 8 | /**
 9 |  * Either ZipStream2 or ZipStream3, but not both, may be used.
10 |  * For code coverage testing, it will always be ZipStream3.
11 |  *
12 |  * @codeCoverageIgnore
13 |  */
14 | class ZipStream2
15 | {
16 |     /**
17 |      * @param resource $fileHandle
18 |      */
19 |     public static function newZipStream($fileHandle): ZipStream
20 |     {
21 |         $options = new Archive();
22 |         $options->setEnableZip64(false);
23 |         $options->setOutputStream($fileHandle);
24 | 
25 |         return new ZipStream(null, $options);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/PhpSpreadsheet/Writer/ZipStream3.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace PhpOffice\PhpSpreadsheet\Writer;
 4 | 
 5 | use ZipStream\ZipStream;
 6 | 
 7 | class ZipStream3
 8 | {
 9 |     /**
10 |      * @param resource $fileHandle
11 |      */
12 |     public static function newZipStream($fileHandle): ZipStream
13 |     {
14 |         return new ZipStream(
15 |             enableZip64: false,
16 |             outputStream: $fileHandle,
17 |             sendHttpHeaders: false,
18 |             defaultEnableZeroHeader: false,
19 |         );
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------