init

lib/PhpSpreadsheet/Reader/Xls/Color.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class Color
+{
+    /**
+     * Read color.
+     *
+     * @param int $color Indexed color
+     * @param array $palette Color palette
+     *
+     * @return array RGB color value, example: ['rgb' => 'FF0000']
+     */
+    public static function map(int $color, array $palette, int $version): array
+    {
+        if ($color <= 0x07 || $color >= 0x40) {
+            // special built-in color
+            return Color\BuiltIn::lookup($color);
+        } elseif (isset($palette[$color - 8])) {
+            // palette color, color index 0x08 maps to pallete index 0
+            return $palette[$color - 8];
+        }
+
+        // default color table
+        if ($version == Xls::XLS_BIFF8) {
+            return Color\BIFF8::lookup($color);
+        }
+
+        // BIFF5
+        return Color\BIFF5::lookup($color);
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Color/BIFF5.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BIFF5
+{
+    private const BIFF5_COLOR_MAP = [
+        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.
+     */
+    public static function lookup(int $color): array
+    {
+        return ['rgb' => self::BIFF5_COLOR_MAP[$color] ?? '000000'];
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Color/BIFF8.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BIFF8
+{
+    private const BIFF8_COLOR_MAP = [
+        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.
+     */
+    public static function lookup(int $color): array
+    {
+        return ['rgb' => self::BIFF8_COLOR_MAP[$color] ?? '000000'];
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Color/BuiltIn.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BuiltIn
+{
+    private const BUILTIN_COLOR_MAP = [
+        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
+     */
+    public static function lookup(int $color): array
+    {
+        return ['rgb' => self::BUILTIN_COLOR_MAP[$color] ?? '000000'];
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/ConditionalFormatting.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Style\Conditional;
+
+class ConditionalFormatting
+{
+    /**
+     * @var array<int, string>
+     */
+    private static array $types = [
+        0x01 => Conditional::CONDITION_CELLIS,
+        0x02 => Conditional::CONDITION_EXPRESSION,
+    ];
+
+    /**
+     * @var array<int, string>
+     */
+    private static array $operators = [
+        0x00 => Conditional::OPERATOR_NONE,
+        0x01 => Conditional::OPERATOR_BETWEEN,
+        0x02 => Conditional::OPERATOR_NOTBETWEEN,
+        0x03 => Conditional::OPERATOR_EQUAL,
+        0x04 => Conditional::OPERATOR_NOTEQUAL,
+        0x05 => Conditional::OPERATOR_GREATERTHAN,
+        0x06 => Conditional::OPERATOR_LESSTHAN,
+        0x07 => Conditional::OPERATOR_GREATERTHANOREQUAL,
+        0x08 => Conditional::OPERATOR_LESSTHANOREQUAL,
+    ];
+
+    public static function type(int $type): ?string
+    {
+        if (isset(self::$types[$type])) {
+            return self::$types[$type];
+        }
+
+        return null;
+    }
+
+    public static function operator(int $operator): ?string
+    {
+        if (isset(self::$operators[$operator])) {
+            return self::$operators[$operator];
+        }
+
+        return null;
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/DataValidationHelper.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
+
+class DataValidationHelper
+{
+    /**
+     * @var array<int, string>
+     */
+    private static array $types = [
+        0x00 => DataValidation::TYPE_NONE,
+        0x01 => DataValidation::TYPE_WHOLE,
+        0x02 => DataValidation::TYPE_DECIMAL,
+        0x03 => DataValidation::TYPE_LIST,
+        0x04 => DataValidation::TYPE_DATE,
+        0x05 => DataValidation::TYPE_TIME,
+        0x06 => DataValidation::TYPE_TEXTLENGTH,
+        0x07 => DataValidation::TYPE_CUSTOM,
+    ];
+
+    /**
+     * @var array<int, string>
+     */
+    private static array $errorStyles = [
+        0x00 => DataValidation::STYLE_STOP,
+        0x01 => DataValidation::STYLE_WARNING,
+        0x02 => DataValidation::STYLE_INFORMATION,
+    ];
+
+    /**
+     * @var array<int, string>
+     */
+    private static array $operators = [
+        0x00 => DataValidation::OPERATOR_BETWEEN,
+        0x01 => DataValidation::OPERATOR_NOTBETWEEN,
+        0x02 => DataValidation::OPERATOR_EQUAL,
+        0x03 => DataValidation::OPERATOR_NOTEQUAL,
+        0x04 => DataValidation::OPERATOR_GREATERTHAN,
+        0x05 => DataValidation::OPERATOR_LESSTHAN,
+        0x06 => DataValidation::OPERATOR_GREATERTHANOREQUAL,
+        0x07 => DataValidation::OPERATOR_LESSTHANOREQUAL,
+    ];
+
+    public static function type(int $type): ?string
+    {
+        if (isset(self::$types[$type])) {
+            return self::$types[$type];
+        }
+
+        return null;
+    }
+
+    public static function errorStyle(int $errorStyle): ?string
+    {
+        if (isset(self::$errorStyles[$errorStyle])) {
+            return self::$errorStyles[$errorStyle];
+        }
+
+        return null;
+    }
+
+    public static function operator(int $operator): ?string
+    {
+        if (isset(self::$operators[$operator])) {
+            return self::$operators[$operator];
+        }
+
+        return null;
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/ErrorCode.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class ErrorCode
+{
+    private const ERROR_CODE_MAP = [
+        0x00 => '#NULL!',
+        0x07 => '#DIV/0!',
+        0x0F => '#VALUE!',
+        0x17 => '#REF!',
+        0x1D => '#NAME?',
+        0x24 => '#NUM!',
+        0x2A => '#N/A',
+    ];
+
+    /**
+     * Map error code, e.g. '#N/A'.
+     */
+    public static function lookup(int $code): string|bool
+    {
+        return self::ERROR_CODE_MAP[$code] ?? false;
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Escher.php

@@ -0,0 +1,609 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Reader\Xls;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer\SpgrContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer\SpgrContainer\SpContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE\Blip;
+
+class 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).
+     */
+    private string $data;
+
+    /**
+     * Size in bytes of the Escher stream data.
+     */
+    private int $dataSize;
+
+    /**
+     * Current position of stream pointer in Escher stream data.
+     */
+    private int $pos;
+
+    /**
+     * The object to be returned by the reader. Modified during load.
+     *
+     * @var BSE|BstoreContainer|DgContainer|DggContainer|\PhpOffice\PhpSpreadsheet\Shared\Escher|SpContainer|SpgrContainer
+     */
+    private $object;
+
+    /**
+     * Create a new Escher instance.
+     */
+    public function __construct(mixed $object)
+    {
+        $this->object = $object;
+    }
+
+    private const WHICH_ROUTINE = [
+        self::DGGCONTAINER => 'readDggContainer',
+        self::DGG => 'readDgg',
+        self::BSTORECONTAINER => 'readBstoreContainer',
+        self::BSE => 'readBSE',
+        self::BLIPJPEG => 'readBlipJPEG',
+        self::BLIPPNG => 'readBlipPNG',
+        self::OPT => 'readOPT',
+        self::TERTIARYOPT => 'readTertiaryOPT',
+        self::SPLITMENUCOLORS => 'readSplitMenuColors',
+        self::DGCONTAINER => 'readDgContainer',
+        self::DG => 'readDg',
+        self::SPGRCONTAINER => 'readSpgrContainer',
+        self::SPCONTAINER => 'readSpContainer',
+        self::SPGR => 'readSpgr',
+        self::SP => 'readSp',
+        self::CLIENTTEXTBOX => 'readClientTextbox',
+        self::CLIENTANCHOR => 'readClientAnchor',
+        self::CLIENTDATA => 'readClientData',
+    ];
+
+    /**
+     * Load Escher stream data. May be a partial Escher stream.
+     */
+    public function load(string $data): BSE|BstoreContainer|DgContainer|DggContainer|\PhpOffice\PhpSpreadsheet\Shared\Escher|SpContainer|SpgrContainer
+    {
+        $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 = Xls::getUInt2d($this->data, $this->pos + 2);
+            $routine = self::WHICH_ROUTINE[$fbt] ?? 'readDefault';
+            if (method_exists($this, $routine)) {
+                $this->$routine();
+            }
+        }
+
+        return $this->object;
+    }
+
+    /**
+     * Read a generic record.
+     */
+    private function readDefault(): void
+    {
+        // offset 0; size: 2; recVer and recInstance
+        //$verInstance = Xls::getUInt2d($this->data, $this->pos);
+
+        // offset: 2; size: 2: Record Type
+        //$fbt = Xls::getUInt2d($this->data, $this->pos + 2);
+
+        // bit: 0-3; mask: 0x000F; recVer
+        //$recVer = (0x000F & $verInstance) >> 0;
+
+        $length = Xls::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(): void
+    {
+        $length = Xls::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 DggContainer();
+        $this->applyAttribute('setDggContainer', $dggContainer);
+        $reader = new self($dggContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read Dgg record (Drawing Group).
+     */
+    private function readDgg(): void
+    {
+        $length = Xls::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(): void
+    {
+        $length = Xls::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 BstoreContainer();
+        $this->applyAttribute('setBstoreContainer', $bstoreContainer);
+        $reader = new self($bstoreContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read BSE record.
+     */
+    private function readBSE(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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 BSE();
+        $this->applyAttribute('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 = Xls::getUInt2d($recordData, 18);
+
+        // offset: 20; size: 4; size of BLIP in bytes
+        //$size = Xls::getInt4d($recordData, 20);
+
+        // offset: 24; size: 4; number of references to this BLIP
+        //$cRef = Xls::getInt4d($recordData, 24);
+
+        // offset: 28; size: 4; MSOFO file offset
+        //$foDelay = Xls::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 self($BSE);
+        $reader->load($blipData);
+    }
+
+    /**
+     * Read BlipJPEG record. Holds raw JPEG image data.
+     */
+    private function readBlipJPEG(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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, [0x046B, 0x06E3])) {
+            //$rgbUid2 = substr($recordData, 16, 16);
+            $pos += 16;
+        }
+
+        // offset: var; size: 1; tag
+        //$tag = ord($recordData[$pos]);
+        ++$pos;
+
+        // offset: var; size: var; the raw image data
+        $data = substr($recordData, $pos);
+
+        $blip = new Blip();
+        $blip->setData($data);
+
+        $this->applyAttribute('setBlip', $blip);
+    }
+
+    /**
+     * Read BlipPNG record. Holds raw PNG image data.
+     */
+    private function readBlipPNG(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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;
+
+        // offset: var; size: var; the raw image data
+        $data = substr($recordData, $pos);
+
+        $blip = new Blip();
+        $blip->setData($data);
+
+        $this->applyAttribute('setBlip', $blip);
+    }
+
+    /**
+     * Read OPT record. This record may occur within DggContainer record or SpContainer.
+     */
+    private function readOPT(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        //$recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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(): void
+    {
+        $length = Xls::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(): void
+    {
+        $length = Xls::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 DgContainer();
+        $this->applyAttribute('setDgContainer', $dgContainer);
+        $reader = new self($dgContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read Dg record (Drawing).
+     */
+    private function readDg(): void
+    {
+        $length = Xls::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(): void
+    {
+        // context is either context DgContainer or SpgrContainer
+
+        $length = Xls::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 SpgrContainer();
+
+        if ($this->object instanceof DgContainer) {
+            // DgContainer
+            $this->object->setSpgrContainer($spgrContainer);
+        } elseif ($this->object instanceof SpgrContainer) {
+            // SpgrContainer
+            $this->object->addChild($spgrContainer);
+        }
+
+        $reader = new self($spgrContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read SpContainer record (Shape Container).
+     */
+    private function readSpContainer(): void
+    {
+        $length = Xls::getInt4d($this->data, $this->pos + 4);
+        $recordData = substr($this->data, $this->pos + 8, $length);
+
+        // add spContainer to spgrContainer
+        $spContainer = new SpContainer();
+        $this->applyAttribute('addChild', $spContainer);
+
+        // move stream pointer to next record
+        $this->pos += 8 + $length;
+
+        // record is a container, read contents
+        $reader = new self($spContainer);
+        $reader->load($recordData);
+    }
+
+    /**
+     * Read Spgr record (Shape Group).
+     */
+    private function readSpgr(): void
+    {
+        $length = Xls::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(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        //$recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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(): void
+    {
+        // offset: 0; size: 2; recVer and recInstance
+
+        // bit: 4-15; mask: 0xFFF0; recInstance
+        //$recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+        $length = Xls::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(): void
+    {
+        $length = Xls::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 = Xls::getUInt2d($recordData, 2);
+
+        // offset: 4; size: 2; upper-left corner horizontal offset in 1/1024 of column width
+        $startOffsetX = Xls::getUInt2d($recordData, 4);
+
+        // offset: 6; size: 2; upper-left corner row index (0-based)
+        $r1 = Xls::getUInt2d($recordData, 6);
+
+        // offset: 8; size: 2; upper-left corner vertical offset in 1/256 of row height
+        $startOffsetY = Xls::getUInt2d($recordData, 8);
+
+        // offset: 10; size: 2; bottom-right corner column index (0-based)
+        $c2 = Xls::getUInt2d($recordData, 10);
+
+        // offset: 12; size: 2; bottom-right corner horizontal offset in 1/1024 of column width
+        $endOffsetX = Xls::getUInt2d($recordData, 12);
+
+        // offset: 14; size: 2; bottom-right corner row index (0-based)
+        $r2 = Xls::getUInt2d($recordData, 14);
+
+        // offset: 16; size: 2; bottom-right corner vertical offset in 1/256 of row height
+        $endOffsetY = Xls::getUInt2d($recordData, 16);
+
+        $this->applyAttribute('setStartCoordinates', Coordinate::stringFromColumnIndex($c1 + 1) . ($r1 + 1));
+        $this->applyAttribute('setStartOffsetX', $startOffsetX);
+        $this->applyAttribute('setStartOffsetY', $startOffsetY);
+        $this->applyAttribute('setEndCoordinates', Coordinate::stringFromColumnIndex($c2 + 1) . ($r2 + 1));
+        $this->applyAttribute('setEndOffsetX', $endOffsetX);
+        $this->applyAttribute('setEndOffsetY', $endOffsetY);
+    }
+
+    private function applyAttribute(string $name, mixed $value): void
+    {
+        if (method_exists($this->object, $name)) {
+            $this->object->$name($value);
+        }
+    }
+
+    /**
+     * Read ClientData record.
+     */
+    private function readClientData(): void
+    {
+        $length = Xls::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(string $data, int $n): void
+    {
+        $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 = Xls::getUInt2d($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 = Xls::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;
+            }
+
+            if (method_exists($this->object, 'setOPT')) {
+                $this->object->setOPT($opidOpid, $value);
+            }
+        }
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/MD5.php

@@ -0,0 +1,193 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class MD5
+{
+    private int $a;
+
+    private int $b;
+
+    private int $c;
+
+    private int $d;
+
+    private static int $allOneBits;
+
+    /**
+     * MD5 stream constructor.
+     */
+    public function __construct()
+    {
+        self::$allOneBits = self::signedInt(0xFFFFFFFF);
+        $this->reset();
+    }
+
+    /**
+     * Reset the MD5 stream context.
+     */
+    public function reset(): void
+    {
+        $this->a = 0x67452301;
+        $this->b = self::signedInt(0xEFCDAB89);
+        $this->c = self::signedInt(0x98BADCFE);
+        $this->d = 0x10325476;
+    }
+
+    /**
+     * Get MD5 stream context.
+     */
+    public function getContext(): string
+    {
+        $s = '';
+        foreach (['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(string $data): void
+    {
+        // @phpstan-ignore-next-line
+        $words = array_values(unpack('V16', $data));
+
+        $A = $this->a;
+        $B = $this->b;
+        $C = $this->c;
+        $D = $this->d;
+
+        $F = [self::class, 'f'];
+        $G = [self::class, 'g'];
+        $H = [self::class, 'h'];
+        $I = [self::class, '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) & self::$allOneBits;
+        $this->b = ($this->b + $B) & self::$allOneBits;
+        $this->c = ($this->c + $C) & self::$allOneBits;
+        $this->d = ($this->d + $D) & self::$allOneBits;
+    }
+
+    private static function f(int $X, int $Y, int $Z): int
+    {
+        return ($X & $Y) | ((~$X) & $Z); // X AND Y OR NOT X AND Z
+    }
+
+    private static function g(int $X, int $Y, int $Z): int
+    {
+        return ($X & $Z) | ($Y & (~$Z)); // X AND Z OR Y AND NOT Z
+    }
+
+    private static function h(int $X, int $Y, int $Z): int
+    {
+        return $X ^ $Y ^ $Z; // X XOR Y XOR Z
+    }
+
+    private static function i(int $X, int $Y, int $Z): int
+    {
+        return $Y ^ ($X | (~$Z)); // Y XOR (X OR NOT Z)
+    }
+
+    /** @param float|int $t may be float on 32-bit system */
+    private static function step(callable $func, int &$A, int $B, int $C, int $D, int $M, int $s, $t): void
+    {
+        $t = self::signedInt($t);
+        $A = (int) ($A + call_user_func($func, $B, $C, $D) + $M + $t) & self::$allOneBits;
+        $A = self::rotate($A, $s);
+        $A = (int) ($B + $A) & self::$allOneBits;
+    }
+
+    /** @param float|int $result may be float on 32-bit system */
+    private static function signedInt($result): int
+    {
+        return is_int($result) ? $result : (int) (PHP_INT_MIN + $result - 1 - PHP_INT_MAX);
+    }
+
+    private static function rotate(int $decimal, int $bits): int
+    {
+        $binary = str_pad(decbin($decimal), 32, '0', STR_PAD_LEFT);
+
+        return self::signedInt(bindec(substr($binary, $bits) . substr($binary, 0, $bits)));
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/RC4.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class RC4
+{
+    /** @var int[] */
+    protected array $s = []; // Context
+
+    protected int $i = 0;
+
+    protected int $j = 0;
+
+    /**
+     * RC4 stream decryption/encryption constrcutor.
+     *
+     * @param string $key Encryption key/passphrase
+     */
+    public function __construct(string $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
+     */
+    public function RC4(string $data): string
+    {
+        $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;
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Style/Border.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
+
+use PhpOffice\PhpSpreadsheet\Style\Border as StyleBorder;
+
+class Border
+{
+    /**
+     * @var array<int, string>
+     */
+    protected static array $borderStyleMap = [
+        0x00 => StyleBorder::BORDER_NONE,
+        0x01 => StyleBorder::BORDER_THIN,
+        0x02 => StyleBorder::BORDER_MEDIUM,
+        0x03 => StyleBorder::BORDER_DASHED,
+        0x04 => StyleBorder::BORDER_DOTTED,
+        0x05 => StyleBorder::BORDER_THICK,
+        0x06 => StyleBorder::BORDER_DOUBLE,
+        0x07 => StyleBorder::BORDER_HAIR,
+        0x08 => StyleBorder::BORDER_MEDIUMDASHED,
+        0x09 => StyleBorder::BORDER_DASHDOT,
+        0x0A => StyleBorder::BORDER_MEDIUMDASHDOT,
+        0x0B => StyleBorder::BORDER_DASHDOTDOT,
+        0x0C => StyleBorder::BORDER_MEDIUMDASHDOTDOT,
+        0x0D => StyleBorder::BORDER_SLANTDASHDOT,
+    ];
+
+    public static function lookup(int $index): string
+    {
+        if (isset(self::$borderStyleMap[$index])) {
+            return self::$borderStyleMap[$index];
+        }
+
+        return StyleBorder::BORDER_NONE;
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Style/CellAlignment.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
+
+use PhpOffice\PhpSpreadsheet\Style\Alignment;
+
+class CellAlignment
+{
+    /**
+     * @var array<int, string>
+     */
+    protected static array $horizontalAlignmentMap = [
+        0 => Alignment::HORIZONTAL_GENERAL,
+        1 => Alignment::HORIZONTAL_LEFT,
+        2 => Alignment::HORIZONTAL_CENTER,
+        3 => Alignment::HORIZONTAL_RIGHT,
+        4 => Alignment::HORIZONTAL_FILL,
+        5 => Alignment::HORIZONTAL_JUSTIFY,
+        6 => Alignment::HORIZONTAL_CENTER_CONTINUOUS,
+    ];
+
+    /**
+     * @var array<int, string>
+     */
+    protected static array $verticalAlignmentMap = [
+        0 => Alignment::VERTICAL_TOP,
+        1 => Alignment::VERTICAL_CENTER,
+        2 => Alignment::VERTICAL_BOTTOM,
+        3 => Alignment::VERTICAL_JUSTIFY,
+    ];
+
+    public static function horizontal(Alignment $alignment, int $horizontal): void
+    {
+        if (array_key_exists($horizontal, self::$horizontalAlignmentMap)) {
+            $alignment->setHorizontal(self::$horizontalAlignmentMap[$horizontal]);
+        }
+    }
+
+    public static function vertical(Alignment $alignment, int $vertical): void
+    {
+        if (array_key_exists($vertical, self::$verticalAlignmentMap)) {
+            $alignment->setVertical(self::$verticalAlignmentMap[$vertical]);
+        }
+    }
+
+    public static function wrap(Alignment $alignment, int $wrap): void
+    {
+        $alignment->setWrapText((bool) $wrap);
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Style/CellFont.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
+
+use PhpOffice\PhpSpreadsheet\Style\Font;
+
+class CellFont
+{
+    public static function escapement(Font $font, int $escapement): void
+    {
+        switch ($escapement) {
+            case 0x0001:
+                $font->setSuperscript(true);
+
+                break;
+            case 0x0002:
+                $font->setSubscript(true);
+
+                break;
+        }
+    }
+
+    /**
+     * @var array<int, string>
+     */
+    protected static array $underlineMap = [
+        0x01 => Font::UNDERLINE_SINGLE,
+        0x02 => Font::UNDERLINE_DOUBLE,
+        0x21 => Font::UNDERLINE_SINGLEACCOUNTING,
+        0x22 => Font::UNDERLINE_DOUBLEACCOUNTING,
+    ];
+
+    public static function underline(Font $font, int $underline): void
+    {
+        if (array_key_exists($underline, self::$underlineMap)) {
+            $font->setUnderline(self::$underlineMap[$underline]);
+        }
+    }
+}

lib/PhpSpreadsheet/Reader/Xls/Style/FillPattern.php

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