<?php

namespace PhpOffice\PhpSpreadsheet\Writer;

use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
use PhpOffice\PhpSpreadsheet\Calculation\Functions;
use PhpOffice\PhpSpreadsheet\HashTable;

< use PhpOffice\PhpSpreadsheet\Shared\File;


use PhpOffice\PhpSpreadsheet\Spreadsheet;

> use PhpOffice\PhpSpreadsheet\Style\Borders;
use PhpOffice\PhpSpreadsheet\Worksheet\Drawing as WorksheetDrawing;
> use PhpOffice\PhpSpreadsheet\Style\Conditional;
use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
> use PhpOffice\PhpSpreadsheet\Style\Fill;
use PhpOffice\PhpSpreadsheet\Writer\Exception as WriterException;
> use PhpOffice\PhpSpreadsheet\Style\Font;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Chart;
> use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Comments;
> use PhpOffice\PhpSpreadsheet\Worksheet\BaseDrawing;


use PhpOffice\PhpSpreadsheet\Writer\Xlsx\ContentTypes;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\DocProps;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Drawing;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Rels;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\RelsRibbon;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\RelsVBA;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\StringTable;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Style;

> use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Table;


use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Theme;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Workbook;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx\Worksheet;
use ZipArchive;
use ZipStream\Exception\OverflowException;
use ZipStream\Option\Archive;
use ZipStream\ZipStream;

class Xlsx extends BaseWriter
{
    /**
     * Office2003 compatibility.
     *
     * @var bool
     */
    private $office2003compatibility = false;

    /**

<      * Private writer parts.
<      *
<      * @var Xlsx\WriterPart[]
<      */
<     private $writerParts = [];
< 
<     /**


     * Private Spreadsheet.
     *
     * @var Spreadsheet
     */
    private $spreadSheet;

    /**
     * Private string table.
     *
     * @var string[]
     */
    private $stringTable = [];

    /**
     * Private unique Conditional HashTable.
     *

<      * @var HashTable



>      * @var HashTable<Conditional>


     */
    private $stylesConditionalHashTable;

    /**
     * Private unique Style HashTable.
     *

<      * @var HashTable



>      * @var HashTable<\PhpOffice\PhpSpreadsheet\Style\Style>


     */
    private $styleHashTable;

    /**
     * Private unique Fill HashTable.
     *

<      * @var HashTable



>      * @var HashTable<Fill>


     */
    private $fillHashTable;

    /**
     * Private unique \PhpOffice\PhpSpreadsheet\Style\Font HashTable.
     *

<      * @var HashTable



>      * @var HashTable<Font>


     */
    private $fontHashTable;

    /**
     * Private unique Borders HashTable.
     *

<      * @var HashTable



>      * @var HashTable<Borders>


     */
    private $bordersHashTable;

    /**
     * Private unique NumberFormat HashTable.
     *

<      * @var HashTable



>      * @var HashTable<NumberFormat>


     */
    private $numFmtHashTable;

    /**
     * Private unique \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\BaseDrawing HashTable.
     *

<      * @var HashTable



>      * @var HashTable<BaseDrawing>


     */
    private $drawingHashTable;

    /**
     * Private handle for zip stream.
     *
     * @var ZipStream
     */
    private $zip;

    /**

>      * @var Chart
     * Create a new Xlsx Writer.
>      */
     */
>     private $writerPartChart;
    public function __construct(Spreadsheet $spreadsheet)
> 
    {
>     /**
        // Assign PhpSpreadsheet
>      * @var Comments
        $this->setSpreadsheet($spreadsheet);
>      */

>     private $writerPartComments;
        $writerPartsArray = [
> 
            'stringtable' => StringTable::class,
>     /**
            'contenttypes' => ContentTypes::class,
>      * @var ContentTypes
            'docprops' => DocProps::class,
>      */
            'rels' => Rels::class,
>     private $writerPartContentTypes;
            'theme' => Theme::class,
> 
            'style' => Style::class,
>     /**
            'workbook' => Workbook::class,
>      * @var DocProps
            'worksheet' => Worksheet::class,
>      */
            'drawing' => Drawing::class,
>     private $writerPartDocProps;
            'comments' => Comments::class,
> 
            'chart' => Chart::class,
>     /**
            'relsvba' => RelsVBA::class,
>      * @var Drawing
            'relsribbonobjects' => RelsRibbon::class,
>      */
        ];
>     private $writerPartDrawing;

> 
        //    Initialise writer parts
>     /**
        //        and Assign their parent IWriters
>      * @var Rels
        foreach ($writerPartsArray as $writer => $class) {
>      */
            $this->writerParts[$writer] = new $class($this);
>     private $writerPartRels;
        }
> 

>     /**
        $hashTablesArray = ['stylesConditionalHashTable', 'fillHashTable', 'fontHashTable',
>      * @var RelsRibbon
            'bordersHashTable', 'numFmtHashTable', 'drawingHashTable',
>      */
            'styleHashTable',
>     private $writerPartRelsRibbon;
        ];
> 

>     /**
        // Set HashTable variables
>      * @var RelsVBA
        foreach ($hashTablesArray as $tableName) {
>      */
            $this->$tableName = new HashTable();
>     private $writerPartRelsVBA;
        }
> 
    }
>     /**

>      * @var StringTable
    /**
>      */
     * Get writer part.
>     private $writerPartStringTable;
     *
> 
     * @param string $pPartName Writer part name
>     /**
     *
>      * @var Style
     * @return \PhpOffice\PhpSpreadsheet\Writer\Xlsx\WriterPart
>      */
     */
>     private $writerPartStyle;
    public function getWriterPart($pPartName)
> 
    {
>     /**
        if ($pPartName != '' && isset($this->writerParts[strtolower($pPartName)])) {
>      * @var Theme
            return $this->writerParts[strtolower($pPartName)];
>      */
        }
>     private $writerPartTheme;

> 
        return null;
>     /**
    }
>      * @var Table

>      */
    /**
>     private $writerPartTable;
     * Save PhpSpreadsheet to file.
> 
     *
>     /**
     * @param resource|string $pFilename
>      * @var Workbook
     */
>      */
    public function save($pFilename): void
>     private $writerPartWorkbook;
    {
> 
        // garbage collect
>     /**
        $this->pathNames = [];
>      * @var Worksheet
        $this->spreadSheet->garbageCollect();
>      */

>     private $writerPartWorksheet;
        $this->openFileHandle($pFilename);
> 

>     /**



<         $writerPartsArray = [
<             'stringtable' => StringTable::class,
<             'contenttypes' => ContentTypes::class,
<             'docprops' => DocProps::class,
<             'rels' => Rels::class,
<             'theme' => Theme::class,
<             'style' => Style::class,
<             'workbook' => Workbook::class,
<             'worksheet' => Worksheet::class,
<             'drawing' => Drawing::class,
<             'comments' => Comments::class,
<             'chart' => Chart::class,
<             'relsvba' => RelsVBA::class,
<             'relsribbonobjects' => RelsRibbon::class,
<         ];
< 
<         //    Initialise writer parts
<         //        and Assign their parent IWriters
<         foreach ($writerPartsArray as $writer => $class) {
<             $this->writerParts[$writer] = new $class($this);
<         }
< 
<         $hashTablesArray = ['stylesConditionalHashTable', 'fillHashTable', 'fontHashTable',
<             'bordersHashTable', 'numFmtHashTable', 'drawingHashTable',
<             'styleHashTable',
<         ];



>         $this->writerPartChart = new Chart($this);
>         $this->writerPartComments = new Comments($this);
>         $this->writerPartContentTypes = new ContentTypes($this);
>         $this->writerPartDocProps = new DocProps($this);
>         $this->writerPartDrawing = new Drawing($this);
>         $this->writerPartRels = new Rels($this);
>         $this->writerPartRelsRibbon = new RelsRibbon($this);
>         $this->writerPartRelsVBA = new RelsVBA($this);
>         $this->writerPartStringTable = new StringTable($this);
>         $this->writerPartStyle = new Style($this);
>         $this->writerPartTheme = new Theme($this);
>         $this->writerPartTable = new Table($this);
>         $this->writerPartWorkbook = new Workbook($this);
>         $this->writerPartWorksheet = new Worksheet($this);



<         foreach ($hashTablesArray as $tableName) {
<             $this->$tableName = new HashTable();



>         // @phpstan-ignore-next-line
>         $this->bordersHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->drawingHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->fillHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->fontHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->numFmtHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->styleHashTable = new HashTable();
>         // @phpstan-ignore-next-line
>         $this->stylesConditionalHashTable = new HashTable();


        // Add [Content_Types].xml to ZIP file

> 
        $this->addZipFile('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->spreadSheet, $this->includeCharts));
>     public function getWriterPartChart(): Chart

>     {
        //if hasMacros, add the vbaProject.bin file, Certificate file(if exists)
>         return $this->writerPartChart;



<     /**
<      * Get writer part.
<      *
<      * @param string $pPartName Writer part name
<      *
<      * @return \PhpOffice\PhpSpreadsheet\Writer\Xlsx\WriterPart
<      */
<     public function getWriterPart($pPartName)



>     public function getWriterPartComments(): Comments
>     {
>         return $this->writerPartComments;
>     }
> 
>     public function getWriterPartContentTypes(): ContentTypes
>     {
>         return $this->writerPartContentTypes;
>     }
> 
>     public function getWriterPartDocProps(): DocProps
>     {
>         return $this->writerPartDocProps;
>     }
> 
>     public function getWriterPartDrawing(): Drawing
>     {
>         return $this->writerPartDrawing;
>     }
> 
>     public function getWriterPartRels(): Rels
>     {
>         return $this->writerPartRels;
>     }
> 
>     public function getWriterPartRelsRibbon(): RelsRibbon
>     {
>         return $this->writerPartRelsRibbon;
>     }
> 
>     public function getWriterPartRelsVBA(): RelsVBA



<         if ($pPartName != '' && isset($this->writerParts[strtolower($pPartName)])) {
<             return $this->writerParts[strtolower($pPartName)];



>         return $this->writerPartRelsVBA;



<         return null;



>     public function getWriterPartStringTable(): StringTable
>     {
>         return $this->writerPartStringTable;
>     }
> 
>     public function getWriterPartStyle(): Style
>     {
>         return $this->writerPartStyle;
>     }
> 
>     public function getWriterPartTheme(): Theme
>     {
>         return $this->writerPartTheme;
>     }
> 
>     public function getWriterPartTable(): Table
>     {
>         return $this->writerPartTable;
>     }
> 
>     public function getWriterPartWorkbook(): Workbook
>     {
>         return $this->writerPartWorkbook;
>     }
> 
>     public function getWriterPartWorksheet(): Worksheet
>     {
>         return $this->writerPartWorksheet;



<      * @param resource|string $pFilename



>      * @param resource|string $filename



<     public function save($pFilename): void



>     public function save($filename, int $flags = 0): void


        //a custom UI in this workbook ? add it ("base" xml and additional objects (pictures) and rels)

>         $this->processFlags($flags);
        if ($this->spreadSheet->hasRibbon()) {
> 



<         $this->openFileHandle($pFilename);
< 



<             $this->stringTable = $this->getWriterPart('StringTable')->createStringTable($this->spreadSheet->getSheet($i), $this->stringTable);



>             $this->stringTable = $this->getWriterPartStringTable()->createStringTable($this->spreadSheet->getSheet($i), $this->stringTable);



<         $this->styleHashTable->addFromSource($this->getWriterPart('Style')->allStyles($this->spreadSheet));
<         $this->stylesConditionalHashTable->addFromSource($this->getWriterPart('Style')->allConditionalStyles($this->spreadSheet));
<         $this->fillHashTable->addFromSource($this->getWriterPart('Style')->allFills($this->spreadSheet));
<         $this->fontHashTable->addFromSource($this->getWriterPart('Style')->allFonts($this->spreadSheet));
<         $this->bordersHashTable->addFromSource($this->getWriterPart('Style')->allBorders($this->spreadSheet));
<         $this->numFmtHashTable->addFromSource($this->getWriterPart('Style')->allNumberFormats($this->spreadSheet));



>         $this->styleHashTable->addFromSource($this->getWriterPartStyle()->allStyles($this->spreadSheet));
>         $this->stylesConditionalHashTable->addFromSource($this->getWriterPartStyle()->allConditionalStyles($this->spreadSheet));
>         $this->fillHashTable->addFromSource($this->getWriterPartStyle()->allFills($this->spreadSheet));
>         $this->fontHashTable->addFromSource($this->getWriterPartStyle()->allFonts($this->spreadSheet));
>         $this->bordersHashTable->addFromSource($this->getWriterPartStyle()->allBorders($this->spreadSheet));
>         $this->numFmtHashTable->addFromSource($this->getWriterPartStyle()->allNumberFormats($this->spreadSheet));



<         $this->drawingHashTable->addFromSource($this->getWriterPart('Drawing')->allDrawings($this->spreadSheet));
< 
<         $options = new Archive();
<         $options->setEnableZip64(false);
<         $options->setOutputStream($this->fileHandle);
< 
<         $this->zip = new ZipStream(null, $options);



>         $this->drawingHashTable->addFromSource($this->getWriterPartDrawing()->allDrawings($this->spreadSheet));




>         $zipContent = [];



<         $this->addZipFile('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->spreadSheet, $this->includeCharts));



>         $zipContent['[Content_Types].xml'] = $this->getWriterPartContentTypes()->writeContentTypes($this->spreadSheet, $this->includeCharts);



<                 $this->addZipFile('xl/vbaProject.bin', $macrosCode); //allways in 'xl', allways named vbaProject.bin



>                 $zipContent['xl/vbaProject.bin'] = $macrosCode; //allways in 'xl', allways named vbaProject.bin



<                     $this->addZipFile('xl/vbaProjectSignature.bin', $this->spreadSheet->getMacrosCertificate());
<                     $this->addZipFile('xl/_rels/vbaProject.bin.rels', $this->getWriterPart('RelsVBA')->writeVBARelationships($this->spreadSheet));



>                     $zipContent['xl/vbaProjectSignature.bin'] = $this->spreadSheet->getMacrosCertificate();
>                     $zipContent['xl/_rels/vbaProject.bin.rels'] = $this->getWriterPartRelsVBA()->writeVBARelationships();



<             $this->addZipFile($tmpRibbonTarget, $this->spreadSheet->getRibbonXMLData('data'));



>             $tmpRibbonTarget = is_string($tmpRibbonTarget) ? $tmpRibbonTarget : '';
>             $zipContent[$tmpRibbonTarget] = $this->spreadSheet->getRibbonXMLData('data');


            $this->addZipFile('docProps/custom.xml', $customPropertiesPart);

>                 if (is_array($ribbonBinObjects)) {



<                     $this->addZipFile($tmpRootPath . $aPath, $aContent);



>                         $zipContent[$tmpRootPath . $aPath] = $aContent;
>                     }



<                 $this->addZipFile($tmpRootPath . '_rels/' . basename($tmpRibbonTarget) . '.rels', $this->getWriterPart('RelsRibbonObjects')->writeRibbonRelationships($this->spreadSheet));



>                 $zipContent[$tmpRootPath . '_rels/' . basename($tmpRibbonTarget) . '.rels'] = $this->getWriterPartRelsRibbon()->writeRibbonRelationships($this->spreadSheet);



<         $this->addZipFile('_rels/.rels', $this->getWriterPart('Rels')->writeRelationships($this->spreadSheet));
<         $this->addZipFile('xl/_rels/workbook.xml.rels', $this->getWriterPart('Rels')->writeWorkbookRelationships($this->spreadSheet));



>         $zipContent['_rels/.rels'] = $this->getWriterPartRels()->writeRelationships($this->spreadSheet);
>         $zipContent['xl/_rels/workbook.xml.rels'] = $this->getWriterPartRels()->writeWorkbookRelationships($this->spreadSheet);



<         $this->addZipFile('docProps/app.xml', $this->getWriterPart('DocProps')->writeDocPropsApp($this->spreadSheet));
<         $this->addZipFile('docProps/core.xml', $this->getWriterPart('DocProps')->writeDocPropsCore($this->spreadSheet));
<         $customPropertiesPart = $this->getWriterPart('DocProps')->writeDocPropsCustom($this->spreadSheet);



>         $zipContent['docProps/app.xml'] = $this->getWriterPartDocProps()->writeDocPropsApp($this->spreadSheet);
>         $zipContent['docProps/core.xml'] = $this->getWriterPartDocProps()->writeDocPropsCore($this->spreadSheet);
>         $customPropertiesPart = $this->getWriterPartDocProps()->writeDocPropsCustom($this->spreadSheet);



<             $this->addZipFile('docProps/custom.xml', $customPropertiesPart);



>             $zipContent['docProps/custom.xml'] = $customPropertiesPart;



<         $this->addZipFile('xl/theme/theme1.xml', $this->getWriterPart('Theme')->writeTheme($this->spreadSheet));



>         $zipContent['xl/theme/theme1.xml'] = $this->getWriterPartTheme()->writeTheme();



<         $this->addZipFile('xl/sharedStrings.xml', $this->getWriterPart('StringTable')->writeStringTable($this->stringTable));



>         $zipContent['xl/sharedStrings.xml'] = $this->getWriterPartStringTable()->writeStringTable($this->stringTable);



<         $this->addZipFile('xl/styles.xml', $this->getWriterPart('Style')->writeStyles($this->spreadSheet));



>         $zipContent['xl/styles.xml'] = $this->getWriterPartStyle()->writeStyles($this->spreadSheet);


        // Add workbook to ZIP file

<         $this->addZipFile('xl/workbook.xml', $this->getWriterPart('Workbook')->writeWorkbook($this->spreadSheet, $this->preCalculateFormulas));



>         $zipContent['xl/workbook.xml'] = $this->getWriterPartWorkbook()->writeWorkbook($this->spreadSheet, $this->preCalculateFormulas);



        $chartCount = 0;
        // Add worksheets
        for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {

<             $this->addZipFile('xl/worksheets/sheet' . ($i + 1) . '.xml', $this->getWriterPart('Worksheet')->writeWorksheet($this->spreadSheet->getSheet($i), $this->stringTable, $this->includeCharts));



>             $zipContent['xl/worksheets/sheet' . ($i + 1) . '.xml'] = $this->getWriterPartWorksheet()->writeWorksheet($this->spreadSheet->getSheet($i), $this->stringTable, $this->includeCharts);


            if ($this->includeCharts) {
                $charts = $this->spreadSheet->getSheet($i)->getChartCollection();
                if (count($charts) > 0) {
                    foreach ($charts as $chart) {

<                         $this->addZipFile('xl/charts/chart' . ($chartCount + 1) . '.xml', $this->getWriterPart('Chart')->writeChart($chart, $this->preCalculateFormulas));



>                         $zipContent['xl/charts/chart' . ($chartCount + 1) . '.xml'] = $this->getWriterPartChart()->writeChart($chart, $this->preCalculateFormulas);


                        ++$chartCount;
                    }
                }
            }
        }

        $chartRef1 = 0;

>         $tableRef1 = 1;


        // Add worksheet relationships (drawings, ...)
        for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {
            // Add relationships

<             $this->addZipFile('xl/worksheets/_rels/sheet' . ($i + 1) . '.xml.rels', $this->getWriterPart('Rels')->writeWorksheetRelationships($this->spreadSheet->getSheet($i), ($i + 1), $this->includeCharts));



>             $zipContent['xl/worksheets/_rels/sheet' . ($i + 1) . '.xml.rels'] = $this->getWriterPartRels()->writeWorksheetRelationships($this->spreadSheet->getSheet($i), ($i + 1), $this->includeCharts, $tableRef1);



            // Add unparsedLoadedData
            $sheetCodeName = $this->spreadSheet->getSheet($i)->getCodeName();
            $unparsedLoadedData = $this->spreadSheet->getUnparsedLoadedData();
            if (isset($unparsedLoadedData['sheets'][$sheetCodeName]['ctrlProps'])) {
                foreach ($unparsedLoadedData['sheets'][$sheetCodeName]['ctrlProps'] as $ctrlProp) {

<                     $this->addZipFile($ctrlProp['filePath'], $ctrlProp['content']);



>                     $zipContent[$ctrlProp['filePath']] = $ctrlProp['content'];


                }
            }
            if (isset($unparsedLoadedData['sheets'][$sheetCodeName]['printerSettings'])) {
                foreach ($unparsedLoadedData['sheets'][$sheetCodeName]['printerSettings'] as $ctrlProp) {

<                     $this->addZipFile($ctrlProp['filePath'], $ctrlProp['content']);



>                     $zipContent[$ctrlProp['filePath']] = $ctrlProp['content'];


                }
            }

            $drawings = $this->spreadSheet->getSheet($i)->getDrawingCollection();
            $drawingCount = count($drawings);
            if ($this->includeCharts) {
                $chartCount = $this->spreadSheet->getSheet($i)->getChartCount();
            }

            // Add drawing and image relationship parts
            if (($drawingCount > 0) || ($chartCount > 0)) {
                // Drawing relationships

<                 $this->addZipFile('xl/drawings/_rels/drawing' . ($i + 1) . '.xml.rels', $this->getWriterPart('Rels')->writeDrawingRelationships($this->spreadSheet->getSheet($i), $chartRef1, $this->includeCharts));



>                 $zipContent['xl/drawings/_rels/drawing' . ($i + 1) . '.xml.rels'] = $this->getWriterPartRels()->writeDrawingRelationships($this->spreadSheet->getSheet($i), $chartRef1, $this->includeCharts);



                // Drawings

<                 $this->addZipFile('xl/drawings/drawing' . ($i + 1) . '.xml', $this->getWriterPart('Drawing')->writeDrawings($this->spreadSheet->getSheet($i), $this->includeCharts));



>                 $zipContent['xl/drawings/drawing' . ($i + 1) . '.xml'] = $this->getWriterPartDrawing()->writeDrawings($this->spreadSheet->getSheet($i), $this->includeCharts);


            } elseif (isset($unparsedLoadedData['sheets'][$sheetCodeName]['drawingAlternateContents'])) {
                // Drawings

<                 $this->addZipFile('xl/drawings/drawing' . ($i + 1) . '.xml', $this->getWriterPart('Drawing')->writeDrawings($this->spreadSheet->getSheet($i), $this->includeCharts));



>                 $zipContent['xl/drawings/drawing' . ($i + 1) . '.xml'] = $this->getWriterPartDrawing()->writeDrawings($this->spreadSheet->getSheet($i), $this->includeCharts);


            }

            // Add unparsed drawings
            if (isset($unparsedLoadedData['sheets'][$sheetCodeName]['Drawings'])) {
                foreach ($unparsedLoadedData['sheets'][$sheetCodeName]['Drawings'] as $relId => $drawingXml) {
                    $drawingFile = array_search($relId, $unparsedLoadedData['sheets'][$sheetCodeName]['drawingOriginalIds']);
                    if ($drawingFile !== false) {

<                         $drawingFile = ltrim($drawingFile, '.');
<                         $this->addZipFile('xl' . $drawingFile, $drawingXml);



>                         //$drawingFile = ltrim($drawingFile, '.');
>                         //$zipContent['xl' . $drawingFile] = $drawingXml;
>                         $zipContent['xl/drawings/drawing' . ($i + 1) . '.xml'] = $drawingXml;


                    }
                }
            }

            // Add comment relationship parts

<             if (count($this->spreadSheet->getSheet($i)->getComments()) > 0) {



>             $legacy = $unparsedLoadedData['sheets'][$this->spreadSheet->getSheet($i)->getCodeName()]['legacyDrawing'] ?? null;
>             if (count($this->spreadSheet->getSheet($i)->getComments()) > 0 || $legacy !== null) {
>                 // VML Comments relationships
>                 $zipContent['xl/drawings/_rels/vmlDrawing' . ($i + 1) . '.vml.rels'] = $this->getWriterPartRels()->writeVMLDrawingRelationships($this->spreadSheet->getSheet($i));
> 


                // VML Comments

<                 $this->addZipFile('xl/drawings/vmlDrawing' . ($i + 1) . '.vml', $this->getWriterPart('Comments')->writeVMLComments($this->spreadSheet->getSheet($i)));



>                 $zipContent['xl/drawings/vmlDrawing' . ($i + 1) . '.vml'] = $legacy ?? $this->getWriterPartComments()->writeVMLComments($this->spreadSheet->getSheet($i));
>             }



                // Comments

<                 $this->addZipFile('xl/comments' . ($i + 1) . '.xml', $this->getWriterPart('Comments')->writeComments($this->spreadSheet->getSheet($i)));



>             if (count($this->spreadSheet->getSheet($i)->getComments()) > 0) {
>                 $zipContent['xl/comments' . ($i + 1) . '.xml'] = $this->getWriterPartComments()->writeComments($this->spreadSheet->getSheet($i));
> 
>                 // Media
>                 foreach ($this->spreadSheet->getSheet($i)->getComments() as $comment) {
>                     if ($comment->hasBackgroundImage()) {
>                         $image = $comment->getBackgroundImage();
>                         $zipContent['xl/media/' . $image->getMediaFilename()] = $this->processDrawing($image);
>                     }
>                 }


            }

            // Add unparsed relationship parts
            if (isset($unparsedLoadedData['sheets'][$sheetCodeName]['vmlDrawings'])) {
                foreach ($unparsedLoadedData['sheets'][$sheetCodeName]['vmlDrawings'] as $vmlDrawing) {

<                     $this->addZipFile($vmlDrawing['filePath'], $vmlDrawing['content']);



>                     if (!isset($zipContent[$vmlDrawing['filePath']])) {
>                         $zipContent[$vmlDrawing['filePath']] = $vmlDrawing['content'];
>                     }


                }
            }

            // Add header/footer relationship parts
            if (count($this->spreadSheet->getSheet($i)->getHeaderFooter()->getImages()) > 0) {
                // VML Drawings

<                 $this->addZipFile('xl/drawings/vmlDrawingHF' . ($i + 1) . '.vml', $this->getWriterPart('Drawing')->writeVMLHeaderFooterImages($this->spreadSheet->getSheet($i)));



>                 $zipContent['xl/drawings/vmlDrawingHF' . ($i + 1) . '.vml'] = $this->getWriterPartDrawing()->writeVMLHeaderFooterImages($this->spreadSheet->getSheet($i));



                // VML Drawing relationships

<                 $this->addZipFile('xl/drawings/_rels/vmlDrawingHF' . ($i + 1) . '.vml.rels', $this->getWriterPart('Rels')->writeHeaderFooterDrawingRelationships($this->spreadSheet->getSheet($i)));



>                 $zipContent['xl/drawings/_rels/vmlDrawingHF' . ($i + 1) . '.vml.rels'] = $this->getWriterPartRels()->writeHeaderFooterDrawingRelationships($this->spreadSheet->getSheet($i));



                // Media
                foreach ($this->spreadSheet->getSheet($i)->getHeaderFooter()->getImages() as $image) {

<                     $this->addZipFile('xl/media/' . $image->getIndexedFilename(), file_get_contents($image->getPath()));



>                     $zipContent['xl/media/' . $image->getIndexedFilename()] = file_get_contents($image->getPath());
>                 }


                }

> 
            }
>             // Add Table parts
        }
>             $tables = $this->spreadSheet->getSheet($i)->getTableCollection();

>             foreach ($tables as $table) {
        // Add media
>                 $zipContent['xl/tables/table' . $tableRef1 . '.xml'] = $this->getWriterPartTable()->writeTable($table, $tableRef1++);


        for ($i = 0; $i < $this->getDrawingHashTable()->count(); ++$i) {
            if ($this->getDrawingHashTable()->getByIndex($i) instanceof WorksheetDrawing) {
                $imageContents = null;
                $imagePath = $this->getDrawingHashTable()->getByIndex($i)->getPath();
                if (strpos($imagePath, 'zip://') !== false) {
                    $imagePath = substr($imagePath, 6);
                    $imagePathSplitted = explode('#', $imagePath);

                    $imageZip = new ZipArchive();
                    $imageZip->open($imagePathSplitted[0]);
                    $imageContents = $imageZip->getFromName($imagePathSplitted[1]);
                    $imageZip->close();
                    unset($imageZip);
                } else {
                    $imageContents = file_get_contents($imagePath);
                }


<                 $this->addZipFile('xl/media/' . str_replace(' ', '_', $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()), $imageContents);



>                 $zipContent['xl/media/' . $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()] = $imageContents;


            } elseif ($this->getDrawingHashTable()->getByIndex($i) instanceof MemoryDrawing) {
                ob_start();

>                 /** @var callable */
                call_user_func(
>                 $callable = $this->getDrawingHashTable()->getByIndex($i)->getRenderingFunction();



<                     $this->getDrawingHashTable()->getByIndex($i)->getRenderingFunction(),



>                     $callable,


                    $this->getDrawingHashTable()->getByIndex($i)->getImageResource()
                );
                $imageContents = ob_get_contents();
                ob_end_clean();


<                 $this->addZipFile('xl/media/' . str_replace(' ', '_', $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()), $imageContents);



>                 $zipContent['xl/media/' . $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()] = $imageContents;


            }
        }

        Functions::setReturnDateType($saveDateReturnType);
        Calculation::getInstance($this->spreadSheet)->getDebugLog()->setWriteDebugLog($saveDebugLog);


>         $this->openFileHandle($filename);
        // Close file
> 
        try {
>         $options = new Archive();
            $this->zip->finish();
>         $options->setEnableZip64(false);
        } catch (OverflowException $e) {
>         $options->setOutputStream($this->fileHandle);
            throw new WriterException('Could not close resource.');
> 
        }
>         $this->zip = new ZipStream(null, $options);

> 
        $this->maybeCloseFileHandle();
>         $this->addZipFiles($zipContent);
    }
> 



    /**
     * Get Spreadsheet object.
     *
     * @return Spreadsheet
     */
    public function getSpreadsheet()
    {
        return $this->spreadSheet;
    }

    /**
     * Set Spreadsheet object.
     *
     * @param Spreadsheet $spreadsheet PhpSpreadsheet object
     *
     * @return $this
     */
    public function setSpreadsheet(Spreadsheet $spreadsheet)
    {
        $this->spreadSheet = $spreadsheet;

        return $this;
    }

    /**
     * Get string table.
     *
     * @return string[]
     */
    public function getStringTable()
    {
        return $this->stringTable;
    }

    /**
     * Get Style HashTable.
     *

<      * @return HashTable



>      * @return HashTable<\PhpOffice\PhpSpreadsheet\Style\Style>


     */
    public function getStyleHashTable()
    {
        return $this->styleHashTable;
    }

    /**
     * Get Conditional HashTable.
     *

<      * @return HashTable



>      * @return HashTable<Conditional>


     */
    public function getStylesConditionalHashTable()
    {
        return $this->stylesConditionalHashTable;
    }

    /**
     * Get Fill HashTable.
     *

<      * @return HashTable



>      * @return HashTable<Fill>


     */
    public function getFillHashTable()
    {
        return $this->fillHashTable;
    }

    /**
     * Get \PhpOffice\PhpSpreadsheet\Style\Font HashTable.
     *

<      * @return HashTable



>      * @return HashTable<Font>


     */
    public function getFontHashTable()
    {
        return $this->fontHashTable;
    }

    /**
     * Get Borders HashTable.
     *

<      * @return HashTable



>      * @return HashTable<Borders>


     */
    public function getBordersHashTable()
    {
        return $this->bordersHashTable;
    }

    /**
     * Get NumberFormat HashTable.
     *

<      * @return HashTable



>      * @return HashTable<NumberFormat>


     */
    public function getNumFmtHashTable()
    {
        return $this->numFmtHashTable;
    }

    /**
     * Get \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet\BaseDrawing HashTable.
     *

<      * @return HashTable



>      * @return HashTable<BaseDrawing>


     */
    public function getDrawingHashTable()
    {
        return $this->drawingHashTable;
    }

    /**
     * Get Office2003 compatibility.
     *
     * @return bool
     */
    public function getOffice2003Compatibility()
    {
        return $this->office2003compatibility;
    }

    /**
     * Set Office2003 compatibility.
     *

<      * @param bool $pValue Office2003 compatibility?



>      * @param bool $office2003compatibility Office2003 compatibility?


     *
     * @return $this
     */

<     public function setOffice2003Compatibility($pValue)



>     public function setOffice2003Compatibility($office2003compatibility)


    {

<         $this->office2003compatibility = $pValue;



>         $this->office2003compatibility = $office2003compatibility;



        return $this;
    }


>     /** @var array */


    private $pathNames = [];

    private function addZipFile(string $path, string $content): void
    {
        if (!in_array($path, $this->pathNames)) {
            $this->pathNames[] = $path;
            $this->zip->addFile($path, $content);
        }

>     }
    }
> 
}
>     private function addZipFiles(array $zipContent): void
>     {
>         foreach ($zipContent as $path => $content) {
>             $this->addZipFile($path, $content);
>         }
>     }
> 
>     /**
>      * @return mixed
>      */
>     private function processDrawing(WorksheetDrawing $drawing)
>     {
>         $data = null;
>         $filename = $drawing->getPath();
>         $imageData = getimagesize($filename);
> 
>         if (!empty($imageData)) {
>             switch ($imageData[2]) {
>                 case 1: // GIF, not supported by BIFF8, we convert to PNG
>                     $image = imagecreatefromgif($filename);
>                     if ($image !== false) {
>                         ob_start();
>                         imagepng($image);
>                         $data = ob_get_contents();
>                         ob_end_clean();
>                     }
> 
>                     break;
> 
>                 case 2: // JPEG
>                     $data = file_get_contents($filename);
> 
>                     break;
> 
>                 case 3: // PNG
>                     $data = file_get_contents($filename);
> 
>                     break;
> 
>                 case 6: // Windows DIB (BMP), we convert to PNG
>                     $image = imagecreatefrombmp($filename);
>                     if ($image !== false) {
>                         ob_start();
>                         imagepng($image);
>                         $data = ob_get_contents();
>                         ob_end_clean();
>                     }
> 
>                     break;
>             }
>         }
> 
>         return $data;