first commit

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Abstract.php

@@ -0,0 +1,301 @@
+<?php
+
+/**
+ * PHPExcel_Reader_Abstract
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+abstract class PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Read data only?
+     * Identifies whether the Reader should only read data values for cells, and ignore any formatting information;
+     *        or whether it should read both data and formatting
+     *
+     * @var    boolean
+     */
+    protected $readDataOnly = false;
+
+    /**
+     * Read empty cells?
+     * Identifies whether the Reader should read data values for cells all cells, or should ignore cells containing
+     *         null value or empty string
+     *
+     * @var    boolean
+     */
+    protected $readEmptyCells = true;
+
+    /**
+     * Read charts that are defined in the workbook?
+     * Identifies whether the Reader should read the definitions for any charts that exist in the workbook;
+     *
+     * @var    boolean
+     */
+    protected $includeCharts = false;
+
+    /**
+     * Restrict which sheets should be loaded?
+     * This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded.
+     *
+     * @var array of string
+     */
+    protected $loadSheetsOnly;
+
+    /**
+     * PHPExcel_Reader_IReadFilter instance
+     *
+     * @var PHPExcel_Reader_IReadFilter
+     */
+    protected $readFilter;
+
+    protected $fileHandle = null;
+
+
+    /**
+     * Read data only?
+     *        If this is true, then the Reader will only read data values for cells, it will not read any formatting information.
+     *        If false (the default) it will read data and formatting.
+     *
+     * @return    boolean
+     */
+    public function getReadDataOnly()
+    {
+        return $this->readDataOnly;
+    }
+
+    /**
+     * Set read data only
+     *        Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information.
+     *        Set to false (the default) to advise the Reader to read both data and formatting for cells.
+     *
+     * @param    boolean    $pValue
+     *
+     * @return    PHPExcel_Reader_IReader
+     */
+    public function setReadDataOnly($pValue = false)
+    {
+        $this->readDataOnly = $pValue;
+        return $this;
+    }
+
+    /**
+     * Read empty cells?
+     *        If this is true (the default), then the Reader will read data values for all cells, irrespective of value.
+     *        If false it will not read data for cells containing a null value or an empty string.
+     *
+     * @return    boolean
+     */
+    public function getReadEmptyCells()
+    {
+        return $this->readEmptyCells;
+    }
+
+    /**
+     * Set read empty cells
+     *        Set to true (the default) to advise the Reader read data values for all cells, irrespective of value.
+     *        Set to false to advise the Reader to ignore cells containing a null value or an empty string.
+     *
+     * @param    boolean    $pValue
+     *
+     * @return    PHPExcel_Reader_IReader
+     */
+    public function setReadEmptyCells($pValue = true)
+    {
+        $this->readEmptyCells = $pValue;
+        return $this;
+    }
+
+    /**
+     * Read charts in workbook?
+     *        If this is true, then the Reader will include any charts that exist in the workbook.
+     *      Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value.
+     *        If false (the default) it will ignore any charts defined in the workbook file.
+     *
+     * @return    boolean
+     */
+    public function getIncludeCharts()
+    {
+        return $this->includeCharts;
+    }
+
+    /**
+     * Set read charts in workbook
+     *        Set to true, to advise the Reader to include any charts that exist in the workbook.
+     *      Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value.
+     *        Set to false (the default) to discard charts.
+     *
+     * @param    boolean    $pValue
+     *
+     * @return    PHPExcel_Reader_IReader
+     */
+    public function setIncludeCharts($pValue = false)
+    {
+        $this->includeCharts = (boolean) $pValue;
+        return $this;
+    }
+
+    /**
+     * Get which sheets to load
+     * Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null
+     *        indicating that all worksheets in the workbook should be loaded.
+     *
+     * @return mixed
+     */
+    public function getLoadSheetsOnly()
+    {
+        return $this->loadSheetsOnly;
+    }
+
+    /**
+     * Set which sheets to load
+     *
+     * @param mixed $value
+     *        This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name.
+     *        If NULL, then it tells the Reader to read all worksheets in the workbook
+     *
+     * @return PHPExcel_Reader_IReader
+     */
+    public function setLoadSheetsOnly($value = null)
+    {
+        if ($value === null) {
+            return $this->setLoadAllSheets();
+        }
+
+        $this->loadSheetsOnly = is_array($value) ? $value : array($value);
+        return $this;
+    }
+
+    /**
+     * Set all sheets to load
+     *        Tells the Reader to load all worksheets from the workbook.
+     *
+     * @return PHPExcel_Reader_IReader
+     */
+    public function setLoadAllSheets()
+    {
+        $this->loadSheetsOnly = null;
+        return $this;
+    }
+
+    /**
+     * Read filter
+     *
+     * @return PHPExcel_Reader_IReadFilter
+     */
+    public function getReadFilter()
+    {
+        return $this->readFilter;
+    }
+
+    /**
+     * Set read filter
+     *
+     * @param PHPExcel_Reader_IReadFilter $pValue
+     * @return PHPExcel_Reader_IReader
+     */
+    public function setReadFilter(PHPExcel_Reader_IReadFilter $pValue)
+    {
+        $this->readFilter = $pValue;
+        return $this;
+    }
+
+    /**
+     * Open file for reading
+     *
+     * @param string $pFilename
+     * @throws    PHPExcel_Reader_Exception
+     * @return resource
+     */
+    protected function openFile($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename) || !is_readable($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        // Open file
+        $this->fileHandle = fopen($pFilename, 'r');
+        if ($this->fileHandle === false) {
+            throw new PHPExcel_Reader_Exception("Could not open file " . $pFilename . " for reading.");
+        }
+    }
+
+    /**
+     * Can the current PHPExcel_Reader_IReader read the file?
+     *
+     * @param     string         $pFilename
+     * @return boolean
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function canRead($pFilename)
+    {
+        // Check if file exists
+        try {
+            $this->openFile($pFilename);
+        } catch (Exception $e) {
+            return false;
+        }
+
+        $readable = $this->isValidFormat();
+        fclose($this->fileHandle);
+        return $readable;
+    }
+
+    /**
+     * Scan theXML for use of <!ENTITY to prevent XXE/XEE attacks
+     *
+     * @param     string         $xml
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function securityScan($xml)
+    {
+        $pattern = '/encoding="(.*?)"/';
+        $result = preg_match($pattern, $xml, $matches);
+        if ($result) {
+            $charset = $matches[1];
+        } else {
+            $charset = 'UTF-8';
+        }
+
+        if ($charset !== 'UTF-8') {
+            $xml = mb_convert_encoding($xml, 'UTF-8', $charset);
+        }
+
+        $pattern = '/\\0?' . implode('\\0?', str_split('<!DOCTYPE')) . '\\0?/';
+        if (preg_match($pattern, $xml)) {
+            throw new PHPExcel_Reader_Exception('Detected use of ENTITY in XML, spreadsheet file load() aborted to prevent XXE/XEE attacks');
+        }
+        return $xml;
+    }
+
+    /**
+     * Scan theXML for use of <!ENTITY to prevent XXE/XEE attacks
+     *
+     * @param     string         $filestream
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function securityScanFile($filestream)
+    {
+        return $this->securityScan(file_get_contents($filestream));
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/CSV.php

@@ -0,0 +1,406 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_CSV
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_CSV extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Input encoding
+     *
+     * @access    private
+     * @var    string
+     */
+    private $inputEncoding = 'UTF-8';
+
+    /**
+     * Delimiter
+     *
+     * @access    private
+     * @var string
+     */
+    private $delimiter = ',';
+
+    /**
+     * Enclosure
+     *
+     * @access    private
+     * @var    string
+     */
+    private $enclosure = '"';
+
+    /**
+     * Sheet index to read
+     *
+     * @access    private
+     * @var    int
+     */
+    private $sheetIndex = 0;
+
+    /**
+     * Load rows contiguously
+     *
+     * @access    private
+     * @var    int
+     */
+    private $contiguous = false;
+
+    /**
+     * Row counter for loading rows contiguously
+     *
+     * @var    int
+     */
+    private $contiguousRow = -1;
+
+
+    /**
+     * Create a new PHPExcel_Reader_CSV
+     */
+    public function __construct()
+    {
+        $this->readFilter = new PHPExcel_Reader_DefaultReadFilter();
+    }
+
+    /**
+     * Validate that the current file is a CSV file
+     *
+     * @return boolean
+     */
+    protected function isValidFormat()
+    {
+        return true;
+    }
+
+    /**
+     * Set input encoding
+     *
+     * @param string $pValue Input encoding
+     */
+    public function setInputEncoding($pValue = 'UTF-8')
+    {
+        $this->inputEncoding = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get input encoding
+     *
+     * @return string
+     */
+    public function getInputEncoding()
+    {
+        return $this->inputEncoding;
+    }
+
+    /**
+     * Move filepointer past any BOM marker
+     *
+     */
+    protected function skipBOM()
+    {
+        rewind($this->fileHandle);
+
+        switch ($this->inputEncoding) {
+            case 'UTF-8':
+                fgets($this->fileHandle, 4) == "\xEF\xBB\xBF" ?
+                    fseek($this->fileHandle, 3) : fseek($this->fileHandle, 0);
+                break;
+            case 'UTF-16LE':
+                fgets($this->fileHandle, 3) == "\xFF\xFE" ?
+                    fseek($this->fileHandle, 2) : fseek($this->fileHandle, 0);
+                break;
+            case 'UTF-16BE':
+                fgets($this->fileHandle, 3) == "\xFE\xFF" ?
+                    fseek($this->fileHandle, 2) : fseek($this->fileHandle, 0);
+                break;
+            case 'UTF-32LE':
+                fgets($this->fileHandle, 5) == "\xFF\xFE\x00\x00" ?
+                    fseek($this->fileHandle, 4) : fseek($this->fileHandle, 0);
+                break;
+            case 'UTF-32BE':
+                fgets($this->fileHandle, 5) == "\x00\x00\xFE\xFF" ?
+                    fseek($this->fileHandle, 4) : fseek($this->fileHandle, 0);
+                break;
+            default:
+                break;
+        }
+    }
+
+    /**
+     * Identify any separator that is explicitly set in the file
+     *
+     */
+    protected function checkSeparator()
+    {
+        $line = fgets($this->fileHandle);
+        if ($line === false) {
+            return;
+        }
+
+        if ((strlen(trim($line, "\r\n")) == 5) && (stripos($line, 'sep=') === 0)) {
+            $this->delimiter = substr($line, 4, 1);
+            return;
+        }
+        return $this->skipBOM();
+    }
+
+    /**
+     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
+     *
+     * @param     string         $pFilename
+     * @throws    PHPExcel_Reader_Exception
+     */
+    public function listWorksheetInfo($pFilename)
+    {
+        // Open file
+        $this->openFile($pFilename);
+        if (!$this->isValidFormat()) {
+            fclose($this->fileHandle);
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+        $fileHandle = $this->fileHandle;
+
+        // Skip BOM, if any
+        $this->skipBOM();
+        $this->checkSeparator();
+
+        $escapeEnclosures = array( "\\" . $this->enclosure, $this->enclosure . $this->enclosure );
+
+        $worksheetInfo = array();
+        $worksheetInfo[0]['worksheetName'] = 'Worksheet';
+        $worksheetInfo[0]['lastColumnLetter'] = 'A';
+        $worksheetInfo[0]['lastColumnIndex'] = 0;
+        $worksheetInfo[0]['totalRows'] = 0;
+        $worksheetInfo[0]['totalColumns'] = 0;
+
+        // Loop through each line of the file in turn
+        while (($rowData = fgetcsv($fileHandle, 0, $this->delimiter, $this->enclosure)) !== false) {
+            $worksheetInfo[0]['totalRows']++;
+            $worksheetInfo[0]['lastColumnIndex'] = max($worksheetInfo[0]['lastColumnIndex'], count($rowData) - 1);
+        }
+
+        $worksheetInfo[0]['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex']);
+        $worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1;
+
+        // Close file
+        fclose($fileHandle);
+
+        return $worksheetInfo;
+    }
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return PHPExcel
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param     string         $pFilename
+     * @param    PHPExcel    $objPHPExcel
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        $lineEnding = ini_get('auto_detect_line_endings');
+        ini_set('auto_detect_line_endings', true);
+
+        // Open file
+        $this->openFile($pFilename);
+        if (!$this->isValidFormat()) {
+            fclose($this->fileHandle);
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+        $fileHandle = $this->fileHandle;
+
+        // Skip BOM, if any
+        $this->skipBOM();
+        $this->checkSeparator();
+
+        // Create new PHPExcel object
+        while ($objPHPExcel->getSheetCount() <= $this->sheetIndex) {
+            $objPHPExcel->createSheet();
+        }
+        $sheet = $objPHPExcel->setActiveSheetIndex($this->sheetIndex);
+
+        $escapeEnclosures = array( "\\" . $this->enclosure,
+                                   $this->enclosure . $this->enclosure
+                                 );
+
+        // Set our starting row based on whether we're in contiguous mode or not
+        $currentRow = 1;
+        if ($this->contiguous) {
+            $currentRow = ($this->contiguousRow == -1) ? $sheet->getHighestRow(): $this->contiguousRow;
+        }
+
+        // Loop through each line of the file in turn
+        while (($rowData = fgetcsv($fileHandle, 0, $this->delimiter, $this->enclosure)) !== false) {
+            $columnLetter = 'A';
+            foreach ($rowData as $rowDatum) {
+                if ($rowDatum != '' && $this->readFilter->readCell($columnLetter, $currentRow)) {
+                    // Unescape enclosures
+                    $rowDatum = str_replace($escapeEnclosures, $this->enclosure, $rowDatum);
+
+                    // Convert encoding if necessary
+                    if ($this->inputEncoding !== 'UTF-8') {
+                        $rowDatum = PHPExcel_Shared_String::ConvertEncoding($rowDatum, 'UTF-8', $this->inputEncoding);
+                    }
+
+                    // Set cell value
+                    $sheet->getCell($columnLetter . $currentRow)->setValue($rowDatum);
+                }
+                ++$columnLetter;
+            }
+            ++$currentRow;
+        }
+
+        // Close file
+        fclose($fileHandle);
+
+        if ($this->contiguous) {
+            $this->contiguousRow = $currentRow;
+        }
+
+        ini_set('auto_detect_line_endings', $lineEnding);
+
+        // Return
+        return $objPHPExcel;
+    }
+
+    /**
+     * Get delimiter
+     *
+     * @return string
+     */
+    public function getDelimiter()
+    {
+        return $this->delimiter;
+    }
+
+    /**
+     * Set delimiter
+     *
+     * @param    string    $pValue        Delimiter, defaults to ,
+     * @return    PHPExcel_Reader_CSV
+     */
+    public function setDelimiter($pValue = ',')
+    {
+        $this->delimiter = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get enclosure
+     *
+     * @return string
+     */
+    public function getEnclosure()
+    {
+        return $this->enclosure;
+    }
+
+    /**
+     * Set enclosure
+     *
+     * @param    string    $pValue        Enclosure, defaults to "
+     * @return PHPExcel_Reader_CSV
+     */
+    public function setEnclosure($pValue = '"')
+    {
+        if ($pValue == '') {
+            $pValue = '"';
+        }
+        $this->enclosure = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get sheet index
+     *
+     * @return integer
+     */
+    public function getSheetIndex()
+    {
+        return $this->sheetIndex;
+    }
+
+    /**
+     * Set sheet index
+     *
+     * @param    integer        $pValue        Sheet index
+     * @return PHPExcel_Reader_CSV
+     */
+    public function setSheetIndex($pValue = 0)
+    {
+        $this->sheetIndex = $pValue;
+        return $this;
+    }
+
+    /**
+     * Set Contiguous
+     *
+     * @param boolean $contiguous
+     */
+    public function setContiguous($contiguous = false)
+    {
+        $this->contiguous = (bool) $contiguous;
+        if (!$contiguous) {
+            $this->contiguousRow = -1;
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get Contiguous
+     *
+     * @return boolean
+     */
+    public function getContiguous()
+    {
+        return $this->contiguous;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/DefaultReadFilter.php

@@ -0,0 +1,51 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_DefaultReadFilter
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_DefaultReadFilter implements PHPExcel_Reader_IReadFilter
+{
+    /**
+     * Should this cell be read?
+     *
+     * @param    $column           Column address (as a string value like "A", or "IV")
+     * @param    $row              Row number
+     * @param    $worksheetName    Optional worksheet name
+     * @return   boolean
+     */
+    public function readCell($column, $row, $worksheetName = '')
+    {
+        return true;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel2003XML.php

@@ -0,0 +1,801 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_Excel2003XML
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Excel2003XML extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Formats
+     *
+     * @var array
+     */
+    protected $styles = array();
+
+    /**
+     * Character set used in the file
+     *
+     * @var string
+     */
+    protected $charSet = 'UTF-8';
+
+    /**
+     * Create a new PHPExcel_Reader_Excel2003XML
+     */
+    public function __construct()
+    {
+        $this->readFilter = new PHPExcel_Reader_DefaultReadFilter();
+    }
+
+
+    /**
+     * Can the current PHPExcel_Reader_IReader read the file?
+     *
+     * @param     string         $pFilename
+     * @return     boolean
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function canRead($pFilename)
+    {
+
+        //    Office                    xmlns:o="urn:schemas-microsoft-com:office:office"
+        //    Excel                    xmlns:x="urn:schemas-microsoft-com:office:excel"
+        //    XML Spreadsheet            xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
+        //    Spreadsheet component    xmlns:c="urn:schemas-microsoft-com:office:component:spreadsheet"
+        //    XML schema                 xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882"
+        //    XML data type            xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
+        //    MS-persist recordset    xmlns:rs="urn:schemas-microsoft-com:rowset"
+        //    Rowset                    xmlns:z="#RowsetSchema"
+        //
+
+        $signature = array(
+                '<?xml version="1.0"',
+                '<?mso-application progid="Excel.Sheet"?>'
+            );
+
+        // Open file
+        $this->openFile($pFilename);
+        $fileHandle = $this->fileHandle;
+        
+        // Read sample data (first 2 KB will do)
+        $data = fread($fileHandle, 2048);
+        fclose($fileHandle);
+
+        $valid = true;
+        foreach ($signature as $match) {
+            // every part of the signature must be present
+            if (strpos($data, $match) === false) {
+                $valid = false;
+                break;
+            }
+        }
+
+        //    Retrieve charset encoding
+        if (preg_match('/<?xml.*encoding=[\'"](.*?)[\'"].*?>/um', $data, $matches)) {
+            $this->charSet = strtoupper($matches[1]);
+        }
+//        echo 'Character Set is ', $this->charSet,'<br />';
+
+        return $valid;
+    }
+
+
+    /**
+     * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object
+     *
+     * @param     string         $pFilename
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function listWorksheetNames($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+        if (!$this->canRead($pFilename)) {
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+
+        $worksheetNames = array();
+
+        $xml = simplexml_load_string($this->securityScan(file_get_contents($pFilename)), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespaces = $xml->getNamespaces(true);
+
+        $xml_ss = $xml->children($namespaces['ss']);
+        foreach ($xml_ss->Worksheet as $worksheet) {
+            $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+            $worksheetNames[] = self::convertStringEncoding((string) $worksheet_ss['Name'], $this->charSet);
+        }
+
+        return $worksheetNames;
+    }
+
+
+    /**
+     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
+     *
+     * @param   string     $pFilename
+     * @throws   PHPExcel_Reader_Exception
+     */
+    public function listWorksheetInfo($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $worksheetInfo = array();
+
+        $xml = simplexml_load_string($this->securityScan(file_get_contents($pFilename)), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespaces = $xml->getNamespaces(true);
+
+        $worksheetID = 1;
+        $xml_ss = $xml->children($namespaces['ss']);
+        foreach ($xml_ss->Worksheet as $worksheet) {
+            $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+
+            $tmpInfo = array();
+            $tmpInfo['worksheetName'] = '';
+            $tmpInfo['lastColumnLetter'] = 'A';
+            $tmpInfo['lastColumnIndex'] = 0;
+            $tmpInfo['totalRows'] = 0;
+            $tmpInfo['totalColumns'] = 0;
+
+            if (isset($worksheet_ss['Name'])) {
+                $tmpInfo['worksheetName'] = (string) $worksheet_ss['Name'];
+            } else {
+                $tmpInfo['worksheetName'] = "Worksheet_{$worksheetID}";
+            }
+
+            if (isset($worksheet->Table->Row)) {
+                $rowIndex = 0;
+
+                foreach ($worksheet->Table->Row as $rowData) {
+                    $columnIndex = 0;
+                    $rowHasData = false;
+
+                    foreach ($rowData->Cell as $cell) {
+                        if (isset($cell->Data)) {
+                            $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex);
+                            $rowHasData = true;
+                        }
+
+                        ++$columnIndex;
+                    }
+
+                    ++$rowIndex;
+
+                    if ($rowHasData) {
+                        $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex);
+                    }
+                }
+            }
+
+            $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);
+            $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;
+
+            $worksheetInfo[] = $tmpInfo;
+            ++$worksheetID;
+        }
+
+        return $worksheetInfo;
+    }
+
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+        $objPHPExcel->removeSheetByIndex(0);
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    protected static function identifyFixedStyleValue($styleList, &$styleAttributeValue)
+    {
+        $styleAttributeValue = strtolower($styleAttributeValue);
+        foreach ($styleList as $style) {
+            if ($styleAttributeValue == strtolower($style)) {
+                $styleAttributeValue = $style;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * pixel units to excel width units(units of 1/256th of a character width)
+     * @param pxs
+     * @return
+     */
+    protected static function pixel2WidthUnits($pxs)
+    {
+        $UNIT_OFFSET_MAP = array(0, 36, 73, 109, 146, 182, 219);
+
+        $widthUnits = 256 * ($pxs / 7);
+        $widthUnits += $UNIT_OFFSET_MAP[($pxs % 7)];
+        return $widthUnits;
+    }
+
+    /**
+     * excel width units(units of 1/256th of a character width) to pixel units
+     * @param widthUnits
+     * @return
+     */
+    protected static function widthUnits2Pixel($widthUnits)
+    {
+        $pixels = ($widthUnits / 256) * 7;
+        $offsetWidthUnits = $widthUnits % 256;
+        $pixels += round($offsetWidthUnits / (256 / 7));
+        return $pixels;
+    }
+
+    protected static function hex2str($hex)
+    {
+        return chr(hexdec($hex[1]));
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param     string         $pFilename
+     * @param    PHPExcel    $objPHPExcel
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        $fromFormats    = array('\-', '\ ');
+        $toFormats      = array('-', ' ');
+
+        $underlineStyles = array (
+            PHPExcel_Style_Font::UNDERLINE_NONE,
+            PHPExcel_Style_Font::UNDERLINE_DOUBLE,
+            PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING,
+            PHPExcel_Style_Font::UNDERLINE_SINGLE,
+            PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING
+        );
+        $verticalAlignmentStyles = array (
+            PHPExcel_Style_Alignment::VERTICAL_BOTTOM,
+            PHPExcel_Style_Alignment::VERTICAL_TOP,
+            PHPExcel_Style_Alignment::VERTICAL_CENTER,
+            PHPExcel_Style_Alignment::VERTICAL_JUSTIFY
+        );
+        $horizontalAlignmentStyles = array (
+            PHPExcel_Style_Alignment::HORIZONTAL_GENERAL,
+            PHPExcel_Style_Alignment::HORIZONTAL_LEFT,
+            PHPExcel_Style_Alignment::HORIZONTAL_RIGHT,
+            PHPExcel_Style_Alignment::HORIZONTAL_CENTER,
+            PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS,
+            PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY
+        );
+
+        $timezoneObj = new DateTimeZone('Europe/London');
+        $GMT = new DateTimeZone('UTC');
+
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        if (!$this->canRead($pFilename)) {
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+
+        $xml = simplexml_load_string($this->securityScan(file_get_contents($pFilename)), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespaces = $xml->getNamespaces(true);
+
+        $docProps = $objPHPExcel->getProperties();
+        if (isset($xml->DocumentProperties[0])) {
+            foreach ($xml->DocumentProperties[0] as $propertyName => $propertyValue) {
+                switch ($propertyName) {
+                    case 'Title':
+                        $docProps->setTitle(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Subject':
+                        $docProps->setSubject(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Author':
+                        $docProps->setCreator(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Created':
+                        $creationDate = strtotime($propertyValue);
+                        $docProps->setCreated($creationDate);
+                        break;
+                    case 'LastAuthor':
+                        $docProps->setLastModifiedBy(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'LastSaved':
+                        $lastSaveDate = strtotime($propertyValue);
+                        $docProps->setModified($lastSaveDate);
+                        break;
+                    case 'Company':
+                        $docProps->setCompany(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Category':
+                        $docProps->setCategory(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Manager':
+                        $docProps->setManager(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Keywords':
+                        $docProps->setKeywords(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                    case 'Description':
+                        $docProps->setDescription(self::convertStringEncoding($propertyValue, $this->charSet));
+                        break;
+                }
+            }
+        }
+        if (isset($xml->CustomDocumentProperties)) {
+            foreach ($xml->CustomDocumentProperties[0] as $propertyName => $propertyValue) {
+                $propertyAttributes = $propertyValue->attributes($namespaces['dt']);
+                $propertyName = preg_replace_callback('/_x([0-9a-z]{4})_/', 'PHPExcel_Reader_Excel2003XML::hex2str', $propertyName);
+                $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_UNKNOWN;
+                switch ((string) $propertyAttributes) {
+                    case 'string':
+                        $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING;
+                        $propertyValue = trim($propertyValue);
+                        break;
+                    case 'boolean':
+                        $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_BOOLEAN;
+                        $propertyValue = (bool) $propertyValue;
+                        break;
+                    case 'integer':
+                        $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_INTEGER;
+                        $propertyValue = intval($propertyValue);
+                        break;
+                    case 'float':
+                        $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_FLOAT;
+                        $propertyValue = floatval($propertyValue);
+                        break;
+                    case 'dateTime.tz':
+                        $propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_DATE;
+                        $propertyValue = strtotime(trim($propertyValue));
+                        break;
+                }
+                $docProps->setCustomProperty($propertyName, $propertyValue, $propertyType);
+            }
+        }
+
+        foreach ($xml->Styles[0] as $style) {
+            $style_ss = $style->attributes($namespaces['ss']);
+            $styleID = (string) $style_ss['ID'];
+//            echo 'Style ID = '.$styleID.'<br />';
+            $this->styles[$styleID] = (isset($this->styles['Default'])) ? $this->styles['Default'] : array();
+            foreach ($style as $styleType => $styleData) {
+                $styleAttributes = $styleData->attributes($namespaces['ss']);
+//                echo $styleType.'<br />';
+                switch ($styleType) {
+                    case 'Alignment':
+                        foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+//                                echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
+                            $styleAttributeValue = (string) $styleAttributeValue;
+                            switch ($styleAttributeKey) {
+                                case 'Vertical':
+                                    if (self::identifyFixedStyleValue($verticalAlignmentStyles, $styleAttributeValue)) {
+                                        $this->styles[$styleID]['alignment']['vertical'] = $styleAttributeValue;
+                                    }
+                                    break;
+                                case 'Horizontal':
+                                    if (self::identifyFixedStyleValue($horizontalAlignmentStyles, $styleAttributeValue)) {
+                                        $this->styles[$styleID]['alignment']['horizontal'] = $styleAttributeValue;
+                                    }
+                                    break;
+                                case 'WrapText':
+                                    $this->styles[$styleID]['alignment']['wrap'] = true;
+                                    break;
+                            }
+                        }
+                        break;
+                    case 'Borders':
+                        foreach ($styleData->Border as $borderStyle) {
+                            $borderAttributes = $borderStyle->attributes($namespaces['ss']);
+                            $thisBorder = array();
+                            foreach ($borderAttributes as $borderStyleKey => $borderStyleValue) {
+//                                    echo $borderStyleKey.' = '.$borderStyleValue.'<br />';
+                                switch ($borderStyleKey) {
+                                    case 'LineStyle':
+                                        $thisBorder['style'] = PHPExcel_Style_Border::BORDER_MEDIUM;
+//                                                $thisBorder['style'] = $borderStyleValue;
+                                        break;
+                                    case 'Weight':
+//                                                $thisBorder['style'] = $borderStyleValue;
+                                        break;
+                                    case 'Position':
+                                        $borderPosition = strtolower($borderStyleValue);
+                                        break;
+                                    case 'Color':
+                                        $borderColour = substr($borderStyleValue, 1);
+                                        $thisBorder['color']['rgb'] = $borderColour;
+                                        break;
+                                }
+                            }
+                            if (!empty($thisBorder)) {
+                                if (($borderPosition == 'left') || ($borderPosition == 'right') || ($borderPosition == 'top') || ($borderPosition == 'bottom')) {
+                                    $this->styles[$styleID]['borders'][$borderPosition] = $thisBorder;
+                                }
+                            }
+                        }
+                        break;
+                    case 'Font':
+                        foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+//                                echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
+                            $styleAttributeValue = (string) $styleAttributeValue;
+                            switch ($styleAttributeKey) {
+                                case 'FontName':
+                                    $this->styles[$styleID]['font']['name'] = $styleAttributeValue;
+                                    break;
+                                case 'Size':
+                                    $this->styles[$styleID]['font']['size'] = $styleAttributeValue;
+                                    break;
+                                case 'Color':
+                                    $this->styles[$styleID]['font']['color']['rgb'] = substr($styleAttributeValue, 1);
+                                    break;
+                                case 'Bold':
+                                    $this->styles[$styleID]['font']['bold'] = true;
+                                    break;
+                                case 'Italic':
+                                    $this->styles[$styleID]['font']['italic'] = true;
+                                    break;
+                                case 'Underline':
+                                    if (self::identifyFixedStyleValue($underlineStyles, $styleAttributeValue)) {
+                                        $this->styles[$styleID]['font']['underline'] = $styleAttributeValue;
+                                    }
+                                    break;
+                            }
+                        }
+                        break;
+                    case 'Interior':
+                        foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+//                                echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
+                            switch ($styleAttributeKey) {
+                                case 'Color':
+                                    $this->styles[$styleID]['fill']['color']['rgb'] = substr($styleAttributeValue, 1);
+                                    break;
+                            }
+                        }
+                        break;
+                    case 'NumberFormat':
+                        foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+//                                echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
+                            $styleAttributeValue = str_replace($fromFormats, $toFormats, $styleAttributeValue);
+                            switch ($styleAttributeValue) {
+                                case 'Short Date':
+                                    $styleAttributeValue = 'dd/mm/yyyy';
+                                    break;
+                            }
+                            if ($styleAttributeValue > '') {
+                                $this->styles[$styleID]['numberformat']['code'] = $styleAttributeValue;
+                            }
+                        }
+                        break;
+                    case 'Protection':
+                        foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+//                                echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />';
+                        }
+                        break;
+                }
+            }
+//            print_r($this->styles[$styleID]);
+//            echo '<hr />';
+        }
+//        echo '<hr />';
+
+        $worksheetID = 0;
+        $xml_ss = $xml->children($namespaces['ss']);
+
+        foreach ($xml_ss->Worksheet as $worksheet) {
+            $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+
+            if ((isset($this->loadSheetsOnly)) && (isset($worksheet_ss['Name'])) &&
+                (!in_array($worksheet_ss['Name'], $this->loadSheetsOnly))) {
+                continue;
+            }
+
+//            echo '<h3>Worksheet: ', $worksheet_ss['Name'],'<h3>';
+//
+            // Create new Worksheet
+            $objPHPExcel->createSheet();
+            $objPHPExcel->setActiveSheetIndex($worksheetID);
+            if (isset($worksheet_ss['Name'])) {
+                $worksheetName = self::convertStringEncoding((string) $worksheet_ss['Name'], $this->charSet);
+                //    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
+                $objPHPExcel->getActiveSheet()->setTitle($worksheetName, false);
+            }
+
+            $columnID = 'A';
+            if (isset($worksheet->Table->Column)) {
+                foreach ($worksheet->Table->Column as $columnData) {
+                    $columnData_ss = $columnData->attributes($namespaces['ss']);
+                    if (isset($columnData_ss['Index'])) {
+                        $columnID = PHPExcel_Cell::stringFromColumnIndex($columnData_ss['Index']-1);
+                    }
+                    if (isset($columnData_ss['Width'])) {
+                        $columnWidth = $columnData_ss['Width'];
+//                        echo '<b>Setting column width for '.$columnID.' to '.$columnWidth.'</b><br />';
+                        $objPHPExcel->getActiveSheet()->getColumnDimension($columnID)->setWidth($columnWidth / 5.4);
+                    }
+                    ++$columnID;
+                }
+            }
+
+            $rowID = 1;
+            if (isset($worksheet->Table->Row)) {
+                $additionalMergedCells = 0;
+                foreach ($worksheet->Table->Row as $rowData) {
+                    $rowHasData = false;
+                    $row_ss = $rowData->attributes($namespaces['ss']);
+                    if (isset($row_ss['Index'])) {
+                        $rowID = (integer) $row_ss['Index'];
+                    }
+//                    echo '<b>Row '.$rowID.'</b><br />';
+
+                    $columnID = 'A';
+                    foreach ($rowData->Cell as $cell) {
+                        $cell_ss = $cell->attributes($namespaces['ss']);
+                        if (isset($cell_ss['Index'])) {
+                            $columnID = PHPExcel_Cell::stringFromColumnIndex($cell_ss['Index']-1);
+                        }
+                        $cellRange = $columnID.$rowID;
+
+                        if ($this->getReadFilter() !== null) {
+                            if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) {
+                                continue;
+                            }
+                        }
+
+                        if ((isset($cell_ss['MergeAcross'])) || (isset($cell_ss['MergeDown']))) {
+                            $columnTo = $columnID;
+                            if (isset($cell_ss['MergeAcross'])) {
+                                $additionalMergedCells += (int)$cell_ss['MergeAcross'];
+                                $columnTo = PHPExcel_Cell::stringFromColumnIndex(PHPExcel_Cell::columnIndexFromString($columnID) + $cell_ss['MergeAcross'] -1);
+                            }
+                            $rowTo = $rowID;
+                            if (isset($cell_ss['MergeDown'])) {
+                                $rowTo = $rowTo + $cell_ss['MergeDown'];
+                            }
+                            $cellRange .= ':'.$columnTo.$rowTo;
+                            $objPHPExcel->getActiveSheet()->mergeCells($cellRange);
+                        }
+
+                        $cellIsSet = $hasCalculatedValue = false;
+                        $cellDataFormula = '';
+                        if (isset($cell_ss['Formula'])) {
+                            $cellDataFormula = $cell_ss['Formula'];
+                            // added this as a check for array formulas
+                            if (isset($cell_ss['ArrayRange'])) {
+                                $cellDataCSEFormula = $cell_ss['ArrayRange'];
+//                                echo "found an array formula at ".$columnID.$rowID."<br />";
+                            }
+                            $hasCalculatedValue = true;
+                        }
+                        if (isset($cell->Data)) {
+                            $cellValue = $cellData = $cell->Data;
+                            $type = PHPExcel_Cell_DataType::TYPE_NULL;
+                            $cellData_ss = $cellData->attributes($namespaces['ss']);
+                            if (isset($cellData_ss['Type'])) {
+                                $cellDataType = $cellData_ss['Type'];
+                                switch ($cellDataType) {
+                                    /*
+                                    const TYPE_STRING        = 's';
+                                    const TYPE_FORMULA        = 'f';
+                                    const TYPE_NUMERIC        = 'n';
+                                    const TYPE_BOOL            = 'b';
+                                    const TYPE_NULL            = 'null';
+                                    const TYPE_INLINE        = 'inlineStr';
+                                    const TYPE_ERROR        = 'e';
+                                    */
+                                    case 'String':
+                                        $cellValue = self::convertStringEncoding($cellValue, $this->charSet);
+                                        $type = PHPExcel_Cell_DataType::TYPE_STRING;
+                                        break;
+                                    case 'Number':
+                                        $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                        $cellValue = (float) $cellValue;
+                                        if (floor($cellValue) == $cellValue) {
+                                            $cellValue = (integer) $cellValue;
+                                        }
+                                        break;
+                                    case 'Boolean':
+                                        $type = PHPExcel_Cell_DataType::TYPE_BOOL;
+                                        $cellValue = ($cellValue != 0);
+                                        break;
+                                    case 'DateTime':
+                                        $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                        $cellValue = PHPExcel_Shared_Date::PHPToExcel(strtotime($cellValue));
+                                        break;
+                                    case 'Error':
+                                        $type = PHPExcel_Cell_DataType::TYPE_ERROR;
+                                        break;
+                                }
+                            }
+
+                            if ($hasCalculatedValue) {
+//                                echo 'FORMULA<br />';
+                                $type = PHPExcel_Cell_DataType::TYPE_FORMULA;
+                                $columnNumber = PHPExcel_Cell::columnIndexFromString($columnID);
+                                if (substr($cellDataFormula, 0, 3) == 'of:') {
+                                    $cellDataFormula = substr($cellDataFormula, 3);
+//                                    echo 'Before: ', $cellDataFormula,'<br />';
+                                    $temp = explode('"', $cellDataFormula);
+                                    $key = false;
+                                    foreach ($temp as &$value) {
+                                        //    Only replace in alternate array entries (i.e. non-quoted blocks)
+                                        if ($key = !$key) {
+                                            $value = str_replace(array('[.', '.', ']'), '', $value);
+                                        }
+                                    }
+                                } else {
+                                    //    Convert R1C1 style references to A1 style references (but only when not quoted)
+//                                    echo 'Before: ', $cellDataFormula,'<br />';
+                                    $temp = explode('"', $cellDataFormula);
+                                    $key = false;
+                                    foreach ($temp as &$value) {
+                                        //    Only replace in alternate array entries (i.e. non-quoted blocks)
+                                        if ($key = !$key) {
+                                            preg_match_all('/(R(\[?-?\d*\]?))(C(\[?-?\d*\]?))/', $value, $cellReferences, PREG_SET_ORDER + PREG_OFFSET_CAPTURE);
+                                            //    Reverse the matches array, otherwise all our offsets will become incorrect if we modify our way
+                                            //        through the formula from left to right. Reversing means that we work right to left.through
+                                            //        the formula
+                                            $cellReferences = array_reverse($cellReferences);
+                                            //    Loop through each R1C1 style reference in turn, converting it to its A1 style equivalent,
+                                            //        then modify the formula to use that new reference
+                                            foreach ($cellReferences as $cellReference) {
+                                                $rowReference = $cellReference[2][0];
+                                                //    Empty R reference is the current row
+                                                if ($rowReference == '') {
+                                                    $rowReference = $rowID;
+                                                }
+                                                //    Bracketed R references are relative to the current row
+                                                if ($rowReference{0} == '[') {
+                                                    $rowReference = $rowID + trim($rowReference, '[]');
+                                                }
+                                                $columnReference = $cellReference[4][0];
+                                                //    Empty C reference is the current column
+                                                if ($columnReference == '') {
+                                                    $columnReference = $columnNumber;
+                                                }
+                                                //    Bracketed C references are relative to the current column
+                                                if ($columnReference{0} == '[') {
+                                                    $columnReference = $columnNumber + trim($columnReference, '[]');
+                                                }
+                                                $A1CellReference = PHPExcel_Cell::stringFromColumnIndex($columnReference-1).$rowReference;
+                                                $value = substr_replace($value, $A1CellReference, $cellReference[0][1], strlen($cellReference[0][0]));
+                                            }
+                                        }
+                                    }
+                                }
+                                unset($value);
+                                //    Then rebuild the formula string
+                                $cellDataFormula = implode('"', $temp);
+//                                echo 'After: ', $cellDataFormula,'<br />';
+                            }
+
+//                            echo 'Cell '.$columnID.$rowID.' is a '.$type.' with a value of '.(($hasCalculatedValue) ? $cellDataFormula : $cellValue).'<br />';
+//
+                            $objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setValueExplicit((($hasCalculatedValue) ? $cellDataFormula : $cellValue), $type);
+                            if ($hasCalculatedValue) {
+//                                echo 'Formula result is '.$cellValue.'<br />';
+                                $objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setCalculatedValue($cellValue);
+                            }
+                            $cellIsSet = $rowHasData = true;
+                        }
+
+                        if (isset($cell->Comment)) {
+//                            echo '<b>comment found</b><br />';
+                            $commentAttributes = $cell->Comment->attributes($namespaces['ss']);
+                            $author = 'unknown';
+                            if (isset($commentAttributes->Author)) {
+                                $author = (string)$commentAttributes->Author;
+//                                echo 'Author: ', $author,'<br />';
+                            }
+                            $node = $cell->Comment->Data->asXML();
+//                            $annotation = str_replace('html:','',substr($node,49,-10));
+//                            echo $annotation,'<br />';
+                            $annotation = strip_tags($node);
+//                            echo 'Annotation: ', $annotation,'<br />';
+                            $objPHPExcel->getActiveSheet()->getComment($columnID.$rowID)->setAuthor(self::convertStringEncoding($author, $this->charSet))->setText($this->parseRichText($annotation));
+                        }
+
+                        if (($cellIsSet) && (isset($cell_ss['StyleID']))) {
+                            $style = (string) $cell_ss['StyleID'];
+//                            echo 'Cell style for '.$columnID.$rowID.' is '.$style.'<br />';
+                            if ((isset($this->styles[$style])) && (!empty($this->styles[$style]))) {
+//                                echo 'Cell '.$columnID.$rowID.'<br />';
+//                                print_r($this->styles[$style]);
+//                                echo '<br />';
+                                if (!$objPHPExcel->getActiveSheet()->cellExists($columnID.$rowID)) {
+                                    $objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setValue(null);
+                                }
+                                $objPHPExcel->getActiveSheet()->getStyle($cellRange)->applyFromArray($this->styles[$style]);
+                            }
+                        }
+                        ++$columnID;
+                        while ($additionalMergedCells > 0) {
+                            ++$columnID;
+                            $additionalMergedCells--;
+                        }
+                    }
+
+                    if ($rowHasData) {
+                        if (isset($row_ss['StyleID'])) {
+                            $rowStyle = $row_ss['StyleID'];
+                        }
+                        if (isset($row_ss['Height'])) {
+                            $rowHeight = $row_ss['Height'];
+//                            echo '<b>Setting row height to '.$rowHeight.'</b><br />';
+                            $objPHPExcel->getActiveSheet()->getRowDimension($rowID)->setRowHeight($rowHeight);
+                        }
+                    }
+
+                    ++$rowID;
+                }
+            }
+            ++$worksheetID;
+        }
+
+        // Return
+        return $objPHPExcel;
+    }
+
+
+    protected static function convertStringEncoding($string, $charset)
+    {
+        if ($charset != 'UTF-8') {
+            return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', $charset);
+        }
+        return $string;
+    }
+
+
+    protected function parseRichText($is = '')
+    {
+        $value = new PHPExcel_RichText();
+
+        $value->createText(self::convertStringEncoding($is, $this->charSet));
+
+        return $value;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel2007/Chart.php

@@ -0,0 +1,520 @@
+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category    PHPExcel
+ * @package        PHPExcel_Reader_Excel2007
+ * @copyright    Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license        http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version        ##VERSION##, ##DATE##
+ */
+
+/**
+ * PHPExcel_Reader_Excel2007_Chart
+ *
+ * @category    PHPExcel
+ * @package        PHPExcel_Reader_Excel2007
+ * @copyright    Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Reader_Excel2007_Chart
+{
+    private static function getAttribute($component, $name, $format)
+    {
+        $attributes = $component->attributes();
+        if (isset($attributes[$name])) {
+            if ($format == 'string') {
+                return (string) $attributes[$name];
+            } elseif ($format == 'integer') {
+                return (integer) $attributes[$name];
+            } elseif ($format == 'boolean') {
+                return (boolean) ($attributes[$name] === '0' || $attributes[$name] !== 'true') ? false : true;
+            } else {
+                return (float) $attributes[$name];
+            }
+        }
+        return null;
+    }
+
+
+    private static function readColor($color, $background = false)
+    {
+        if (isset($color["rgb"])) {
+            return (string)$color["rgb"];
+        } elseif (isset($color["indexed"])) {
+            return PHPExcel_Style_Color::indexedColor($color["indexed"]-7, $background)->getARGB();
+        }
+    }
+
+    public static function readChart($chartElements, $chartName)
+    {
+        $namespacesChartMeta = $chartElements->getNamespaces(true);
+        $chartElementsC = $chartElements->children($namespacesChartMeta['c']);
+
+        $XaxisLabel = $YaxisLabel = $legend = $title = null;
+        $dispBlanksAs = $plotVisOnly = null;
+
+        foreach ($chartElementsC as $chartElementKey => $chartElement) {
+            switch ($chartElementKey) {
+                case "chart":
+                    foreach ($chartElement as $chartDetailsKey => $chartDetails) {
+                        $chartDetailsC = $chartDetails->children($namespacesChartMeta['c']);
+                        switch ($chartDetailsKey) {
+                            case "plotArea":
+                                $plotAreaLayout = $XaxisLable = $YaxisLable = null;
+                                $plotSeries = $plotAttributes = array();
+                                foreach ($chartDetails as $chartDetailKey => $chartDetail) {
+                                    switch ($chartDetailKey) {
+                                        case "layout":
+                                            $plotAreaLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta, 'plotArea');
+                                            break;
+                                        case "catAx":
+                                            if (isset($chartDetail->title)) {
+                                                $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta, 'cat');
+                                            }
+                                            break;
+                                        case "dateAx":
+                                            if (isset($chartDetail->title)) {
+                                                $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta, 'cat');
+                                            }
+                                            break;
+                                        case "valAx":
+                                            if (isset($chartDetail->title)) {
+                                                $YaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta, 'cat');
+                                            }
+                                            break;
+                                        case "barChart":
+                                        case "bar3DChart":
+                                            $barDirection = self::getAttribute($chartDetail->barDir, 'val', 'string');
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotDirection($barDirection);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "lineChart":
+                                        case "line3DChart":
+                                            $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "areaChart":
+                                        case "area3DChart":
+                                            $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "doughnutChart":
+                                        case "pieChart":
+                                        case "pie3DChart":
+                                            $explosion = isset($chartDetail->ser->explosion);
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotStyle($explosion);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "scatterChart":
+                                            $scatterStyle = self::getAttribute($chartDetail->scatterStyle, 'val', 'string');
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotStyle($scatterStyle);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "bubbleChart":
+                                            $bubbleScale = self::getAttribute($chartDetail->bubbleScale, 'val', 'integer');
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotStyle($bubbleScale);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "radarChart":
+                                            $radarStyle = self::getAttribute($chartDetail->radarStyle, 'val', 'string');
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotStyle($radarStyle);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "surfaceChart":
+                                        case "surface3DChart":
+                                            $wireFrame = self::getAttribute($chartDetail->wireframe, 'val', 'boolean');
+                                            $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotSer->setPlotStyle($wireFrame);
+                                            $plotSeries[] = $plotSer;
+                                            $plotAttributes = self::readChartAttributes($chartDetail);
+                                            break;
+                                        case "stockChart":
+                                            $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+                                            $plotAttributes = self::readChartAttributes($plotAreaLayout);
+                                            break;
+                                    }
+                                }
+                                if ($plotAreaLayout == null) {
+                                    $plotAreaLayout = new PHPExcel_Chart_Layout();
+                                }
+                                $plotArea = new PHPExcel_Chart_PlotArea($plotAreaLayout, $plotSeries);
+                                self::setChartAttributes($plotAreaLayout, $plotAttributes);
+                                break;
+                            case "plotVisOnly":
+                                $plotVisOnly = self::getAttribute($chartDetails, 'val', 'string');
+                                break;
+                            case "dispBlanksAs":
+                                $dispBlanksAs = self::getAttribute($chartDetails, 'val', 'string');
+                                break;
+                            case "title":
+                                $title = self::chartTitle($chartDetails, $namespacesChartMeta, 'title');
+                                break;
+                            case "legend":
+                                $legendPos = 'r';
+                                $legendLayout = null;
+                                $legendOverlay = false;
+                                foreach ($chartDetails as $chartDetailKey => $chartDetail) {
+                                    switch ($chartDetailKey) {
+                                        case "legendPos":
+                                            $legendPos = self::getAttribute($chartDetail, 'val', 'string');
+                                            break;
+                                        case "overlay":
+                                            $legendOverlay = self::getAttribute($chartDetail, 'val', 'boolean');
+                                            break;
+                                        case "layout":
+                                            $legendLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta, 'legend');
+                                            break;
+                                    }
+                                }
+                                $legend = new PHPExcel_Chart_Legend($legendPos, $legendLayout, $legendOverlay);
+                                break;
+                        }
+                    }
+            }
+        }
+        $chart = new PHPExcel_Chart($chartName, $title, $legend, $plotArea, $plotVisOnly, $dispBlanksAs, $XaxisLabel, $YaxisLabel);
+
+        return $chart;
+    }
+
+    private static function chartTitle($titleDetails, $namespacesChartMeta, $type)
+    {
+        $caption = array();
+        $titleLayout = null;
+        foreach ($titleDetails as $titleDetailKey => $chartDetail) {
+            switch ($titleDetailKey) {
+                case "tx":
+                    $titleDetails = $chartDetail->rich->children($namespacesChartMeta['a']);
+                    foreach ($titleDetails as $titleKey => $titleDetail) {
+                        switch ($titleKey) {
+                            case "p":
+                                $titleDetailPart = $titleDetail->children($namespacesChartMeta['a']);
+                                $caption[] = self::parseRichText($titleDetailPart);
+                        }
+                    }
+                    break;
+                case "layout":
+                    $titleLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
+                    break;
+            }
+        }
+
+        return new PHPExcel_Chart_Title($caption, $titleLayout);
+    }
+
+    private static function chartLayoutDetails($chartDetail, $namespacesChartMeta)
+    {
+        if (!isset($chartDetail->manualLayout)) {
+            return null;
+        }
+        $details = $chartDetail->manualLayout->children($namespacesChartMeta['c']);
+        if (is_null($details)) {
+            return null;
+        }
+        $layout = array();
+        foreach ($details as $detailKey => $detail) {
+//            echo $detailKey, ' => ',self::getAttribute($detail, 'val', 'string'),PHP_EOL;
+            $layout[$detailKey] = self::getAttribute($detail, 'val', 'string');
+        }
+        return new PHPExcel_Chart_Layout($layout);
+    }
+
+    private static function chartDataSeries($chartDetail, $namespacesChartMeta, $plotType)
+    {
+        $multiSeriesType = null;
+        $smoothLine = false;
+        $seriesLabel = $seriesCategory = $seriesValues = $plotOrder = array();
+
+        $seriesDetailSet = $chartDetail->children($namespacesChartMeta['c']);
+        foreach ($seriesDetailSet as $seriesDetailKey => $seriesDetails) {
+            switch ($seriesDetailKey) {
+                case "grouping":
+                    $multiSeriesType = self::getAttribute($chartDetail->grouping, 'val', 'string');
+                    break;
+                case "ser":
+                    $marker = null;
+                    foreach ($seriesDetails as $seriesKey => $seriesDetail) {
+                        switch ($seriesKey) {
+                            case "idx":
+                                $seriesIndex = self::getAttribute($seriesDetail, 'val', 'integer');
+                                break;
+                            case "order":
+                                $seriesOrder = self::getAttribute($seriesDetail, 'val', 'integer');
+                                $plotOrder[$seriesIndex] = $seriesOrder;
+                                break;
+                            case "tx":
+                                $seriesLabel[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
+                                break;
+                            case "marker":
+                                $marker = self::getAttribute($seriesDetail->symbol, 'val', 'string');
+                                break;
+                            case "smooth":
+                                $smoothLine = self::getAttribute($seriesDetail, 'val', 'boolean');
+                                break;
+                            case "cat":
+                                $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
+                                break;
+                            case "val":
+                                $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+                                break;
+                            case "xVal":
+                                $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+                                break;
+                            case "yVal":
+                                $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+                                break;
+                        }
+                    }
+            }
+        }
+        return new PHPExcel_Chart_DataSeries($plotType, $multiSeriesType, $plotOrder, $seriesLabel, $seriesCategory, $seriesValues, $smoothLine);
+    }
+
+
+    private static function chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker = null, $smoothLine = false)
+    {
+        if (isset($seriesDetail->strRef)) {
+            $seriesSource = (string) $seriesDetail->strRef->f;
+            $seriesData = self::chartDataSeriesValues($seriesDetail->strRef->strCache->children($namespacesChartMeta['c']), 's');
+
+            return new PHPExcel_Chart_DataSeriesValues('String', $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker, $smoothLine);
+        } elseif (isset($seriesDetail->numRef)) {
+            $seriesSource = (string) $seriesDetail->numRef->f;
+            $seriesData = self::chartDataSeriesValues($seriesDetail->numRef->numCache->children($namespacesChartMeta['c']));
+
+            return new PHPExcel_Chart_DataSeriesValues('Number', $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker, $smoothLine);
+        } elseif (isset($seriesDetail->multiLvlStrRef)) {
+            $seriesSource = (string) $seriesDetail->multiLvlStrRef->f;
+            $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlStrRef->multiLvlStrCache->children($namespacesChartMeta['c']), 's');
+            $seriesData['pointCount'] = count($seriesData['dataValues']);
+
+            return new PHPExcel_Chart_DataSeriesValues('String', $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker, $smoothLine);
+        } elseif (isset($seriesDetail->multiLvlNumRef)) {
+            $seriesSource = (string) $seriesDetail->multiLvlNumRef->f;
+            $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlNumRef->multiLvlNumCache->children($namespacesChartMeta['c']), 's');
+            $seriesData['pointCount'] = count($seriesData['dataValues']);
+
+            return new PHPExcel_Chart_DataSeriesValues('String', $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker, $smoothLine);
+        }
+        return null;
+    }
+
+
+    private static function chartDataSeriesValues($seriesValueSet, $dataType = 'n')
+    {
+        $seriesVal = array();
+        $formatCode = '';
+        $pointCount = 0;
+
+        foreach ($seriesValueSet as $seriesValueIdx => $seriesValue) {
+            switch ($seriesValueIdx) {
+                case 'ptCount':
+                    $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
+                    break;
+                case 'formatCode':
+                    $formatCode = (string) $seriesValue;
+                    break;
+                case 'pt':
+                    $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
+                    if ($dataType == 's') {
+                        $seriesVal[$pointVal] = (string) $seriesValue->v;
+                    } else {
+                        $seriesVal[$pointVal] = (float) $seriesValue->v;
+                    }
+                    break;
+            }
+        }
+
+        return array(
+            'formatCode'    => $formatCode,
+            'pointCount'    => $pointCount,
+            'dataValues'    => $seriesVal
+        );
+    }
+
+    private static function chartDataSeriesValuesMultiLevel($seriesValueSet, $dataType = 'n')
+    {
+        $seriesVal = array();
+        $formatCode = '';
+        $pointCount = 0;
+
+        foreach ($seriesValueSet->lvl as $seriesLevelIdx => $seriesLevel) {
+            foreach ($seriesLevel as $seriesValueIdx => $seriesValue) {
+                switch ($seriesValueIdx) {
+                    case 'ptCount':
+                        $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
+                        break;
+                    case 'formatCode':
+                        $formatCode = (string) $seriesValue;
+                        break;
+                    case 'pt':
+                        $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
+                        if ($dataType == 's') {
+                            $seriesVal[$pointVal][] = (string) $seriesValue->v;
+                        } else {
+                            $seriesVal[$pointVal][] = (float) $seriesValue->v;
+                        }
+                        break;
+                }
+            }
+        }
+
+        return array(
+            'formatCode'    => $formatCode,
+            'pointCount'    => $pointCount,
+            'dataValues'    => $seriesVal
+        );
+    }
+
+    private static function parseRichText($titleDetailPart = null)
+    {
+        $value = new PHPExcel_RichText();
+
+        foreach ($titleDetailPart as $titleDetailElementKey => $titleDetailElement) {
+            if (isset($titleDetailElement->t)) {
+                $objText = $value->createTextRun((string) $titleDetailElement->t);
+            }
+            if (isset($titleDetailElement->rPr)) {
+                if (isset($titleDetailElement->rPr->rFont["val"])) {
+                    $objText->getFont()->setName((string) $titleDetailElement->rPr->rFont["val"]);
+                }
+
+                $fontSize = (self::getAttribute($titleDetailElement->rPr, 'sz', 'integer'));
+                if (!is_null($fontSize)) {
+                    $objText->getFont()->setSize(floor($fontSize / 100));
+                }
+
+                $fontColor = (self::getAttribute($titleDetailElement->rPr, 'color', 'string'));
+                if (!is_null($fontColor)) {
+                    $objText->getFont()->setColor(new PHPExcel_Style_Color(self::readColor($fontColor)));
+                }
+
+                $bold = self::getAttribute($titleDetailElement->rPr, 'b', 'boolean');
+                if (!is_null($bold)) {
+                    $objText->getFont()->setBold($bold);
+                }
+
+                $italic = self::getAttribute($titleDetailElement->rPr, 'i', 'boolean');
+                if (!is_null($italic)) {
+                    $objText->getFont()->setItalic($italic);
+                }
+
+                $baseline = self::getAttribute($titleDetailElement->rPr, 'baseline', 'integer');
+                if (!is_null($baseline)) {
+                    if ($baseline > 0) {
+                        $objText->getFont()->setSuperScript(true);
+                    } elseif ($baseline < 0) {
+                        $objText->getFont()->setSubScript(true);
+                    }
+                }
+
+                $underscore = (self::getAttribute($titleDetailElement->rPr, 'u', 'string'));
+                if (!is_null($underscore)) {
+                    if ($underscore == 'sng') {
+                        $objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE);
+                    } elseif ($underscore == 'dbl') {
+                        $objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE);
+                    } else {
+                        $objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_NONE);
+                    }
+                }
+
+                $strikethrough = (self::getAttribute($titleDetailElement->rPr, 's', 'string'));
+                if (!is_null($strikethrough)) {
+                    if ($strikethrough == 'noStrike') {
+                        $objText->getFont()->setStrikethrough(false);
+                    } else {
+                        $objText->getFont()->setStrikethrough(true);
+                    }
+                }
+            }
+        }
+
+        return $value;
+    }
+
+    private static function readChartAttributes($chartDetail)
+    {
+        $plotAttributes = array();
+        if (isset($chartDetail->dLbls)) {
+            if (isset($chartDetail->dLbls->howLegendKey)) {
+                $plotAttributes['showLegendKey'] = self::getAttribute($chartDetail->dLbls->showLegendKey, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showVal)) {
+                $plotAttributes['showVal'] = self::getAttribute($chartDetail->dLbls->showVal, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showCatName)) {
+                $plotAttributes['showCatName'] = self::getAttribute($chartDetail->dLbls->showCatName, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showSerName)) {
+                $plotAttributes['showSerName'] = self::getAttribute($chartDetail->dLbls->showSerName, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showPercent)) {
+                $plotAttributes['showPercent'] = self::getAttribute($chartDetail->dLbls->showPercent, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showBubbleSize)) {
+                $plotAttributes['showBubbleSize'] = self::getAttribute($chartDetail->dLbls->showBubbleSize, 'val', 'string');
+            }
+            if (isset($chartDetail->dLbls->showLeaderLines)) {
+                $plotAttributes['showLeaderLines'] = self::getAttribute($chartDetail->dLbls->showLeaderLines, 'val', 'string');
+            }
+        }
+
+        return $plotAttributes;
+    }
+
+    private static function setChartAttributes($plotArea, $plotAttributes)
+    {
+        foreach ($plotAttributes as $plotAttributeKey => $plotAttributeValue) {
+            switch ($plotAttributeKey) {
+                case 'showLegendKey':
+                    $plotArea->setShowLegendKey($plotAttributeValue);
+                    break;
+                case 'showVal':
+                    $plotArea->setShowVal($plotAttributeValue);
+                    break;
+                case 'showCatName':
+                    $plotArea->setShowCatName($plotAttributeValue);
+                    break;
+                case 'showSerName':
+                    $plotArea->setShowSerName($plotAttributeValue);
+                    break;
+                case 'showPercent':
+                    $plotArea->setShowPercent($plotAttributeValue);
+                    break;
+                case 'showBubbleSize':
+                    $plotArea->setShowBubbleSize($plotAttributeValue);
+                    break;
+                case 'showLeaderLines':
+                    $plotArea->setShowLeaderLines($plotAttributeValue);
+                    break;
+            }
+        }
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel2007/Theme.php

@@ -0,0 +1,127 @@
+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel2007
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+
+
+/**
+ * PHPExcel_Reader_Excel2007_Theme
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel2007
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Reader_Excel2007_Theme
+{
+    /**
+     * Theme Name
+     *
+     * @var string
+     */
+    private $themeName;
+
+    /**
+     * Colour Scheme Name
+     *
+     * @var string
+     */
+    private $colourSchemeName;
+
+    /**
+     * Colour Map indexed by position
+     *
+     * @var array of string
+     */
+    private $colourMapValues;
+
+
+    /**
+     * Colour Map
+     *
+     * @var array of string
+     */
+    private $colourMap;
+
+
+    /**
+     * Create a new PHPExcel_Theme
+     *
+     */
+    public function __construct($themeName, $colourSchemeName, $colourMap)
+    {
+        // Initialise values
+        $this->themeName        = $themeName;
+        $this->colourSchemeName = $colourSchemeName;
+        $this->colourMap        = $colourMap;
+    }
+
+    /**
+     * Get Theme Name
+     *
+     * @return string
+     */
+    public function getThemeName()
+    {
+        return $this->themeName;
+    }
+
+    /**
+     * Get colour Scheme Name
+     *
+     * @return string
+     */
+    public function getColourSchemeName()
+    {
+        return $this->colourSchemeName;
+    }
+
+    /**
+     * Get colour Map Value by Position
+     *
+     * @return string
+     */
+    public function getColourByIndex($index = 0)
+    {
+        if (isset($this->colourMap[$index])) {
+            return $this->colourMap[$index];
+        }
+        return null;
+    }
+
+    /**
+     * Implement PHP __clone to create a deep clone, not just a shallow copy.
+     */
+    public function __clone()
+    {
+        $vars = get_object_vars($this);
+        foreach ($vars as $key => $value) {
+            if ((is_object($value)) && ($key != '_parent')) {
+                $this->$key = clone $value;
+            } else {
+                $this->$key = $value;
+            }
+        }
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Color.php

@@ -0,0 +1,32 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Color
+{
+    /**
+     * Read color
+     *
+     * @param int $color Indexed color
+     * @param array $palette Color palette
+     * @return array RGB color value, example: array('rgb' => 'FF0000')
+     */
+    public static function map($color, $palette, $version)
+    {
+        if ($color <= 0x07 || $color >= 0x40) {
+            // special built-in color
+            return PHPExcel_Reader_Excel5_Color_BuiltIn::lookup($color);
+        } elseif (isset($palette) && isset($palette[$color - 8])) {
+            // palette color, color index 0x08 maps to pallete index 0
+            return $palette[$color - 8];
+        } else {
+            // default color table
+            if ($version == PHPExcel_Reader_Excel5::XLS_BIFF8) {
+                return PHPExcel_Reader_Excel5_Color_BIFF8::lookup($color);
+            } else {
+                // BIFF5
+                return PHPExcel_Reader_Excel5_Color_BIFF5::lookup($color);
+            }
+        }
+
+        return $color;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Color/BIFF5.php

@@ -0,0 +1,77 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Color_BIFF5
+{
+    protected static $map = array(
+        0x08 => '000000',
+        0x09 => 'FFFFFF',
+        0x0A => 'FF0000',
+        0x0B => '00FF00',
+        0x0C => '0000FF',
+        0x0D => 'FFFF00',
+        0x0E => 'FF00FF',
+        0x0F => '00FFFF',
+        0x10 => '800000',
+        0x11 => '008000',
+        0x12 => '000080',
+        0x13 => '808000',
+        0x14 => '800080',
+        0x15 => '008080',
+        0x16 => 'C0C0C0',
+        0x17 => '808080',
+        0x18 => '8080FF',
+        0x19 => '802060',
+        0x1A => 'FFFFC0',
+        0x1B => 'A0E0F0',
+        0x1C => '600080',
+        0x1D => 'FF8080',
+        0x1E => '0080C0',
+        0x1F => 'C0C0FF',
+        0x20 => '000080',
+        0x21 => 'FF00FF',
+        0x22 => 'FFFF00',
+        0x23 => '00FFFF',
+        0x24 => '800080',
+        0x25 => '800000',
+        0x26 => '008080',
+        0x27 => '0000FF',
+        0x28 => '00CFFF',
+        0x29 => '69FFFF',
+        0x2A => 'E0FFE0',
+        0x2B => 'FFFF80',
+        0x2C => 'A6CAF0',
+        0x2D => 'DD9CB3',
+        0x2E => 'B38FEE',
+        0x2F => 'E3E3E3',
+        0x30 => '2A6FF9',
+        0x31 => '3FB8CD',
+        0x32 => '488436',
+        0x33 => '958C41',
+        0x34 => '8E5E42',
+        0x35 => 'A0627A',
+        0x36 => '624FAC',
+        0x37 => '969696',
+        0x38 => '1D2FBE',
+        0x39 => '286676',
+        0x3A => '004500',
+        0x3B => '453E01',
+        0x3C => '6A2813',
+        0x3D => '85396A',
+        0x3E => '4A3285',
+        0x3F => '424242',
+    );
+
+    /**
+     * Map color array from BIFF5 built-in color index
+     *
+     * @param int $color
+     * @return array
+     */
+    public static function lookup($color)
+    {
+        if (isset(self::$map[$color])) {
+            return array('rgb' => self::$map[$color]);
+        }
+        return array('rgb' => '000000');
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Color/BIFF8.php

@@ -0,0 +1,77 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Color_BIFF8
+{
+    protected static $map = array(
+        0x08 => '000000',
+        0x09 => 'FFFFFF',
+        0x0A => 'FF0000',
+        0x0B => '00FF00',
+        0x0C => '0000FF',
+        0x0D => 'FFFF00',
+        0x0E => 'FF00FF',
+        0x0F => '00FFFF',
+        0x10 => '800000',
+        0x11 => '008000',
+        0x12 => '000080',
+        0x13 => '808000',
+        0x14 => '800080',
+        0x15 => '008080',
+        0x16 => 'C0C0C0',
+        0x17 => '808080',
+        0x18 => '9999FF',
+        0x19 => '993366',
+        0x1A => 'FFFFCC',
+        0x1B => 'CCFFFF',
+        0x1C => '660066',
+        0x1D => 'FF8080',
+        0x1E => '0066CC',
+        0x1F => 'CCCCFF',
+        0x20 => '000080',
+        0x21 => 'FF00FF',
+        0x22 => 'FFFF00',
+        0x23 => '00FFFF',
+        0x24 => '800080',
+        0x25 => '800000',
+        0x26 => '008080',
+        0x27 => '0000FF',
+        0x28 => '00CCFF',
+        0x29 => 'CCFFFF',
+        0x2A => 'CCFFCC',
+        0x2B => 'FFFF99',
+        0x2C => '99CCFF',
+        0x2D => 'FF99CC',
+        0x2E => 'CC99FF',
+        0x2F => 'FFCC99',
+        0x30 => '3366FF',
+        0x31 => '33CCCC',
+        0x32 => '99CC00',
+        0x33 => 'FFCC00',
+        0x34 => 'FF9900',
+        0x35 => 'FF6600',
+        0x36 => '666699',
+        0x37 => '969696',
+        0x38 => '003366',
+        0x39 => '339966',
+        0x3A => '003300',
+        0x3B => '333300',
+        0x3C => '993300',
+        0x3D => '993366',
+        0x3E => '333399',
+        0x3F => '333333',
+    );
+
+   /**
+     * Map color array from BIFF8 built-in color index
+     *
+     * @param int $color
+     * @return array
+     */
+    public static function lookup($color)
+    {
+        if (isset(self::$map[$color])) {
+            return array('rgb' => self::$map[$color]);
+        }
+        return array('rgb' => '000000');
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Color/BuiltIn.php

@@ -0,0 +1,31 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Color_BuiltIn
+{
+    protected static $map = array(
+        0x00 => '000000',
+        0x01 => 'FFFFFF',
+        0x02 => 'FF0000',
+        0x03 => '00FF00',
+        0x04 => '0000FF',
+        0x05 => 'FFFF00',
+        0x06 => 'FF00FF',
+        0x07 => '00FFFF',
+        0x40 => '000000', // system window text color
+        0x41 => 'FFFFFF', // system window background color
+    );
+
+    /**
+     * Map built-in color to RGB value
+     *
+     * @param int $color Indexed color
+     * @return array
+     */
+    public static function lookup($color)
+    {
+        if (isset(self::$map[$color])) {
+            return array('rgb' => self::$map[$color]);
+        }
+        return array('rgb' => '000000');
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/ErrorCode.php

@@ -0,0 +1,28 @@
+<?php
+
+class PHPExcel_Reader_Excel5_ErrorCode
+{
+    protected static $map = array(
+        0x00 => '#NULL!',
+        0x07 => '#DIV/0!',
+        0x0F => '#VALUE!',
+        0x17 => '#REF!',
+        0x1D => '#NAME?',
+        0x24 => '#NUM!',
+        0x2A => '#N/A',
+    );
+
+    /**
+     * Map error code, e.g. '#N/A'
+     *
+     * @param int $code
+     * @return string
+     */
+    public static function lookup($code)
+    {
+        if (isset(self::$map[$code])) {
+            return self::$map[$code];
+        }
+        return false;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Escher.php

@@ -0,0 +1,669 @@
+<?php
+
+/**
+ * PHPExcel_Reader_Excel5_Escher
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel5
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Excel5_Escher
+{
+    const DGGCONTAINER      = 0xF000;
+    const BSTORECONTAINER   = 0xF001;
+    const DGCONTAINER       = 0xF002;
+    const SPGRCONTAINER     = 0xF003;
+    const SPCONTAINER       = 0xF004;
+    const DGG               = 0xF006;
+    const BSE               = 0xF007;
+    const DG                = 0xF008;
+    const SPGR              = 0xF009;
+    const SP                = 0xF00A;
+    const OPT               = 0xF00B;
+    const CLIENTTEXTBOX     = 0xF00D;
+    const CLIENTANCHOR      = 0xF010;
+    const CLIENTDATA        = 0xF011;
+    const BLIPJPEG          = 0xF01D;
+    const BLIPPNG           = 0xF01E;
+    const SPLITMENUCOLORS   = 0xF11E;
+    const TERTIARYOPT       = 0xF122;
+
+    /**
+     * Escher stream data (binary)
+     *
+     * @var string
+     */
+    private $data;
+
+    /**
+     * Size in bytes of the Escher stream data
+     *
+     * @var int
+     */
+    private $dataSize;
+
+    /**
+     * Current position of stream pointer in Escher stream data
+     *
+     * @var int
+     */
+    private $pos;
+
+    /**
+     * The object to be returned by the reader. Modified during load.
+     *
+     * @var mixed
+     */
+    private $object;
+
+    /**
+     * Create a new PHPExcel_Reader_Excel5_Escher instance
+     *
+     * @param mixed $object
+     */
+    public function __construct($object)
+    {
+        $this->object = $object;
+    }
+
+    /**
+     * Load Escher stream data. May be a partial Escher stream.
+     *
+     * @param string $data
+     */
+    public function load($data)
+    {
+        $this->data = $data;
+
+        // total byte size of Excel data (workbook global substream + sheet substreams)
+        $this->dataSize = strlen($this->data);
+
+        $this->pos = 0;
+
+        // Parse Escher stream
+        while ($this->pos < $this->dataSize) {
+            // offset: 2; size: 2: Record Type
+            $fbt = PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos + 2);
+
+            switch ($fbt) {
+                case self::DGGCONTAINER:
+                    $this->readDggContainer();
+                    break;
+                case self::DGG:
+                    $this->readDgg();
+                    break;
+                case self::BSTORECONTAINER:
+                    $this->readBstoreContainer();
+                    break;
+                case self::BSE:
+                    $this->readBSE();
+                    break;
+                case self::BLIPJPEG:
+                    $this->readBlipJPEG();
+                    break;
+                case self::BLIPPNG:
+                    $this->readBlipPNG();
+                    break;
+                case self::OPT:
+                    $this->readOPT();
+                    break;
+                case self::TERTIARYOPT:
+                    $this->readTertiaryOPT();
+                    break;
+                case self::SPLITMENUCOLORS:
+                    $this->readSplitMenuColors();
+                    break;
+                case self::DGCONTAINER:
+                    $this->readDgContainer();
+                    break;
+                case self::DG:
+                    $this->readDg();
+                    break;
+                case self::SPGRCONTAINER:
+                    $this->readSpgrContainer();
+                    break;
+                case self::SPCONTAINER:
+                    $this->readSpContainer();
+                    break;
+                case self::SPGR:
+                    $this->readSpgr();
+                    break;
+                case self::SP:
+                    $this->readSp();
+                    break;
+                case self::CLIENTTEXTBOX:
+                    $this->readClientTextbox();
+                    break;
+                case self::CLIENTANCHOR:
+                    $this->readClientAnchor();
+                    break;
+                case self::CLIENTDATA:
+                    $this->readClientData();
+                    break;
+                default:
+                    $this->readDefault();
+                    break;
+            }
+        }
+
+        return $this->object;
+    }
+
+    /**
+     * Read a generic record
+     */
+    private function readDefault()
+    {
+        // offset 0; size: 2; recVer and recInstance
+        $verInstance = PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos);
+
+        // offset: 2; size: 2: Record Type
+        $fbt = PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos + 2);
+
+        // bit: 0-3; mask: 0x000F; recVer
+        $recVer = (0x000F & $verInstance) >> 0;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read DggContainer record (Drawing Group Container)
+     */
+    private function readDggContainer()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $dggContainer = new PHPExcel_Shared_Escher_DggContainer();
+        $this->object->setDggContainer($dggContainer);
+        $reader = new PHPExcel_Reader_Excel5_Escher($dggContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read Dgg record (Drawing Group)
+     */
+    private function readDgg()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read BstoreContainer record (Blip Store Container)
+     */
+    private function readBstoreContainer()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $bstoreContainer = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer();
+        $this->object->setBstoreContainer($bstoreContainer);
+        $reader = new PHPExcel_Reader_Excel5_Escher($bstoreContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read BSE record
+     */
+    private function readBSE()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // add BSE to BstoreContainer
+        $BSE = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE();
+        $this->object->addBSE($BSE);
+
+        $BSE->setBLIPType($recInstance);
+
+        // offset: 0; size: 1; btWin32 (MSOBLIPTYPE)
+        $btWin32 = ord($recordData[0]);
+
+        // offset: 1; size: 1; btWin32 (MSOBLIPTYPE)
+        $btMacOS = ord($recordData[1]);
+
+        // offset: 2; size: 16; MD4 digest
+        $rgbUid = substr($recordData, 2, 16);
+
+        // offset: 18; size: 2; tag
+        $tag = PHPExcel_Reader_Excel5::getInt2d($recordData, 18);
+
+        // offset: 20; size: 4; size of BLIP in bytes
+        $size = PHPExcel_Reader_Excel5::getInt4d($recordData, 20);
+
+        // offset: 24; size: 4; number of references to this BLIP
+        $cRef = PHPExcel_Reader_Excel5::getInt4d($recordData, 24);
+
+        // offset: 28; size: 4; MSOFO file offset
+        $foDelay = PHPExcel_Reader_Excel5::getInt4d($recordData, 28);
+
+        // offset: 32; size: 1; unused1
+        $unused1 = ord($recordData{32});
+
+        // offset: 33; size: 1; size of nameData in bytes (including null terminator)
+        $cbName = ord($recordData{33});
+
+        // offset: 34; size: 1; unused2
+        $unused2 = ord($recordData{34});
+
+        // offset: 35; size: 1; unused3
+        $unused3 = ord($recordData{35});
+
+        // offset: 36; size: $cbName; nameData
+        $nameData = substr($recordData, 36, $cbName);
+
+        // offset: 36 + $cbName, size: var; the BLIP data
+        $blipData = substr($recordData, 36 + $cbName);
+
+        // record is a container, read contents
+        $reader = new PHPExcel_Reader_Excel5_Escher($BSE);
+        $reader->load($blipData);
+    }
+
+    /**
+     * Read BlipJPEG record. Holds raw JPEG image data
+     */
+    private function readBlipJPEG()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        $pos = 0;
+
+        // offset: 0; size: 16; rgbUid1 (MD4 digest of)
+        $rgbUid1 = substr($recordData, 0, 16);
+        $pos += 16;
+
+        // offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
+        if (in_array($recInstance, array(0x046B, 0x06E3))) {
+            $rgbUid2 = substr($recordData, 16, 16);
+            $pos += 16;
+        }
+
+        // offset: var; size: 1; tag
+        $tag = ord($recordData{$pos});
+        $pos += 1;
+
+        // offset: var; size: var; the raw image data
+        $data = substr($recordData, $pos);
+
+        $blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
+        $blip->setData($data);
+
+        $this->object->setBlip($blip);
+    }
+
+    /**
+     * Read BlipPNG record. Holds raw PNG image data
+     */
+    private function readBlipPNG()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        $pos = 0;
+
+        // offset: 0; size: 16; rgbUid1 (MD4 digest of)
+        $rgbUid1 = substr($recordData, 0, 16);
+        $pos += 16;
+
+        // offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
+        if ($recInstance == 0x06E1) {
+            $rgbUid2 = substr($recordData, 16, 16);
+            $pos += 16;
+        }
+
+        // offset: var; size: 1; tag
+        $tag = ord($recordData{$pos});
+        $pos += 1;
+
+        // offset: var; size: var; the raw image data
+        $data = substr($recordData, $pos);
+
+        $blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
+        $blip->setData($data);
+
+        $this->object->setBlip($blip);
+    }
+
+    /**
+     * Read OPT record. This record may occur within DggContainer record or SpContainer
+     */
+    private function readOPT()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        $this->readOfficeArtRGFOPTE($recordData, $recInstance);
+    }
+
+    /**
+     * Read TertiaryOPT record
+     */
+    private function readTertiaryOPT()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read SplitMenuColors record
+     */
+    private function readSplitMenuColors()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read DgContainer record (Drawing Container)
+     */
+    private function readDgContainer()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $dgContainer = new PHPExcel_Shared_Escher_DgContainer();
+        $this->object->setDgContainer($dgContainer);
+        $reader = new PHPExcel_Reader_Excel5_Escher($dgContainer);
+        $escher = $reader->load($recordData);
+    }
+
+    /**
+     * Read Dg record (Drawing)
+     */
+    private function readDg()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read SpgrContainer record (Shape Group Container)
+     */
+    private function readSpgrContainer()
+    {
+        // context is either context DgContainer or SpgrContainer
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $spgrContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer();
+
+        if ($this->object instanceof PHPExcel_Shared_Escher_DgContainer) {
+            // DgContainer
+            $this->object->setSpgrContainer($spgrContainer);
+        } else {
+            // SpgrContainer
+            $this->object->addChild($spgrContainer);
+        }
+
+        $reader = new PHPExcel_Reader_Excel5_Escher($spgrContainer);
+        $escher = $reader->load($recordData);
+    }
+
+    /**
+     * Read SpContainer record (Shape Container)
+     */
+    private function readSpContainer()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // add spContainer to spgrContainer
+        $spContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer();
+        $this->object->addChild($spContainer);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $reader = new PHPExcel_Reader_Excel5_Escher($spContainer);
+        $escher = $reader->load($recordData);
+    }
+
+    /**
+     * Read Spgr record (Shape Group)
+     */
+    private function readSpgr()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read Sp record (Shape)
+     */
+    private function readSp()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read ClientTextbox record
+     */
+    private function readClientTextbox()
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::getInt2d($this->data, $this->pos)) >> 4;
+
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read ClientAnchor record. This record holds information about where the shape is anchored in worksheet
+     */
+    private function readClientAnchor()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // offset: 2; size: 2; upper-left corner column index (0-based)
+        $c1 = PHPExcel_Reader_Excel5::getInt2d($recordData, 2);
+
+        // offset: 4; size: 2; upper-left corner horizontal offset in 1/1024 of column width
+        $startOffsetX = PHPExcel_Reader_Excel5::getInt2d($recordData, 4);
+
+        // offset: 6; size: 2; upper-left corner row index (0-based)
+        $r1 = PHPExcel_Reader_Excel5::getInt2d($recordData, 6);
+
+        // offset: 8; size: 2; upper-left corner vertical offset in 1/256 of row height
+        $startOffsetY = PHPExcel_Reader_Excel5::getInt2d($recordData, 8);
+
+        // offset: 10; size: 2; bottom-right corner column index (0-based)
+        $c2 = PHPExcel_Reader_Excel5::getInt2d($recordData, 10);
+
+        // offset: 12; size: 2; bottom-right corner horizontal offset in 1/1024 of column width
+        $endOffsetX = PHPExcel_Reader_Excel5::getInt2d($recordData, 12);
+
+        // offset: 14; size: 2; bottom-right corner row index (0-based)
+        $r2 = PHPExcel_Reader_Excel5::getInt2d($recordData, 14);
+
+        // offset: 16; size: 2; bottom-right corner vertical offset in 1/256 of row height
+        $endOffsetY = PHPExcel_Reader_Excel5::getInt2d($recordData, 16);
+
+        // set the start coordinates
+        $this->object->setStartCoordinates(PHPExcel_Cell::stringFromColumnIndex($c1) . ($r1 + 1));
+
+        // set the start offsetX
+        $this->object->setStartOffsetX($startOffsetX);
+
+        // set the start offsetY
+        $this->object->setStartOffsetY($startOffsetY);
+
+        // set the end coordinates
+        $this->object->setEndCoordinates(PHPExcel_Cell::stringFromColumnIndex($c2) . ($r2 + 1));
+
+        // set the end offsetX
+        $this->object->setEndOffsetX($endOffsetX);
+
+        // set the end offsetY
+        $this->object->setEndOffsetY($endOffsetY);
+    }
+
+    /**
+     * Read ClientData record
+     */
+    private function readClientData()
+    {
+        $length = PHPExcel_Reader_Excel5::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+    }
+
+    /**
+     * Read OfficeArtRGFOPTE table of property-value pairs
+     *
+     * @param string $data Binary data
+     * @param int $n Number of properties
+     */
+    private function readOfficeArtRGFOPTE($data, $n)
+    {
+        $splicedComplexData = substr($data, 6 * $n);
+
+        // loop through property-value pairs
+        for ($i = 0; $i < $n; ++$i) {
+            // read 6 bytes at a time
+            $fopte = substr($data, 6 * $i, 6);
+
+            // offset: 0; size: 2; opid
+            $opid = PHPExcel_Reader_Excel5::getInt2d($fopte, 0);
+
+            // bit: 0-13; mask: 0x3FFF; opid.opid
+            $opidOpid = (0x3FFF & $opid) >> 0;
+
+            // bit: 14; mask 0x4000; 1 = value in op field is BLIP identifier
+            $opidFBid = (0x4000 & $opid) >> 14;
+
+            // bit: 15; mask 0x8000; 1 = this is a complex property, op field specifies size of complex data
+            $opidFComplex = (0x8000 & $opid) >> 15;
+
+            // offset: 2; size: 4; the value for this property
+            $op = PHPExcel_Reader_Excel5::getInt4d($fopte, 2);
+
+            if ($opidFComplex) {
+                $complexData = substr($splicedComplexData, 0, $op);
+                $splicedComplexData = substr($splicedComplexData, $op);
+
+                // we store string value with complex data
+                $value = $complexData;
+            } else {
+                // we store integer value
+                $value = $op;
+            }
+
+            $this->object->setOPT($opidOpid, $value);
+        }
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/MD5.php

@@ -0,0 +1,203 @@
+<?php
+
+/**
+ * PHPExcel_Reader_Excel5_MD5
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel5
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt        LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Excel5_MD5
+{
+    // Context
+    private $a;
+    private $b;
+    private $c;
+    private $d;
+
+    /**
+     * MD5 stream constructor
+     */
+    public function __construct()
+    {
+        $this->reset();
+    }
+
+    /**
+     * Reset the MD5 stream context
+     */
+    public function reset()
+    {
+        $this->a = 0x67452301;
+        $this->b = 0xEFCDAB89;
+        $this->c = 0x98BADCFE;
+        $this->d = 0x10325476;
+    }
+
+    /**
+     * Get MD5 stream context
+     *
+     * @return string
+     */
+    public function getContext()
+    {
+        $s = '';
+        foreach (array('a', 'b', 'c', 'd') as $i) {
+            $v = $this->{$i};
+            $s .= chr($v & 0xff);
+            $s .= chr(($v >> 8) & 0xff);
+            $s .= chr(($v >> 16) & 0xff);
+            $s .= chr(($v >> 24) & 0xff);
+        }
+
+        return $s;
+    }
+
+    /**
+     * Add data to context
+     *
+     * @param string $data Data to add
+     */
+    public function add($data)
+    {
+        $words = array_values(unpack('V16', $data));
+
+        $A = $this->a;
+        $B = $this->b;
+        $C = $this->c;
+        $D = $this->d;
+
+        $F = array('PHPExcel_Reader_Excel5_MD5','f');
+        $G = array('PHPExcel_Reader_Excel5_MD5','g');
+        $H = array('PHPExcel_Reader_Excel5_MD5','h');
+        $I = array('PHPExcel_Reader_Excel5_MD5','i');
+
+        /* ROUND 1 */
+        self::step($F, $A, $B, $C, $D, $words[0], 7, 0xd76aa478);
+        self::step($F, $D, $A, $B, $C, $words[1], 12, 0xe8c7b756);
+        self::step($F, $C, $D, $A, $B, $words[2], 17, 0x242070db);
+        self::step($F, $B, $C, $D, $A, $words[3], 22, 0xc1bdceee);
+        self::step($F, $A, $B, $C, $D, $words[4], 7, 0xf57c0faf);
+        self::step($F, $D, $A, $B, $C, $words[5], 12, 0x4787c62a);
+        self::step($F, $C, $D, $A, $B, $words[6], 17, 0xa8304613);
+        self::step($F, $B, $C, $D, $A, $words[7], 22, 0xfd469501);
+        self::step($F, $A, $B, $C, $D, $words[8], 7, 0x698098d8);
+        self::step($F, $D, $A, $B, $C, $words[9], 12, 0x8b44f7af);
+        self::step($F, $C, $D, $A, $B, $words[10], 17, 0xffff5bb1);
+        self::step($F, $B, $C, $D, $A, $words[11], 22, 0x895cd7be);
+        self::step($F, $A, $B, $C, $D, $words[12], 7, 0x6b901122);
+        self::step($F, $D, $A, $B, $C, $words[13], 12, 0xfd987193);
+        self::step($F, $C, $D, $A, $B, $words[14], 17, 0xa679438e);
+        self::step($F, $B, $C, $D, $A, $words[15], 22, 0x49b40821);
+
+        /* ROUND 2 */
+        self::step($G, $A, $B, $C, $D, $words[1], 5, 0xf61e2562);
+        self::step($G, $D, $A, $B, $C, $words[6], 9, 0xc040b340);
+        self::step($G, $C, $D, $A, $B, $words[11], 14, 0x265e5a51);
+        self::step($G, $B, $C, $D, $A, $words[0], 20, 0xe9b6c7aa);
+        self::step($G, $A, $B, $C, $D, $words[5], 5, 0xd62f105d);
+        self::step($G, $D, $A, $B, $C, $words[10], 9, 0x02441453);
+        self::step($G, $C, $D, $A, $B, $words[15], 14, 0xd8a1e681);
+        self::step($G, $B, $C, $D, $A, $words[4], 20, 0xe7d3fbc8);
+        self::step($G, $A, $B, $C, $D, $words[9], 5, 0x21e1cde6);
+        self::step($G, $D, $A, $B, $C, $words[14], 9, 0xc33707d6);
+        self::step($G, $C, $D, $A, $B, $words[3], 14, 0xf4d50d87);
+        self::step($G, $B, $C, $D, $A, $words[8], 20, 0x455a14ed);
+        self::step($G, $A, $B, $C, $D, $words[13], 5, 0xa9e3e905);
+        self::step($G, $D, $A, $B, $C, $words[2], 9, 0xfcefa3f8);
+        self::step($G, $C, $D, $A, $B, $words[7], 14, 0x676f02d9);
+        self::step($G, $B, $C, $D, $A, $words[12], 20, 0x8d2a4c8a);
+
+        /* ROUND 3 */
+        self::step($H, $A, $B, $C, $D, $words[5], 4, 0xfffa3942);
+        self::step($H, $D, $A, $B, $C, $words[8], 11, 0x8771f681);
+        self::step($H, $C, $D, $A, $B, $words[11], 16, 0x6d9d6122);
+        self::step($H, $B, $C, $D, $A, $words[14], 23, 0xfde5380c);
+        self::step($H, $A, $B, $C, $D, $words[1], 4, 0xa4beea44);
+        self::step($H, $D, $A, $B, $C, $words[4], 11, 0x4bdecfa9);
+        self::step($H, $C, $D, $A, $B, $words[7], 16, 0xf6bb4b60);
+        self::step($H, $B, $C, $D, $A, $words[10], 23, 0xbebfbc70);
+        self::step($H, $A, $B, $C, $D, $words[13], 4, 0x289b7ec6);
+        self::step($H, $D, $A, $B, $C, $words[0], 11, 0xeaa127fa);
+        self::step($H, $C, $D, $A, $B, $words[3], 16, 0xd4ef3085);
+        self::step($H, $B, $C, $D, $A, $words[6], 23, 0x04881d05);
+        self::step($H, $A, $B, $C, $D, $words[9], 4, 0xd9d4d039);
+        self::step($H, $D, $A, $B, $C, $words[12], 11, 0xe6db99e5);
+        self::step($H, $C, $D, $A, $B, $words[15], 16, 0x1fa27cf8);
+        self::step($H, $B, $C, $D, $A, $words[2], 23, 0xc4ac5665);
+
+        /* ROUND 4 */
+        self::step($I, $A, $B, $C, $D, $words[0], 6, 0xf4292244);
+        self::step($I, $D, $A, $B, $C, $words[7], 10, 0x432aff97);
+        self::step($I, $C, $D, $A, $B, $words[14], 15, 0xab9423a7);
+        self::step($I, $B, $C, $D, $A, $words[5], 21, 0xfc93a039);
+        self::step($I, $A, $B, $C, $D, $words[12], 6, 0x655b59c3);
+        self::step($I, $D, $A, $B, $C, $words[3], 10, 0x8f0ccc92);
+        self::step($I, $C, $D, $A, $B, $words[10], 15, 0xffeff47d);
+        self::step($I, $B, $C, $D, $A, $words[1], 21, 0x85845dd1);
+        self::step($I, $A, $B, $C, $D, $words[8], 6, 0x6fa87e4f);
+        self::step($I, $D, $A, $B, $C, $words[15], 10, 0xfe2ce6e0);
+        self::step($I, $C, $D, $A, $B, $words[6], 15, 0xa3014314);
+        self::step($I, $B, $C, $D, $A, $words[13], 21, 0x4e0811a1);
+        self::step($I, $A, $B, $C, $D, $words[4], 6, 0xf7537e82);
+        self::step($I, $D, $A, $B, $C, $words[11], 10, 0xbd3af235);
+        self::step($I, $C, $D, $A, $B, $words[2], 15, 0x2ad7d2bb);
+        self::step($I, $B, $C, $D, $A, $words[9], 21, 0xeb86d391);
+
+        $this->a = ($this->a + $A) & 0xffffffff;
+        $this->b = ($this->b + $B) & 0xffffffff;
+        $this->c = ($this->c + $C) & 0xffffffff;
+        $this->d = ($this->d + $D) & 0xffffffff;
+    }
+
+    private static function f($X, $Y, $Z)
+    {
+        return (($X & $Y) | ((~ $X) & $Z)); // X AND Y OR NOT X AND Z
+    }
+
+    private static function g($X, $Y, $Z)
+    {
+        return (($X & $Z) | ($Y & (~ $Z))); // X AND Z OR Y AND NOT Z
+    }
+
+    private static function h($X, $Y, $Z)
+    {
+        return ($X ^ $Y ^ $Z); // X XOR Y XOR Z
+    }
+
+    private static function i($X, $Y, $Z)
+    {
+        return ($Y ^ ($X | (~ $Z))) ; // Y XOR (X OR NOT Z)
+    }
+
+    private static function step($func, &$A, $B, $C, $D, $M, $s, $t)
+    {
+        $A = ($A + call_user_func($func, $B, $C, $D) + $M + $t) & 0xffffffff;
+        $A = self::rotate($A, $s);
+        $A = ($B + $A) & 0xffffffff;
+    }
+
+    private static function rotate($decimal, $bits)
+    {
+        $binary = str_pad(decbin($decimal), 32, "0", STR_PAD_LEFT);
+        return bindec(substr($binary, $bits).substr($binary, 0, $bits));
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/RC4.php

@@ -0,0 +1,81 @@
+<?php
+
+/**
+ * PHPExcel_Reader_Excel5_RC4
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel5
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Excel5_RC4
+{
+    // Context
+    protected $s = array();
+    protected $i = 0;
+    protected $j = 0;
+
+    /**
+     * RC4 stream decryption/encryption constrcutor
+     *
+     * @param string $key Encryption key/passphrase
+     */
+    public function __construct($key)
+    {
+        $len = strlen($key);
+
+        for ($this->i = 0; $this->i < 256; $this->i++) {
+            $this->s[$this->i] = $this->i;
+        }
+
+        $this->j = 0;
+        for ($this->i = 0; $this->i < 256; $this->i++) {
+            $this->j = ($this->j + $this->s[$this->i] + ord($key[$this->i % $len])) % 256;
+            $t = $this->s[$this->i];
+            $this->s[$this->i] = $this->s[$this->j];
+            $this->s[$this->j] = $t;
+        }
+        $this->i = $this->j = 0;
+    }
+
+    /**
+     * Symmetric decryption/encryption function
+     *
+     * @param string $data Data to encrypt/decrypt
+     *
+     * @return string
+     */
+    public function RC4($data)
+    {
+        $len = strlen($data);
+        for ($c = 0; $c < $len; $c++) {
+            $this->i = ($this->i + 1) % 256;
+            $this->j = ($this->j + $this->s[$this->i]) % 256;
+            $t = $this->s[$this->i];
+            $this->s[$this->i] = $this->s[$this->j];
+            $this->s[$this->j] = $t;
+
+            $t = ($this->s[$this->i] + $this->s[$this->j]) % 256;
+
+            $data[$c] = chr(ord($data[$c]) ^ $this->s[$t]);
+        }
+        return $data;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Style/Border.php

@@ -0,0 +1,36 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Style_Border
+{
+    protected static $map = array(
+        0x00 => PHPExcel_Style_Border::BORDER_NONE,
+        0x01 => PHPExcel_Style_Border::BORDER_THIN,
+        0x02 => PHPExcel_Style_Border::BORDER_MEDIUM,
+        0x03 => PHPExcel_Style_Border::BORDER_DASHED,
+        0x04 => PHPExcel_Style_Border::BORDER_DOTTED,
+        0x05 => PHPExcel_Style_Border::BORDER_THICK,
+        0x06 => PHPExcel_Style_Border::BORDER_DOUBLE,
+        0x07 => PHPExcel_Style_Border::BORDER_HAIR,
+        0x08 => PHPExcel_Style_Border::BORDER_MEDIUMDASHED,
+        0x09 => PHPExcel_Style_Border::BORDER_DASHDOT,
+        0x0A => PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT,
+        0x0B => PHPExcel_Style_Border::BORDER_DASHDOTDOT,
+        0x0C => PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT,
+        0x0D => PHPExcel_Style_Border::BORDER_SLANTDASHDOT,
+    );
+
+    /**
+     * Map border style
+     * OpenOffice documentation: 2.5.11
+     *
+     * @param int $index
+     * @return string
+     */
+    public static function lookup($index)
+    {
+        if (isset(self::$map[$index])) {
+            return self::$map[$index];
+        }
+        return PHPExcel_Style_Border::BORDER_NONE;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Excel5/Style/FillPattern.php

@@ -0,0 +1,41 @@
+<?php
+
+class PHPExcel_Reader_Excel5_Style_FillPattern
+{
+    protected static $map = array(
+        0x00 => PHPExcel_Style_Fill::FILL_NONE,
+        0x01 => PHPExcel_Style_Fill::FILL_SOLID,
+        0x02 => PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY,
+        0x03 => PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY,
+        0x04 => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY,
+        0x05 => PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL,
+        0x06 => PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL,
+        0x07 => PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN,
+        0x08 => PHPExcel_Style_Fill::FILL_PATTERN_DARKUP,
+        0x09 => PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID,
+        0x0A => PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS,
+        0x0B => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL,
+        0x0C => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL,
+        0x0D => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN,
+        0x0E => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP,
+        0x0F => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID,
+        0x10 => PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS,
+        0x11 => PHPExcel_Style_Fill::FILL_PATTERN_GRAY125,
+        0x12 => PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625,
+    );
+
+    /**
+     * Get fill pattern from index
+     * OpenOffice documentation: 2.5.12
+     *
+     * @param int $index
+     * @return string
+     */
+    public static function lookup($index)
+    {
+        if (isset(self::$map[$index])) {
+            return self::$map[$index];
+        }
+        return PHPExcel_Style_Fill::FILL_NONE;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Exception.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * PHPExcel_Reader_Exception
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Exception extends PHPExcel_Exception
+{
+    /**
+     * Error handler callback
+     *
+     * @param mixed $code
+     * @param mixed $string
+     * @param mixed $file
+     * @param mixed $line
+     * @param mixed $context
+     */
+    public static function errorHandlerCallback($code, $string, $file, $line, $context)
+    {
+        $e = new self($string, $code);
+        $e->line = $line;
+        $e->file = $file;
+        throw $e;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/Gnumeric.php

@@ -0,0 +1,850 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_Gnumeric
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_Gnumeric extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Formats
+     *
+     * @var array
+     */
+    private $styles = array();
+
+    /**
+     * Shared Expressions
+     *
+     * @var array
+     */
+    private $expressions = array();
+
+    private $referenceHelper = null;
+
+    /**
+     * Create a new PHPExcel_Reader_Gnumeric
+     */
+    public function __construct()
+    {
+        $this->readFilter     = new PHPExcel_Reader_DefaultReadFilter();
+        $this->referenceHelper = PHPExcel_ReferenceHelper::getInstance();
+    }
+
+    /**
+     * Can the current PHPExcel_Reader_IReader read the file?
+     *
+     * @param     string         $pFilename
+     * @return     boolean
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function canRead($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        // Check if gzlib functions are available
+        if (!function_exists('gzread')) {
+            throw new PHPExcel_Reader_Exception("gzlib library is not enabled");
+        }
+
+        // Read signature data (first 3 bytes)
+        $fh = fopen($pFilename, 'r');
+        $data = fread($fh, 2);
+        fclose($fh);
+
+        if ($data != chr(0x1F).chr(0x8B)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object
+     *
+     * @param     string         $pFilename
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function listWorksheetNames($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $xml = new XMLReader();
+        $xml->xml($this->securityScanFile('compress.zlib://'.realpath($pFilename)), null, PHPExcel_Settings::getLibXmlLoaderOptions());
+        $xml->setParserProperty(2, true);
+
+        $worksheetNames = array();
+        while ($xml->read()) {
+            if ($xml->name == 'gnm:SheetName' && $xml->nodeType == XMLReader::ELEMENT) {
+                $xml->read();    //    Move onto the value node
+                $worksheetNames[] = (string) $xml->value;
+            } elseif ($xml->name == 'gnm:Sheets') {
+                //    break out of the loop once we've got our sheet names rather than parse the entire file
+                break;
+            }
+        }
+
+        return $worksheetNames;
+    }
+
+    /**
+     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
+     *
+     * @param   string     $pFilename
+     * @throws   PHPExcel_Reader_Exception
+     */
+    public function listWorksheetInfo($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $xml = new XMLReader();
+        $xml->xml($this->securityScanFile('compress.zlib://'.realpath($pFilename)), null, PHPExcel_Settings::getLibXmlLoaderOptions());
+        $xml->setParserProperty(2, true);
+
+        $worksheetInfo = array();
+        while ($xml->read()) {
+            if ($xml->name == 'gnm:Sheet' && $xml->nodeType == XMLReader::ELEMENT) {
+                $tmpInfo = array(
+                    'worksheetName' => '',
+                    'lastColumnLetter' => 'A',
+                    'lastColumnIndex' => 0,
+                    'totalRows' => 0,
+                    'totalColumns' => 0,
+                );
+
+                while ($xml->read()) {
+                    if ($xml->name == 'gnm:Name' && $xml->nodeType == XMLReader::ELEMENT) {
+                        $xml->read();    //    Move onto the value node
+                        $tmpInfo['worksheetName'] = (string) $xml->value;
+                    } elseif ($xml->name == 'gnm:MaxCol' && $xml->nodeType == XMLReader::ELEMENT) {
+                        $xml->read();    //    Move onto the value node
+                        $tmpInfo['lastColumnIndex'] = (int) $xml->value;
+                        $tmpInfo['totalColumns'] = (int) $xml->value + 1;
+                    } elseif ($xml->name == 'gnm:MaxRow' && $xml->nodeType == XMLReader::ELEMENT) {
+                        $xml->read();    //    Move onto the value node
+                        $tmpInfo['totalRows'] = (int) $xml->value + 1;
+                        break;
+                    }
+                }
+                $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);
+                $worksheetInfo[] = $tmpInfo;
+            }
+        }
+
+        return $worksheetInfo;
+    }
+
+    private function gzfileGetContents($filename)
+    {
+        $file = @gzopen($filename, 'rb');
+        if ($file !== false) {
+            $data = '';
+            while (!gzeof($file)) {
+                $data .= gzread($file, 1024);
+            }
+            gzclose($file);
+        }
+        return $data;
+    }
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param     string         $pFilename
+     * @param    PHPExcel    $objPHPExcel
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $timezoneObj = new DateTimeZone('Europe/London');
+        $GMT = new DateTimeZone('UTC');
+
+        $gFileData = $this->gzfileGetContents($pFilename);
+
+//        echo '<pre>';
+//        echo htmlentities($gFileData,ENT_QUOTES,'UTF-8');
+//        echo '</pre><hr />';
+//
+        $xml = simplexml_load_string($this->securityScan($gFileData), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespacesMeta = $xml->getNamespaces(true);
+
+//        var_dump($namespacesMeta);
+//
+        $gnmXML = $xml->children($namespacesMeta['gnm']);
+
+        $docProps = $objPHPExcel->getProperties();
+        //    Document Properties are held differently, depending on the version of Gnumeric
+        if (isset($namespacesMeta['office'])) {
+            $officeXML = $xml->children($namespacesMeta['office']);
+            $officeDocXML = $officeXML->{'document-meta'};
+            $officeDocMetaXML = $officeDocXML->meta;
+
+            foreach ($officeDocMetaXML as $officePropertyData) {
+                $officePropertyDC = array();
+                if (isset($namespacesMeta['dc'])) {
+                    $officePropertyDC = $officePropertyData->children($namespacesMeta['dc']);
+                }
+                foreach ($officePropertyDC as $propertyName => $propertyValue) {
+                    $propertyValue = (string) $propertyValue;
+                    switch ($propertyName) {
+                        case 'title':
+                            $docProps->setTitle(trim($propertyValue));
+                            break;
+                        case 'subject':
+                            $docProps->setSubject(trim($propertyValue));
+                            break;
+                        case 'creator':
+                            $docProps->setCreator(trim($propertyValue));
+                            $docProps->setLastModifiedBy(trim($propertyValue));
+                            break;
+                        case 'date':
+                            $creationDate = strtotime(trim($propertyValue));
+                            $docProps->setCreated($creationDate);
+                            $docProps->setModified($creationDate);
+                            break;
+                        case 'description':
+                            $docProps->setDescription(trim($propertyValue));
+                            break;
+                    }
+                }
+                $officePropertyMeta = array();
+                if (isset($namespacesMeta['meta'])) {
+                    $officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']);
+                }
+                foreach ($officePropertyMeta as $propertyName => $propertyValue) {
+                    $attributes = $propertyValue->attributes($namespacesMeta['meta']);
+                    $propertyValue = (string) $propertyValue;
+                    switch ($propertyName) {
+                        case 'keyword':
+                            $docProps->setKeywords(trim($propertyValue));
+                            break;
+                        case 'initial-creator':
+                            $docProps->setCreator(trim($propertyValue));
+                            $docProps->setLastModifiedBy(trim($propertyValue));
+                            break;
+                        case 'creation-date':
+                            $creationDate = strtotime(trim($propertyValue));
+                            $docProps->setCreated($creationDate);
+                            $docProps->setModified($creationDate);
+                            break;
+                        case 'user-defined':
+                            list(, $attrName) = explode(':', $attributes['name']);
+                            switch ($attrName) {
+                                case 'publisher':
+                                    $docProps->setCompany(trim($propertyValue));
+                                    break;
+                                case 'category':
+                                    $docProps->setCategory(trim($propertyValue));
+                                    break;
+                                case 'manager':
+                                    $docProps->setManager(trim($propertyValue));
+                                    break;
+                            }
+                            break;
+                    }
+                }
+            }
+        } elseif (isset($gnmXML->Summary)) {
+            foreach ($gnmXML->Summary->Item as $summaryItem) {
+                $propertyName = $summaryItem->name;
+                $propertyValue = $summaryItem->{'val-string'};
+                switch ($propertyName) {
+                    case 'title':
+                        $docProps->setTitle(trim($propertyValue));
+                        break;
+                    case 'comments':
+                        $docProps->setDescription(trim($propertyValue));
+                        break;
+                    case 'keywords':
+                        $docProps->setKeywords(trim($propertyValue));
+                        break;
+                    case 'category':
+                        $docProps->setCategory(trim($propertyValue));
+                        break;
+                    case 'manager':
+                        $docProps->setManager(trim($propertyValue));
+                        break;
+                    case 'author':
+                        $docProps->setCreator(trim($propertyValue));
+                        $docProps->setLastModifiedBy(trim($propertyValue));
+                        break;
+                    case 'company':
+                        $docProps->setCompany(trim($propertyValue));
+                        break;
+                }
+            }
+        }
+
+        $worksheetID = 0;
+        foreach ($gnmXML->Sheets->Sheet as $sheet) {
+            $worksheetName = (string) $sheet->Name;
+//            echo '<b>Worksheet: ', $worksheetName,'</b><br />';
+            if ((isset($this->loadSheetsOnly)) && (!in_array($worksheetName, $this->loadSheetsOnly))) {
+                continue;
+            }
+
+            $maxRow = $maxCol = 0;
+
+            // Create new Worksheet
+            $objPHPExcel->createSheet();
+            $objPHPExcel->setActiveSheetIndex($worksheetID);
+            //    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
+            $objPHPExcel->getActiveSheet()->setTitle($worksheetName, false);
+
+            if ((!$this->readDataOnly) && (isset($sheet->PrintInformation))) {
+                if (isset($sheet->PrintInformation->Margins)) {
+                    foreach ($sheet->PrintInformation->Margins->children('gnm', true) as $key => $margin) {
+                        $marginAttributes = $margin->attributes();
+                        $marginSize = 72 / 100;    //    Default
+                        switch ($marginAttributes['PrefUnit']) {
+                            case 'mm':
+                                $marginSize = intval($marginAttributes['Points']) / 100;
+                                break;
+                        }
+                        switch ($key) {
+                            case 'top':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setTop($marginSize);
+                                break;
+                            case 'bottom':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setBottom($marginSize);
+                                break;
+                            case 'left':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setLeft($marginSize);
+                                break;
+                            case 'right':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setRight($marginSize);
+                                break;
+                            case 'header':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setHeader($marginSize);
+                                break;
+                            case 'footer':
+                                $objPHPExcel->getActiveSheet()->getPageMargins()->setFooter($marginSize);
+                                break;
+                        }
+                    }
+                }
+            }
+
+            foreach ($sheet->Cells->Cell as $cell) {
+                $cellAttributes = $cell->attributes();
+                $row = (int) $cellAttributes->Row + 1;
+                $column = (int) $cellAttributes->Col;
+
+                if ($row > $maxRow) {
+                    $maxRow = $row;
+                }
+                if ($column > $maxCol) {
+                    $maxCol = $column;
+                }
+
+                $column = PHPExcel_Cell::stringFromColumnIndex($column);
+
+                // Read cell?
+                if ($this->getReadFilter() !== null) {
+                    if (!$this->getReadFilter()->readCell($column, $row, $worksheetName)) {
+                        continue;
+                    }
+                }
+
+                $ValueType = $cellAttributes->ValueType;
+                $ExprID = (string) $cellAttributes->ExprID;
+//                echo 'Cell ', $column, $row,'<br />';
+//                echo 'Type is ', $ValueType,'<br />';
+//                echo 'Value is ', $cell,'<br />';
+                $type = PHPExcel_Cell_DataType::TYPE_FORMULA;
+                if ($ExprID > '') {
+                    if (((string) $cell) > '') {
+                        $this->expressions[$ExprID] = array(
+                            'column'    => $cellAttributes->Col,
+                            'row'        => $cellAttributes->Row,
+                            'formula'    => (string) $cell
+                        );
+//                        echo 'NEW EXPRESSION ', $ExprID,'<br />';
+                    } else {
+                        $expression = $this->expressions[$ExprID];
+
+                        $cell = $this->referenceHelper->updateFormulaReferences(
+                            $expression['formula'],
+                            'A1',
+                            $cellAttributes->Col - $expression['column'],
+                            $cellAttributes->Row - $expression['row'],
+                            $worksheetName
+                        );
+//                        echo 'SHARED EXPRESSION ', $ExprID,'<br />';
+//                        echo 'New Value is ', $cell,'<br />';
+                    }
+                    $type = PHPExcel_Cell_DataType::TYPE_FORMULA;
+                } else {
+                    switch ($ValueType) {
+                        case '10':        //    NULL
+                            $type = PHPExcel_Cell_DataType::TYPE_NULL;
+                            break;
+                        case '20':        //    Boolean
+                            $type = PHPExcel_Cell_DataType::TYPE_BOOL;
+                            $cell = ($cell == 'TRUE') ? true: false;
+                            break;
+                        case '30':        //    Integer
+                            $cell = intval($cell);
+                            // Excel 2007+ doesn't differentiate between integer and float, so set the value and dropthru to the next (numeric) case
+                        case '40':        //    Float
+                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                            break;
+                        case '50':        //    Error
+                            $type = PHPExcel_Cell_DataType::TYPE_ERROR;
+                            break;
+                        case '60':        //    String
+                            $type = PHPExcel_Cell_DataType::TYPE_STRING;
+                            break;
+                        case '70':        //    Cell Range
+                        case '80':        //    Array
+                    }
+                }
+                $objPHPExcel->getActiveSheet()->getCell($column.$row)->setValueExplicit($cell, $type);
+            }
+
+            if ((!$this->readDataOnly) && (isset($sheet->Objects))) {
+                foreach ($sheet->Objects->children('gnm', true) as $key => $comment) {
+                    $commentAttributes = $comment->attributes();
+                    //    Only comment objects are handled at the moment
+                    if ($commentAttributes->Text) {
+                        $objPHPExcel->getActiveSheet()->getComment((string)$commentAttributes->ObjectBound)->setAuthor((string)$commentAttributes->Author)->setText($this->parseRichText((string)$commentAttributes->Text));
+                    }
+                }
+            }
+//            echo '$maxCol=', $maxCol,'; $maxRow=', $maxRow,'<br />';
+//
+            foreach ($sheet->Styles->StyleRegion as $styleRegion) {
+                $styleAttributes = $styleRegion->attributes();
+                if (($styleAttributes['startRow'] <= $maxRow) &&
+                    ($styleAttributes['startCol'] <= $maxCol)) {
+                    $startColumn = PHPExcel_Cell::stringFromColumnIndex((int) $styleAttributes['startCol']);
+                    $startRow = $styleAttributes['startRow'] + 1;
+
+                    $endColumn = ($styleAttributes['endCol'] > $maxCol) ? $maxCol : (int) $styleAttributes['endCol'];
+                    $endColumn = PHPExcel_Cell::stringFromColumnIndex($endColumn);
+                    $endRow = ($styleAttributes['endRow'] > $maxRow) ? $maxRow : $styleAttributes['endRow'];
+                    $endRow += 1;
+                    $cellRange = $startColumn.$startRow.':'.$endColumn.$endRow;
+//                    echo $cellRange,'<br />';
+
+                    $styleAttributes = $styleRegion->Style->attributes();
+//                    var_dump($styleAttributes);
+//                    echo '<br />';
+
+                    //    We still set the number format mask for date/time values, even if readDataOnly is true
+                    if ((!$this->readDataOnly) ||
+                        (PHPExcel_Shared_Date::isDateTimeFormatCode((string) $styleAttributes['Format']))) {
+                        $styleArray = array();
+                        $styleArray['numberformat']['code'] = (string) $styleAttributes['Format'];
+                        //    If readDataOnly is false, we set all formatting information
+                        if (!$this->readDataOnly) {
+                            switch ($styleAttributes['HAlign']) {
+                                case '1':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL;
+                                    break;
+                                case '2':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_LEFT;
+                                    break;
+                                case '4':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_RIGHT;
+                                    break;
+                                case '8':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_CENTER;
+                                    break;
+                                case '16':
+                                case '64':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS;
+                                    break;
+                                case '32':
+                                    $styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY;
+                                    break;
+                            }
+
+                            switch ($styleAttributes['VAlign']) {
+                                case '1':
+                                    $styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_TOP;
+                                    break;
+                                case '2':
+                                    $styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_BOTTOM;
+                                    break;
+                                case '4':
+                                    $styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_CENTER;
+                                    break;
+                                case '8':
+                                    $styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_JUSTIFY;
+                                    break;
+                            }
+
+                            $styleArray['alignment']['wrap'] = ($styleAttributes['WrapText'] == '1') ? true : false;
+                            $styleArray['alignment']['shrinkToFit'] = ($styleAttributes['ShrinkToFit'] == '1') ? true : false;
+                            $styleArray['alignment']['indent'] = (intval($styleAttributes["Indent"]) > 0) ? $styleAttributes["indent"] : 0;
+
+                            $RGB = self::parseGnumericColour($styleAttributes["Fore"]);
+                            $styleArray['font']['color']['rgb'] = $RGB;
+                            $RGB = self::parseGnumericColour($styleAttributes["Back"]);
+                            $shade = $styleAttributes["Shade"];
+                            if (($RGB != '000000') || ($shade != '0')) {
+                                $styleArray['fill']['color']['rgb'] = $styleArray['fill']['startcolor']['rgb'] = $RGB;
+                                $RGB2 = self::parseGnumericColour($styleAttributes["PatternColor"]);
+                                $styleArray['fill']['endcolor']['rgb'] = $RGB2;
+                                switch ($shade) {
+                                    case '1':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_SOLID;
+                                        break;
+                                    case '2':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_GRADIENT_LINEAR;
+                                        break;
+                                    case '3':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_GRADIENT_PATH;
+                                        break;
+                                    case '4':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN;
+                                        break;
+                                    case '5':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY;
+                                        break;
+                                    case '6':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID;
+                                        break;
+                                    case '7':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL;
+                                        break;
+                                    case '8':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS;
+                                        break;
+                                    case '9':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKUP;
+                                        break;
+                                    case '10':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL;
+                                        break;
+                                    case '11':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625;
+                                        break;
+                                    case '12':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_GRAY125;
+                                        break;
+                                    case '13':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN;
+                                        break;
+                                    case '14':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY;
+                                        break;
+                                    case '15':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID;
+                                        break;
+                                    case '16':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL;
+                                        break;
+                                    case '17':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS;
+                                        break;
+                                    case '18':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP;
+                                        break;
+                                    case '19':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL;
+                                        break;
+                                    case '20':
+                                        $styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY;
+                                        break;
+                                }
+                            }
+
+                            $fontAttributes = $styleRegion->Style->Font->attributes();
+//                            var_dump($fontAttributes);
+//                            echo '<br />';
+                            $styleArray['font']['name'] = (string) $styleRegion->Style->Font;
+                            $styleArray['font']['size'] = intval($fontAttributes['Unit']);
+                            $styleArray['font']['bold'] = ($fontAttributes['Bold'] == '1') ? true : false;
+                            $styleArray['font']['italic'] = ($fontAttributes['Italic'] == '1') ? true : false;
+                            $styleArray['font']['strike'] = ($fontAttributes['StrikeThrough'] == '1') ? true : false;
+                            switch ($fontAttributes['Underline']) {
+                                case '1':
+                                    $styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_SINGLE;
+                                    break;
+                                case '2':
+                                    $styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_DOUBLE;
+                                    break;
+                                case '3':
+                                    $styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING;
+                                    break;
+                                case '4':
+                                    $styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING;
+                                    break;
+                                default:
+                                    $styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_NONE;
+                                    break;
+                            }
+                            switch ($fontAttributes['Script']) {
+                                case '1':
+                                    $styleArray['font']['superScript'] = true;
+                                    break;
+                                case '-1':
+                                    $styleArray['font']['subScript'] = true;
+                                    break;
+                            }
+
+                            if (isset($styleRegion->Style->StyleBorder)) {
+                                if (isset($styleRegion->Style->StyleBorder->Top)) {
+                                    $styleArray['borders']['top'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Top->attributes());
+                                }
+                                if (isset($styleRegion->Style->StyleBorder->Bottom)) {
+                                    $styleArray['borders']['bottom'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Bottom->attributes());
+                                }
+                                if (isset($styleRegion->Style->StyleBorder->Left)) {
+                                    $styleArray['borders']['left'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Left->attributes());
+                                }
+                                if (isset($styleRegion->Style->StyleBorder->Right)) {
+                                    $styleArray['borders']['right'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Right->attributes());
+                                }
+                                if ((isset($styleRegion->Style->StyleBorder->Diagonal)) && (isset($styleRegion->Style->StyleBorder->{'Rev-Diagonal'}))) {
+                                    $styleArray['borders']['diagonal'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Diagonal->attributes());
+                                    $styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_BOTH;
+                                } elseif (isset($styleRegion->Style->StyleBorder->Diagonal)) {
+                                    $styleArray['borders']['diagonal'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->Diagonal->attributes());
+                                    $styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_UP;
+                                } elseif (isset($styleRegion->Style->StyleBorder->{'Rev-Diagonal'})) {
+                                    $styleArray['borders']['diagonal'] = self::parseBorderAttributes($styleRegion->Style->StyleBorder->{'Rev-Diagonal'}->attributes());
+                                    $styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_DOWN;
+                                }
+                            }
+                            if (isset($styleRegion->Style->HyperLink)) {
+                                //    TO DO
+                                $hyperlink = $styleRegion->Style->HyperLink->attributes();
+                            }
+                        }
+//                        var_dump($styleArray);
+//                        echo '<br />';
+                        $objPHPExcel->getActiveSheet()->getStyle($cellRange)->applyFromArray($styleArray);
+                    }
+                }
+            }
+
+            if ((!$this->readDataOnly) && (isset($sheet->Cols))) {
+                //    Column Widths
+                $columnAttributes = $sheet->Cols->attributes();
+                $defaultWidth = $columnAttributes['DefaultSizePts']  / 5.4;
+                $c = 0;
+                foreach ($sheet->Cols->ColInfo as $columnOverride) {
+                    $columnAttributes = $columnOverride->attributes();
+                    $column = $columnAttributes['No'];
+                    $columnWidth = $columnAttributes['Unit']  / 5.4;
+                    $hidden = ((isset($columnAttributes['Hidden'])) && ($columnAttributes['Hidden'] == '1')) ? true : false;
+                    $columnCount = (isset($columnAttributes['Count'])) ? $columnAttributes['Count'] : 1;
+                    while ($c < $column) {
+                        $objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($defaultWidth);
+                        ++$c;
+                    }
+                    while (($c < ($column+$columnCount)) && ($c <= $maxCol)) {
+                        $objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($columnWidth);
+                        if ($hidden) {
+                            $objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setVisible(false);
+                        }
+                        ++$c;
+                    }
+                }
+                while ($c <= $maxCol) {
+                    $objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($defaultWidth);
+                    ++$c;
+                }
+            }
+
+            if ((!$this->readDataOnly) && (isset($sheet->Rows))) {
+                //    Row Heights
+                $rowAttributes = $sheet->Rows->attributes();
+                $defaultHeight = $rowAttributes['DefaultSizePts'];
+                $r = 0;
+
+                foreach ($sheet->Rows->RowInfo as $rowOverride) {
+                    $rowAttributes = $rowOverride->attributes();
+                    $row = $rowAttributes['No'];
+                    $rowHeight = $rowAttributes['Unit'];
+                    $hidden = ((isset($rowAttributes['Hidden'])) && ($rowAttributes['Hidden'] == '1')) ? true : false;
+                    $rowCount = (isset($rowAttributes['Count'])) ? $rowAttributes['Count'] : 1;
+                    while ($r < $row) {
+                        ++$r;
+                        $objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight);
+                    }
+                    while (($r < ($row+$rowCount)) && ($r < $maxRow)) {
+                        ++$r;
+                        $objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($rowHeight);
+                        if ($hidden) {
+                            $objPHPExcel->getActiveSheet()->getRowDimension($r)->setVisible(false);
+                        }
+                    }
+                }
+                while ($r < $maxRow) {
+                    ++$r;
+                    $objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight);
+                }
+            }
+
+            //    Handle Merged Cells in this worksheet
+            if (isset($sheet->MergedRegions)) {
+                foreach ($sheet->MergedRegions->Merge as $mergeCells) {
+                    if (strpos($mergeCells, ':') !== false) {
+                        $objPHPExcel->getActiveSheet()->mergeCells($mergeCells);
+                    }
+                }
+            }
+
+            $worksheetID++;
+        }
+
+        //    Loop through definedNames (global named ranges)
+        if (isset($gnmXML->Names)) {
+            foreach ($gnmXML->Names->Name as $namedRange) {
+                $name = (string) $namedRange->name;
+                $range = (string) $namedRange->value;
+                if (stripos($range, '#REF!') !== false) {
+                    continue;
+                }
+
+                $range = explode('!', $range);
+                $range[0] = trim($range[0], "'");
+                if ($worksheet = $objPHPExcel->getSheetByName($range[0])) {
+                    $extractedRange = str_replace('$', '', $range[1]);
+                    $objPHPExcel->addNamedRange(new PHPExcel_NamedRange($name, $worksheet, $extractedRange));
+                }
+            }
+        }
+
+        // Return
+        return $objPHPExcel;
+    }
+
+    private static function parseBorderAttributes($borderAttributes)
+    {
+        $styleArray = array();
+        if (isset($borderAttributes["Color"])) {
+            $styleArray['color']['rgb'] = self::parseGnumericColour($borderAttributes["Color"]);
+        }
+
+        switch ($borderAttributes["Style"]) {
+            case '0':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_NONE;
+                break;
+            case '1':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                break;
+            case '2':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUM;
+                break;
+            case '3':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_SLANTDASHDOT;
+                break;
+            case '4':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHED;
+                break;
+            case '5':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_THICK;
+                break;
+            case '6':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_DOUBLE;
+                break;
+            case '7':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_DOTTED;
+                break;
+            case '8':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHED;
+                break;
+            case '9':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHDOT;
+                break;
+            case '10':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT;
+                break;
+            case '11':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHDOTDOT;
+                break;
+            case '12':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT;
+                break;
+            case '13':
+                $styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT;
+                break;
+        }
+        return $styleArray;
+    }
+
+    private function parseRichText($is = '')
+    {
+        $value = new PHPExcel_RichText();
+        $value->createText($is);
+
+        return $value;
+    }
+
+    private static function parseGnumericColour($gnmColour)
+    {
+        list($gnmR, $gnmG, $gnmB) = explode(':', $gnmColour);
+        $gnmR = substr(str_pad($gnmR, 4, '0', STR_PAD_RIGHT), 0, 2);
+        $gnmG = substr(str_pad($gnmG, 4, '0', STR_PAD_RIGHT), 0, 2);
+        $gnmB = substr(str_pad($gnmB, 4, '0', STR_PAD_RIGHT), 0, 2);
+        return $gnmR . $gnmG . $gnmB;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/HTML.php

@@ -0,0 +1,549 @@
+<?php
+
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_HTML
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+/** PHPExcel root directory */
+class PHPExcel_Reader_HTML extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+
+    /**
+     * Input encoding
+     *
+     * @var string
+     */
+    protected $inputEncoding = 'ANSI';
+
+    /**
+     * Sheet index to read
+     *
+     * @var int
+     */
+    protected $sheetIndex = 0;
+
+    /**
+     * Formats
+     *
+     * @var array
+     */
+    protected $formats = array(
+        'h1' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 24,
+            ),
+        ), //    Bold, 24pt
+        'h2' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 18,
+            ),
+        ), //    Bold, 18pt
+        'h3' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 13.5,
+            ),
+        ), //    Bold, 13.5pt
+        'h4' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 12,
+            ),
+        ), //    Bold, 12pt
+        'h5' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 10,
+            ),
+        ), //    Bold, 10pt
+        'h6' => array(
+            'font' => array(
+                'bold' => true,
+                'size' => 7.5,
+            ),
+        ), //    Bold, 7.5pt
+        'a' => array(
+            'font' => array(
+                'underline' => true,
+                'color' => array(
+                    'argb' => PHPExcel_Style_Color::COLOR_BLUE,
+                ),
+            ),
+        ), //    Blue underlined
+        'hr' => array(
+            'borders' => array(
+                'bottom' => array(
+                    'style' => PHPExcel_Style_Border::BORDER_THIN,
+                    'color' => array(
+                        PHPExcel_Style_Color::COLOR_BLACK,
+                    ),
+                ),
+            ),
+        ), //    Bottom border
+    );
+
+    protected $rowspan = array();
+
+    /**
+     * Create a new PHPExcel_Reader_HTML
+     */
+    public function __construct()
+    {
+        $this->readFilter = new PHPExcel_Reader_DefaultReadFilter();
+    }
+
+    /**
+     * Validate that the current file is an HTML file
+     *
+     * @return boolean
+     */
+    protected function isValidFormat()
+    {
+        //    Reading 2048 bytes should be enough to validate that the format is HTML
+        $data = fread($this->fileHandle, 2048);
+        if ((strpos($data, '<') !== false) &&
+                (strlen($data) !== strlen(strip_tags($data)))) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param  string                    $pFilename
+     * @return PHPExcel
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    /**
+     * Set input encoding
+     *
+     * @param string $pValue Input encoding
+     */
+    public function setInputEncoding($pValue = 'ANSI')
+    {
+        $this->inputEncoding = $pValue;
+
+        return $this;
+    }
+
+    /**
+     * Get input encoding
+     *
+     * @return string
+     */
+    public function getInputEncoding()
+    {
+        return $this->inputEncoding;
+    }
+
+    //    Data Array used for testing only, should write to PHPExcel object on completion of tests
+    protected $dataArray = array();
+    protected $tableLevel = 0;
+    protected $nestedColumn = array('A');
+
+    protected function setTableStartColumn($column)
+    {
+        if ($this->tableLevel == 0) {
+            $column = 'A';
+        }
+        ++$this->tableLevel;
+        $this->nestedColumn[$this->tableLevel] = $column;
+
+        return $this->nestedColumn[$this->tableLevel];
+    }
+
+    protected function getTableStartColumn()
+    {
+        return $this->nestedColumn[$this->tableLevel];
+    }
+
+    protected function releaseTableStartColumn()
+    {
+        --$this->tableLevel;
+
+        return array_pop($this->nestedColumn);
+    }
+
+    protected function flushCell($sheet, $column, $row, &$cellContent)
+    {
+        if (is_string($cellContent)) {
+            //    Simple String content
+            if (trim($cellContent) > '') {
+                //    Only actually write it if there's content in the string
+//                echo 'FLUSH CELL: ' , $column , $row , ' => ' , $cellContent , '<br />';
+                //    Write to worksheet to be done here...
+                //    ... we return the cell so we can mess about with styles more easily
+                $sheet->setCellValue($column . $row, $cellContent, true);
+                $this->dataArray[$row][$column] = $cellContent;
+            }
+        } else {
+            //    We have a Rich Text run
+            //    TODO
+            $this->dataArray[$row][$column] = 'RICH TEXT: ' . $cellContent;
+        }
+        $cellContent = (string) '';
+    }
+
+    protected function processDomElement(DOMNode $element, $sheet, &$row, &$column, &$cellContent, $format = null)
+    {
+        foreach ($element->childNodes as $child) {
+            if ($child instanceof DOMText) {
+                $domText = preg_replace('/\s+/u', ' ', trim($child->nodeValue));
+                if (is_string($cellContent)) {
+                    //    simply append the text if the cell content is a plain text string
+                    $cellContent .= $domText;
+                } else {
+                    //    but if we have a rich text run instead, we need to append it correctly
+                    //    TODO
+                }
+            } elseif ($child instanceof DOMElement) {
+//                echo '<b>DOM ELEMENT: </b>' , strtoupper($child->nodeName) , '<br />';
+
+                $attributeArray = array();
+                foreach ($child->attributes as $attribute) {
+//                    echo '<b>ATTRIBUTE: </b>' , $attribute->name , ' => ' , $attribute->value , '<br />';
+                    $attributeArray[$attribute->name] = $attribute->value;
+                }
+
+                switch ($child->nodeName) {
+                    case 'meta':
+                        foreach ($attributeArray as $attributeName => $attributeValue) {
+                            switch ($attributeName) {
+                                case 'content':
+                                    //    TODO
+                                    //    Extract character set, so we can convert to UTF-8 if required
+                                    break;
+                            }
+                        }
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        break;
+                    case 'title':
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        $sheet->setTitle($cellContent);
+                        $cellContent = '';
+                        break;
+                    case 'span':
+                    case 'div':
+                    case 'font':
+                    case 'i':
+                    case 'em':
+                    case 'strong':
+                    case 'b':
+//                        echo 'STYLING, SPAN OR DIV<br />';
+                        if ($cellContent > '') {
+                            $cellContent .= ' ';
+                        }
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        if ($cellContent > '') {
+                            $cellContent .= ' ';
+                        }
+//                        echo 'END OF STYLING, SPAN OR DIV<br />';
+                        break;
+                    case 'hr':
+                        $this->flushCell($sheet, $column, $row, $cellContent);
+                        ++$row;
+                        if (isset($this->formats[$child->nodeName])) {
+                            $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+                        } else {
+                            $cellContent = '----------';
+                            $this->flushCell($sheet, $column, $row, $cellContent);
+                        }
+                        ++$row;
+                        // Add a break after a horizontal rule, simply by allowing the code to dropthru
+                    case 'br':
+                        if ($this->tableLevel > 0) {
+                            //    If we're inside a table, replace with a \n
+                            $cellContent .= "\n";
+                        } else {
+                            //    Otherwise flush our existing content and move the row cursor on
+                            $this->flushCell($sheet, $column, $row, $cellContent);
+                            ++$row;
+                        }
+//                        echo 'HARD LINE BREAK: ' , '<br />';
+                        break;
+                    case 'a':
+//                        echo 'START OF HYPERLINK: ' , '<br />';
+                        foreach ($attributeArray as $attributeName => $attributeValue) {
+                            switch ($attributeName) {
+                                case 'href':
+//                                    echo 'Link to ' , $attributeValue , '<br />';
+                                    $sheet->getCell($column . $row)->getHyperlink()->setUrl($attributeValue);
+                                    if (isset($this->formats[$child->nodeName])) {
+                                        $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+                                    }
+                                    break;
+                            }
+                        }
+                        $cellContent .= ' ';
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                        echo 'END OF HYPERLINK:' , '<br />';
+                        break;
+                    case 'h1':
+                    case 'h2':
+                    case 'h3':
+                    case 'h4':
+                    case 'h5':
+                    case 'h6':
+                    case 'ol':
+                    case 'ul':
+                    case 'p':
+                        if ($this->tableLevel > 0) {
+                            //    If we're inside a table, replace with a \n
+                            $cellContent .= "\n";
+//                            echo 'LIST ENTRY: ' , '<br />';
+                            $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                            echo 'END OF LIST ENTRY:' , '<br />';
+                        } else {
+                            if ($cellContent > '') {
+                                $this->flushCell($sheet, $column, $row, $cellContent);
+                                $row++;
+                            }
+//                            echo 'START OF PARAGRAPH: ' , '<br />';
+                            $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                            echo 'END OF PARAGRAPH:' , '<br />';
+                            $this->flushCell($sheet, $column, $row, $cellContent);
+
+                            if (isset($this->formats[$child->nodeName])) {
+                                $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+                            }
+
+                            $row++;
+                            $column = 'A';
+                        }
+                        break;
+                    case 'li':
+                        if ($this->tableLevel > 0) {
+                            //    If we're inside a table, replace with a \n
+                            $cellContent .= "\n";
+//                            echo 'LIST ENTRY: ' , '<br />';
+                            $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                            echo 'END OF LIST ENTRY:' , '<br />';
+                        } else {
+                            if ($cellContent > '') {
+                                $this->flushCell($sheet, $column, $row, $cellContent);
+                            }
+                            ++$row;
+//                            echo 'LIST ENTRY: ' , '<br />';
+                            $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                            echo 'END OF LIST ENTRY:' , '<br />';
+                            $this->flushCell($sheet, $column, $row, $cellContent);
+                            $column = 'A';
+                        }
+                        break;
+                    case 'table':
+                        $this->flushCell($sheet, $column, $row, $cellContent);
+                        $column = $this->setTableStartColumn($column);
+//                        echo 'START OF TABLE LEVEL ' , $this->tableLevel , '<br />';
+                        if ($this->tableLevel > 1) {
+                            --$row;
+                        }
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                        echo 'END OF TABLE LEVEL ' , $this->tableLevel , '<br />';
+                        $column = $this->releaseTableStartColumn();
+                        if ($this->tableLevel > 1) {
+                            ++$column;
+                        } else {
+                            ++$row;
+                        }
+                        break;
+                    case 'thead':
+                    case 'tbody':
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        break;
+                    case 'tr':
+                        $column = $this->getTableStartColumn();
+                        $cellContent = '';
+//                        echo 'START OF TABLE ' , $this->tableLevel , ' ROW<br />';
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        ++$row;
+//                        echo 'END OF TABLE ' , $this->tableLevel , ' ROW<br />';
+                        break;
+                    case 'th':
+                    case 'td':
+//                        echo 'START OF TABLE ' , $this->tableLevel , ' CELL<br />';
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+//                        echo 'END OF TABLE ' , $this->tableLevel , ' CELL<br />';
+
+                        while (isset($this->rowspan[$column . $row])) {
+                            ++$column;
+                        }
+
+                        $this->flushCell($sheet, $column, $row, $cellContent);
+
+//                        if (isset($attributeArray['style']) && !empty($attributeArray['style'])) {
+//                            $styleAry = $this->getPhpExcelStyleArray($attributeArray['style']);
+//
+//                            if (!empty($styleAry)) {
+//                                $sheet->getStyle($column . $row)->applyFromArray($styleAry);
+//                            }
+//                        }
+
+                        if (isset($attributeArray['rowspan']) && isset($attributeArray['colspan'])) {
+                            //create merging rowspan and colspan
+                            $columnTo = $column;
+                            for ($i = 0; $i < $attributeArray['colspan'] - 1; $i++) {
+                                ++$columnTo;
+                            }
+                            $range = $column . $row . ':' . $columnTo . ($row + $attributeArray['rowspan'] - 1);
+                            foreach (\PHPExcel_Cell::extractAllCellReferencesInRange($range) as $value) {
+                                $this->rowspan[$value] = true;
+                            }
+                            $sheet->mergeCells($range);
+                            $column = $columnTo;
+                        } elseif (isset($attributeArray['rowspan'])) {
+                            //create merging rowspan
+                            $range = $column . $row . ':' . $column . ($row + $attributeArray['rowspan'] - 1);
+                            foreach (\PHPExcel_Cell::extractAllCellReferencesInRange($range) as $value) {
+                                $this->rowspan[$value] = true;
+                            }
+                            $sheet->mergeCells($range);
+                        } elseif (isset($attributeArray['colspan'])) {
+                            //create merging colspan
+                            $columnTo = $column;
+                            for ($i = 0; $i < $attributeArray['colspan'] - 1; $i++) {
+                                ++$columnTo;
+                            }
+                            $sheet->mergeCells($column . $row . ':' . $columnTo . $row);
+                            $column = $columnTo;
+                        }
+                        ++$column;
+                        break;
+                    case 'body':
+                        $row = 1;
+                        $column = 'A';
+                        $content = '';
+                        $this->tableLevel = 0;
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                        break;
+                    default:
+                        $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+                }
+            }
+        }
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param  string                    $pFilename
+     * @param  PHPExcel                  $objPHPExcel
+     * @return PHPExcel
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        // Open file to validate
+        $this->openFile($pFilename);
+        if (!$this->isValidFormat()) {
+            fclose($this->fileHandle);
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid HTML file.");
+        }
+        //    Close after validating
+        fclose($this->fileHandle);
+
+        // Create new PHPExcel
+        while ($objPHPExcel->getSheetCount() <= $this->sheetIndex) {
+            $objPHPExcel->createSheet();
+        }
+        $objPHPExcel->setActiveSheetIndex($this->sheetIndex);
+
+        //    Create a new DOM object
+        $dom = new domDocument;
+        //    Reload the HTML file into the DOM object
+        $loaded = $dom->loadHTML(mb_convert_encoding($this->securityScanFile($pFilename), 'HTML-ENTITIES', 'UTF-8'));
+        if ($loaded === false) {
+            throw new PHPExcel_Reader_Exception('Failed to load ' . $pFilename . ' as a DOM Document');
+        }
+
+        //    Discard white space
+        $dom->preserveWhiteSpace = false;
+
+        $row = 0;
+        $column = 'A';
+        $content = '';
+        $this->processDomElement($dom, $objPHPExcel->getActiveSheet(), $row, $column, $content);
+
+        // Return
+        return $objPHPExcel;
+    }
+
+    /**
+     * Get sheet index
+     *
+     * @return int
+     */
+    public function getSheetIndex()
+    {
+        return $this->sheetIndex;
+    }
+
+    /**
+     * Set sheet index
+     *
+     * @param  int                  $pValue Sheet index
+     * @return PHPExcel_Reader_HTML
+     */
+    public function setSheetIndex($pValue = 0)
+    {
+        $this->sheetIndex = $pValue;
+
+        return $this;
+    }
+
+    /**
+     * Scan theXML for use of <!ENTITY to prevent XXE/XEE attacks
+     *
+     * @param     string         $xml
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function securityScan($xml)
+    {
+        $pattern = '/\\0?' . implode('\\0?', str_split('<!ENTITY')) . '\\0?/';
+        if (preg_match($pattern, $xml)) {
+            throw new PHPExcel_Reader_Exception('Detected use of ENTITY in XML, spreadsheet file load() aborted to prevent XXE/XEE attacks');
+        }
+        return $xml;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/IReadFilter.php

@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * PHPExcel_Reader_IReadFilter
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+interface PHPExcel_Reader_IReadFilter
+{
+    /**
+     * Should this cell be read?
+     *
+     * @param    $column           Column address (as a string value like "A", or "IV")
+     * @param    $row              Row number
+     * @param    $worksheetName    Optional worksheet name
+     * @return   boolean
+     */
+    public function readCell($column, $row, $worksheetName = '');
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/IReader.php

@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * PHPExcel_Reader_IReader
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+interface PHPExcel_Reader_IReader
+{
+    /**
+     * Can the current PHPExcel_Reader_IReader read the file?
+     *
+     * @param     string         $pFilename
+     * @return     boolean
+     */
+    public function canRead($pFilename);
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return  PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function load($pFilename);
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/OOCalc.php

@@ -0,0 +1,696 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_OOCalc
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_OOCalc extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Formats
+     *
+     * @var array
+     */
+    private $styles = array();
+
+    /**
+     * Create a new PHPExcel_Reader_OOCalc
+     */
+    public function __construct()
+    {
+        $this->readFilter     = new PHPExcel_Reader_DefaultReadFilter();
+    }
+
+    /**
+     * Can the current PHPExcel_Reader_IReader read the file?
+     *
+     * @param     string         $pFilename
+     * @return     boolean
+     * @throws PHPExcel_Reader_Exception
+     */
+    public function canRead($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+        // Check if zip class exists
+//        if (!class_exists($zipClass, false)) {
+//            throw new PHPExcel_Reader_Exception($zipClass . " library is not enabled");
+//        }
+
+        $mimeType = 'UNKNOWN';
+        // Load file
+        $zip = new $zipClass;
+        if ($zip->open($pFilename) === true) {
+            // check if it is an OOXML archive
+            $stat = $zip->statName('mimetype');
+            if ($stat && ($stat['size'] <= 255)) {
+                $mimeType = $zip->getFromName($stat['name']);
+            } elseif ($stat = $zip->statName('META-INF/manifest.xml')) {
+                $xml = simplexml_load_string($this->securityScan($zip->getFromName('META-INF/manifest.xml')), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+                $namespacesContent = $xml->getNamespaces(true);
+                if (isset($namespacesContent['manifest'])) {
+                    $manifest = $xml->children($namespacesContent['manifest']);
+                    foreach ($manifest as $manifestDataSet) {
+                        $manifestAttributes = $manifestDataSet->attributes($namespacesContent['manifest']);
+                        if ($manifestAttributes->{'full-path'} == '/') {
+                            $mimeType = (string) $manifestAttributes->{'media-type'};
+                            break;
+                        }
+                    }
+                }
+            }
+
+            $zip->close();
+
+            return ($mimeType === 'application/vnd.oasis.opendocument.spreadsheet');
+        }
+
+        return false;
+    }
+
+
+    /**
+     * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object
+     *
+     * @param     string         $pFilename
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function listWorksheetNames($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+        $zip = new $zipClass;
+        if (!$zip->open($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file.");
+        }
+
+        $worksheetNames = array();
+
+        $xml = new XMLReader();
+        $res = $xml->xml($this->securityScanFile('zip://'.realpath($pFilename).'#content.xml'), null, PHPExcel_Settings::getLibXmlLoaderOptions());
+        $xml->setParserProperty(2, true);
+
+        //    Step into the first level of content of the XML
+        $xml->read();
+        while ($xml->read()) {
+            //    Quickly jump through to the office:body node
+            while ($xml->name !== 'office:body') {
+                if ($xml->isEmptyElement) {
+                    $xml->read();
+                } else {
+                    $xml->next();
+                }
+            }
+            //    Now read each node until we find our first table:table node
+            while ($xml->read()) {
+                if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) {
+                    //    Loop through each table:table node reading the table:name attribute for each worksheet name
+                    do {
+                        $worksheetNames[] = $xml->getAttribute('table:name');
+                        $xml->next();
+                    } while ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT);
+                }
+            }
+        }
+
+        return $worksheetNames;
+    }
+
+    /**
+     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
+     *
+     * @param   string     $pFilename
+     * @throws   PHPExcel_Reader_Exception
+     */
+    public function listWorksheetInfo($pFilename)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $worksheetInfo = array();
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+        $zip = new $zipClass;
+        if (!$zip->open($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file.");
+        }
+
+        $xml = new XMLReader();
+        $res = $xml->xml($this->securityScanFile('zip://'.realpath($pFilename).'#content.xml'), null, PHPExcel_Settings::getLibXmlLoaderOptions());
+        $xml->setParserProperty(2, true);
+
+        //    Step into the first level of content of the XML
+        $xml->read();
+        while ($xml->read()) {
+            //    Quickly jump through to the office:body node
+            while ($xml->name !== 'office:body') {
+                if ($xml->isEmptyElement) {
+                    $xml->read();
+                } else {
+                    $xml->next();
+                }
+            }
+                //    Now read each node until we find our first table:table node
+            while ($xml->read()) {
+                if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) {
+                    $worksheetNames[] = $xml->getAttribute('table:name');
+
+                    $tmpInfo = array(
+                        'worksheetName' => $xml->getAttribute('table:name'),
+                        'lastColumnLetter' => 'A',
+                        'lastColumnIndex' => 0,
+                        'totalRows' => 0,
+                        'totalColumns' => 0,
+                    );
+
+                    //    Loop through each child node of the table:table element reading
+                    $currCells = 0;
+                    do {
+                        $xml->read();
+                        if ($xml->name == 'table:table-row' && $xml->nodeType == XMLReader::ELEMENT) {
+                            $rowspan = $xml->getAttribute('table:number-rows-repeated');
+                            $rowspan = empty($rowspan) ? 1 : $rowspan;
+                            $tmpInfo['totalRows'] += $rowspan;
+                            $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+                            $currCells = 0;
+                            //    Step into the row
+                            $xml->read();
+                            do {
+                                if ($xml->name == 'table:table-cell' && $xml->nodeType == XMLReader::ELEMENT) {
+                                    if (!$xml->isEmptyElement) {
+                                        $currCells++;
+                                        $xml->next();
+                                    } else {
+                                        $xml->read();
+                                    }
+                                } elseif ($xml->name == 'table:covered-table-cell' && $xml->nodeType == XMLReader::ELEMENT) {
+                                    $mergeSize = $xml->getAttribute('table:number-columns-repeated');
+                                    $currCells += $mergeSize;
+                                    $xml->read();
+                                }
+                            } while ($xml->name != 'table:table-row');
+                        }
+                    } while ($xml->name != 'table:table');
+
+                    $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+                    $tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1;
+                    $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);
+                    $worksheetInfo[] = $tmpInfo;
+                }
+            }
+
+//                foreach ($workbookData->table as $worksheetDataSet) {
+//                    $worksheetData = $worksheetDataSet->children($namespacesContent['table']);
+//                    $worksheetDataAttributes = $worksheetDataSet->attributes($namespacesContent['table']);
+//
+//                    $rowIndex = 0;
+//                    foreach ($worksheetData as $key => $rowData) {
+//                        switch ($key) {
+//                            case 'table-row' :
+//                                $rowDataTableAttributes = $rowData->attributes($namespacesContent['table']);
+//                                $rowRepeats = (isset($rowDataTableAttributes['number-rows-repeated'])) ?
+//                                        $rowDataTableAttributes['number-rows-repeated'] : 1;
+//                                $columnIndex = 0;
+//
+//                                foreach ($rowData as $key => $cellData) {
+//                                    $cellDataTableAttributes = $cellData->attributes($namespacesContent['table']);
+//                                    $colRepeats = (isset($cellDataTableAttributes['number-columns-repeated'])) ?
+//                                        $cellDataTableAttributes['number-columns-repeated'] : 1;
+//                                    $cellDataOfficeAttributes = $cellData->attributes($namespacesContent['office']);
+//                                    if (isset($cellDataOfficeAttributes['value-type'])) {
+//                                        $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex + $colRepeats - 1);
+//                                        $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex + $rowRepeats);
+//                                    }
+//                                    $columnIndex += $colRepeats;
+//                                }
+//                                $rowIndex += $rowRepeats;
+//                                break;
+//                        }
+//                    }
+//
+//                    $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);
+//                    $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;
+//
+//                }
+//            }
+        }
+
+        return $worksheetInfo;
+    }
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    private static function identifyFixedStyleValue($styleList, &$styleAttributeValue)
+    {
+        $styleAttributeValue = strtolower($styleAttributeValue);
+        foreach ($styleList as $style) {
+            if ($styleAttributeValue == strtolower($style)) {
+                $styleAttributeValue = $style;
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param     string         $pFilename
+     * @param    PHPExcel    $objPHPExcel
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        // Check if file exists
+        if (!file_exists($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
+        }
+
+        $timezoneObj = new DateTimeZone('Europe/London');
+        $GMT = new DateTimeZone('UTC');
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+        $zip = new $zipClass;
+        if (!$zip->open($pFilename)) {
+            throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file.");
+        }
+
+//        echo '<h1>Meta Information</h1>';
+        $xml = simplexml_load_string($this->securityScan($zip->getFromName("meta.xml")), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespacesMeta = $xml->getNamespaces(true);
+//        echo '<pre>';
+//        print_r($namespacesMeta);
+//        echo '</pre><hr />';
+
+        $docProps = $objPHPExcel->getProperties();
+        $officeProperty = $xml->children($namespacesMeta['office']);
+        foreach ($officeProperty as $officePropertyData) {
+            $officePropertyDC = array();
+            if (isset($namespacesMeta['dc'])) {
+                $officePropertyDC = $officePropertyData->children($namespacesMeta['dc']);
+            }
+            foreach ($officePropertyDC as $propertyName => $propertyValue) {
+                $propertyValue = (string) $propertyValue;
+                switch ($propertyName) {
+                    case 'title':
+                        $docProps->setTitle($propertyValue);
+                        break;
+                    case 'subject':
+                        $docProps->setSubject($propertyValue);
+                        break;
+                    case 'creator':
+                        $docProps->setCreator($propertyValue);
+                        $docProps->setLastModifiedBy($propertyValue);
+                        break;
+                    case 'date':
+                        $creationDate = strtotime($propertyValue);
+                        $docProps->setCreated($creationDate);
+                        $docProps->setModified($creationDate);
+                        break;
+                    case 'description':
+                        $docProps->setDescription($propertyValue);
+                        break;
+                }
+            }
+            $officePropertyMeta = array();
+            if (isset($namespacesMeta['dc'])) {
+                $officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']);
+            }
+            foreach ($officePropertyMeta as $propertyName => $propertyValue) {
+                $propertyValueAttributes = $propertyValue->attributes($namespacesMeta['meta']);
+                $propertyValue = (string) $propertyValue;
+                switch ($propertyName) {
+                    case 'initial-creator':
+                        $docProps->setCreator($propertyValue);
+                        break;
+                    case 'keyword':
+                        $docProps->setKeywords($propertyValue);
+                        break;
+                    case 'creation-date':
+                        $creationDate = strtotime($propertyValue);
+                        $docProps->setCreated($creationDate);
+                        break;
+                    case 'user-defined':
+                        $propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING;
+                        foreach ($propertyValueAttributes as $key => $value) {
+                            if ($key == 'name') {
+                                $propertyValueName = (string) $value;
+                            } elseif ($key == 'value-type') {
+                                switch ($value) {
+                                    case 'date':
+                                        $propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue, 'date');
+                                        $propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_DATE;
+                                        break;
+                                    case 'boolean':
+                                        $propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue, 'bool');
+                                        $propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_BOOLEAN;
+                                        break;
+                                    case 'float':
+                                        $propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue, 'r4');
+                                        $propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_FLOAT;
+                                        break;
+                                    default:
+                                        $propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING;
+                                }
+                            }
+                        }
+                        $docProps->setCustomProperty($propertyValueName, $propertyValue, $propertyValueType);
+                        break;
+                }
+            }
+        }
+
+
+//        echo '<h1>Workbook Content</h1>';
+        $xml = simplexml_load_string($this->securityScan($zip->getFromName("content.xml")), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+        $namespacesContent = $xml->getNamespaces(true);
+//        echo '<pre>';
+//        print_r($namespacesContent);
+//        echo '</pre><hr />';
+
+        $workbook = $xml->children($namespacesContent['office']);
+        foreach ($workbook->body->spreadsheet as $workbookData) {
+            $workbookData = $workbookData->children($namespacesContent['table']);
+            $worksheetID = 0;
+            foreach ($workbookData->table as $worksheetDataSet) {
+                $worksheetData = $worksheetDataSet->children($namespacesContent['table']);
+//                print_r($worksheetData);
+//                echo '<br />';
+                $worksheetDataAttributes = $worksheetDataSet->attributes($namespacesContent['table']);
+//                print_r($worksheetDataAttributes);
+//                echo '<br />';
+                if ((isset($this->loadSheetsOnly)) && (isset($worksheetDataAttributes['name'])) &&
+                    (!in_array($worksheetDataAttributes['name'], $this->loadSheetsOnly))) {
+                    continue;
+                }
+
+//                echo '<h2>Worksheet '.$worksheetDataAttributes['name'].'</h2>';
+                // Create new Worksheet
+                $objPHPExcel->createSheet();
+                $objPHPExcel->setActiveSheetIndex($worksheetID);
+                if (isset($worksheetDataAttributes['name'])) {
+                    $worksheetName = (string) $worksheetDataAttributes['name'];
+                    //    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
+                    $objPHPExcel->getActiveSheet()->setTitle($worksheetName, false);
+                }
+
+                $rowID = 1;
+                foreach ($worksheetData as $key => $rowData) {
+//                    echo '<b>'.$key.'</b><br />';
+                    switch ($key) {
+                        case 'table-header-rows':
+                            foreach ($rowData as $key => $cellData) {
+                                $rowData = $cellData;
+                                break;
+                            }
+                        case 'table-row':
+                            $rowDataTableAttributes = $rowData->attributes($namespacesContent['table']);
+                            $rowRepeats = (isset($rowDataTableAttributes['number-rows-repeated'])) ? $rowDataTableAttributes['number-rows-repeated'] : 1;
+                            $columnID = 'A';
+                            foreach ($rowData as $key => $cellData) {
+                                if ($this->getReadFilter() !== null) {
+                                    if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) {
+                                        continue;
+                                    }
+                                }
+
+//                                echo '<b>'.$columnID.$rowID.'</b><br />';
+                                $cellDataText = (isset($namespacesContent['text'])) ? $cellData->children($namespacesContent['text']) : '';
+                                $cellDataOffice = $cellData->children($namespacesContent['office']);
+                                $cellDataOfficeAttributes = $cellData->attributes($namespacesContent['office']);
+                                $cellDataTableAttributes = $cellData->attributes($namespacesContent['table']);
+
+//                                echo 'Office Attributes: ';
+//                                print_r($cellDataOfficeAttributes);
+//                                echo '<br />Table Attributes: ';
+//                                print_r($cellDataTableAttributes);
+//                                echo '<br />Cell Data Text';
+//                                print_r($cellDataText);
+//                                echo '<br />';
+//
+                                $type = $formatting = $hyperlink = null;
+                                $hasCalculatedValue = false;
+                                $cellDataFormula = '';
+                                if (isset($cellDataTableAttributes['formula'])) {
+                                    $cellDataFormula = $cellDataTableAttributes['formula'];
+                                    $hasCalculatedValue = true;
+                                }
+
+                                if (isset($cellDataOffice->annotation)) {
+//                                    echo 'Cell has comment<br />';
+                                    $annotationText = $cellDataOffice->annotation->children($namespacesContent['text']);
+                                    $textArray = array();
+                                    foreach ($annotationText as $t) {
+                                        if (isset($t->span)) {
+                                            foreach ($t->span as $text) {
+                                                $textArray[] = (string)$text;
+                                            }
+                                        } else {
+                                            $textArray[] = (string) $t;
+                                        }
+                                    }
+                                    $text = implode("\n", $textArray);
+//                                    echo $text, '<br />';
+                                    $objPHPExcel->getActiveSheet()->getComment($columnID.$rowID)->setText($this->parseRichText($text));
+//                                                                    ->setAuthor( $author )
+                                }
+
+                                if (isset($cellDataText->p)) {
+                                    // Consolidate if there are multiple p records (maybe with spans as well)
+                                    $dataArray = array();
+                                    // Text can have multiple text:p and within those, multiple text:span.
+                                    // text:p newlines, but text:span does not.
+                                    // Also, here we assume there is no text data is span fields are specified, since
+                                    // we have no way of knowing proper positioning anyway.
+                                    foreach ($cellDataText->p as $pData) {
+                                        if (isset($pData->span)) {
+                                            // span sections do not newline, so we just create one large string here
+                                            $spanSection = "";
+                                            foreach ($pData->span as $spanData) {
+                                                $spanSection .= $spanData;
+                                            }
+                                            array_push($dataArray, $spanSection);
+                                        } else {
+                                            array_push($dataArray, $pData);
+                                        }
+                                    }
+                                    $allCellDataText = implode($dataArray, "\n");
+
+//                                    echo 'Value Type is '.$cellDataOfficeAttributes['value-type'].'<br />';
+                                    switch ($cellDataOfficeAttributes['value-type']) {
+                                        case 'string':
+                                            $type = PHPExcel_Cell_DataType::TYPE_STRING;
+                                            $dataValue = $allCellDataText;
+                                            if (isset($dataValue->a)) {
+                                                $dataValue = $dataValue->a;
+                                                $cellXLinkAttributes = $dataValue->attributes($namespacesContent['xlink']);
+                                                $hyperlink = $cellXLinkAttributes['href'];
+                                            }
+                                            break;
+                                        case 'boolean':
+                                            $type = PHPExcel_Cell_DataType::TYPE_BOOL;
+                                            $dataValue = ($allCellDataText == 'TRUE') ? true : false;
+                                            break;
+                                        case 'percentage':
+                                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                            $dataValue = (float) $cellDataOfficeAttributes['value'];
+                                            if (floor($dataValue) == $dataValue) {
+                                                $dataValue = (integer) $dataValue;
+                                            }
+                                            $formatting = PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00;
+                                            break;
+                                        case 'currency':
+                                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                            $dataValue = (float) $cellDataOfficeAttributes['value'];
+                                            if (floor($dataValue) == $dataValue) {
+                                                $dataValue = (integer) $dataValue;
+                                            }
+                                            $formatting = PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE;
+                                            break;
+                                        case 'float':
+                                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                            $dataValue = (float) $cellDataOfficeAttributes['value'];
+                                            if (floor($dataValue) == $dataValue) {
+                                                if ($dataValue == (integer) $dataValue) {
+                                                    $dataValue = (integer) $dataValue;
+                                                } else {
+                                                    $dataValue = (float) $dataValue;
+                                                }
+                                            }
+                                            break;
+                                        case 'date':
+                                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                            $dateObj = new DateTime($cellDataOfficeAttributes['date-value'], $GMT);
+                                            $dateObj->setTimeZone($timezoneObj);
+                                            list($year, $month, $day, $hour, $minute, $second) = explode(' ', $dateObj->format('Y m d H i s'));
+                                            $dataValue = PHPExcel_Shared_Date::FormattedPHPToExcel($year, $month, $day, $hour, $minute, $second);
+                                            if ($dataValue != floor($dataValue)) {
+                                                $formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15.' '.PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4;
+                                            } else {
+                                                $formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15;
+                                            }
+                                            break;
+                                        case 'time':
+                                            $type = PHPExcel_Cell_DataType::TYPE_NUMERIC;
+                                            $dataValue = PHPExcel_Shared_Date::PHPToExcel(strtotime('01-01-1970 '.implode(':', sscanf($cellDataOfficeAttributes['time-value'], 'PT%dH%dM%dS'))));
+                                            $formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4;
+                                            break;
+                                    }
+//                                    echo 'Data value is '.$dataValue.'<br />';
+//                                    if ($hyperlink !== null) {
+//                                        echo 'Hyperlink is '.$hyperlink.'<br />';
+//                                    }
+                                } else {
+                                    $type = PHPExcel_Cell_DataType::TYPE_NULL;
+                                    $dataValue = null;
+                                }
+
+                                if ($hasCalculatedValue) {
+                                    $type = PHPExcel_Cell_DataType::TYPE_FORMULA;
+//                                    echo 'Formula: ', $cellDataFormula, PHP_EOL;
+                                    $cellDataFormula = substr($cellDataFormula, strpos($cellDataFormula, ':=')+1);
+                                    $temp = explode('"', $cellDataFormula);
+                                    $tKey = false;
+                                    foreach ($temp as &$value) {
+                                        //    Only replace in alternate array entries (i.e. non-quoted blocks)
+                                        if ($tKey = !$tKey) {
+                                            $value = preg_replace('/\[([^\.]+)\.([^\.]+):\.([^\.]+)\]/Ui', '$1!$2:$3', $value);    //  Cell range reference in another sheet
+                                            $value = preg_replace('/\[([^\.]+)\.([^\.]+)\]/Ui', '$1!$2', $value);       //  Cell reference in another sheet
+                                            $value = preg_replace('/\[\.([^\.]+):\.([^\.]+)\]/Ui', '$1:$2', $value);    //  Cell range reference
+                                            $value = preg_replace('/\[\.([^\.]+)\]/Ui', '$1', $value);                  //  Simple cell reference
+                                            $value = PHPExcel_Calculation::translateSeparator(';', ',', $value, $inBraces);
+                                        }
+                                    }
+                                    unset($value);
+                                    //    Then rebuild the formula string
+                                    $cellDataFormula = implode('"', $temp);
+//                                    echo 'Adjusted Formula: ', $cellDataFormula, PHP_EOL;
+                                }
+
+                                $colRepeats = (isset($cellDataTableAttributes['number-columns-repeated'])) ? $cellDataTableAttributes['number-columns-repeated'] : 1;
+                                if ($type !== null) {
+                                    for ($i = 0; $i < $colRepeats; ++$i) {
+                                        if ($i > 0) {
+                                            ++$columnID;
+                                        }
+                                        if ($type !== PHPExcel_Cell_DataType::TYPE_NULL) {
+                                            for ($rowAdjust = 0; $rowAdjust < $rowRepeats; ++$rowAdjust) {
+                                                $rID = $rowID + $rowAdjust;
+                                                $objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->setValueExplicit((($hasCalculatedValue) ? $cellDataFormula : $dataValue), $type);
+                                                if ($hasCalculatedValue) {
+//                                                    echo 'Forumla result is '.$dataValue.'<br />';
+                                                    $objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->setCalculatedValue($dataValue);
+                                                }
+                                                if ($formatting !== null) {
+                                                    $objPHPExcel->getActiveSheet()->getStyle($columnID.$rID)->getNumberFormat()->setFormatCode($formatting);
+                                                } else {
+                                                    $objPHPExcel->getActiveSheet()->getStyle($columnID.$rID)->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_GENERAL);
+                                                }
+                                                if ($hyperlink !== null) {
+                                                    $objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->getHyperlink()->setUrl($hyperlink);
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                //    Merged cells
+                                if ((isset($cellDataTableAttributes['number-columns-spanned'])) || (isset($cellDataTableAttributes['number-rows-spanned']))) {
+                                    if (($type !== PHPExcel_Cell_DataType::TYPE_NULL) || (!$this->readDataOnly)) {
+                                        $columnTo = $columnID;
+                                        if (isset($cellDataTableAttributes['number-columns-spanned'])) {
+                                            $columnTo = PHPExcel_Cell::stringFromColumnIndex(PHPExcel_Cell::columnIndexFromString($columnID) + $cellDataTableAttributes['number-columns-spanned'] -2);
+                                        }
+                                        $rowTo = $rowID;
+                                        if (isset($cellDataTableAttributes['number-rows-spanned'])) {
+                                            $rowTo = $rowTo + $cellDataTableAttributes['number-rows-spanned'] - 1;
+                                        }
+                                        $cellRange = $columnID.$rowID.':'.$columnTo.$rowTo;
+                                        $objPHPExcel->getActiveSheet()->mergeCells($cellRange);
+                                    }
+                                }
+
+                                ++$columnID;
+                            }
+                            $rowID += $rowRepeats;
+                            break;
+                    }
+                }
+                ++$worksheetID;
+            }
+        }
+
+        // Return
+        return $objPHPExcel;
+    }
+
+    private function parseRichText($is = '')
+    {
+        $value = new PHPExcel_RichText();
+
+        $value->createText($is);
+
+        return $value;
+    }
+}

vendor/phpoffice/phpexcel/Classes/PHPExcel/Reader/SYLK.php

@@ -0,0 +1,478 @@
+<?php
+
+/** PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+    /**
+     * @ignore
+     */
+    define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
+    require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_Reader_SYLK
+ *
+ * Copyright (c) 2006 - 2015 PHPExcel
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader
+ * @copyright  Copyright (c) 2006 - 2015 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    ##VERSION##, ##DATE##
+ */
+class PHPExcel_Reader_SYLK extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
+{
+    /**
+     * Input encoding
+     *
+     * @var string
+     */
+    private $inputEncoding = 'ANSI';
+
+    /**
+     * Sheet index to read
+     *
+     * @var int
+     */
+    private $sheetIndex = 0;
+
+    /**
+     * Formats
+     *
+     * @var array
+     */
+    private $formats = array();
+
+    /**
+     * Format Count
+     *
+     * @var int
+     */
+    private $format = 0;
+
+    /**
+     * Create a new PHPExcel_Reader_SYLK
+     */
+    public function __construct()
+    {
+        $this->readFilter = new PHPExcel_Reader_DefaultReadFilter();
+    }
+
+    /**
+     * Validate that the current file is a SYLK file
+     *
+     * @return boolean
+     */
+    protected function isValidFormat()
+    {
+        // Read sample data (first 2 KB will do)
+        $data = fread($this->fileHandle, 2048);
+
+        // Count delimiters in file
+        $delimiterCount = substr_count($data, ';');
+        if ($delimiterCount < 1) {
+            return false;
+        }
+
+        // Analyze first line looking for ID; signature
+        $lines = explode("\n", $data);
+        if (substr($lines[0], 0, 4) != 'ID;P') {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Set input encoding
+     *
+     * @param string $pValue Input encoding
+     */
+    public function setInputEncoding($pValue = 'ANSI')
+    {
+        $this->inputEncoding = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get input encoding
+     *
+     * @return string
+     */
+    public function getInputEncoding()
+    {
+        return $this->inputEncoding;
+    }
+
+    /**
+     * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
+     *
+     * @param   string     $pFilename
+     * @throws   PHPExcel_Reader_Exception
+     */
+    public function listWorksheetInfo($pFilename)
+    {
+        // Open file
+        $this->openFile($pFilename);
+        if (!$this->isValidFormat()) {
+            fclose($this->fileHandle);
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+        $fileHandle = $this->fileHandle;
+        rewind($fileHandle);
+
+        $worksheetInfo = array();
+        $worksheetInfo[0]['worksheetName'] = 'Worksheet';
+        $worksheetInfo[0]['lastColumnLetter'] = 'A';
+        $worksheetInfo[0]['lastColumnIndex'] = 0;
+        $worksheetInfo[0]['totalRows'] = 0;
+        $worksheetInfo[0]['totalColumns'] = 0;
+
+        // Loop through file
+        $rowData = array();
+
+        // loop through one row (line) at a time in the file
+        $rowIndex = 0;
+        while (($rowData = fgets($fileHandle)) !== false) {
+            $columnIndex = 0;
+
+            // convert SYLK encoded $rowData to UTF-8
+            $rowData = PHPExcel_Shared_String::SYLKtoUTF8($rowData);
+
+            // explode each row at semicolons while taking into account that literal semicolon (;)
+            // is escaped like this (;;)
+            $rowData = explode("\t", str_replace('¤', ';', str_replace(';', "\t", str_replace(';;', '¤', rtrim($rowData)))));
+
+            $dataType = array_shift($rowData);
+            if ($dataType == 'C') {
+                //  Read cell value data
+                foreach ($rowData as $rowDatum) {
+                    switch ($rowDatum{0}) {
+                        case 'C':
+                        case 'X':
+                            $columnIndex = substr($rowDatum, 1) - 1;
+                            break;
+                        case 'R':
+                        case 'Y':
+                            $rowIndex = substr($rowDatum, 1);
+                            break;
+                    }
+
+                    $worksheetInfo[0]['totalRows'] = max($worksheetInfo[0]['totalRows'], $rowIndex);
+                    $worksheetInfo[0]['lastColumnIndex'] = max($worksheetInfo[0]['lastColumnIndex'], $columnIndex);
+                }
+            }
+        }
+
+        $worksheetInfo[0]['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex']);
+        $worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1;
+
+        // Close file
+        fclose($fileHandle);
+
+        return $worksheetInfo;
+    }
+
+    /**
+     * Loads PHPExcel from file
+     *
+     * @param     string         $pFilename
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function load($pFilename)
+    {
+        // Create new PHPExcel
+        $objPHPExcel = new PHPExcel();
+
+        // Load into this instance
+        return $this->loadIntoExisting($pFilename, $objPHPExcel);
+    }
+
+    /**
+     * Loads PHPExcel from file into PHPExcel instance
+     *
+     * @param     string         $pFilename
+     * @param    PHPExcel    $objPHPExcel
+     * @return     PHPExcel
+     * @throws     PHPExcel_Reader_Exception
+     */
+    public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel)
+    {
+        // Open file
+        $this->openFile($pFilename);
+        if (!$this->isValidFormat()) {
+            fclose($this->fileHandle);
+            throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file.");
+        }
+        $fileHandle = $this->fileHandle;
+        rewind($fileHandle);
+
+        // Create new PHPExcel
+        while ($objPHPExcel->getSheetCount() <= $this->sheetIndex) {
+            $objPHPExcel->createSheet();
+        }
+        $objPHPExcel->setActiveSheetIndex($this->sheetIndex);
+
+        $fromFormats    = array('\-',    '\ ');
+        $toFormats        = array('-',    ' ');
+
+        // Loop through file
+        $rowData = array();
+        $column = $row = '';
+
+        // loop through one row (line) at a time in the file
+        while (($rowData = fgets($fileHandle)) !== false) {
+            // convert SYLK encoded $rowData to UTF-8
+            $rowData = PHPExcel_Shared_String::SYLKtoUTF8($rowData);
+
+            // explode each row at semicolons while taking into account that literal semicolon (;)
+            // is escaped like this (;;)
+            $rowData = explode("\t", str_replace('¤', ';', str_replace(';', "\t", str_replace(';;', '¤', rtrim($rowData)))));
+
+            $dataType = array_shift($rowData);
+            //    Read shared styles
+            if ($dataType == 'P') {
+                $formatArray = array();
+                foreach ($rowData as $rowDatum) {
+                    switch ($rowDatum{0}) {
+                        case 'P':
+                            $formatArray['numberformat']['code'] = str_replace($fromFormats, $toFormats, substr($rowDatum, 1));
+                            break;
+                        case 'E':
+                        case 'F':
+                            $formatArray['font']['name'] = substr($rowDatum, 1);
+                            break;
+                        case 'L':
+                            $formatArray['font']['size'] = substr($rowDatum, 1);
+                            break;
+                        case 'S':
+                            $styleSettings = substr($rowDatum, 1);
+                            for ($i=0; $i<strlen($styleSettings); ++$i) {
+                                switch ($styleSettings{$i}) {
+                                    case 'I':
+                                        $formatArray['font']['italic'] = true;
+                                        break;
+                                    case 'D':
+                                        $formatArray['font']['bold'] = true;
+                                        break;
+                                    case 'T':
+                                        $formatArray['borders']['top']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'B':
+                                        $formatArray['borders']['bottom']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'L':
+                                        $formatArray['borders']['left']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'R':
+                                        $formatArray['borders']['right']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                }
+                $this->formats['P'.$this->format++] = $formatArray;
+            //    Read cell value data
+            } elseif ($dataType == 'C') {
+                $hasCalculatedValue = false;
+                $cellData = $cellDataFormula = '';
+                foreach ($rowData as $rowDatum) {
+                    switch ($rowDatum{0}) {
+                        case 'C':
+                        case 'X':
+                            $column = substr($rowDatum, 1);
+                            break;
+                        case 'R':
+                        case 'Y':
+                            $row = substr($rowDatum, 1);
+                            break;
+                        case 'K':
+                            $cellData = substr($rowDatum, 1);
+                            break;
+                        case 'E':
+                            $cellDataFormula = '='.substr($rowDatum, 1);
+                            //    Convert R1C1 style references to A1 style references (but only when not quoted)
+                            $temp = explode('"', $cellDataFormula);
+                            $key = false;
+                            foreach ($temp as &$value) {
+                                //    Only count/replace in alternate array entries
+                                if ($key = !$key) {
+                                    preg_match_all('/(R(\[?-?\d*\]?))(C(\[?-?\d*\]?))/', $value, $cellReferences, PREG_SET_ORDER+PREG_OFFSET_CAPTURE);
+                                    //    Reverse the matches array, otherwise all our offsets will become incorrect if we modify our way
+                                    //        through the formula from left to right. Reversing means that we work right to left.through
+                                    //        the formula
+                                    $cellReferences = array_reverse($cellReferences);
+                                    //    Loop through each R1C1 style reference in turn, converting it to its A1 style equivalent,
+                                    //        then modify the formula to use that new reference
+                                    foreach ($cellReferences as $cellReference) {
+                                        $rowReference = $cellReference[2][0];
+                                        //    Empty R reference is the current row
+                                        if ($rowReference == '') {
+                                            $rowReference = $row;
+                                        }
+                                        //    Bracketed R references are relative to the current row
+                                        if ($rowReference{0} == '[') {
+                                            $rowReference = $row + trim($rowReference, '[]');
+                                        }
+                                        $columnReference = $cellReference[4][0];
+                                        //    Empty C reference is the current column
+                                        if ($columnReference == '') {
+                                            $columnReference = $column;
+                                        }
+                                        //    Bracketed C references are relative to the current column
+                                        if ($columnReference{0} == '[') {
+                                            $columnReference = $column + trim($columnReference, '[]');
+                                        }
+                                        $A1CellReference = PHPExcel_Cell::stringFromColumnIndex($columnReference-1).$rowReference;
+
+                                        $value = substr_replace($value, $A1CellReference, $cellReference[0][1], strlen($cellReference[0][0]));
+                                    }
+                                }
+                            }
+                            unset($value);
+                            //    Then rebuild the formula string
+                            $cellDataFormula = implode('"', $temp);
+                            $hasCalculatedValue = true;
+                            break;
+                    }
+                }
+                $columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1);
+                $cellData = PHPExcel_Calculation::unwrapResult($cellData);
+
+                // Set cell value
+                $objPHPExcel->getActiveSheet()->getCell($columnLetter.$row)->setValue(($hasCalculatedValue) ? $cellDataFormula : $cellData);
+                if ($hasCalculatedValue) {
+                    $cellData = PHPExcel_Calculation::unwrapResult($cellData);
+                    $objPHPExcel->getActiveSheet()->getCell($columnLetter.$row)->setCalculatedValue($cellData);
+                }
+            //    Read cell formatting
+            } elseif ($dataType == 'F') {
+                $formatStyle = $columnWidth = $styleSettings = '';
+                $styleData = array();
+                foreach ($rowData as $rowDatum) {
+                    switch ($rowDatum{0}) {
+                        case 'C':
+                        case 'X':
+                            $column = substr($rowDatum, 1);
+                            break;
+                        case 'R':
+                        case 'Y':
+                            $row = substr($rowDatum, 1);
+                            break;
+                        case 'P':
+                            $formatStyle = $rowDatum;
+                            break;
+                        case 'W':
+                            list($startCol, $endCol, $columnWidth) = explode(' ', substr($rowDatum, 1));
+                            break;
+                        case 'S':
+                            $styleSettings = substr($rowDatum, 1);
+                            for ($i=0; $i<strlen($styleSettings); ++$i) {
+                                switch ($styleSettings{$i}) {
+                                    case 'I':
+                                        $styleData['font']['italic'] = true;
+                                        break;
+                                    case 'D':
+                                        $styleData['font']['bold'] = true;
+                                        break;
+                                    case 'T':
+                                        $styleData['borders']['top']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'B':
+                                        $styleData['borders']['bottom']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'L':
+                                        $styleData['borders']['left']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                    case 'R':
+                                        $styleData['borders']['right']['style'] = PHPExcel_Style_Border::BORDER_THIN;
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                }
+                if (($formatStyle > '') && ($column > '') && ($row > '')) {
+                    $columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1);
+                    if (isset($this->formats[$formatStyle])) {
+                        $objPHPExcel->getActiveSheet()->getStyle($columnLetter.$row)->applyFromArray($this->formats[$formatStyle]);
+                    }
+                }
+                if ((!empty($styleData)) && ($column > '') && ($row > '')) {
+                    $columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1);
+                    $objPHPExcel->getActiveSheet()->getStyle($columnLetter.$row)->applyFromArray($styleData);
+                }
+                if ($columnWidth > '') {
+                    if ($startCol == $endCol) {
+                        $startCol = PHPExcel_Cell::stringFromColumnIndex($startCol-1);
+                        $objPHPExcel->getActiveSheet()->getColumnDimension($startCol)->setWidth($columnWidth);
+                    } else {
+                        $startCol = PHPExcel_Cell::stringFromColumnIndex($startCol-1);
+                        $endCol = PHPExcel_Cell::stringFromColumnIndex($endCol-1);
+                        $objPHPExcel->getActiveSheet()->getColumnDimension($startCol)->setWidth($columnWidth);
+                        do {
+                            $objPHPExcel->getActiveSheet()->getColumnDimension(++$startCol)->setWidth($columnWidth);
+                        } while ($startCol != $endCol);
+                    }
+                }
+            } else {
+                foreach ($rowData as $rowDatum) {
+                    switch ($rowDatum{0}) {
+                        case 'C':
+                        case 'X':
+                            $column = substr($rowDatum, 1);
+                            break;
+                        case 'R':
+                        case 'Y':
+                            $row = substr($rowDatum, 1);
+                            break;
+                    }
+                }
+            }
+        }
+
+        // Close file
+        fclose($fileHandle);
+
+        // Return
+        return $objPHPExcel;
+    }
+
+    /**
+     * Get sheet index
+     *
+     * @return int
+     */
+    public function getSheetIndex()
+    {
+        return $this->sheetIndex;
+    }
+
+    /**
+     * Set sheet index
+     *
+     * @param    int        $pValue        Sheet index
+     * @return PHPExcel_Reader_SYLK
+     */
+    public function setSheetIndex($pValue = 0)
+    {
+        $this->sheetIndex = $pValue;
+        return $this;
+    }
+}