Proyectos de Subversion Moodle

<?php

namespace PhpOffice\PhpSpreadsheet\Reader;

use PhpOffice\PhpSpreadsheet\Calculation\Information\ExcelError;

use PhpOffice\PhpSpreadsheet\Cell\Coordinate;

use PhpOffice\PhpSpreadsheet\Cell\DataType;

use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;

use PhpOffice\PhpSpreadsheet\Comment;

use PhpOffice\PhpSpreadsheet\DefinedName;

use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\AutoFilter;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Chart;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\ColumnAndRowAttributes;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\ConditionalStyles;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\DataValidations;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Hyperlinks;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Namespaces;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\PageSetup;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Properties as PropertyReader;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\SharedFormula;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\SheetViewOptions;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\SheetViews;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Styles;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\TableReader;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Theme;

use PhpOffice\PhpSpreadsheet\Reader\Xlsx\WorkbookView;

use PhpOffice\PhpSpreadsheet\ReferenceHelper;

use PhpOffice\PhpSpreadsheet\RichText\RichText;

use PhpOffice\PhpSpreadsheet\Shared\Date;

use PhpOffice\PhpSpreadsheet\Shared\Drawing;

use PhpOffice\PhpSpreadsheet\Shared\File;

use PhpOffice\PhpSpreadsheet\Shared\Font;

use PhpOffice\PhpSpreadsheet\Shared\StringHelper;

use PhpOffice\PhpSpreadsheet\Spreadsheet;

use PhpOffice\PhpSpreadsheet\Style\Color;

use PhpOffice\PhpSpreadsheet\Style\Font as StyleFont;

use PhpOffice\PhpSpreadsheet\Style\NumberFormat;

use PhpOffice\PhpSpreadsheet\Style\Style;

use PhpOffice\PhpSpreadsheet\Worksheet\HeaderFooterDrawing;

use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;

use SimpleXMLElement;

use Stringable;

use Throwable;

use XMLReader;

use ZipArchive;

class Xlsx extends BaseReader

{

    const INITIAL_FILE = '_rels/.rels';

    /**

     * ReferenceHelper instance.

     */

    private ReferenceHelper $referenceHelper;

    private ZipArchive $zip;

    private Styles $styleReader;

    private array $sharedFormulae = [];

    /**

     * Create a new Xlsx Reader instance.

     */

    public function __construct()

    {

        parent::__construct();

        $this->referenceHelper = ReferenceHelper::getInstance();

        $this->securityScanner = XmlScanner::getInstance($this);

    }

    /**

     * Can the current IReader read the file?

     */

    public function canRead(string $filename): bool

    {

        if (!File::testFileNoThrow($filename, self::INITIAL_FILE)) {

            return false;

        }

        $result = false;

        $this->zip = $zip = new ZipArchive();

        if ($zip->open($filename) === true) {

            [$workbookBasename] = $this->getWorkbookBaseName();

            $result = !empty($workbookBasename);

            $zip->close();

        }

        return $result;

    }

    public static function testSimpleXml(mixed $value): SimpleXMLElement

    {

        return ($value instanceof SimpleXMLElement) ? $value : new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><root></root>');

    }

    public static function getAttributes(?SimpleXMLElement $value, string $ns = ''): SimpleXMLElement

    {

        return self::testSimpleXml($value === null ? $value : $value->attributes($ns));

    }

    // Phpstan thinks, correctly, that xpath can return false.

    private static function xpathNoFalse(SimpleXMLElement $sxml, string $path): array

    {

        return self::falseToArray($sxml->xpath($path));

    }

    public static function falseToArray(mixed $value): array

    {

        return is_array($value) ? $value : [];

    }

    private function loadZip(string $filename, string $ns = '', bool $replaceUnclosedBr = false): SimpleXMLElement

    {

        $contents = $this->getFromZipArchive($this->zip, $filename);

        if ($replaceUnclosedBr) {

            $contents = str_replace('<br>', '<br/>', $contents);

        }

        $rels = @simplexml_load_string(

            $this->getSecurityScannerOrThrow()->scan($contents),

            'SimpleXMLElement',

            0,

            $ns

        );

        return self::testSimpleXml($rels);

    }

    // This function is just to identify cases where I'm not sure

    // why empty namespace is required.

    private function loadZipNonamespace(string $filename, string $ns): SimpleXMLElement

    {

        $contents = $this->getFromZipArchive($this->zip, $filename);

        $rels = simplexml_load_string(

            $this->getSecurityScannerOrThrow()->scan($contents),

            'SimpleXMLElement',

            0,

            ($ns === '' ? $ns : '')

        );

        return self::testSimpleXml($rels);

    }

    private const REL_TO_MAIN = [

        Namespaces::PURL_OFFICE_DOCUMENT => Namespaces::PURL_MAIN,

        Namespaces::THUMBNAIL => '',

    ];

    private const REL_TO_DRAWING = [

        Namespaces::PURL_RELATIONSHIPS => Namespaces::PURL_DRAWING,

    ];

    private const REL_TO_CHART = [

        Namespaces::PURL_RELATIONSHIPS => Namespaces::PURL_CHART,

    ];

    /**

     * Reads names of the worksheets from a file, without parsing the whole file to a Spreadsheet object.

     */

    public function listWorksheetNames(string $filename): array

    {

        File::assertFile($filename, self::INITIAL_FILE);

        $worksheetNames = [];

        $this->zip = $zip = new ZipArchive();

        $zip->open($filename);

        //    The files we're looking at here are small enough that simpleXML is more efficient than XMLReader

        $rels = $this->loadZip(self::INITIAL_FILE, Namespaces::RELATIONSHIPS);

        foreach ($rels->Relationship as $relx) {

            $rel = self::getAttributes($relx);

            $relType = (string) $rel['Type'];

            $mainNS = self::REL_TO_MAIN[$relType] ?? Namespaces::MAIN;

            if ($mainNS !== '') {

                $xmlWorkbook = $this->loadZip((string) $rel['Target'], $mainNS);

                if ($xmlWorkbook->sheets) {

                    foreach ($xmlWorkbook->sheets->sheet as $eleSheet) {

                        // Check if sheet should be skipped

                        $worksheetNames[] = (string) self::getAttributes($eleSheet)['name'];

                    }

                }

            }

        }

        $zip->close();

        return $worksheetNames;

    }

    /**

     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).

     */

    public function listWorksheetInfo(string $filename): array

    {

        File::assertFile($filename, self::INITIAL_FILE);

        $worksheetInfo = [];

        $this->zip = $zip = new ZipArchive();

        $zip->open($filename);

        $rels = $this->loadZip(self::INITIAL_FILE, Namespaces::RELATIONSHIPS);

        foreach ($rels->Relationship as $relx) {

            $rel = self::getAttributes($relx);

            $relType = (string) $rel['Type'];

            $mainNS = self::REL_TO_MAIN[$relType] ?? Namespaces::MAIN;

            if ($mainNS !== '') {

                $relTarget = (string) $rel['Target'];

                $dir = dirname($relTarget);

                $namespace = dirname($relType);

                $relsWorkbook = $this->loadZip("$dir/_rels/" . basename($relTarget) . '.rels', Namespaces::RELATIONSHIPS);

                $worksheets = [];

                foreach ($relsWorkbook->Relationship as $elex) {

                    $ele = self::getAttributes($elex);

                    if (

                        ((string) $ele['Type'] === "$namespace/worksheet")

                        || ((string) $ele['Type'] === "$namespace/chartsheet")

                    ) {

                        $worksheets[(string) $ele['Id']] = $ele['Target'];

                    }

                }

                $xmlWorkbook = $this->loadZip($relTarget, $mainNS);

                if ($xmlWorkbook->sheets) {

                    $dir = dirname($relTarget);

                    foreach ($xmlWorkbook->sheets->sheet as $eleSheet) {

                        $tmpInfo = [

                            'worksheetName' => (string) self::getAttributes($eleSheet)['name'],

                            'lastColumnLetter' => 'A',

                            'lastColumnIndex' => 0,

                            'totalRows' => 0,

                            'totalColumns' => 0,

                        ];

                        $sheetState = (string) (self::getAttributes($eleSheet)['state'] ?? Worksheet::SHEETSTATE_VISIBLE);

                        $tmpInfo['sheetState'] = $sheetState;

                        $fileWorksheet = (string) $worksheets[self::getArrayItemString(self::getAttributes($eleSheet, $namespace), 'id')];

                        $fileWorksheetPath = str_starts_with($fileWorksheet, '/') ? substr($fileWorksheet, 1) : "$dir/$fileWorksheet";

                        $xml = new XMLReader();

                        $xml->xml(

                            $this->getSecurityScannerOrThrow()

                                ->scan(

                                    $this->getFromZipArchive(

                                        $this->zip,

                                        $fileWorksheetPath

                                    )

                                )

                        );

                        $xml->setParserProperty(2, true);

                        $currCells = 0;

                        while ($xml->read()) {

                            if ($xml->localName == 'row' && $xml->nodeType == XMLReader::ELEMENT && $xml->namespaceURI === $mainNS) {

                                $row = (int) $xml->getAttribute('r');

                                $tmpInfo['totalRows'] = $row;

                                $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);

                                $currCells = 0;

                            } elseif ($xml->localName == 'c' && $xml->nodeType == XMLReader::ELEMENT && $xml->namespaceURI === $mainNS) {

                                $cell = $xml->getAttribute('r');

                                $currCells = $cell ? max($currCells, Coordinate::indexesFromString($cell)[0]) : ($currCells + 1);

                            }

                        }

                        $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);

                        $xml->close();

                        $tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1;

                        $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);

                        $worksheetInfo[] = $tmpInfo;

                    }

                }

            }

        }

        $zip->close();

        return $worksheetInfo;

    }

    private static function castToBoolean(SimpleXMLElement $c): bool

    {

        $value = isset($c->v) ? (string) $c->v : null;

        if ($value == '0') {

            return false;

        } elseif ($value == '1') {

            return true;

        }

        return (bool) $c->v;

    }

    private static function castToError(?SimpleXMLElement $c): ?string

    {

        return isset($c, $c->v) ? (string) $c->v : null;

    }

    private static function castToString(?SimpleXMLElement $c): ?string

    {

        return isset($c, $c->v) ? (string) $c->v : null;

    }

    public static function replacePrefixes(string $formula): string

    {

        return str_replace(['_xlfn.', '_xlws.'], '', $formula);

    }

    private function castToFormula(?SimpleXMLElement $c, string $r, string &$cellDataType, mixed &$value, mixed &$calculatedValue, string $castBaseType, bool $updateSharedCells = true): void

    {

        if ($c === null) {

            return;

        }

        $attr = $c->f->attributes();

        $cellDataType = DataType::TYPE_FORMULA;

        $formula = self::replacePrefixes((string) $c->f);

        $value = "=$formula";

        $calculatedValue = self::$castBaseType($c);

        // Shared formula?

        if (isset($attr['t']) && strtolower((string) $attr['t']) == 'shared') {

            $instance = (string) $attr['si'];

            if (!isset($this->sharedFormulae[(string) $attr['si']])) {

                $this->sharedFormulae[$instance] = new SharedFormula($r, $value);

            } elseif ($updateSharedCells === true) {

                // It's only worth the overhead of adjusting the shared formula for this cell if we're actually loading

                //     the cell, which may not be the case if we're using a read filter.

                $master = Coordinate::indexesFromString($this->sharedFormulae[$instance]->master());

                $current = Coordinate::indexesFromString($r);

                $difference = [0, 0];

                $difference[0] = $current[0] - $master[0];

                $difference[1] = $current[1] - $master[1];

                $value = $this->referenceHelper->updateFormulaReferences($this->sharedFormulae[$instance]->formula(), 'A1', $difference[0], $difference[1]);

            }

        }

    }

    private function fileExistsInArchive(ZipArchive $archive, string $fileName = ''): bool

    {

        // Root-relative paths

        if (str_contains($fileName, '//')) {

            $fileName = substr($fileName, strpos($fileName, '//') + 1);

        }

        $fileName = File::realpath($fileName);

        // Sadly, some 3rd party xlsx generators don't use consistent case for filenaming

        //    so we need to load case-insensitively from the zip file

        // Apache POI fixes

        $contents = $archive->locateName($fileName, ZipArchive::FL_NOCASE);

        if ($contents === false) {

            $contents = $archive->locateName(substr($fileName, 1), ZipArchive::FL_NOCASE);

        }

        return $contents !== false;

    }

    private function getFromZipArchive(ZipArchive $archive, string $fileName = ''): string

    {

        // Root-relative paths

        if (str_contains($fileName, '//')) {

            $fileName = substr($fileName, strpos($fileName, '//') + 1);

        }

        // Relative paths generated by dirname($filename) when $filename

        // has no path (i.e.files in root of the zip archive)

        $fileName = (string) preg_replace('/^\.\//', '', $fileName);

        $fileName = File::realpath($fileName);

        // Sadly, some 3rd party xlsx generators don't use consistent case for filenaming

        //    so we need to load case-insensitively from the zip file

        $contents = $archive->getFromName($fileName, 0, ZipArchive::FL_NOCASE);

        // Apache POI fixes

        if ($contents === false) {

            $contents = $archive->getFromName(substr($fileName, 1), 0, ZipArchive::FL_NOCASE);

        }

        // Has the file been saved with Windoze directory separators rather than unix?

        if ($contents === false) {

            $contents = $archive->getFromName(str_replace('/', '\\', $fileName), 0, ZipArchive::FL_NOCASE);

        }

        return ($contents === false) ? '' : $contents;

    }

    /**

     * Loads Spreadsheet from file.

     */

    protected function loadSpreadsheetFromFile(string $filename): Spreadsheet

    {

        File::assertFile($filename, self::INITIAL_FILE);

        // Initialisations

        $excel = new Spreadsheet();

        $excel->setValueBinder($this->valueBinder);

        $excel->removeSheetByIndex(0);

        $addingFirstCellStyleXf = true;

        $addingFirstCellXf = true;

        $unparsedLoadedData = [];

        $this->zip = $zip = new ZipArchive();

        $zip->open($filename);

        //    Read the theme first, because we need the colour scheme when reading the styles

        [$workbookBasename, $xmlNamespaceBase] = $this->getWorkbookBaseName();

        $drawingNS = self::REL_TO_DRAWING[$xmlNamespaceBase] ?? Namespaces::DRAWINGML;

        $chartNS = self::REL_TO_CHART[$xmlNamespaceBase] ?? Namespaces::CHART;

        $wbRels = $this->loadZip("xl/_rels/{$workbookBasename}.rels", Namespaces::RELATIONSHIPS);

        $theme = null;

        $this->styleReader = new Styles();

        foreach ($wbRels->Relationship as $relx) {

            $rel = self::getAttributes($relx);

            $relTarget = (string) $rel['Target'];

            if (str_starts_with($relTarget, '/xl/')) {

                $relTarget = substr($relTarget, 4);

            }

            switch ($rel['Type']) {

                case "$xmlNamespaceBase/theme":

                    if (!$this->fileExistsInArchive($zip, "xl/{$relTarget}")) {

                        break; // issue3770

                    }

                    $themeOrderArray = ['lt1', 'dk1', 'lt2', 'dk2'];

                    $themeOrderAdditional = count($themeOrderArray);

                    $xmlTheme = $this->loadZip("xl/{$relTarget}", $drawingNS);

                    $xmlThemeName = self::getAttributes($xmlTheme);

                    $xmlTheme = $xmlTheme->children($drawingNS);

                    $themeName = (string) $xmlThemeName['name'];

                    $colourScheme = self::getAttributes($xmlTheme->themeElements->clrScheme);

                    $colourSchemeName = (string) $colourScheme['name'];

                    $excel->getTheme()->setThemeColorName($colourSchemeName);

                    $colourScheme = $xmlTheme->themeElements->clrScheme->children($drawingNS);

                    $themeColours = [];

                    foreach ($colourScheme as $k => $xmlColour) {

                        $themePos = array_search($k, $themeOrderArray);

                        if ($themePos === false) {

                            $themePos = $themeOrderAdditional++;

                        }

                        if (isset($xmlColour->sysClr)) {

                            $xmlColourData = self::getAttributes($xmlColour->sysClr);

                            $themeColours[$themePos] = (string) $xmlColourData['lastClr'];

                            $excel->getTheme()->setThemeColor($k, (string) $xmlColourData['lastClr']);

                        } elseif (isset($xmlColour->srgbClr)) {

                            $xmlColourData = self::getAttributes($xmlColour->srgbClr);

                            $themeColours[$themePos] = (string) $xmlColourData['val'];

                            $excel->getTheme()->setThemeColor($k, (string) $xmlColourData['val']);

                        }

                    }

                    $theme = new Theme($themeName, $colourSchemeName, $themeColours);

                    $this->styleReader->setTheme($theme);

                    $fontScheme = self::getAttributes($xmlTheme->themeElements->fontScheme);

                    $fontSchemeName = (string) $fontScheme['name'];

                    $excel->getTheme()->setThemeFontName($fontSchemeName);

                    $majorFonts = [];

                    $minorFonts = [];

                    $fontScheme = $xmlTheme->themeElements->fontScheme->children($drawingNS);

                    $majorLatin = self::getAttributes($fontScheme->majorFont->latin)['typeface'] ?? '';

                    $majorEastAsian = self::getAttributes($fontScheme->majorFont->ea)['typeface'] ?? '';

                    $majorComplexScript = self::getAttributes($fontScheme->majorFont->cs)['typeface'] ?? '';

                    $minorLatin = self::getAttributes($fontScheme->minorFont->latin)['typeface'] ?? '';

                    $minorEastAsian = self::getAttributes($fontScheme->minorFont->ea)['typeface'] ?? '';

                    $minorComplexScript = self::getAttributes($fontScheme->minorFont->cs)['typeface'] ?? '';

                    foreach ($fontScheme->majorFont->font as $xmlFont) {

                        $fontAttributes = self::getAttributes($xmlFont);

                        $script = (string) ($fontAttributes['script'] ?? '');

                        if (!empty($script)) {

                            $majorFonts[$script] = (string) ($fontAttributes['typeface'] ?? '');

                        }

                    }

                    foreach ($fontScheme->minorFont->font as $xmlFont) {

                        $fontAttributes = self::getAttributes($xmlFont);

                        $script = (string) ($fontAttributes['script'] ?? '');

                        if (!empty($script)) {

                            $minorFonts[$script] = (string) ($fontAttributes['typeface'] ?? '');

                        }

                    }

                    $excel->getTheme()->setMajorFontValues($majorLatin, $majorEastAsian, $majorComplexScript, $majorFonts);

                    $excel->getTheme()->setMinorFontValues($minorLatin, $minorEastAsian, $minorComplexScript, $minorFonts);

                    break;

            }

        }

        $rels = $this->loadZip(self::INITIAL_FILE, Namespaces::RELATIONSHIPS);

        $propertyReader = new PropertyReader($this->getSecurityScannerOrThrow(), $excel->getProperties());

        $charts = $chartDetails = [];

        foreach ($rels->Relationship as $relx) {

            $rel = self::getAttributes($relx);

            $relTarget = (string) $rel['Target'];

            // issue 3553

            if ($relTarget[0] === '/') {

                $relTarget = substr($relTarget, 1);

            }

            $relType = (string) $rel['Type'];

            $mainNS = self::REL_TO_MAIN[$relType] ?? Namespaces::MAIN;

            switch ($relType) {

                case Namespaces::CORE_PROPERTIES:

                    $propertyReader->readCoreProperties($this->getFromZipArchive($zip, $relTarget));

                    break;

                case "$xmlNamespaceBase/extended-properties":

                    $propertyReader->readExtendedProperties($this->getFromZipArchive($zip, $relTarget));

                    break;

                case "$xmlNamespaceBase/custom-properties":

                    $propertyReader->readCustomProperties($this->getFromZipArchive($zip, $relTarget));

                    break;

                    //Ribbon

                case Namespaces::EXTENSIBILITY:

                    $customUI = $relTarget;

                    if ($customUI) {

                        $this->readRibbon($excel, $customUI, $zip);

                    }

                    break;

                case "$xmlNamespaceBase/officeDocument":

                    $dir = dirname($relTarget);

                    // Do not specify namespace in next stmt - do it in Xpath

                    $relsWorkbook = $this->loadZip("$dir/_rels/" . basename($relTarget) . '.rels', Namespaces::RELATIONSHIPS);

                    $relsWorkbook->registerXPathNamespace('rel', Namespaces::RELATIONSHIPS);

                    $worksheets = [];

                    $macros = $customUI = null;

                    foreach ($relsWorkbook->Relationship as $elex) {

                        $ele = self::getAttributes($elex);

                        switch ($ele['Type']) {

                            case Namespaces::WORKSHEET:

                            case Namespaces::PURL_WORKSHEET:

                                $worksheets[(string) $ele['Id']] = $ele['Target'];

                                break;

                            case Namespaces::CHARTSHEET:

                                if ($this->includeCharts === true) {

                                    $worksheets[(string) $ele['Id']] = $ele['Target'];

                                }

                                break;

                                // a vbaProject ? (: some macros)

                            case Namespaces::VBA:

                                $macros = $ele['Target'];

                                break;

                        }

                    }

                    if ($macros !== null) {

                        $macrosCode = $this->getFromZipArchive($zip, 'xl/vbaProject.bin'); //vbaProject.bin always in 'xl' dir and always named vbaProject.bin

                        if (!empty($macrosCode)) {

                            $excel->setMacrosCode($macrosCode);

                            $excel->setHasMacros(true);

                            //short-circuit : not reading vbaProject.bin.rel to get Signature =>allways vbaProjectSignature.bin in 'xl' dir

                            $Certificate = $this->getFromZipArchive($zip, 'xl/vbaProjectSignature.bin');

                            $excel->setMacrosCertificate($Certificate);

                        }

                    }

                    $relType = "rel:Relationship[@Type='"

                        . "$xmlNamespaceBase/styles"

                        . "']";

                    /** @var ?SimpleXMLElement */

                    $xpath = self::getArrayItem(self::xpathNoFalse($relsWorkbook, $relType));

                    if ($xpath === null) {

                        $xmlStyles = self::testSimpleXml(null);

                    } else {

                        $stylesTarget = (string) $xpath['Target'];

                        $stylesTarget = str_starts_with($stylesTarget, '/') ? substr($stylesTarget, 1) : "$dir/$stylesTarget";

                        $xmlStyles = $this->loadZip($stylesTarget, $mainNS);

                    }

                    $palette = self::extractPalette($xmlStyles);

                    $this->styleReader->setWorkbookPalette($palette);

                    $fills = self::extractStyles($xmlStyles, 'fills', 'fill');

                    $fonts = self::extractStyles($xmlStyles, 'fonts', 'font');

                    $borders = self::extractStyles($xmlStyles, 'borders', 'border');

                    $xfTags = self::extractStyles($xmlStyles, 'cellXfs', 'xf');

                    $cellXfTags = self::extractStyles($xmlStyles, 'cellStyleXfs', 'xf');

                    $styles = [];

                    $cellStyles = [];

                    $numFmts = null;

                    if (/*$xmlStyles && */ $xmlStyles->numFmts[0]) {

                        $numFmts = $xmlStyles->numFmts[0];

                    }

                    if (isset($numFmts)) {

                        $numFmts->registerXPathNamespace('sml', $mainNS);

                    }

                    $this->styleReader->setNamespace($mainNS);

                    if (!$this->readDataOnly/* && $xmlStyles*/) {

                        foreach ($xfTags as $xfTag) {

                            $xf = self::getAttributes($xfTag);

                            $numFmt = null;

                            if ($xf['numFmtId']) {

                                if (isset($numFmts)) {

                                    /** @var ?SimpleXMLElement */

                                    $tmpNumFmt = self::getArrayItem($numFmts->xpath("sml:numFmt[@numFmtId=$xf[numFmtId]]"));

                                    if (isset($tmpNumFmt['formatCode'])) {

                                        $numFmt = (string) $tmpNumFmt['formatCode'];

                                    }

                                }

                                // We shouldn't override any of the built-in MS Excel values (values below id 164)

                                //  But there's a lot of naughty homebrew xlsx writers that do use "reserved" id values that aren't actually used

                                //  So we make allowance for them rather than lose formatting masks

                                if (

                                    $numFmt === null

                                    && (int) $xf['numFmtId'] < 164

                                    && NumberFormat::builtInFormatCode((int) $xf['numFmtId']) !== ''

                                ) {

                                    $numFmt = NumberFormat::builtInFormatCode((int) $xf['numFmtId']);

                                }

                            }

                            $quotePrefix = (bool) (string) ($xf['quotePrefix'] ?? '');

                            $style = (object) [

                                'numFmt' => $numFmt ?? NumberFormat::FORMAT_GENERAL,

                                'font' => $fonts[(int) ($xf['fontId'])],

                                'fill' => $fills[(int) ($xf['fillId'])],

                                'border' => $borders[(int) ($xf['borderId'])],

                                'alignment' => $xfTag->alignment,

                                'protection' => $xfTag->protection,

                                'quotePrefix' => $quotePrefix,

                            ];

                            $styles[] = $style;

                            // add style to cellXf collection

                            $objStyle = new Style();

                            $this->styleReader->readStyle($objStyle, $style);

                            if ($addingFirstCellXf) {

                                $excel->removeCellXfByIndex(0); // remove the default style

                                $addingFirstCellXf = false;

                            }

                            $excel->addCellXf($objStyle);

                        }

                        foreach ($cellXfTags as $xfTag) {

                            $xf = self::getAttributes($xfTag);

                            $numFmt = NumberFormat::FORMAT_GENERAL;

                            if ($numFmts && $xf['numFmtId']) {

                                /** @var ?SimpleXMLElement */

                                $tmpNumFmt = self::getArrayItem($numFmts->xpath("sml:numFmt[@numFmtId=$xf[numFmtId]]"));

                                if (isset($tmpNumFmt['formatCode'])) {

                                    $numFmt = (string) $tmpNumFmt['formatCode'];

                                } elseif ((int) $xf['numFmtId'] < 165) {

                                    $numFmt = NumberFormat::builtInFormatCode((int) $xf['numFmtId']);

                                }

                            }

                            $quotePrefix = (bool) (string) ($xf['quotePrefix'] ?? '');

                            $cellStyle = (object) [

                                'numFmt' => $numFmt,

                                'font' => $fonts[(int) ($xf['fontId'])],

                                'fill' => $fills[((int) $xf['fillId'])],

                                'border' => $borders[(int) ($xf['borderId'])],

                                'alignment' => $xfTag->alignment,

                                'protection' => $xfTag->protection,

                                'quotePrefix' => $quotePrefix,

                            ];

                            $cellStyles[] = $cellStyle;

                            // add style to cellStyleXf collection

                            $objStyle = new Style();

                            $this->styleReader->readStyle($objStyle, $cellStyle);

                            if ($addingFirstCellStyleXf) {

                                $excel->removeCellStyleXfByIndex(0); // remove the default style

                                $addingFirstCellStyleXf = false;

                            }

                            $excel->addCellStyleXf($objStyle);

                        }

                    }

                    $this->styleReader->setStyleXml($xmlStyles);

                    $this->styleReader->setNamespace($mainNS);

                    $this->styleReader->setStyleBaseData($theme, $styles, $cellStyles);

                    $dxfs = $this->styleReader->dxfs($this->readDataOnly);

                    $styles = $this->styleReader->styles();

                    // Read content after setting the styles

                    $sharedStrings = [];

                    $relType = "rel:Relationship[@Type='"

                        //. Namespaces::SHARED_STRINGS

                        . "$xmlNamespaceBase/sharedStrings"

                        . "']";

                    /** @var ?SimpleXMLElement */

                    $xpath = self::getArrayItem($relsWorkbook->xpath($relType));

                    if ($xpath) {

                        $sharedStringsTarget = (string) $xpath['Target'];

                        $sharedStringsTarget = str_starts_with($sharedStringsTarget, '/') ? substr($sharedStringsTarget, 1) : "$dir/$sharedStringsTarget";

                        $xmlStrings = $this->loadZip($sharedStringsTarget, $mainNS);

                        if (isset($xmlStrings->si)) {

                            foreach ($xmlStrings->si as $val) {

                                if (isset($val->t)) {

                                    $sharedStrings[] = StringHelper::controlCharacterOOXML2PHP((string) $val->t);

                                } elseif (isset($val->r)) {

                                    $sharedStrings[] = $this->parseRichText($val);

                                } else {

                                    $sharedStrings[] = '';

                                }

                            }

                        }

                    }

                    $xmlWorkbook = $this->loadZipNoNamespace($relTarget, $mainNS);

                    $xmlWorkbookNS = $this->loadZip($relTarget, $mainNS);

                    // Set base date

                    $excel->setExcelCalendar(Date::CALENDAR_WINDOWS_1900);

                    if ($xmlWorkbookNS->workbookPr) {

                        Date::setExcelCalendar(Date::CALENDAR_WINDOWS_1900);

                        $attrs1904 = self::getAttributes($xmlWorkbookNS->workbookPr);

                        if (isset($attrs1904['date1904'])) {

                            if (self::boolean((string) $attrs1904['date1904'])) {

                                Date::setExcelCalendar(Date::CALENDAR_MAC_1904);

                                $excel->setExcelCalendar(Date::CALENDAR_MAC_1904);

                            }

                        }

                    }

                    // Set protection

                    $this->readProtection($excel, $xmlWorkbook);

                    $sheetId = 0; // keep track of new sheet id in final workbook

                    $oldSheetId = -1; // keep track of old sheet id in final workbook

                    $countSkippedSheets = 0; // keep track of number of skipped sheets

                    $mapSheetId = []; // mapping of sheet ids from old to new

                    $charts = $chartDetails = [];

                    if ($xmlWorkbookNS->sheets) {

                        foreach ($xmlWorkbookNS->sheets->sheet as $eleSheet) {

                            $eleSheetAttr = self::getAttributes($eleSheet);

                            ++$oldSheetId;

                            // Check if sheet should be skipped

                            if (is_array($this->loadSheetsOnly) && !in_array((string) $eleSheetAttr['name'], $this->loadSheetsOnly)) {

                                ++$countSkippedSheets;

                                $mapSheetId[$oldSheetId] = null;

                                continue;

                            }

                            $sheetReferenceId = self::getArrayItemString(self::getAttributes($eleSheet, $xmlNamespaceBase), 'id');

                            if (isset($worksheets[$sheetReferenceId]) === false) {

                                ++$countSkippedSheets;

                                $mapSheetId[$oldSheetId] = null;

                                continue;

                            }

                            // Map old sheet id in original workbook to new sheet id.

                            // They will differ if loadSheetsOnly() is being used

                            $mapSheetId[$oldSheetId] = $oldSheetId - $countSkippedSheets;

                            // Load sheet

                            $docSheet = $excel->createSheet();

                            //    Use false for $updateFormulaCellReferences to prevent adjustment of worksheet

                            //        references in formula cells... during the load, all formulae should be correct,

                            //        and we're simply bringing the worksheet name in line with the formula, not the

                            //        reverse

                            $docSheet->setTitle((string) $eleSheetAttr['name'], false, false);

                            $fileWorksheet = (string) $worksheets[$sheetReferenceId];

                            // issue 3665 adds test for /.

                            // This broke XlsxRootZipFilesTest,

                            //  but Excel reports an error with that file.

                            //  Testing dir for . avoids this problem.

                            //  It might be better just to drop the test.

                            if ($fileWorksheet[0] == '/' && $dir !== '.') {

                                $fileWorksheet = substr($fileWorksheet, strlen($dir) + 2);

                            }

                            $xmlSheet = $this->loadZipNoNamespace("$dir/$fileWorksheet", $mainNS);

                            $xmlSheetNS = $this->loadZip("$dir/$fileWorksheet", $mainNS);

                            // Shared Formula table is unique to each Worksheet, so we need to reset it here

                            $this->sharedFormulae = [];

                            if (isset($eleSheetAttr['state']) && (string) $eleSheetAttr['state'] != '') {

                                $docSheet->setSheetState((string) $eleSheetAttr['state']);

                            }

                            if ($xmlSheetNS) {

                                $xmlSheetMain = $xmlSheetNS->children($mainNS);

                                // Setting Conditional Styles adjusts selected cells, so we need to execute this

                                //    before reading the sheet view data to get the actual selected cells

                                if (!$this->readDataOnly && ($xmlSheet->conditionalFormatting)) {

                                    (new ConditionalStyles($docSheet, $xmlSheet, $dxfs, $this->styleReader))->load();

                                }

                                if (!$this->readDataOnly && $xmlSheet->extLst) {

                                    (new ConditionalStyles($docSheet, $xmlSheet, $dxfs, $this->styleReader))->loadFromExt();

                                }

                                if (isset($xmlSheetMain->sheetViews, $xmlSheetMain->sheetViews->sheetView)) {

                                    $sheetViews = new SheetViews($xmlSheetMain->sheetViews->sheetView, $docSheet);

                                    $sheetViews->load();

                                }

                                $sheetViewOptions = new SheetViewOptions($docSheet, $xmlSheetNS);

                                $sheetViewOptions->load($this->readDataOnly, $this->styleReader);

                                (new ColumnAndRowAttributes($docSheet, $xmlSheetNS))

                                    ->load($this->getReadFilter(), $this->readDataOnly, $this->ignoreRowsWithNoCells);

                            }

                            $holdSelectedCells = $docSheet->getSelectedCells();

                            if ($xmlSheetNS && $xmlSheetNS->sheetData && $xmlSheetNS->sheetData->row) {

                                $cIndex = 1; // Cell Start from 1

                                foreach ($xmlSheetNS->sheetData->row as $row) {

                                    $rowIndex = 1;

                                    foreach ($row->c as $c) {

                                        $cAttr = self::getAttributes($c);

                                        $r = (string) $cAttr['r'];

                                        if ($r == '') {

                                            $r = Coordinate::stringFromColumnIndex($rowIndex) . $cIndex;

                                        }

                                        $cellDataType = (string) $cAttr['t'];

                                        $originalCellDataTypeNumeric = $cellDataType === '';

                                        $value = null;

                                        $calculatedValue = null;

                                        // Read cell?

                                        $coordinates = Coordinate::coordinateFromString($r);

                                        if (!$this->getReadFilter()->readCell($coordinates[0], (int) $coordinates[1], $docSheet->getTitle())) {

                                            // Normally, just testing for the f attribute should identify this cell as containing a formula

                                            // that we need to read, even though it is outside of the filter range, in case it is a shared formula.

                                            // But in some cases, this attribute isn't set; so we need to delve a level deeper and look at

                                            // whether or not the cell has a child formula element that is shared.

                                            if (isset($cAttr->f) || (isset($c->f, $c->f->attributes()['t']) && strtolower((string) $c->f->attributes()['t']) === 'shared')) {

                                                $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToError', false);

                                            }

                                            ++$rowIndex;

                                            continue;

                                        }

                                        // Read cell!

                                        $useFormula = isset($c->f)

                                            && ((string) $c->f !== '' || (isset($c->f->attributes()['t']) && strtolower((string) $c->f->attributes()['t']) === 'shared'));

                                        switch ($cellDataType) {

                                            case DataType::TYPE_STRING:

                                                if ((string) $c->v != '') {

                                                    $value = $sharedStrings[(int) ($c->v)];

                                                    if ($value instanceof RichText) {

                                                        $value = clone $value;

                                                    }

                                                } else {

                                                    $value = '';

                                                }

                                                break;

                                            case DataType::TYPE_BOOL:

                                                if (!$useFormula) {

                                                    if (isset($c->v)) {

                                                        $value = self::castToBoolean($c);

                                                    } else {

                                                        $value = null;

                                                        $cellDataType = DataType::TYPE_NULL;

                                                    }

                                                } else {

                                                    // Formula

                                                    $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToBoolean');

                                                    self::storeFormulaAttributes($c->f, $docSheet, $r);

                                                }

                                                break;

                                            case DataType::TYPE_STRING2:

                                                if ($useFormula) {

                                                    $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToString');

                                                    self::storeFormulaAttributes($c->f, $docSheet, $r);

                                                } else {

                                                    $value = self::castToString($c);

                                                }

                                                break;

                                            case DataType::TYPE_INLINE:

                                                if ($useFormula) {

                                                    $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToError');

                                                    self::storeFormulaAttributes($c->f, $docSheet, $r);

                                                } else {

                                                    $value = $this->parseRichText($c->is);

                                                }

                                                break;

                                            case DataType::TYPE_ERROR:

                                                if (!$useFormula) {

                                                    $value = self::castToError($c);

                                                } else {

                                                    // Formula

                                                    $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToError');

                                                    $eattr = $c->attributes();

                                                    if (isset($eattr['vm'])) {

                                                        if ($calculatedValue === ExcelError::VALUE()) {

                                                            $calculatedValue = ExcelError::SPILL();

                                                        }

                                                    }

                                                }

                                                break;

                                            default:

                                                if (!$useFormula) {

                                                    $value = self::castToString($c);

                                                    if (is_numeric($value)) {

                                                        $value += 0;

                                                        $cellDataType = DataType::TYPE_NUMERIC;

                                                    }

                                                } else {

                                                    // Formula

                                                    $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, 'castToString');

                                                    if (is_numeric($calculatedValue)) {

                                                        $calculatedValue += 0;

                                                    }

                                                    self::storeFormulaAttributes($c->f, $docSheet, $r);

                                                }

                                                break;

                                        }

                                        // read empty cells or the cells are not empty

                                        if ($this->readEmptyCells || ($value !== null && $value !== '')) {

                                            // Rich text?

                                            if ($value instanceof RichText && $this->readDataOnly) {

                                                $value = $value->getPlainText();

                                            }

                                            $cell = $docSheet->getCell($r);

                                            // Assign value

                                            if ($cellDataType != '') {

                                                // it is possible, that datatype is numeric but with an empty string, which result in an error

                                                if ($cellDataType === DataType::TYPE_NUMERIC && ($value === '' || $value === null)) {

                                                    $cellDataType = DataType::TYPE_NULL;

                                                }

                                                if ($cellDataType !== DataType::TYPE_NULL) {

                                                    $cell->setValueExplicit($value, $cellDataType);

                                                }

                                            } else {

                                                $cell->setValue($value);

                                            }

                                            if ($calculatedValue !== null) {

                                                $cell->setCalculatedValue($calculatedValue, $originalCellDataTypeNumeric);

                                            }

                                            // Style information?

                                            if (!$this->readDataOnly) {

                                                $cAttrS = (int) ($cAttr['s'] ?? 0);

                                                // no style index means 0, it seems

                                                $cAttrS = isset($styles[$cAttrS]) ? $cAttrS : 0;

                                                $cell->setXfIndex($cAttrS);

                                                // issue 3495

                                                if ($cellDataType === DataType::TYPE_FORMULA && $styles[$cAttrS]->quotePrefix === true) {

                                                    $holdSelected = $docSheet->getSelectedCells();

                                                    $cell->getStyle()->setQuotePrefix(false);

                                                    $docSheet->setSelectedCells($holdSelected);

                                                }

                                            }

                                        }

                                        ++$rowIndex;

                                    }

                                    ++$cIndex;

                                }

                            }

                            $docSheet->setSelectedCells($holdSelectedCells);

                            if (!$this->readDataOnly && $xmlSheetNS && $xmlSheetNS->ignoredErrors) {

                                foreach ($xmlSheetNS->ignoredErrors->ignoredError as $ignoredError) {

                                    $this->processIgnoredErrors($ignoredError, $docSheet);

                                }

                            }

                            if (!$this->readDataOnly && $xmlSheetNS && $xmlSheetNS->sheetProtection) {

                                $protAttr = $xmlSheetNS->sheetProtection->attributes() ?? [];

                                foreach ($protAttr as $key => $value) {

                                    $method = 'set' . ucfirst($key);

                                    $docSheet->getProtection()->$method(self::boolean((string) $value));

                                }

                            }

                            if ($xmlSheet) {

                                $this->readSheetProtection($docSheet, $xmlSheet);

                            }

                            if ($this->readDataOnly === false) {

                                $this->readAutoFilter($xmlSheetNS, $docSheet);

                                $this->readBackgroundImage($xmlSheetNS, $docSheet, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels');

                            }

                            $this->readTables($xmlSheetNS, $docSheet, $dir, $fileWorksheet, $zip, $mainNS);