mkm/TaskSystem
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新

Browse Source
This commit is contained in:
mkm 2023-08-09 15:01:48 +08:00
parent 7df9900d11
commit 15b0f7fa9f
84 changed files with 0 additions and 8138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
vendor/bin/carbon.bat vendored
View File

@ -1,5 +0,0 @@
@ECHO OFF
setlocal DISABLEDELAYEDEXPANSION
SET BIN_TARGET=%~dp0/carbon
SET COMPOSER_RUNTIME_BIN_DIR=%~dp0
php "%BIN_TARGET%" %*

52
vendor/maennchen/zipstream-php/src/CentralDirectoryFileHeader.php vendored
View File

@ -1,52 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
use DateTimeInterface;
/**
* @internal
*/
abstract class CentralDirectoryFileHeader
{
private const SIGNATURE = 0x02014b50;
public static function generate(
int $versionMadeBy,
int $versionNeededToExtract,
int $generalPurposeBitFlag,
CompressionMethod $compressionMethod,
DateTimeInterface $lastModificationDateTime,
int $crc32,
int $compressedSize,
int $uncompressedSize,
string $fileName,
string $extraField,
string $fileComment,
int $diskNumberStart,
int $internalFileAttributes,
int $externalFileAttributes,
int $relativeOffsetOfLocalHeader,
): string {
return PackField::pack(
new PackField(format: 'V', value: self::SIGNATURE),
new PackField(format: 'v', value: $versionMadeBy),
new PackField(format: 'v', value: $versionNeededToExtract),
new PackField(format: 'v', value: $generalPurposeBitFlag),
new PackField(format: 'v', value: $compressionMethod->value),
new PackField(format: 'V', value: Time::dateTimeToDosTime($lastModificationDateTime)),
new PackField(format: 'V', value: $crc32),
new PackField(format: 'V', value: $compressedSize),
new PackField(format: 'V', value: $uncompressedSize),
new PackField(format: 'v', value: strlen($fileName)),
new PackField(format: 'v', value: strlen($extraField)),
new PackField(format: 'v', value: strlen($fileComment)),
new PackField(format: 'v', value: $diskNumberStart),
new PackField(format: 'v', value: $internalFileAttributes),
new PackField(format: 'V', value: $externalFileAttributes),
new PackField(format: 'V', value: $relativeOffsetOfLocalHeader),
) . $fileName . $extraField . $fileComment;
}
}

106
vendor/maennchen/zipstream-php/src/CompressionMethod.php vendored
View File

@ -1,106 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
enum CompressionMethod: int
{
/**
* The file is stored (no compression)
*/
case STORE = 0x00;
// 0x01: legacy algorithm - The file is Shrunk
// 0x02: legacy algorithm - The file is Reduced with compression factor 1
// 0x03: legacy algorithm - The file is Reduced with compression factor 2
// 0x04: legacy algorithm - The file is Reduced with compression factor 3
// 0x05: legacy algorithm - The file is Reduced with compression factor 4
// 0x06: legacy algorithm - The file is Imploded
// 0x07: Reserved for Tokenizing compression algorithm
/**
* The file is Deflated
*/
case DEFLATE = 0x08;
// /**
// * Enhanced Deflating using Deflate64(tm)
// */
// case DEFLATE_64 = 0x09;
// /**
// * PKWARE Data Compression Library Imploding (old IBM TERSE)
// */
// case PKWARE = 0x0a;
// // 0x0b: Reserved by PKWARE
// /**
// * File is compressed using BZIP2 algorithm
// */
// case BZIP2 = 0x0c;
// // 0x0d: Reserved by PKWARE
// /**
// * LZMA
// */
// case LZMA = 0x0e;
// // 0x0f: Reserved by PKWARE
// /**
// * IBM z/OS CMPSC Compression
// */
// case IBM_ZOS_CMPSC = 0x10;
// // 0x11: Reserved by PKWARE
// /**
// * File is compressed using IBM TERSE
// */
// case IBM_TERSE = 0x12;
// /**
// * IBM LZ77 z Architecture
// */
// case IBM_LZ77 = 0x13;
// // 0x14: deprecated (use method 93 for zstd)
// /**
// * Zstandard (zstd) Compression
// */
// case ZSTD = 0x5d;
// /**
// * MP3 Compression
// */
// case MP3 = 0x5e;
// /**
// * XZ Compression
// */
// case XZ = 0x5f;
// /**
// * JPEG variant
// */
// case JPEG = 0x60;
// /**
// * WavPack compressed data
// */
// case WAV_PACK = 0x61;
// /**
// * PPMd version I, Rev 1
// */
// case PPMD_1_1 = 0x62;
// /**
// * AE-x encryption marker
// */
// case AE_X_ENCRYPTION = 0x63;
}

26
vendor/maennchen/zipstream-php/src/DataDescriptor.php vendored
View File

@ -1,26 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
/**
* @internal
*/
abstract class DataDescriptor
{
private const SIGNATURE = 0x08074b50;
public static function generate(
int $crc32UncompressedData,
int $compressedSize,
int $uncompressedSize,
): string {
return PackField::pack(
new PackField(format: 'V', value: self::SIGNATURE),
new PackField(format: 'V', value: $crc32UncompressedData),
new PackField(format: 'V', value: $compressedSize),
new PackField(format: 'V', value: $uncompressedSize),
);
}
}

35
vendor/maennchen/zipstream-php/src/EndOfCentralDirectory.php vendored
View File

@ -1,35 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
/**
* @internal
*/
abstract class EndOfCentralDirectory
{
private const SIGNATURE = 0x06054b50;
public static function generate(
int $numberOfThisDisk,
int $numberOfTheDiskWithCentralDirectoryStart,
int $numberOfCentralDirectoryEntriesOnThisDisk,
int $numberOfCentralDirectoryEntries,
int $sizeOfCentralDirectory,
int $centralDirectoryStartOffsetOnDisk,
string $zipFileComment,
): string {
/** @psalm-suppress MixedArgument */
return PackField::pack(
new PackField(format: 'V', value: static::SIGNATURE),
new PackField(format: 'v', value: $numberOfThisDisk),
new PackField(format: 'v', value: $numberOfTheDiskWithCentralDirectoryStart),
new PackField(format: 'v', value: $numberOfCentralDirectoryEntriesOnThisDisk),
new PackField(format: 'v', value: $numberOfCentralDirectoryEntries),
new PackField(format: 'V', value: $sizeOfCentralDirectory),
new PackField(format: 'V', value: $centralDirectoryStartOffsetOnDisk),
new PackField(format: 'v', value: strlen($zipFileComment)),
) . $zipFileComment;
}
}

23
vendor/maennchen/zipstream-php/src/Exception/DosTimeOverflowException.php vendored
View File

@ -1,23 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Exception;
use DateTimeInterface;
use ZipStream\Exception;
/**
* This Exception gets invoked if a file wasn't found
*/
class DosTimeOverflowException extends Exception
{
/**
* @internal
*/
public function __construct(
public readonly DateTimeInterface $dateTime
) {
parent::__construct('The date ' . $dateTime->format(DateTimeInterface::ATOM) . " can't be represented as DOS time / date.");
}
}

23
vendor/maennchen/zipstream-php/src/Exception/FileSizeIncorrectException.php vendored
View File

@ -1,23 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Exception;
use ZipStream\Exception;
/**
* This Exception gets invoked if a file is not as large as it was specified.
*/
class FileSizeIncorrectException extends Exception
{
/**
* @internal
*/
public function __construct(
public readonly int $expectedSize,
public readonly int $actualSize
) {
parent::__construct("File is {$actualSize} instead of {$expectedSize} bytes large. Adjust `exactSize` parameter.");
}
}

29
vendor/maennchen/zipstream-php/src/Exception/ResourceActionException.php vendored
View File

@ -1,29 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Exception;
use ZipStream\Exception;
/**
* This Exception gets invoked if a resource like `fread` returns false
*/
class ResourceActionException extends Exception
{
/**
* @var ?resource
*/
public $resource;
/**
* @param resource $resource
*/
public function __construct(
public readonly string $function,
$resource = null,
) {
$this->resource = $resource;
parent::__construct('Function ' . $function . 'failed on resource.');
}
}

19
vendor/maennchen/zipstream-php/src/Exception/SimulationFileUnknownException.php vendored
View File

@ -1,19 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Exception;
use ZipStream\Exception;
/**
* This Exception gets invoked if a strict simulation is executed and the file
* information can't be determined without reading the entire file.
*/
class SimulationFileUnknownException extends Exception
{
public function __construct()
{
parent::__construct('The details of the strict simulation file could not be determined without reading the entire file.');
}
}

22
vendor/maennchen/zipstream-php/src/Exception/StreamNotSeekableException.php vendored
View File

@ -1,22 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Exception;
use ZipStream\Exception;
/**
* This Exception gets invoked if a non seekable stream is
* provided and zero headers are disabled.
*/
class StreamNotSeekableException extends Exception
{
/**
* @internal
*/
public function __construct()
{
parent::__construct('enableZeroHeader must be enable to add non seekable streams');
}
}

89
vendor/maennchen/zipstream-php/src/GeneralPurposeBitFlag.php vendored
View File

@ -1,89 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
/**
* @internal
*/
abstract class GeneralPurposeBitFlag
{
/**
* If set, indicates that the file is encrypted.
*/
public const ENCRYPTED = 1 << 0;
/**
* (For Methods 8 and 9 - Deflating)
* Normal (-en) compression option was used.
*/
public const DEFLATE_COMPRESSION_NORMAL = 0 << 1;
/**
* (For Methods 8 and 9 - Deflating)
* Maximum (-exx/-ex) compression option was used.
*/
public const DEFLATE_COMPRESSION_MAXIMUM = 1 << 1;
/**
* (For Methods 8 and 9 - Deflating)
* Fast (-ef) compression option was used.
*/
public const DEFLATE_COMPRESSION_FAST = 10 << 1;
/**
* (For Methods 8 and 9 - Deflating)
* Super Fast (-es) compression option was used.
*/
public const DEFLATE_COMPRESSION_SUPERFAST = 11 << 1;
/**
* If the compression method used was type 14,
* LZMA, then this bit, if set, indicates
* an end-of-stream (EOS) marker is used to
* mark the end of the compressed data stream.
* If clear, then an EOS marker is not present
* and the compressed data size must be known
* to extract.
*/
public const LZMA_EOS = 1 << 1;
/**
* If this bit is set, the fields crc-32, compressed
* size and uncompressed size are set to zero in the
* local header. The correct values are put in the
* data descriptor immediately following the compressed
* data.
*/
public const ZERO_HEADER = 1 << 3;
/**
* If this bit is set, this indicates that the file is
* compressed patched data.
*/
public const COMPRESSED_PATCHED_DATA = 1 << 5;
/**
* Strong encryption. If this bit is set, you MUST
* set the version needed to extract value to at least
* 50 and you MUST also set bit 0. If AES encryption
* is used, the version needed to extract value MUST
* be at least 51.
*/
public const STRONG_ENCRYPTION = 1 << 6;
/**
* Language encoding flag (EFS). If this bit is set,
* the filename and comment fields for this file
* MUST be encoded using UTF-8.
*/
public const EFS = 1 << 11;
/**
* Set when encrypting the Central Directory to indicate
* selected data values in the Local Header are masked to
* hide their actual values.
*/
public const ENCRYPT_CENTRAL_DIRECTORY = 1 << 13;
}

40
vendor/maennchen/zipstream-php/src/LocalFileHeader.php vendored
View File

@ -1,40 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
use DateTimeInterface;
/**
* @internal
*/
abstract class LocalFileHeader
{
private const SIGNATURE = 0x04034b50;
public static function generate(
int $versionNeededToExtract,
int $generalPurposeBitFlag,
CompressionMethod $compressionMethod,
DateTimeInterface $lastModificationDateTime,
int $crc32UncompressedData,
int $compressedSize,
int $uncompressedSize,
string $fileName,
string $extraField,
): string {
return PackField::pack(
new PackField(format: 'V', value: self::SIGNATURE),
new PackField(format: 'v', value: $versionNeededToExtract),
new PackField(format: 'v', value: $generalPurposeBitFlag),
new PackField(format: 'v', value: $compressionMethod->value),
new PackField(format: 'V', value: Time::dateTimeToDosTime($lastModificationDateTime)),
new PackField(format: 'V', value: $crc32UncompressedData),
new PackField(format: 'V', value: $compressedSize),
new PackField(format: 'V', value: $uncompressedSize),
new PackField(format: 'v', value: strlen($fileName)),
new PackField(format: 'v', value: strlen($extraField)),
) . $fileName . $extraField;
}
}

35
vendor/maennchen/zipstream-php/src/OperationMode.php vendored
View File

@ -1,35 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
/**
* ZipStream execution operation modes
*/
enum OperationMode
{
/**
* Stream file into output stream
*/
case NORMAL;
/**
* Simulate the zip to figure out the resulting file size
*
* This only supports entries where the file size is known beforehand and
* deflation is disabled.
*/
case SIMULATE_STRICT;
/**
* Simulate the zip to figure out the resulting file size
*
* If the file size is not known beforehand or deflation is enabled, the
* entry streams will be read and rewound.
*
* If the entry does not support rewinding either, you will not be able to
* use the same stream in a later operation mode like `NORMAL`.
*/
case SIMULATE_LAX;
}

57
vendor/maennchen/zipstream-php/src/PackField.php vendored
View File

@ -1,57 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
use RuntimeException;
/**
* @internal
* TODO: Make class readonly when requiring PHP 8.2 exclusively
*/
class PackField
{
public const MAX_V = 0xFFFFFFFF;
public const MAX_v = 0xFFFF;
public function __construct(
public readonly string $format,
public readonly int|string $value
) {
}
/**
* Create a format string and argument list for pack(), then call
* pack() and return the result.
*/
public static function pack(self ...$fields): string
{
$fmt = array_reduce($fields, function (string $acc, self $field) {
return $acc . $field->format;
}, '');
$args = array_map(function (self $field) {
switch($field->format) {
case 'V':
if ($field->value > self::MAX_V) {
throw new RuntimeException(print_r($field->value, true) . ' is larger than 32 bits');
}
break;
case 'v':
if ($field->value > self::MAX_v) {
throw new RuntimeException(print_r($field->value, true) . ' is larger than 16 bits');
}
break;
case 'P': break;
default:
break;
}
return $field->value;
}, $fields);
return pack($fmt, ...$args);
}
}

45
vendor/maennchen/zipstream-php/src/Time.php vendored
View File

@ -1,45 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
use DateInterval;
use DateTimeImmutable;
use DateTimeInterface;
use ZipStream\Exception\DosTimeOverflowException;
/**
* @internal
*/
abstract class Time
{
private const DOS_MINIMUM_DATE = '1980-01-01 00:00:00Z';
public static function dateTimeToDosTime(DateTimeInterface $dateTime): int
{
$dosMinimumDate = new DateTimeImmutable(self::DOS_MINIMUM_DATE);
if ($dateTime->getTimestamp() < $dosMinimumDate->getTimestamp()) {
throw new DosTimeOverflowException(dateTime: $dateTime);
}
$dateTime = DateTimeImmutable::createFromInterface($dateTime)->sub(new DateInterval('P1980Y'));
['year' => $year,
'mon' => $month,
'mday' => $day,
'hours' => $hour,
'minutes' => $minute,
'seconds' => $second
] = getdate($dateTime->getTimestamp());
return
($year << 25) |
($month << 21) |
($day << 16) |
($hour << 11) |
($minute << 5) |
($second >> 1);
}
}

12
vendor/maennchen/zipstream-php/src/Version.php vendored
View File

@ -1,12 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream;
enum Version: int
{
case STORE = 0x000A; // 1.00
case DEFLATE = 0x0014; // 2.00
case ZIP64 = 0x002D; // 4.50
}

28
vendor/maennchen/zipstream-php/src/Zip64/DataDescriptor.php vendored
View File

@ -1,28 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Zip64;
use ZipStream\PackField;
/**
* @internal
*/
abstract class DataDescriptor
{
private const SIGNATURE = 0x08074b50;
public static function generate(
int $crc32UncompressedData,
int $compressedSize,
int $uncompressedSize,
): string {
return PackField::pack(
new PackField(format: 'V', value: self::SIGNATURE),
new PackField(format: 'V', value: $crc32UncompressedData),
new PackField(format: 'P', value: $compressedSize),
new PackField(format: 'P', value: $uncompressedSize),
);
}
}

43
vendor/maennchen/zipstream-php/src/Zip64/EndOfCentralDirectory.php vendored
View File

@ -1,43 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Zip64;
use ZipStream\PackField;
/**
* @internal
*/
abstract class EndOfCentralDirectory
{
private const SIGNATURE = 0x06064b50;
public static function generate(
int $versionMadeBy,
int $versionNeededToExtract,
int $numberOfThisDisk,
int $numberOfTheDiskWithCentralDirectoryStart,
int $numberOfCentralDirectoryEntriesOnThisDisk,
int $numberOfCentralDirectoryEntries,
int $sizeOfCentralDirectory,
int $centralDirectoryStartOffsetOnDisk,
string $extensibleDataSector,
): string {
$recordSize = 44 + strlen($extensibleDataSector); // (length of block - 12) = 44;
/** @psalm-suppress MixedArgument */
return PackField::pack(
new PackField(format: 'V', value: static::SIGNATURE),
new PackField(format: 'P', value: $recordSize),
new PackField(format: 'v', value: $versionMadeBy),
new PackField(format: 'v', value: $versionNeededToExtract),
new PackField(format: 'V', value: $numberOfThisDisk),
new PackField(format: 'V', value: $numberOfTheDiskWithCentralDirectoryStart),
new PackField(format: 'P', value: $numberOfCentralDirectoryEntriesOnThisDisk),
new PackField(format: 'P', value: $numberOfCentralDirectoryEntries),
new PackField(format: 'P', value: $sizeOfCentralDirectory),
new PackField(format: 'P', value: $centralDirectoryStartOffsetOnDisk),
) . $extensibleDataSector;
}
}

29
vendor/maennchen/zipstream-php/src/Zip64/EndOfCentralDirectoryLocator.php vendored
View File

@ -1,29 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Zip64;
use ZipStream\PackField;
/**
* @internal
*/
abstract class EndOfCentralDirectoryLocator
{
private const SIGNATURE = 0x07064b50;
public static function generate(
int $numberOfTheDiskWithZip64CentralDirectoryStart,
int $zip64centralDirectoryStartOffsetOnDisk,
int $totalNumberOfDisks,
): string {
/** @psalm-suppress MixedArgument */
return PackField::pack(
new PackField(format: 'V', value: static::SIGNATURE),
new PackField(format: 'V', value: $numberOfTheDiskWithZip64CentralDirectoryStart),
new PackField(format: 'P', value: $zip64centralDirectoryStartOffsetOnDisk),
new PackField(format: 'V', value: $totalNumberOfDisks),
);
}
}

46
vendor/maennchen/zipstream-php/src/Zip64/ExtendedInformationExtraField.php vendored
View File

@ -1,46 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Zip64;
use ZipStream\PackField;
/**
* @internal
*/
abstract class ExtendedInformationExtraField
{
private const TAG = 0x0001;
public static function generate(
?int $originalSize = null,
?int $compressedSize = null,
?int $relativeHeaderOffset = null,
?int $diskStartNumber = null,
): string {
return PackField::pack(
new PackField(format: 'v', value: self::TAG),
new PackField(
format: 'v',
value:
($originalSize === null ? 0 : 8) +
($compressedSize === null ? 0 : 8) +
($relativeHeaderOffset === null ? 0 : 8) +
($diskStartNumber === null ? 0 : 4)
),
...($originalSize === null ? [] : [
new PackField(format: 'P', value: $originalSize),
]),
...($compressedSize === null ? [] : [
new PackField(format: 'P', value: $compressedSize),
]),
...($relativeHeaderOffset === null ? [] : [
new PackField(format: 'P', value: $relativeHeaderOffset),
]),
...($diskStartNumber === null ? [] : [
new PackField(format: 'V', value: $diskStartNumber),
]),
);
}
}

23
vendor/maennchen/zipstream-php/src/Zs/ExtendedInformationExtraField.php vendored
View File

@ -1,23 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Zs;
use ZipStream\PackField;
/**
* @internal
*/
abstract class ExtendedInformationExtraField
{
private const TAG = 0x5653;
public static function generate(): string
{
return PackField::pack(
new PackField(format: 'v', value: self::TAG),
new PackField(format: 'v', value: 0x0000),
);
}
}

49
vendor/maennchen/zipstream-php/test/Assertions.php vendored
View File

@ -1,49 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
trait Assertions
{
protected function assertFileContains(string $filePath, string $needle): void
{
$last = '';
$handle = fopen($filePath, 'r');
while (!feof($handle)) {
$line = fgets($handle, 1024);
if(str_contains($last . $line, $needle)) {
fclose($handle);
return;
}
$last = $line;
}
fclose($handle);
$this->fail("File {$filePath} must contain {$needle}");
}
protected function assertFileDoesNotContain(string $filePath, string $needle): void
{
$last = '';
$handle = fopen($filePath, 'r');
while (!feof($handle)) {
$line = fgets($handle, 1024);
if(str_contains($last . $line, $needle)) {
fclose($handle);
$this->fail("File {$filePath} must not contain {$needle}");
}
$last = $line;
}
fclose($handle);
}
}

60
vendor/maennchen/zipstream-php/test/CentralDirectoryFileHeaderTest.php vendored
View File

@ -1,60 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\CentralDirectoryFileHeader;
use ZipStream\CompressionMethod;
class CentralDirectoryFileHeaderTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$dateTime = new DateTimeImmutable('2022-01-01 01:01:01Z');
$header = CentralDirectoryFileHeader::generate(
versionMadeBy: 0x603,
versionNeededToExtract: 0x002D,
generalPurposeBitFlag: 0x2222,
compressionMethod: CompressionMethod::DEFLATE,
lastModificationDateTime: $dateTime,
crc32: 0x11111111,
compressedSize: 0x77777777,
uncompressedSize: 0x99999999,
fileName: 'test.png',
extraField: 'some content',
fileComment: 'some comment',
diskNumberStart: 0,
internalFileAttributes: 0,
externalFileAttributes: 32,
relativeOffsetOfLocalHeader: 0x1234,
);
$this->assertSame(
bin2hex($header),
'504b0102' . // 4 bytes; central file header signature
'0306' . // 2 bytes; version made by
'2d00' . // 2 bytes; version needed to extract
'2222' . // 2 bytes; general purpose bit flag
'0800' . // 2 bytes; compression method
'2008' . // 2 bytes; last mod file time
'2154' . // 2 bytes; last mod file date
'11111111' . // 4 bytes; crc-32
'77777777' . // 4 bytes; compressed size
'99999999' . // 4 bytes; uncompressed size
'0800' . // 2 bytes; file name length (n)
'0c00' . // 2 bytes; extra field length (m)
'0c00' . // 2 bytes; file comment length (o)
'0000' . // 2 bytes; disk number start
'0000' . // 2 bytes; internal file attributes
'20000000' . // 4 bytes; external file attributes
'34120000' . // 4 bytes; relative offset of local header
'746573742e706e67' . // n bytes; file name
'736f6d6520636f6e74656e74' . // m bytes; extra field
'736f6d6520636f6d6d656e74' // o bytes; file comment
);
}
}

26
vendor/maennchen/zipstream-php/test/DataDescriptorTest.php vendored
View File

@ -1,26 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use PHPUnit\Framework\TestCase;
use ZipStream\DataDescriptor;
class DataDescriptorTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$this->assertSame(
bin2hex(DataDescriptor::generate(
crc32UncompressedData: 0x11111111,
compressedSize: 0x77777777,
uncompressedSize: 0x99999999,
)),
'504b0708' . // 4 bytes; Optional data descriptor signature = 0x08074b50
'11111111' . // 4 bytes; CRC-32 of uncompressed data
'77777777' . // 4 bytes; Compressed size
'99999999' // 4 bytes; Uncompressed size
);
}
}

35
vendor/maennchen/zipstream-php/test/EndOfCentralDirectoryTest.php vendored
View File

@ -1,35 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use PHPUnit\Framework\TestCase;
use ZipStream\EndOfCentralDirectory;
class EndOfCentralDirectoryTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$this->assertSame(
bin2hex(EndOfCentralDirectory::generate(
numberOfThisDisk: 0x00,
numberOfTheDiskWithCentralDirectoryStart: 0x00,
numberOfCentralDirectoryEntriesOnThisDisk: 0x10,
numberOfCentralDirectoryEntries: 0x10,
sizeOfCentralDirectory: 0x22,
centralDirectoryStartOffsetOnDisk: 0x33,
zipFileComment: 'foo',
)),
'504b0506' . // 4 bytes; end of central dir signature 0x06054b50
'0000' . // 2 bytes; number of this disk
'0000' . // 2 bytes; number of the disk with the start of the central directory
'1000' . // 2 bytes; total number of entries in the central directory on this disk
'1000' . // 2 bytes; total number of entries in the central directory
'22000000' . // 4 bytes; size of the central directory
'33000000' . // 4 bytes; offset of start of central directory with respect to the starting disk number
'0300' . // 2 bytes; .ZIP file comment length
bin2hex('foo')
);
}
}

106
vendor/maennchen/zipstream-php/test/EndlessCycleStream.php vendored
View File

@ -1,106 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use Psr\Http\Message\StreamInterface;
use RuntimeException;
class EndlessCycleStream implements StreamInterface
{
private int $offset = 0;
public function __construct(private readonly string $toRepeat = '0')
{
}
public function __toString(): string
{
throw new RuntimeException('Infinite Stream!');
}
public function close(): void
{
$this->detach();
}
/**
* @return null
*/
public function detach()
{
return;
}
public function getSize(): ?int
{
return null;
}
public function tell(): int
{
return $this->offset;
}
public function eof(): bool
{
return false;
}
public function isSeekable(): bool
{
return true;
}
public function seek(int $offset, int $whence = SEEK_SET): void
{
switch($whence) {
case SEEK_SET:
$this->offset = $offset;
break;
case SEEK_CUR:
$this->offset += $offset;
break;
case SEEK_END:
throw new RuntimeException('Infinite Stream!');
break;
}
}
public function rewind(): void
{
$this->seek(0);
}
public function isWritable(): bool
{
return false;
}
public function write(string $string): int
{
throw new RuntimeException('Not writeable');
}
public function isReadable(): bool
{
return true;
}
public function read(int $length): string
{
$this->offset += $length;
return substr(str_repeat($this->toRepeat, (int) ceil($length / strlen($this->toRepeat))), 0, $length);
}
public function getContents(): string
{
throw new RuntimeException('Infinite Stream!');
}
public function getMetadata(?string $key = null): array|null
{
return $key !== null ? null : [];
}
}

141
vendor/maennchen/zipstream-php/test/FaultInjectionResource.php vendored
View File

@ -1,141 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
class FaultInjectionResource
{
public const NAME = 'zipstream-php-test-broken-resource';
/** @var resource */
public $context;
private array $injectFaults;
private string $mode;
/**
* @return resource
*/
public static function getResource(array $injectFaults)
{
self::register();
return fopen(self::NAME . '://foobar', 'rw+', false, self::createStreamContext($injectFaults));
}
public function stream_open(string $path, string $mode, int $options, string &$opened_path = null): bool
{
$options = stream_context_get_options($this->context);
if (!isset($options[self::NAME]['injectFaults'])) {
return false;
}
$this->mode = $mode;
$this->injectFaults = $options[self::NAME]['injectFaults'];
if ($this->shouldFail(__FUNCTION__)) {
return false;
}
return true;
}
public function stream_write(string $data)
{
if ($this->shouldFail(__FUNCTION__)) {
return false;
}
return true;
}
public function stream_eof()
{
return true;
}
public function stream_seek(int $offset, int $whence): bool
{
if ($this->shouldFail(__FUNCTION__)) {
return false;
}
return true;
}
public function stream_tell(): int
{
if ($this->shouldFail(__FUNCTION__)) {
return false;
}
return 0;
}
public static function register(): void
{
if (!in_array(self::NAME, stream_get_wrappers(), true)) {
stream_wrapper_register(self::NAME, __CLASS__);
}
}
public function stream_stat(): array
{
static $modeMap = [
'r' => 33060,
'rb' => 33060,
'r+' => 33206,
'w' => 33188,
'wb' => 33188,
];
return [
'dev' => 0,
'ino' => 0,
'mode' => $modeMap[$this->mode],
'nlink' => 0,
'uid' => 0,
'gid' => 0,
'rdev' => 0,
'size' => 0,
'atime' => 0,
'mtime' => 0,
'ctime' => 0,
'blksize' => 0,
'blocks' => 0,
];
}
public function url_stat(string $path, int $flags): array
{
return [
'dev' => 0,
'ino' => 0,
'mode' => 0,
'nlink' => 0,
'uid' => 0,
'gid' => 0,
'rdev' => 0,
'size' => 0,
'atime' => 0,
'mtime' => 0,
'ctime' => 0,
'blksize' => 0,
'blocks' => 0,
];
}
private static function createStreamContext(array $injectFaults)
{
return stream_context_create([
self::NAME => ['injectFaults' => $injectFaults],
]);
}
private function shouldFail(string $function): bool
{
return in_array($function, $this->injectFaults, true);
}
}

47
vendor/maennchen/zipstream-php/test/LocalFileHeaderTest.php vendored
View File

@ -1,47 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\CompressionMethod;
use ZipStream\LocalFileHeader;
class LocalFileHeaderTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$dateTime = new DateTimeImmutable('2022-01-01 01:01:01Z');
$header = LocalFileHeader::generate(
versionNeededToExtract: 0x002D,
generalPurposeBitFlag: 0x2222,
compressionMethod: CompressionMethod::DEFLATE,
lastModificationDateTime: $dateTime,
crc32UncompressedData: 0x11111111,
compressedSize: 0x77777777,
uncompressedSize: 0x99999999,
fileName: 'test.png',
extraField: 'some content'
);
$this->assertSame(
bin2hex((string) $header),
'504b0304' . // 4 bytes; Local file header signature
'2d00' . // 2 bytes; Version needed to extract (minimum)
'2222' . // 2 bytes; General purpose bit flag
'0800' . // 2 bytes; Compression method; e.g. none = 0, DEFLATE = 8
'2008' . // 2 bytes; File last modification time
'2154' . // 2 bytes; File last modification date
'11111111' . // 4 bytes; CRC-32 of uncompressed data
'77777777' . // 4 bytes; Compressed size (or 0xffffffff for ZIP64)
'99999999' . // 4 bytes; Uncompressed size (or 0xffffffff for ZIP64)
'0800' . // 2 bytes; File name length (n)
'0c00' . // 2 bytes; Extra field length (m)
'746573742e706e67' . // n bytes; File name
'736f6d6520636f6e74656e74' // m bytes; Extra field
);
}
}

42
vendor/maennchen/zipstream-php/test/PackFieldTest.php vendored
View File

@ -1,42 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use PHPUnit\Framework\TestCase;
use RuntimeException;
use ZipStream\PackField;
class PackFieldTest extends TestCase
{
public function testPacksFields(): void
{
$this->assertSame(
bin2hex(PackField::pack(new PackField(format: 'v', value: 0x1122))),
'2211',
);
}
public function testOverflow2(): void
{
$this->expectException(RuntimeException::class);
PackField::pack(new PackField(format: 'v', value: 0xFFFFF));
}
public function testOverflow4(): void
{
$this->expectException(RuntimeException::class);
PackField::pack(new PackField(format: 'V', value: 0xFFFFFFFFF));
}
public function testUnknownOperator(): void
{
$this->assertSame(
bin2hex(PackField::pack(new PackField(format: 'a', value: 0x1122))),
'34',
);
}
}

160
vendor/maennchen/zipstream-php/test/ResourceStream.php vendored
View File

@ -1,160 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use Psr\Http\Message\StreamInterface;
use RuntimeException;
/**
* @internal
*/
class ResourceStream implements StreamInterface
{
public function __construct(
/**
* @var resource
*/
private $stream
) {
}
public function __toString(): string
{
if ($this->isSeekable()) {
$this->seek(0);
}
return (string) stream_get_contents($this->stream);
}
public function close(): void
{
$stream = $this->detach();
if ($stream) {
fclose($stream);
}
}
public function detach()
{
$result = $this->stream;
// According to the interface, the stream is left in an unusable state;
/** @psalm-suppress PossiblyNullPropertyAssignmentValue */
$this->stream = null;
return $result;
}
public function seek(int $offset, int $whence = SEEK_SET): void
{
if (!$this->isSeekable()) {
throw new RuntimeException();
}
if (fseek($this->stream, $offset, $whence) !== 0) {
// @codeCoverageIgnoreStart
throw new RuntimeException();
// @codeCoverageIgnoreEnd
}
}
public function isSeekable(): bool
{
return (bool)$this->getMetadata('seekable');
}
public function getMetadata(?string $key = null)
{
$metadata = stream_get_meta_data($this->stream);
return $key !== null ? @$metadata[$key] : $metadata;
}
public function getSize(): ?int
{
$stats = fstat($this->stream);
return $stats['size'];
}
public function tell(): int
{
$position = ftell($this->stream);
if ($position === false) {
// @codeCoverageIgnoreStart
throw new RuntimeException();
// @codeCoverageIgnoreEnd
}
return $position;
}
public function eof(): bool
{
return feof($this->stream);
}
public function rewind(): void
{
$this->seek(0);
}
public function write(string $string): int
{
if (!$this->isWritable()) {
throw new RuntimeException();
}
if (fwrite($this->stream, $string) === false) {
// @codeCoverageIgnoreStart
throw new RuntimeException();
// @codeCoverageIgnoreEnd
}
return strlen($string);
}
public function isWritable(): bool
{
$mode = $this->getMetadata('mode');
if (!is_string($mode)) {
// @codeCoverageIgnoreStart
throw new RuntimeException('Could not get stream mode from metadata!');
// @codeCoverageIgnoreEnd
}
return preg_match('/[waxc+]/', $mode) === 1;
}
public function read(int $length): string
{
if (!$this->isReadable()) {
throw new RuntimeException();
}
$result = fread($this->stream, $length);
if ($result === false) {
// @codeCoverageIgnoreStart
throw new RuntimeException();
// @codeCoverageIgnoreEnd
}
return $result;
}
public function isReadable(): bool
{
$mode = $this->getMetadata('mode');
if (!is_string($mode)) {
// @codeCoverageIgnoreStart
throw new RuntimeException('Could not get stream mode from metadata!');
// @codeCoverageIgnoreEnd
}
return preg_match('/[r+]/', $mode) === 1;
}
public function getContents(): string
{
if (!$this->isReadable()) {
throw new RuntimeException();
}
$result = stream_get_contents($this->stream);
if ($result === false) {
// @codeCoverageIgnoreStart
throw new RuntimeException();
// @codeCoverageIgnoreEnd
}
return $result;
}
}

35
vendor/maennchen/zipstream-php/test/TimeTest.php vendored
View File

@ -1,35 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use DateTimeImmutable;
use PHPUnit\Framework\TestCase;
use ZipStream\Exception\DosTimeOverflowException;
use ZipStream\Time;
class TimeTest extends TestCase
{
public function testNormalDateToDosTime(): void
{
$this->assertSame(
Time::dateTimeToDosTime(new DateTimeImmutable('2014-11-17T17:46:08Z')),
1165069764
);
// January 1 1980 - DOS Epoch.
$this->assertSame(
Time::dateTimeToDosTime(new DateTimeImmutable('1980-01-01T00:00:00+00:00')),
2162688
);
}
public function testTooEarlyDateToDosTime(): void
{
$this->expectException(DosTimeOverflowException::class);
// January 1 1980 is the minimum DOS Epoch.
Time::dateTimeToDosTime(new DateTimeImmutable('1970-01-01T00:00:00+00:00'));
}
}

135
vendor/maennchen/zipstream-php/test/Util.php vendored
View File

@ -1,135 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test;
use function fgets;
use function pclose;
use function popen;
use function preg_match;
use RecursiveDirectoryIterator;
use RecursiveIteratorIterator;
use function strtolower;
use ZipArchive;
trait Util
{
protected function getTmpFileStream(): array
{
$tmp = tempnam(sys_get_temp_dir(), 'zipstreamtest');
$stream = fopen($tmp, 'wb+');
return [$tmp, $stream];
}
protected function cmdExists(string $command): bool
{
if (strtolower(\substr(PHP_OS, 0, 3)) === 'win') {
$fp = popen("where $command", 'r');
$result = fgets($fp, 255);
$exists = !preg_match('#Could not find files#', $result);
pclose($fp);
} else { // non-Windows
$fp = popen("which $command", 'r');
$result = fgets($fp, 255);
$exists = !empty($result);
pclose($fp);
}
return $exists;
}
protected function dumpZipContents(string $path): string
{
if (!$this->cmdExists('hexdump')) {
return '';
}
$output = [];
if (!exec("hexdump -C \"$path\" | head -n 50", $output)) {
return '';
}
return "\nHexdump:\n" . implode("\n", $output);
}
protected function validateAndExtractZip(string $zipPath): string
{
$tmpDir = $this->getTmpDir();
$zipArchive = new ZipArchive();
$result = $zipArchive->open($zipPath);
if ($result !== true) {
$codeName = $this->zipArchiveOpenErrorCodeName($result);
$debugInformation = $this->dumpZipContents($zipPath);
$this->fail("Failed to open {$zipPath}. Code: $result ($codeName)$debugInformation");
return $tmpDir;
}
$this->assertSame(0, $zipArchive->status);
$this->assertSame(0, $zipArchive->statusSys);
$zipArchive->extractTo($tmpDir);
$zipArchive->close();
return $tmpDir;
}
protected function zipArchiveOpenErrorCodeName(int $code): string
{
switch($code) {
case ZipArchive::ER_EXISTS: return 'ER_EXISTS';
case ZipArchive::ER_INCONS: return 'ER_INCONS';
case ZipArchive::ER_INVAL: return 'ER_INVAL';
case ZipArchive::ER_MEMORY: return 'ER_MEMORY';
case ZipArchive::ER_NOENT: return 'ER_NOENT';
case ZipArchive::ER_NOZIP: return 'ER_NOZIP';
case ZipArchive::ER_OPEN: return 'ER_OPEN';
case ZipArchive::ER_READ: return 'ER_READ';
case ZipArchive::ER_SEEK: return 'ER_SEEK';
default: return 'unknown';
}
}
protected function getTmpDir(): string
{
$tmp = tempnam(sys_get_temp_dir(), 'zipstreamtest');
unlink($tmp);
mkdir($tmp) or $this->fail('Failed to make directory');
return $tmp;
}
/**
* @return string[]
*/
protected function getRecursiveFileList(string $path, bool $includeDirectories = false): array
{
$data = [];
$path = (string)realpath($path);
$files = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path));
$pathLen = strlen($path);
foreach ($files as $file) {
$filePath = $file->getRealPath();
if (is_dir($filePath) && !$includeDirectories) {
continue;
}
$data[] = substr($filePath, $pathLen + 1);
}
sort($data);
return $data;
}
}

28
vendor/maennchen/zipstream-php/test/Zip64/DataDescriptorTest.php vendored
View File

@ -1,28 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test\Zip64;
use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\DataDescriptor;
class DataDescriptorTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$descriptor = DataDescriptor::generate(
crc32UncompressedData: 0x11111111,
compressedSize: (0x77777777 << 32) + 0x66666666,
uncompressedSize: (0x99999999 << 32) + 0x88888888,
);
$this->assertSame(
bin2hex($descriptor),
'504b0708' . // 4 bytes; Optional data descriptor signature = 0x08074b50
'11111111' . // 4 bytes; CRC-32 of uncompressed data
'6666666677777777' . // 8 bytes; Compressed size
'8888888899999999' // 8 bytes; Uncompressed size
);
}
}

28
vendor/maennchen/zipstream-php/test/Zip64/EndOfCentralDirectoryLocatorTest.php vendored
View File

@ -1,28 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test\Zip64;
use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\EndOfCentralDirectoryLocator;
class EndOfCentralDirectoryLocatorTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$descriptor = EndOfCentralDirectoryLocator::generate(
numberOfTheDiskWithZip64CentralDirectoryStart: 0x11111111,
zip64centralDirectoryStartOffsetOnDisk: (0x22222222 << 32) + 0x33333333,
totalNumberOfDisks: 0x44444444,
);
$this->assertSame(
bin2hex($descriptor),
'504b0607' . // 4 bytes; zip64 end of central dir locator signature - 0x07064b50
'11111111' . // 4 bytes; number of the disk with the start of the zip64 end of central directory
'3333333322222222' . // 28 bytes; relative offset of the zip64 end of central directory record
'44444444' // 4 bytes;total number of disks
);
}
}

41
vendor/maennchen/zipstream-php/test/Zip64/EndOfCentralDirectoryTest.php vendored
View File

@ -1,41 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test\Zip64;
use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\EndOfCentralDirectory;
class EndOfCentralDirectoryTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$descriptor = EndOfCentralDirectory::generate(
versionMadeBy: 0x3333,
versionNeededToExtract: 0x4444,
numberOfThisDisk: 0x55555555,
numberOfTheDiskWithCentralDirectoryStart: 0x66666666,
numberOfCentralDirectoryEntriesOnThisDisk: (0x77777777 << 32) + 0x88888888,
numberOfCentralDirectoryEntries: (0x99999999 << 32) + 0xAAAAAAAA,
sizeOfCentralDirectory: (0xBBBBBBBB << 32) + 0xCCCCCCCC,
centralDirectoryStartOffsetOnDisk: (0xDDDDDDDD << 32) + 0xEEEEEEEE,
extensibleDataSector: 'foo',
);
$this->assertSame(
bin2hex($descriptor),
'504b0606' . // 4 bytes;zip64 end of central dir signature - 0x06064b50
'2f00000000000000' . // 8 bytes; size of zip64 end of central directory record
'3333' . // 2 bytes; version made by
'4444' . // 2 bytes; version needed to extract
'55555555' . // 4 bytes; number of this disk
'66666666' . // 4 bytes; number of the disk with the start of the central directory
'8888888877777777' . // 8 bytes; total number of entries in the central directory on this disk
'aaaaaaaa99999999' . // 8 bytes; total number of entries in the central directory
'ccccccccbbbbbbbb' . // 8 bytes; size of the central directory
'eeeeeeeedddddddd' . // 8 bytes; offset of start of central directory with respect to the starting disk number
bin2hex('foo')
);
}
}

42
vendor/maennchen/zipstream-php/test/Zip64/ExtendedInformationExtraFieldTest.php vendored
View File

@ -1,42 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test\Zip64;
use PHPUnit\Framework\TestCase;
use ZipStream\Zip64\ExtendedInformationExtraField;
class ExtendedInformationExtraFieldTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$extraField = ExtendedInformationExtraField::generate(
originalSize: (0x77777777 << 32) + 0x66666666,
compressedSize: (0x99999999 << 32) + 0x88888888,
relativeHeaderOffset: (0x22222222 << 32) + 0x11111111,
diskStartNumber: 0x33333333,
);
$this->assertSame(
bin2hex($extraField),
'0100' . // 2 bytes; Tag for this "extra" block type
'1c00' . // 2 bytes; Size of this "extra" block
'6666666677777777' . // 8 bytes; Original uncompressed file size
'8888888899999999' . // 8 bytes; Size of compressed data
'1111111122222222' . // 8 bytes; Offset of local header record
'33333333' // 4 bytes; Number of the disk on which this file starts
);
}
public function testSerializesEmptyCorrectly(): void
{
$extraField = ExtendedInformationExtraField::generate();
$this->assertSame(
bin2hex($extraField),
'0100' . // 2 bytes; Tag for this "extra" block type
'0000' // 2 bytes; Size of this "extra" block
);
}
}

22
vendor/maennchen/zipstream-php/test/Zs/ExtendedInformationExtraFieldTest.php vendored
View File

@ -1,22 +0,0 @@
<?php
declare(strict_types=1);
namespace ZipStream\Test\Zs;
use PHPUnit\Framework\TestCase;
use ZipStream\Zs\ExtendedInformationExtraField;
class ExtendedInformationExtraFieldTest extends TestCase
{
public function testSerializesCorrectly(): void
{
$extraField = ExtendedInformationExtraField::generate();
$this->assertSame(
bin2hex((string) $extraField),
'5356' . // 2 bytes; Tag for this "extra" block type
'0000' // 2 bytes; TODO: Document
);
}
}

15
vendor/phpoffice/phpspreadsheet/phpunit10.xml.dist vendored
View File

@ -1,15 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.1/phpunit.xsd" bootstrap="./tests/bootstrap.php" backupGlobals="true" colors="true" cacheResultFile="/tmp/.phpspreadsheet.phpunit.result.cache">
<coverage/>
<php>
<ini name="memory_limit" value="2048M"/>
</php>
<testsuite name="PhpSpreadsheet Unit Test Suite">
<directory>./tests/PhpSpreadsheetTests</directory>
</testsuite>
<source>
<include>
<directory suffix=".php">./src</directory>
</include>
</source>
</phpunit>

66
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Cell/IgnoredErrors.php vendored
View File

@ -1,66 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Cell;
class IgnoredErrors
{
/** @var bool */
private $numberStoredAsText = false;
/** @var bool */
private $formula = false;
/** @var bool */
private $twoDigitTextYear = false;
/** @var bool */
private $evalError = false;
public function setNumberStoredAsText(bool $value): self
{
$this->numberStoredAsText = $value;
return $this;
}
public function getNumberStoredAsText(): bool
{
return $this->numberStoredAsText;
}
public function setFormula(bool $value): self
{
$this->formula = $value;
return $this;
}
public function getFormula(): bool
{
return $this->formula;
}
public function setTwoDigitTextYear(bool $value): self
{
$this->twoDigitTextYear = $value;
return $this;
}
public function getTwoDigitTextYear(): bool
{
return $this->twoDigitTextYear;
}
public function setEvalError(bool $value): self
{
$this->evalError = $value;
return $this;
}
public function getEvalError(): bool
{
return $this->evalError;
}
}

56
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Chart/AxisText.php vendored
View File

@ -1,56 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Chart;
use PhpOffice\PhpSpreadsheet\Style\Font;
class AxisText extends Properties
{
/** @var ?int */
private $rotation;
/** @var Font */
private $font;
public function __construct()
{
parent::__construct();
$this->font = new Font();
$this->font->setSize(null, true);
}
public function setRotation(?int $rotation): self
{
$this->rotation = $rotation;
return $this;
}
public function getRotation(): ?int
{
return $this->rotation;
}
public function getFillColorObject(): ChartColor
{
$fillColor = $this->font->getChartColor();
if ($fillColor === null) {
$fillColor = new ChartColor();
$this->font->setChartColorFromObject($fillColor);
}
return $fillColor;
}
public function getFont(): Font
{
return $this->font;
}
public function setFont(Font $font): self
{
$this->font = $font;
return $this;
}
}

89
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Helper/Downloader.php vendored
View File

@ -1,89 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Helper;
use PhpOffice\PhpSpreadsheet\Exception;
class Downloader
{
protected string $filepath;
protected string $filename;
protected string $filetype;
protected const CONTENT_TYPES = [
'xlsx' => 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
'xls' => 'application/vnd.ms-excel',
'ods' => 'application/vnd.oasis.opendocument.spreadsheet',
'csv' => 'text/csv',
'html' => 'text/html',
'pdf' => 'application/pdf',
];
public function __construct(string $folder, string $filename, ?string $filetype = null)
{
if ((is_dir($folder) === false) || (is_readable($folder) === false)) {
throw new Exception("Folder {$folder} is not accessable");
}
$filepath = "{$folder}/{$filename}";
$this->filepath = (string) realpath($filepath);
$this->filename = basename($filepath);
if ((file_exists($this->filepath) === false) || (is_readable($this->filepath) === false)) {
throw new Exception("{$this->filename} not found, or cannot be read");
}
$filetype ??= pathinfo($filename, PATHINFO_EXTENSION);
if (array_key_exists(strtolower($filetype), self::CONTENT_TYPES) === false) {
throw new Exception("Invalid filetype: {$filetype} cannot be downloaded");
}
$this->filetype = strtolower($filetype);
}
public function download(): void
{
$this->headers();
readfile($this->filepath);
}
public function headers(): void
{
ob_clean();
$this->contentType();
$this->contentDisposition();
$this->cacheHeaders();
$this->fileSize();
flush();
}
protected function contentType(): void
{
header('Content-Type: ' . self::CONTENT_TYPES[$this->filetype]);
}
protected function contentDisposition(): void
{
header('Content-Disposition: attachment;filename="' . $this->filename . '"');
}
protected function cacheHeaders(): void
{
header('Cache-Control: max-age=0');
// If you're serving to IE 9, then the following may be needed
header('Cache-Control: max-age=1');
// If you're serving to IE over SSL, then the following may be needed
header('Expires: Mon, 26 Jul 1997 05:00:00 GMT'); // Date in the past
header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT'); // always modified
header('Cache-Control: cache, must-revalidate'); // HTTP/1.1
header('Pragma: public'); // HTTP/1.0
}
protected function fileSize(): void
{
header('Content-Length: ' . filesize($this->filepath));
}
}

46
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Helper/Handler.php vendored
View File

@ -1,46 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Helper;
class Handler
{
/** @var string */
private static $invalidHex = 'Y';
// A bunch of methods to show that we continue
// to capture messages even using PhpUnit 10.
public static function suppressed(): bool
{
return @trigger_error('hello');
}
public static function deprecated(): string
{
return (string) hexdec(self::$invalidHex);
}
public static function notice(string $value): void
{
date_default_timezone_set($value);
}
public static function warning(): bool
{
return file_get_contents(__FILE__ . 'noexist') !== false;
}
public static function userDeprecated(): bool
{
return trigger_error('hello', E_USER_DEPRECATED);
}
public static function userNotice(): bool
{
return trigger_error('userNotice', E_USER_NOTICE);
}
public static function userWarning(): bool
{
return trigger_error('userWarning', E_USER_WARNING);
}
}

26
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SharedFormula.php vendored
View File

@ -1,26 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
class SharedFormula
{
private string $master;
private string $formula;
public function __construct(string $master, string $formula)
{
$this->master = $master;
$this->formula = $formula;
}
public function master(): string
{
return $this->master;
}
public function formula(): string
{
return $this->formula;
}
}

177
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml/DataValidations.php vendored
View File

@ -1,177 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Reader\Xml;
use PhpOffice\PhpSpreadsheet\Cell\AddressHelper;
use PhpOffice\PhpSpreadsheet\Cell\AddressRange;
use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Namespaces;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use SimpleXMLElement;
class DataValidations
{
private const OPERATOR_MAPPINGS = [
'between' => DataValidation::OPERATOR_BETWEEN,
'equal' => DataValidation::OPERATOR_EQUAL,
'greater' => DataValidation::OPERATOR_GREATERTHAN,
'greaterorequal' => DataValidation::OPERATOR_GREATERTHANOREQUAL,
'less' => DataValidation::OPERATOR_LESSTHAN,
'lessorequal' => DataValidation::OPERATOR_LESSTHANOREQUAL,
'notbetween' => DataValidation::OPERATOR_NOTBETWEEN,
'notequal' => DataValidation::OPERATOR_NOTEQUAL,
];
private const TYPE_MAPPINGS = [
'textlength' => DataValidation::TYPE_TEXTLENGTH,
];
private int $thisRow = 0;
private int $thisColumn = 0;
private function replaceR1C1(array $matches): string
{
return AddressHelper::convertToA1($matches[0], $this->thisRow, $this->thisColumn, false);
}
public function loadDataValidations(SimpleXMLElement $worksheet, Spreadsheet $spreadsheet): void
{
$xmlX = $worksheet->children(Namespaces::URN_EXCEL);
$sheet = $spreadsheet->getActiveSheet();
/** @var callable */
$pregCallback = [$this, 'replaceR1C1'];
foreach ($xmlX->DataValidation as $dataValidation) {
$cells = [];
$validation = new DataValidation();
// set defaults
$validation->setShowDropDown(true);
$validation->setShowInputMessage(true);
$validation->setShowErrorMessage(true);
$validation->setShowDropDown(true);
$this->thisRow = 1;
$this->thisColumn = 1;
foreach ($dataValidation as $tagName => $tagValue) {
$tagValue = (string) $tagValue;
$tagValueLower = strtolower($tagValue);
switch ($tagName) {
case 'Range':
foreach (explode(',', $tagValue) as $range) {
$cell = '';
if (preg_match('/^R(\d+)C(\d+):R(\d+)C(\d+)$/', (string) $range, $selectionMatches) === 1) {
// range
$firstCell = Coordinate::stringFromColumnIndex((int) $selectionMatches[2])
. $selectionMatches[1];
$cell = $firstCell
. ':'
. Coordinate::stringFromColumnIndex((int) $selectionMatches[4])
. $selectionMatches[3];
$this->thisRow = (int) $selectionMatches[1];
$this->thisColumn = (int) $selectionMatches[2];
$sheet->getCell($firstCell);
} elseif (preg_match('/^R(\d+)C(\d+)$/', (string) $range, $selectionMatches) === 1) {
// cell
$cell = Coordinate::stringFromColumnIndex((int) $selectionMatches[2])
. $selectionMatches[1];
$sheet->getCell($cell);
$this->thisRow = (int) $selectionMatches[1];
$this->thisColumn = (int) $selectionMatches[2];
} elseif (preg_match('/^C(\d+)$/', (string) $range, $selectionMatches) === 1) {
// column
$firstCell = Coordinate::stringFromColumnIndex((int) $selectionMatches[1])
. '1';
$cell = $firstCell
. ':'
. Coordinate::stringFromColumnIndex((int) $selectionMatches[1])
. ((string) AddressRange::MAX_ROW);
$this->thisColumn = (int) $selectionMatches[1];
$sheet->getCell($firstCell);
} elseif (preg_match('/^R(\d+)$/', (string) $range, $selectionMatches)) {
// row
$firstCell = 'A'
. $selectionMatches[1];
$cell = $firstCell
. ':'
. AddressRange::MAX_COLUMN
. $selectionMatches[1];
$this->thisRow = (int) $selectionMatches[1];
$sheet->getCell($firstCell);
}
$validation->setSqref($cell);
$stRange = $sheet->shrinkRangeToFit($cell);
$cells = array_merge($cells, Coordinate::extractAllCellReferencesInRange($stRange));
}
break;
case 'Type':
$validation->setType(self::TYPE_MAPPINGS[$tagValueLower] ?? $tagValueLower);
break;
case 'Qualifier':
$validation->setOperator(self::OPERATOR_MAPPINGS[$tagValueLower] ?? $tagValueLower);
break;
case 'InputTitle':
$validation->setPromptTitle($tagValue);
break;
case 'InputMessage':
$validation->setPrompt($tagValue);
break;
case 'InputHide':
$validation->setShowInputMessage(false);
break;
case 'ErrorStyle':
$validation->setErrorStyle($tagValueLower);
break;
case 'ErrorTitle':
$validation->setErrorTitle($tagValue);
break;
case 'ErrorMessage':
$validation->setError($tagValue);
break;
case 'ErrorHide':
$validation->setShowErrorMessage(false);
break;
case 'ComboHide':
$validation->setShowDropDown(false);
break;
case 'UseBlank':
$validation->setAllowBlank(true);
break;
case 'CellRangeList':
// FIXME missing FIXME
break;
case 'Min':
case 'Value':
$tagValue = (string) preg_replace_callback(AddressHelper::R1C1_COORDINATE_REGEX, $pregCallback, $tagValue);
$validation->setFormula1($tagValue);
break;
case 'Max':
$tagValue = (string) preg_replace_callback(AddressHelper::R1C1_COORDINATE_REGEX, $pregCallback, $tagValue);
$validation->setFormula2($tagValue);
break;
}
}
foreach ($cells as $cell) {
$sheet->getCell($cell)->setDataValidation(clone $validation);
}
}
}
}

125
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Date.php vendored
View File

@ -1,125 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
class Date extends DateTimeWizard
{
/**
* Year (4 digits), e.g. 2023.
*/
public const YEAR_FULL = 'yyyy';
/**
* Year (last 2 digits), e.g. 23.
*/
public const YEAR_SHORT = 'yy';
public const MONTH_FIRST_LETTER = 'mmmmm';
/**
* Month name, long form, e.g. January.
*/
public const MONTH_NAME_FULL = 'mmmm';
/**
* Month name, short form, e.g. Jan.
*/
public const MONTH_NAME_SHORT = 'mmm';
/**
* Month number with a leading zero if required, e.g. 01.
*/
public const MONTH_NUMBER_LONG = 'mm';
/**
* Month number without a leading zero, e.g. 1.
*/
public const MONTH_NUMBER_SHORT = 'm';
/**
* Day of the week, full form, e.g. Tuesday.
*/
public const WEEKDAY_NAME_LONG = 'dddd';
/**
* Day of the week, short form, e.g. Tue.
*/
public const WEEKDAY_NAME_SHORT = 'ddd';
/**
* Day number with a leading zero, e.g. 03.
*/
public const DAY_NUMBER_LONG = 'dd';
/**
* Day number without a leading zero, e.g. 3.
*/
public const DAY_NUMBER_SHORT = 'd';
protected const DATE_BLOCKS = [
self::YEAR_FULL,
self::YEAR_SHORT,
self::MONTH_FIRST_LETTER,
self::MONTH_NAME_FULL,
self::MONTH_NAME_SHORT,
self::MONTH_NUMBER_LONG,
self::MONTH_NUMBER_SHORT,
self::WEEKDAY_NAME_LONG,
self::WEEKDAY_NAME_SHORT,
self::DAY_NUMBER_LONG,
self::DAY_NUMBER_SHORT,
];
public const SEPARATOR_DASH = '-';
public const SEPARATOR_DOT = '.';
public const SEPARATOR_SLASH = '/';
public const SEPARATOR_SPACE_NONBREAKING = "\u{a0}";
public const SEPARATOR_SPACE = ' ';
protected const DATE_DEFAULT = [
self::YEAR_FULL,
self::MONTH_NUMBER_LONG,
self::DAY_NUMBER_LONG,
];
/**
* @var string[]
*/
protected array $separators;
/**
* @var string[]
*/
protected array $formatBlocks;
/**
* @param null|string|string[] $separators
* If you want to use the same separator for all format blocks, then it can be passed as a string literal;
* if you wish to use different separators, then they should be passed as an array.
* If you want to use only a single format block, then pass a null as the separator argument
*/
public function __construct($separators = self::SEPARATOR_DASH, string ...$formatBlocks)
{
$separators ??= self::SEPARATOR_DASH;
$formatBlocks = (count($formatBlocks) === 0) ? self::DATE_DEFAULT : $formatBlocks;
$this->separators = $this->padSeparatorArray(
is_array($separators) ? $separators : [$separators],
count($formatBlocks) - 1
);
$this->formatBlocks = array_map([$this, 'mapFormatBlocks'], $formatBlocks);
}
private function mapFormatBlocks(string $value): string
{
// Any date masking codes are returned as lower case values
if (in_array(mb_strtolower($value), self::DATE_BLOCKS, true)) {
return mb_strtolower($value);
}
// Wrap any string literals in quotes, so that they're clearly defined as string literals
return $this->wrapLiteral($value);
}
public function format(): string
{
return implode('', array_map([$this, 'intersperse'], $this->formatBlocks, $this->separators));
}
}

50
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/NumberFormat/Wizard/DateTime.php vendored
View File

@ -1,50 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
class DateTime extends DateTimeWizard
{
/**
* @var string[]
*/
protected array $separators;
/**
* @var array<DateTimeWizard|string>
*/
protected array $formatBlocks;
/**
* @param null|string|string[] $separators
* If you want to use only a single format block, then pass a null as the separator argument
* @param DateTimeWizard|string ...$formatBlocks
*/
public function __construct($separators, ...$formatBlocks)
{
$this->separators = $this->padSeparatorArray(
is_array($separators) ? $separators : [$separators],
count($formatBlocks) - 1
);
$this->formatBlocks = array_map([$this, 'mapFormatBlocks'], $formatBlocks);
}
/**
* @param DateTimeWizard|string $value
*/
private function mapFormatBlocks($value): string
{
// Any date masking codes are returned as lower case values
if (is_object($value)) {
// We can't explicitly test for Stringable until PHP >= 8.0
return $value;
}
// Wrap any string literals in quotes, so that they're clearly defined as string literals
return $this->wrapLiteral($value);
}
public function format(): string
{
return implode('', array_map([$this, 'intersperse'], $this->formatBlocks, $this->separators));
}
}

44
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/NumberFormat/Wizard/DateTimeWizard.php vendored
View File

@ -1,44 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
abstract class DateTimeWizard implements Wizard
{
protected const NO_ESCAPING_NEEDED = "$+-/():!^&'~{}<>= ";
protected function padSeparatorArray(array $separators, int $count): array
{
$lastSeparator = array_pop($separators);
return $separators + array_fill(0, $count, $lastSeparator);
}
protected function escapeSingleCharacter(string $value): string
{
if (strpos(self::NO_ESCAPING_NEEDED, $value) !== false) {
return $value;
}
return "\\{$value}";
}
protected function wrapLiteral(string $value): string
{
if (mb_strlen($value, 'UTF-8') === 1) {
return $this->escapeSingleCharacter($value);
}
// Wrap any other string literals in quotes, so that they're clearly defined as string literals
return '"' . str_replace('"', '""', $value) . '"';
}
protected function intersperse(string $formatBlock, ?string $separator): string
{
return "{$formatBlock}{$separator}";
}
public function __toString(): string
{
return $this->format();
}
}

153
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Duration.php vendored
View File

@ -1,153 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
class Duration extends DateTimeWizard
{
public const DAYS_DURATION = 'd';
/**
* Hours as a duration (can exceed 24), e.g. 29.
*/
public const HOURS_DURATION = '[h]';
/**
* Hours without a leading zero, e.g. 9.
*/
public const HOURS_SHORT = 'h';
/**
* Hours with a leading zero, e.g. 09.
*/
public const HOURS_LONG = 'hh';
/**
* Minutes as a duration (can exceed 60), e.g. 109.
*/
public const MINUTES_DURATION = '[m]';
/**
* Minutes without a leading zero, e.g. 5.
*/
public const MINUTES_SHORT = 'm';
/**
* Minutes with a leading zero, e.g. 05.
*/
public const MINUTES_LONG = 'mm';
/**
* Seconds as a duration (can exceed 60), e.g. 129.
*/
public const SECONDS_DURATION = '[s]';
/**
* Seconds without a leading zero, e.g. 2.
*/
public const SECONDS_SHORT = 's';
/**
* Seconds with a leading zero, e.g. 02.
*/
public const SECONDS_LONG = 'ss';
protected const DURATION_BLOCKS = [
self::DAYS_DURATION,
self::HOURS_DURATION,
self::HOURS_LONG,
self::HOURS_SHORT,
self::MINUTES_DURATION,
self::MINUTES_LONG,
self::MINUTES_SHORT,
self::SECONDS_DURATION,
self::SECONDS_LONG,
self::SECONDS_SHORT,
];
protected const DURATION_MASKS = [
self::DAYS_DURATION => self::DAYS_DURATION,
self::HOURS_DURATION => self::HOURS_SHORT,
self::MINUTES_DURATION => self::MINUTES_LONG,
self::SECONDS_DURATION => self::SECONDS_LONG,
];
protected const DURATION_DEFAULTS = [
self::HOURS_LONG => self::HOURS_DURATION,
self::HOURS_SHORT => self::HOURS_DURATION,
self::MINUTES_LONG => self::MINUTES_DURATION,
self::MINUTES_SHORT => self::MINUTES_DURATION,
self::SECONDS_LONG => self::SECONDS_DURATION,
self::SECONDS_SHORT => self::SECONDS_DURATION,
];
public const SEPARATOR_COLON = ':';
public const SEPARATOR_SPACE_NONBREAKING = "\u{a0}";
public const SEPARATOR_SPACE = ' ';
public const DURATION_DEFAULT = [
self::HOURS_DURATION,
self::MINUTES_LONG,
self::SECONDS_LONG,
];
/**
* @var string[]
*/
protected array $separators;
/**
* @var string[]
*/
protected array $formatBlocks;
protected bool $durationIsSet = false;
/**
* @param null|string|string[] $separators
* If you want to use the same separator for all format blocks, then it can be passed as a string literal;
* if you wish to use different separators, then they should be passed as an array.
* If you want to use only a single format block, then pass a null as the separator argument
*/
public function __construct($separators = self::SEPARATOR_COLON, string ...$formatBlocks)
{
$separators ??= self::SEPARATOR_COLON;
$formatBlocks = (count($formatBlocks) === 0) ? self::DURATION_DEFAULT : $formatBlocks;
$this->separators = $this->padSeparatorArray(
is_array($separators) ? $separators : [$separators],
count($formatBlocks) - 1
);
$this->formatBlocks = array_map([$this, 'mapFormatBlocks'], $formatBlocks);
if ($this->durationIsSet === false) {
// We need at least one duration mask, so if none has been set we change the first mask element
// to a duration.
$this->formatBlocks[0] = self::DURATION_DEFAULTS[mb_strtolower($this->formatBlocks[0])];
}
}
private function mapFormatBlocks(string $value): string
{
// Any duration masking codes are returned as lower case values
if (in_array(mb_strtolower($value), self::DURATION_BLOCKS, true)) {
if (array_key_exists(mb_strtolower($value), self::DURATION_MASKS)) {
if ($this->durationIsSet) {
// We should only have a single duration mask, the first defined in the mask set,
// so convert any additional duration masks to standard time masks.
$value = self::DURATION_MASKS[mb_strtolower($value)];
}
$this->durationIsSet = true;
}
return mb_strtolower($value);
}
// Wrap any string literals in quotes, so that they're clearly defined as string literals
return $this->wrapLiteral($value);
}
public function format(): string
{
return implode('', array_map([$this, 'intersperse'], $this->formatBlocks, $this->separators));
}
}

105
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/NumberFormat/Wizard/Time.php vendored
View File

@ -1,105 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style\NumberFormat\Wizard;
class Time extends DateTimeWizard
{
/**
* Hours without a leading zero, e.g. 9.
*/
public const HOURS_SHORT = 'h';
/**
* Hours with a leading zero, e.g. 09.
*/
public const HOURS_LONG = 'hh';
/**
* Minutes without a leading zero, e.g. 5.
*/
public const MINUTES_SHORT = 'm';
/**
* Minutes with a leading zero, e.g. 05.
*/
public const MINUTES_LONG = 'mm';
/**
* Seconds without a leading zero, e.g. 2.
*/
public const SECONDS_SHORT = 's';
/**
* Seconds with a leading zero, e.g. 02.
*/
public const SECONDS_LONG = 'ss';
public const MORNING_AFTERNOON = 'AM/PM';
protected const TIME_BLOCKS = [
self::HOURS_LONG,
self::HOURS_SHORT,
self::MINUTES_LONG,
self::MINUTES_SHORT,
self::SECONDS_LONG,
self::SECONDS_SHORT,
self::MORNING_AFTERNOON,
];
public const SEPARATOR_COLON = ':';
public const SEPARATOR_SPACE_NONBREAKING = "\u{a0}";
public const SEPARATOR_SPACE = ' ';
protected const TIME_DEFAULT = [
self::HOURS_LONG,
self::MINUTES_LONG,
self::SECONDS_LONG,
];
/**
* @var string[]
*/
protected array $separators;
/**
* @var string[]
*/
protected array $formatBlocks;
/**
* @param null|string|string[] $separators
* If you want to use the same separator for all format blocks, then it can be passed as a string literal;
* if you wish to use different separators, then they should be passed as an array.
* If you want to use only a single format block, then pass a null as the separator argument
*/
public function __construct($separators = self::SEPARATOR_COLON, string ...$formatBlocks)
{
$separators ??= self::SEPARATOR_COLON;
$formatBlocks = (count($formatBlocks) === 0) ? self::TIME_DEFAULT : $formatBlocks;
$this->separators = $this->padSeparatorArray(
is_array($separators) ? $separators : [$separators],
count($formatBlocks) - 1
);
$this->formatBlocks = array_map([$this, 'mapFormatBlocks'], $formatBlocks);
}
private function mapFormatBlocks(string $value): string
{
// Any date masking codes are returned as lower case values
// except for AM/PM, which is set to uppercase
if (in_array(mb_strtolower($value), self::TIME_BLOCKS, true)) {
return mb_strtolower($value);
} elseif (mb_strtoupper($value) === self::MORNING_AFTERNOON) {
return mb_strtoupper($value);
}
// Wrap any string literals in quotes, so that they're clearly defined as string literals
return $this->wrapLiteral($value);
}
public function format(): string
{
return implode('', array_map([$this, 'intersperse'], $this->formatBlocks, $this->separators));
}
}

175
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Style/RgbTint.php vendored
View File

@ -1,175 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Style;
/**
* Class to handle tint applied to color.
* Code borrows heavily from some Python projects.
*
* @see https://docs.python.org/3/library/colorsys.html
* @see https://gist.github.com/Mike-Honey/b36e651e9a7f1d2e1d60ce1c63b9b633
*/
class RgbTint
{
private const ONE_THIRD = 1.0 / 3.0;
private const ONE_SIXTH = 1.0 / 6.0;
private const TWO_THIRD = 2.0 / 3.0;
private const RGBMAX = 255.0;
/**
* MS excel's tint function expects that HLS is base 240.
*
* @see https://social.msdn.microsoft.com/Forums/en-US/e9d8c136-6d62-4098-9b1b-dac786149f43/excel-color-tint-algorithm-incorrect?forum=os_binaryfile#d3c2ac95-52e0-476b-86f1-e2a697f24969
*/
private const HLSMAX = 240.0;
/**
* Convert red/green/blue to hue/luminance/saturation.
*
* @param float $red 0.0 through 1.0
* @param float $green 0.0 through 1.0
* @param float $blue 0.0 through 1.0
*
* @return float[]
*/
private static function rgbToHls(float $red, float $green, float $blue): array
{
$maxc = max($red, $green, $blue);
$minc = min($red, $green, $blue);
$luminance = ($minc + $maxc) / 2.0;
if ($minc === $maxc) {
return [0.0, $luminance, 0.0];
}
$maxMinusMin = $maxc - $minc;
if ($luminance <= 0.5) {
$s = $maxMinusMin / ($maxc + $minc);
} else {
$s = $maxMinusMin / (2.0 - $maxc - $minc);
}
$rc = ($maxc - $red) / $maxMinusMin;
$gc = ($maxc - $green) / $maxMinusMin;
$bc = ($maxc - $blue) / $maxMinusMin;
if ($red === $maxc) {
$h = $bc - $gc;
} elseif ($green === $maxc) {
$h = 2.0 + $rc - $bc;
} else {
$h = 4.0 + $gc - $rc;
}
$h = self::positiveDecimalPart($h / 6.0);
return [$h, $luminance, $s];
}
/** @var mixed */
private static $scrutinizerZeroPointZero = 0.0;
/**
* Convert hue/luminance/saturation to red/green/blue.
*
* @param float $hue 0.0 through 1.0
* @param float $luminance 0.0 through 1.0
* @param float $saturation 0.0 through 1.0
*
* @return float[]
*/
private static function hlsToRgb($hue, $luminance, $saturation): array
{
if ($saturation === self::$scrutinizerZeroPointZero) {
return [$luminance, $luminance, $luminance];
}
if ($luminance <= 0.5) {
$m2 = $luminance * (1.0 + $saturation);
} else {
$m2 = $luminance + $saturation - ($luminance * $saturation);
}
$m1 = 2.0 * $luminance - $m2;
return [
self::vFunction($m1, $m2, $hue + self::ONE_THIRD),
self::vFunction($m1, $m2, $hue),
self::vFunction($m1, $m2, $hue - self::ONE_THIRD),
];
}
private static function vFunction(float $m1, float $m2, float $hue): float
{
$hue = self::positiveDecimalPart($hue);
if ($hue < self::ONE_SIXTH) {
return $m1 + ($m2 - $m1) * $hue * 6.0;
}
if ($hue < 0.5) {
return $m2;
}
if ($hue < self::TWO_THIRD) {
return $m1 + ($m2 - $m1) * (self::TWO_THIRD - $hue) * 6.0;
}
return $m1;
}
private static function positiveDecimalPart(float $hue): float
{
$hue = fmod($hue, 1.0);
return ($hue >= 0.0) ? $hue : (1.0 + $hue);
}
/**
* Convert red/green/blue to HLSMAX-based hue/luminance/saturation.
*
* @return int[]
*/
private static function rgbToMsHls(int $red, int $green, int $blue): array
{
$red01 = $red / self::RGBMAX;
$green01 = $green / self::RGBMAX;
$blue01 = $blue / self::RGBMAX;
[$hue, $luminance, $saturation] = self::rgbToHls($red01, $green01, $blue01);
return [
(int) round($hue * self::HLSMAX),
(int) round($luminance * self::HLSMAX),
(int) round($saturation * self::HLSMAX),
];
}
/**
* Converts HLSMAX based HLS values to rgb values in the range (0,1).
*
* @return float[]
*/
private static function msHlsToRgb(int $hue, int $lightness, int $saturation): array
{
return self::hlsToRgb($hue / self::HLSMAX, $lightness / self::HLSMAX, $saturation / self::HLSMAX);
}
/**
* Tints HLSMAX based luminance.
*
* @see http://ciintelligence.blogspot.co.uk/2012/02/converting-excel-theme-color-and-tint.html
*/
private static function tintLuminance(float $tint, float $luminance): int
{
if ($tint < 0) {
return (int) round($luminance * (1.0 + $tint));
}
return (int) round($luminance * (1.0 - $tint) + (self::HLSMAX - self::HLSMAX * (1.0 - $tint)));
}
/**
* Return result of tinting supplied rgb as 6 hex digits.
*/
public static function rgbAndTintToRgb(int $red, int $green, int $blue, float $tint): string
{
[$hue, $luminance, $saturation] = self::rgbToMsHls($red, $green, $blue);
[$red, $green, $blue] = self::msHlsToRgb($hue, self::tintLuminance($tint, $luminance), $saturation);
return sprintf(
'%02X%02X%02X',
(int) round($red * self::RGBMAX),
(int) round($green * self::RGBMAX),
(int) round($blue * self::RGBMAX)
);
}
}

269
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Theme.php vendored
View File

@ -1,269 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet;
class Theme
{
/** @var string */
private $themeColorName = 'Office';
/** @var string */
private $themeFontName = 'Office';
public const COLOR_SCHEME_2013_PLUS_NAME = 'Office 2013+';
public const COLOR_SCHEME_2013_PLUS = [
'dk1' => '000000',
'lt1' => 'FFFFFF',
'dk2' => '44546A',
'lt2' => 'E7E6E6',
'accent1' => '4472C4',
'accent2' => 'ED7D31',
'accent3' => 'A5A5A5',
'accent4' => 'FFC000',
'accent5' => '5B9BD5',
'accent6' => '70AD47',
'hlink' => '0563C1',
'folHlink' => '954F72',
];
public const COLOR_SCHEME_2007_2010_NAME = 'Office 2007-2010';
public const COLOR_SCHEME_2007_2010 = [
'dk1' => '000000',
'lt1' => 'FFFFFF',
'dk2' => '1F497D',
'lt2' => 'EEECE1',
'accent1' => '4F81BD',
'accent2' => 'C0504D',
'accent3' => '9BBB59',
'accent4' => '8064A2',
'accent5' => '4BACC6',
'accent6' => 'F79646',
'hlink' => '0000FF',
'folHlink' => '800080',
];
/** @var string[] */
private $themeColors = self::COLOR_SCHEME_2007_2010;
/** @var string */
private $majorFontLatin = 'Cambria';
/** @var string */
private $majorFontEastAsian = '';
/** @var string */
private $majorFontComplexScript = '';
/** @var string */
private $minorFontLatin = 'Calibri';
/** @var string */
private $minorFontEastAsian = '';
/** @var string */
private $minorFontComplexScript = '';
/**
* Map of Major (header) fonts to write.
*
* @var string[]
*/
private $majorFontSubstitutions = self::FONTS_TIMES_SUBSTITUTIONS;
/**
* Map of Minor (body) fonts to write.
*
* @var string[]
*/
private $minorFontSubstitutions = self::FONTS_ARIAL_SUBSTITUTIONS;
public const FONTS_TIMES_SUBSTITUTIONS = [
'Jpan' => 'ＭＳ Ｐゴシック',
'Hang' => '맑은 고딕',
'Hans' => '宋体',
'Hant' => '新細明體',
'Arab' => 'Times New Roman',
'Hebr' => 'Times New Roman',
'Thai' => 'Tahoma',
'Ethi' => 'Nyala',
'Beng' => 'Vrinda',
'Gujr' => 'Shruti',
'Khmr' => 'MoolBoran',
'Knda' => 'Tunga',
'Guru' => 'Raavi',
'Cans' => 'Euphemia',
'Cher' => 'Plantagenet Cherokee',
'Yiii' => 'Microsoft Yi Baiti',
'Tibt' => 'Microsoft Himalaya',
'Thaa' => 'MV Boli',
'Deva' => 'Mangal',
'Telu' => 'Gautami',
'Taml' => 'Latha',
'Syrc' => 'Estrangelo Edessa',
'Orya' => 'Kalinga',
'Mlym' => 'Kartika',
'Laoo' => 'DokChampa',
'Sinh' => 'Iskoola Pota',
'Mong' => 'Mongolian Baiti',
'Viet' => 'Times New Roman',
'Uigh' => 'Microsoft Uighur',
'Geor' => 'Sylfaen',
];
public const FONTS_ARIAL_SUBSTITUTIONS = [
'Jpan' => 'ＭＳ Ｐゴシック',
'Hang' => '맑은 고딕',
'Hans' => '宋体',
'Hant' => '新細明體',
'Arab' => 'Arial',
'Hebr' => 'Arial',
'Thai' => 'Tahoma',
'Ethi' => 'Nyala',
'Beng' => 'Vrinda',
'Gujr' => 'Shruti',
'Khmr' => 'DaunPenh',
'Knda' => 'Tunga',
'Guru' => 'Raavi',
'Cans' => 'Euphemia',
'Cher' => 'Plantagenet Cherokee',
'Yiii' => 'Microsoft Yi Baiti',
'Tibt' => 'Microsoft Himalaya',
'Thaa' => 'MV Boli',
'Deva' => 'Mangal',
'Telu' => 'Gautami',
'Taml' => 'Latha',
'Syrc' => 'Estrangelo Edessa',
'Orya' => 'Kalinga',
'Mlym' => 'Kartika',
'Laoo' => 'DokChampa',
'Sinh' => 'Iskoola Pota',
'Mong' => 'Mongolian Baiti',
'Viet' => 'Arial',
'Uigh' => 'Microsoft Uighur',
'Geor' => 'Sylfaen',
];
public function getThemeColors(): array
{
return $this->themeColors;
}
public function setThemeColor(string $key, string $value): self
{
$this->themeColors[$key] = $value;
return $this;
}
public function getThemeColorName(): string
{
return $this->themeColorName;
}
public function setThemeColorName(string $name, ?array $themeColors = null): self
{
$this->themeColorName = $name;
if ($name === self::COLOR_SCHEME_2007_2010_NAME) {
$themeColors = $themeColors ?? self::COLOR_SCHEME_2007_2010;
} elseif ($name === self::COLOR_SCHEME_2013_PLUS_NAME) {
$themeColors = $themeColors ?? self::COLOR_SCHEME_2013_PLUS;
}
if ($themeColors !== null) {
$this->themeColors = $themeColors;
}
return $this;
}
public function getMajorFontLatin(): string
{
return $this->majorFontLatin;
}
public function getMajorFontEastAsian(): string
{
return $this->majorFontEastAsian;
}
public function getMajorFontComplexScript(): string
{
return $this->majorFontComplexScript;
}
public function getMajorFontSubstitutions(): array
{
return $this->majorFontSubstitutions;
}
/** @param null|array $substitutions */
public function setMajorFontValues(?string $latin, ?string $eastAsian, ?string $complexScript, $substitutions): self
{
if (!empty($latin)) {
$this->majorFontLatin = $latin;
}
if ($eastAsian !== null) {
$this->majorFontEastAsian = $eastAsian;
}
if ($complexScript !== null) {
$this->majorFontComplexScript = $complexScript;
}
if ($substitutions !== null) {
$this->majorFontSubstitutions = $substitutions;
}
return $this;
}
public function getMinorFontLatin(): string
{
return $this->minorFontLatin;
}
public function getMinorFontEastAsian(): string
{
return $this->minorFontEastAsian;
}
public function getMinorFontComplexScript(): string
{
return $this->minorFontComplexScript;
}
public function getMinorFontSubstitutions(): array
{
return $this->minorFontSubstitutions;
}
/** @param null|array $substitutions */
public function setMinorFontValues(?string $latin, ?string $eastAsian, ?string $complexScript, $substitutions): self
{
if (!empty($latin)) {
$this->minorFontLatin = $latin;
}
if ($eastAsian !== null) {
$this->minorFontEastAsian = $eastAsian;
}
if ($complexScript !== null) {
$this->minorFontComplexScript = $complexScript;
}
if ($substitutions !== null) {
$this->minorFontSubstitutions = $substitutions;
}
return $this;
}
public function getThemeFontName(): string
{
return $this->themeFontName;
}
public function setThemeFontName(?string $name): self
{
if (!empty($name)) {
$this->themeFontName = $name;
}
return $this;
}
}

17
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Writer/ZipStream0.php vendored
View File

@ -1,17 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Writer;
use ZipStream\Option\Archive;
use ZipStream\ZipStream;
class ZipStream0
{
/**
* @param resource $fileHandle
*/
public static function newZipStream($fileHandle): ZipStream
{
return class_exists(Archive::class) ? ZipStream2::newZipStream($fileHandle) : ZipStream3::newZipStream($fileHandle);
}
}

21
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Writer/ZipStream2.php vendored
View File

@ -1,21 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Writer;
use ZipStream\Option\Archive;
use ZipStream\ZipStream;
class ZipStream2
{
/**
* @param resource $fileHandle
*/
public static function newZipStream($fileHandle): ZipStream
{
$options = new Archive();
$options->setEnableZip64(false);
$options->setOutputStream($fileHandle);
return new ZipStream(null, $options);
}
}

22
vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Writer/ZipStream3.php vendored
View File

@ -1,22 +0,0 @@
<?php
namespace PhpOffice\PhpSpreadsheet\Writer;
use ZipStream\Option\Archive;
use ZipStream\ZipStream;
class ZipStream3
{
/**
* @param resource $fileHandle
*/
public static function newZipStream($fileHandle): ZipStream
{
return new ZipStream(
enableZip64: false,
outputStream: $fileHandle,
sendHttpHeaders: false,
defaultEnableZeroHeader: false,
);
}
}

45
vendor/symfony/mime/DraftEmail.php vendored
View File

@ -1,45 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime;
use Symfony\Component\Mime\Header\Headers;
use Symfony\Component\Mime\Part\AbstractPart;
/**
* @author Kevin Bond <kevinbond@gmail.com>
*/
class DraftEmail extends Email
{
public function __construct(Headers $headers = null, AbstractPart $body = null)
{
parent::__construct($headers, $body);
$this->getHeaders()->addTextHeader('X-Unsent', '1');
}
/**
* Override default behavior as draft emails do not require From/Sender/Date/Message-ID headers.
* These are added by the client that actually sends the email.
*/
public function getPreparedHeaders(): Headers
{
$headers = clone $this->getHeaders();
if (!$headers->has('MIME-Version')) {
$headers->addTextHeader('MIME-Version', '1.0');
}
$headers->remove('Bcc');
return $headers;
}
}

23
vendor/symfony/mime/HtmlToTextConverter/DefaultHtmlToTextConverter.php vendored
View File

@ -1,23 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\HtmlToTextConverter;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
class DefaultHtmlToTextConverter implements HtmlToTextConverterInterface
{
public function convert(string $html, string $charset): string
{
return strip_tags(preg_replace('{<(head|style)\b.*?</\1>}is', '', $html));
}
}

25
vendor/symfony/mime/HtmlToTextConverter/HtmlToTextConverterInterface.php vendored
View File

@ -1,25 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\HtmlToTextConverter;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
interface HtmlToTextConverterInterface
{
/**
* Converts an HTML representation of a Message to a text representation.
*
* The output must use the same charset as the HTML one.
*/
public function convert(string $html, string $charset): string;
}

35
vendor/symfony/mime/HtmlToTextConverter/LeagueHtmlToMarkdownConverter.php vendored
View File

@ -1,35 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\HtmlToTextConverter;
use League\HTMLToMarkdown\HtmlConverter;
use League\HTMLToMarkdown\HtmlConverterInterface;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
class LeagueHtmlToMarkdownConverter implements HtmlToTextConverterInterface
{
public function __construct(
private HtmlConverterInterface $converter = new HtmlConverter([
'hard_break' => true,
'strip_tags' => true,
'remove_nodes' => 'head style',
]),
) {
}
public function convert(string $html, string $charset): string
{
return $this->converter->convert($html);
}
}

51
vendor/symfony/mime/Part/File.php vendored
View File

@ -1,51 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Mime\Part;
use Symfony\Component\Mime\MimeTypes;
/**
* @author Fabien Potencier <fabien@symfony.com>
*/
class File
{
private static $mimeTypes;
public function __construct(
private string $path,
private ?string $filename = null,
) {
}
public function getPath(): string
{
return $this->path;
}
public function getContentType(): string
{
$ext = strtolower(pathinfo($this->path, \PATHINFO_EXTENSION));
self::$mimeTypes ??= new MimeTypes();
return self::$mimeTypes->getMimeTypes($ext)[0] ?? 'application/octet-stream';
}
public function getSize(): int
{
return filesize($this->path);
}
public function getFilename(): string
{
return $this->filename ??= basename($this->getPath());
}
}

48
vendor/symfony/translation/CatalogueMetadataAwareInterface.php vendored
View File

@ -1,48 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation;
/**
* This interface is used to get, set, and delete metadata about the Catalogue.
*
* @author Hugo Alliaume <hugo@alliau.me>
*/
interface CatalogueMetadataAwareInterface
{
/**
* Gets catalogue metadata for the given domain and key.
*
* Passing an empty domain will return an array with all catalogue metadata indexed by
* domain and then by key. Passing an empty key will return an array with all
* catalogue metadata for the given domain.
*
* @return mixed The value that was set or an array with the domains/keys or null
*/
public function getCatalogueMetadata(string $key = '', string $domain = 'messages'): mixed;
/**
* Adds catalogue metadata to a message domain.
*
* @return void
*/
public function setCatalogueMetadata(string $key, mixed $value, string $domain = 'messages');
/**
* Deletes catalogue metadata for the given key and domain.
*
* Passing an empty domain will delete all catalogue metadata. Passing an empty key will
* delete all metadata for the given domain.
*
* @return void
*/
public function deleteCatalogueMetadata(string $key = '', string $domain = 'messages');
}

80
vendor/symfony/translation/Extractor/PhpAstExtractor.php vendored
View File

@ -1,80 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation\Extractor;
use PhpParser\NodeTraverser;
use PhpParser\NodeVisitor;
use PhpParser\Parser;
use PhpParser\ParserFactory;
use Symfony\Component\Finder\Finder;
use Symfony\Component\Translation\Extractor\Visitor\AbstractVisitor;
use Symfony\Component\Translation\MessageCatalogue;
/**
* PhpAstExtractor extracts translation messages from a PHP AST.
*
* @author Mathieu Santostefano <msantostefano@protonmail.com>
*/
final class PhpAstExtractor extends AbstractFileExtractor implements ExtractorInterface
{
private Parser $parser;
public function __construct(
/**
* @param iterable<AbstractVisitor&NodeVisitor> $visitors
*/
private readonly iterable $visitors,
private string $prefix = '',
) {
if (!class_exists(ParserFactory::class)) {
throw new \LogicException(sprintf('You cannot use "%s" as the "nikic/php-parser" package is not installed. Try running "composer require nikic/php-parser".', static::class));
}
$this->parser = (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
}
public function extract(iterable|string $resource, MessageCatalogue $catalogue): void
{
foreach ($this->extractFiles($resource) as $file) {
$traverser = new NodeTraverser();
/** @var AbstractVisitor&NodeVisitor $visitor */
foreach ($this->visitors as $visitor) {
$visitor->initialize($catalogue, $file, $this->prefix);
$traverser->addVisitor($visitor);
}
$nodes = $this->parser->parse(file_get_contents($file));
$traverser->traverse($nodes);
}
}
public function setPrefix(string $prefix): void
{
$this->prefix = $prefix;
}
protected function canBeExtracted(string $file): bool
{
return 'php' === pathinfo($file, \PATHINFO_EXTENSION)
&& $this->isFile($file)
&& preg_match('/\bt\(|->trans\(|TranslatableMessage|Symfony\\\\Component\\\\Validator\\\\Constraints/i', file_get_contents($file));
}
protected function extractFromDirectory(array|string $resource): iterable|Finder
{
if (!class_exists(Finder::class)) {
throw new \LogicException(sprintf('You cannot use "%s" as the "symfony/finder" package is not installed. Try running "composer require symfony/finder".', static::class));
}
return (new Finder())->files()->name('*.php')->in($resource);
}
}

124
vendor/symfony/translation/Extractor/Visitor/AbstractVisitor.php vendored
View File

@ -1,124 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation\Extractor\Visitor;
use PhpParser\Node;
use Symfony\Component\Translation\MessageCatalogue;
/**
* @author Mathieu Santostefano <msantostefano@protonmail.com>
*/
abstract class AbstractVisitor
{
private MessageCatalogue $catalogue;
private \SplFileInfo $file;
private string $messagePrefix;
public function initialize(MessageCatalogue $catalogue, \SplFileInfo $file, string $messagePrefix): void
{
$this->catalogue = $catalogue;
$this->file = $file;
$this->messagePrefix = $messagePrefix;
}
protected function addMessageToCatalogue(string $message, ?string $domain, int $line): void
{
$domain ??= 'messages';
$this->catalogue->set($message, $this->messagePrefix.$message, $domain);
$metadata = $this->catalogue->getMetadata($message, $domain) ?? [];
$normalizedFilename = preg_replace('{[\\\\/]+}', '/', $this->file);
$metadata['sources'][] = $normalizedFilename.':'.$line;
$this->catalogue->setMetadata($message, $metadata, $domain);
}
protected function getStringArguments(Node\Expr\CallLike|Node\Attribute|Node\Expr\New_ $node, int|string $index, bool $indexIsRegex = false): array
{
if (\is_string($index)) {
return $this->getStringNamedArguments($node, $index, $indexIsRegex);
}
$args = $node instanceof Node\Expr\CallLike ? $node->getRawArgs() : $node->args;
if (!($arg = $args[$index] ?? null) instanceof Node\Arg) {
return [];
}
return (array) $this->getStringValue($arg->value);
}
protected function hasNodeNamedArguments(Node\Expr\CallLike|Node\Attribute|Node\Expr\New_ $node): bool
{
$args = $node instanceof Node\Expr\CallLike ? $node->getRawArgs() : $node->args;
foreach ($args as $arg) {
if ($arg instanceof Node\Arg && null !== $arg->name) {
return true;
}
}
return false;
}
protected function nodeFirstNamedArgumentIndex(Node\Expr\CallLike|Node\Attribute|Node\Expr\New_ $node): int
{
$args = $node instanceof Node\Expr\CallLike ? $node->getRawArgs() : $node->args;
foreach ($args as $i => $arg) {
if ($arg instanceof Node\Arg && null !== $arg->name) {
return $i;
}
}
return \PHP_INT_MAX;
}
private function getStringNamedArguments(Node\Expr\CallLike|Node\Attribute $node, string $argumentName = null, bool $isArgumentNamePattern = false): array
{
$args = $node instanceof Node\Expr\CallLike ? $node->getArgs() : $node->args;
$argumentValues = [];
foreach ($args as $arg) {
if (!$isArgumentNamePattern && $arg->name?->toString() === $argumentName) {
$argumentValues[] = $this->getStringValue($arg->value);
} elseif ($isArgumentNamePattern && preg_match($argumentName, $arg->name?->toString() ?? '') > 0) {
$argumentValues[] = $this->getStringValue($arg->value);
}
}
return array_filter($argumentValues);
}
private function getStringValue(Node $node): ?string
{
if ($node instanceof Node\Scalar\String_) {
return $node->value;
}
if ($node instanceof Node\Expr\BinaryOp\Concat) {
if (null === $left = $this->getStringValue($node->left)) {
return null;
}
if (null === $right = $this->getStringValue($node->right)) {
return null;
}
return $left.$right;
}
if ($node instanceof Node\Expr\Assign && $node->expr instanceof Node\Scalar\String_) {
return $node->expr->value;
}
return null;
}
}

112
vendor/symfony/translation/Extractor/Visitor/ConstraintVisitor.php vendored
View File

@ -1,112 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation\Extractor\Visitor;
use PhpParser\Node;
use PhpParser\NodeVisitor;
/**
* @author Mathieu Santostefano <msantostefano@protonmail.com>
*
* Code mostly comes from https://github.com/php-translation/extractor/blob/master/src/Visitor/Php/Symfony/Constraint.php
*/
final class ConstraintVisitor extends AbstractVisitor implements NodeVisitor
{
public function __construct(
private readonly array $constraintClassNames = []
) {
}
public function beforeTraverse(array $nodes): ?Node
{
return null;
}
public function enterNode(Node $node): ?Node
{
if (!$node instanceof Node\Expr\New_ && !$node instanceof Node\Attribute) {
return null;
}
$className = $node instanceof Node\Attribute ? $node->name : $node->class;
if (!$className instanceof Node\Name) {
return null;
}
$parts = $className->parts;
$isConstraintClass = false;
foreach ($parts as $part) {
if (\in_array($part, $this->constraintClassNames, true)) {
$isConstraintClass = true;
break;
}
}
if (!$isConstraintClass) {
return null;
}
$arg = $node->args[0] ?? null;
if (!$arg instanceof Node\Arg) {
return null;
}
if ($this->hasNodeNamedArguments($node)) {
$messages = $this->getStringArguments($node, '/message/i', true);
} else {
if (!$arg->value instanceof Node\Expr\Array_) {
// There is no way to guess which argument is a message to be translated.
return null;
}
$messages = [];
$options = $arg->value;
/** @var Node\Expr\ArrayItem $item */
foreach ($options->items as $item) {
if (!$item->key instanceof Node\Scalar\String_) {
continue;
}
if (false === stripos($item->key->value ?? '', 'message')) {
continue;
}
if (!$item->value instanceof Node\Scalar\String_) {
continue;
}
$messages[] = $item->value->value;
break;
}
}
foreach ($messages as $message) {
$this->addMessageToCatalogue($message, 'validators', $node->getStartLine());
}
return null;
}
public function leaveNode(Node $node): ?Node
{
return null;
}
public function afterTraverse(array $nodes): ?Node
{
return null;
}
}

65
vendor/symfony/translation/Extractor/Visitor/TransMethodVisitor.php vendored
View File

@ -1,65 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation\Extractor\Visitor;
use PhpParser\Node;
use PhpParser\NodeVisitor;
/**
* @author Mathieu Santostefano <msantostefano@protonmail.com>
*/
final class TransMethodVisitor extends AbstractVisitor implements NodeVisitor
{
public function beforeTraverse(array $nodes): ?Node
{
return null;
}
public function enterNode(Node $node): ?Node
{
if (!$node instanceof Node\Expr\MethodCall && !$node instanceof Node\Expr\FuncCall) {
return null;
}
if (!\is_string($node->name) && !$node->name instanceof Node\Identifier && !$node->name instanceof Node\Name) {
return null;
}
$name = (string) $node->name;
if ('trans' === $name || 't' === $name) {
$firstNamedArgumentIndex = $this->nodeFirstNamedArgumentIndex($node);
if (!$messages = $this->getStringArguments($node, 0 < $firstNamedArgumentIndex ? 0 : 'message')) {
return null;
}
$domain = $this->getStringArguments($node, 2 < $firstNamedArgumentIndex ? 2 : 'domain')[0] ?? null;
foreach ($messages as $message) {
$this->addMessageToCatalogue($message, $domain, $node->getStartLine());
}
}
return null;
}
public function leaveNode(Node $node): ?Node
{
return null;
}
public function afterTraverse(array $nodes): ?Node
{
return null;
}
}

65
vendor/symfony/translation/Extractor/Visitor/TranslatableMessageVisitor.php vendored
View File

@ -1,65 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation\Extractor\Visitor;
use PhpParser\Node;
use PhpParser\NodeVisitor;
/**
* @author Mathieu Santostefano <msantostefano@protonmail.com>
*/
final class TranslatableMessageVisitor extends AbstractVisitor implements NodeVisitor
{
public function beforeTraverse(array $nodes): ?Node
{
return null;
}
public function enterNode(Node $node): ?Node
{
if (!$node instanceof Node\Expr\New_) {
return null;
}
if (!($className = $node->class) instanceof Node\Name) {
return null;
}
if (!\in_array('TranslatableMessage', $className->parts, true)) {
return null;
}
$firstNamedArgumentIndex = $this->nodeFirstNamedArgumentIndex($node);
if (!$messages = $this->getStringArguments($node, 0 < $firstNamedArgumentIndex ? 0 : 'message')) {
return null;
}
$domain = $this->getStringArguments($node, 2 < $firstNamedArgumentIndex ? 2 : 'domain')[0] ?? null;
foreach ($messages as $message) {
$this->addMessageToCatalogue($message, $domain, $node->getStartLine());
}
return null;
}
public function leaveNode(Node $node): ?Node
{
return null;
}
public function afterTraverse(array $nodes): ?Node
{
return null;
}
}

78
vendor/symfony/translation/LocaleSwitcher.php vendored
View File

@ -1,78 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\Translation;
use Symfony\Component\Routing\RequestContext;
use Symfony\Contracts\Translation\LocaleAwareInterface;
/**
* @author Kevin Bond <kevinbond@gmail.com>
*/
class LocaleSwitcher implements LocaleAwareInterface
{
private string $defaultLocale;
/**
* @param LocaleAwareInterface[] $localeAwareServices
*/
public function __construct(
private string $locale,
private iterable $localeAwareServices,
private ?RequestContext $requestContext = null,
) {
$this->defaultLocale = $locale;
}
public function setLocale(string $locale): void
{
if (class_exists(\Locale::class)) {
\Locale::setDefault($locale);
}
$this->locale = $locale;
$this->requestContext?->setParameter('_locale', $locale);
foreach ($this->localeAwareServices as $service) {
$service->setLocale($locale);
}
}
public function getLocale(): string
{
return $this->locale;
}
/**
* Switch to a new locale, execute a callback, then switch back to the original.
*
* @template T
*
* @param callable():T $callback
*
* @return T
*/
public function runWithLocale(string $locale, callable $callback): mixed
{
$original = $this->getLocale();
$this->setLocale($locale);
try {
return $callback();
} finally {
$this->setLocale($original);
}
}
public function reset(): void
{
$this->setLocale($this->defaultLocale);
}
}

2261
vendor/symfony/translation/Resources/schemas/xliff-core-1.2-transitional.xsd vendored
View File

File diff suppressed because it is too large Load Diff

16
vendor/symfony/var-exporter/Exception/LogicException.php vendored
View File

@ -1,16 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter\Exception;
class LogicException extends \LogicException implements ExceptionInterface
{
}

78
vendor/symfony/var-exporter/Hydrator.php vendored
View File

@ -1,78 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter;
use Symfony\Component\VarExporter\Internal\Hydrator as InternalHydrator;
/**
* Utility class to hydrate the properties of an object.
*
* @author Nicolas Grekas <p@tchwork.com>
*/
final class Hydrator
{
/**
* Sets the properties of an object, including private and protected ones.
*
* For example:
*
* // Sets the public or protected $object->propertyName property
* Hydrator::hydrate($object, ['propertyName' => $propertyValue]);
*
* // Sets a private property defined on its parent Bar class:
* Hydrator::hydrate($object, ["\0Bar\0privateBarProperty" => $propertyValue]);
*
* // Alternative way to set the private $object->privateBarProperty property
* Hydrator::hydrate($object, [], [
* Bar::class => ['privateBarProperty' => $propertyValue],
* ]);
*
* Instances of ArrayObject, ArrayIterator and SplObjectStorage can be hydrated
* by using the special "\0" property name to define their internal value:
*
* // Hydrates an SplObjectStorage where $info1 is attached to $obj1, etc.
* Hydrator::hydrate($object, ["\0" => [$obj1, $info1, $obj2, $info2...]]);
*
* // Hydrates an ArrayObject populated with $inputArray
* Hydrator::hydrate($object, ["\0" => [$inputArray]]);
*
* @template T of object
*
* @param T $instance The object to hydrate
* @param array<string, mixed> $properties The properties to set on the instance
* @param array<class-string, array<string, mixed>> $scopedProperties The properties to set on the instance,
* keyed by their declaring class
*
* @return T
*/
public static function hydrate(object $instance, array $properties = [], array $scopedProperties = []): object
{
if ($properties) {
$class = $instance::class;
$propertyScopes = InternalHydrator::$propertyScopes[$class] ??= InternalHydrator::getPropertyScopes($class);
foreach ($properties as $name => &$value) {
[$scope, $name, $readonlyScope] = $propertyScopes[$name] ?? [$class, $name, $class];
$scopedProperties[$readonlyScope ?? $scope][$name] = &$value;
}
unset($value);
}
foreach ($scopedProperties as $scope => $properties) {
if ($properties) {
(InternalHydrator::$simpleHydrators[$scope] ??= InternalHydrator::getSimpleHydrator($scope))($properties, $instance);
}
}
return $instance;
}
}

146
vendor/symfony/var-exporter/Internal/LazyObjectRegistry.php vendored
View File

@ -1,146 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter\Internal;
/**
* Stores the state of lazy objects and caches related reflection information.
*
* As a micro-optimization, this class uses no type declarations.
*
* @internal
*/
class LazyObjectRegistry
{
/**
* @var array<class-string, \ReflectionClass>
*/
public static $classReflectors = [];
/**
* @var array<class-string, array<string, mixed>>
*/
public static $defaultProperties = [];
/**
* @var array<class-string, list<\Closure>>
*/
public static $classResetters = [];
/**
* @var array<class-string, array{get: \Closure, set: \Closure, isset: \Closure, unset: \Closure}>
*/
public static $classAccessors = [];
/**
* @var array<class-string, array{set: bool, isset: bool, unset: bool, clone: bool, serialize: bool, unserialize: bool, sleep: bool, wakeup: bool, destruct: bool, get: int}>
*/
public static $parentMethods = [];
public static ?\Closure $noInitializerState = null;
public static function getClassResetters($class)
{
$classProperties = [];
if ((self::$classReflectors[$class] ??= new \ReflectionClass($class))->isInternal()) {
$propertyScopes = [];
} else {
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
}
foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
$propertyScopes[$k = "\0$scope\0$name"] ?? $propertyScopes[$k = "\0*\0$name"] ?? $k = $name;
if ($k === $key && "\0$class\0lazyObjectState" !== $k) {
$classProperties[$readonlyScope ?? $scope][$name] = $key;
}
}
$resetters = [];
foreach ($classProperties as $scope => $properties) {
$resetters[] = \Closure::bind(static function ($instance, $skippedProperties, $onlyProperties = null) use ($properties) {
foreach ($properties as $name => $key) {
if (!\array_key_exists($key, $skippedProperties) && (null === $onlyProperties || \array_key_exists($key, $onlyProperties))) {
unset($instance->$name);
}
}
}, null, $scope);
}
$resetters[] = static function ($instance, $skippedProperties, $onlyProperties = null) {
foreach ((array) $instance as $name => $value) {
if ("\0" !== ($name[0] ?? '') && !\array_key_exists($name, $skippedProperties) && (null === $onlyProperties || \array_key_exists($name, $onlyProperties))) {
unset($instance->$name);
}
}
};
return $resetters;
}
public static function getClassAccessors($class)
{
return \Closure::bind(static fn () => [
'get' => static function &($instance, $name, $readonly) {
if (!$readonly) {
return $instance->$name;
}
$value = $instance->$name;
return $value;
},
'set' => static function ($instance, $name, $value) {
$instance->$name = $value;
},
'isset' => static fn ($instance, $name) => isset($instance->$name),
'unset' => static function ($instance, $name) {
unset($instance->$name);
},
], null, \Closure::class === $class ? null : $class)();
}
public static function getParentMethods($class)
{
$parent = get_parent_class($class);
$methods = [];
foreach (['set', 'isset', 'unset', 'clone', 'serialize', 'unserialize', 'sleep', 'wakeup', 'destruct', 'get'] as $method) {
if (!$parent || !method_exists($parent, '__'.$method)) {
$methods[$method] = false;
} else {
$m = new \ReflectionMethod($parent, '__'.$method);
$methods[$method] = !$m->isAbstract() && !$m->isPrivate();
}
}
$methods['get'] = $methods['get'] ? ($m->returnsReference() ? 2 : 1) : 0;
return $methods;
}
public static function getScope($propertyScopes, $class, $property, $readonlyScope = null)
{
if (null === $readonlyScope && !isset($propertyScopes[$k = "\0$class\0$property"]) && !isset($propertyScopes[$k = "\0*\0$property"])) {
return null;
}
$frame = debug_backtrace(\DEBUG_BACKTRACE_PROVIDE_OBJECT | \DEBUG_BACKTRACE_IGNORE_ARGS, 3)[2];
if (\ReflectionProperty::class === $scope = $frame['class'] ?? \Closure::class) {
$scope = $frame['object']->class;
}
if (null === $readonlyScope && '*' === $k[1] && ($class === $scope || (is_subclass_of($class, $scope) && !isset($propertyScopes["\0$scope\0$property"])))) {
return null;
}
return $scope;
}
}

130
vendor/symfony/var-exporter/Internal/LazyObjectState.php vendored
View File

@ -1,130 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter\Internal;
use Symfony\Component\VarExporter\Hydrator as PublicHydrator;
/**
* Keeps the state of lazy objects.
*
* As a micro-optimization, this class uses no type declarations.
*
* @internal
*/
class LazyObjectState
{
public const STATUS_UNINITIALIZED_FULL = 1;
public const STATUS_UNINITIALIZED_PARTIAL = 2;
public const STATUS_INITIALIZED_FULL = 3;
public const STATUS_INITIALIZED_PARTIAL = 4;
/**
* @var array<string, true>
*/
public readonly array $skippedProperties;
/**
* @var self::STATUS_*
*/
public int $status = 0;
public object $realInstance;
public function __construct(public readonly \Closure|array $initializer, $skippedProperties = [])
{
$this->skippedProperties = $skippedProperties;
$this->status = \is_array($initializer) ? self::STATUS_UNINITIALIZED_PARTIAL : self::STATUS_UNINITIALIZED_FULL;
}
public function initialize($instance, $propertyName, $propertyScope)
{
if (self::STATUS_INITIALIZED_FULL === $this->status) {
return self::STATUS_INITIALIZED_FULL;
}
if (\is_array($this->initializer)) {
$class = $instance::class;
$propertyScope ??= $class;
$propertyScopes = Hydrator::$propertyScopes[$class];
$propertyScopes[$k = "\0$propertyScope\0$propertyName"] ?? $propertyScopes[$k = "\0*\0$propertyName"] ?? $k = $propertyName;
if ($initializer = $this->initializer[$k] ?? null) {
$value = $initializer(...[$instance, $propertyName, $propertyScope, LazyObjectRegistry::$defaultProperties[$class][$k] ?? null]);
$accessor = LazyObjectRegistry::$classAccessors[$propertyScope] ??= LazyObjectRegistry::getClassAccessors($propertyScope);
$accessor['set']($instance, $propertyName, $value);
return $this->status = self::STATUS_INITIALIZED_PARTIAL;
}
$status = self::STATUS_UNINITIALIZED_PARTIAL;
if ($initializer = $this->initializer["\0"] ?? null) {
if (!\is_array($values = $initializer($instance, LazyObjectRegistry::$defaultProperties[$class]))) {
throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
}
$properties = (array) $instance;
foreach ($values as $key => $value) {
if ($k === $key) {
$status = self::STATUS_INITIALIZED_PARTIAL;
}
if (!\array_key_exists($key, $properties) && [$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
$scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
$accessor = LazyObjectRegistry::$classAccessors[$scope] ??= LazyObjectRegistry::getClassAccessors($scope);
$accessor['set']($instance, $name, $value);
}
}
}
return $status;
}
$this->status = self::STATUS_INITIALIZED_FULL;
try {
if ($defaultProperties = array_diff_key(LazyObjectRegistry::$defaultProperties[$instance::class], $this->skippedProperties)) {
PublicHydrator::hydrate($instance, $defaultProperties);
}
($this->initializer)($instance);
} catch (\Throwable $e) {
$this->status = self::STATUS_UNINITIALIZED_FULL;
$this->reset($instance);
throw $e;
}
return self::STATUS_INITIALIZED_FULL;
}
public function reset($instance): void
{
$class = $instance::class;
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
$skippedProperties = $this->skippedProperties;
$properties = (array) $instance;
$onlyProperties = \is_array($this->initializer) ? $this->initializer : null;
foreach ($propertyScopes as $key => [$scope, $name, $readonlyScope]) {
$propertyScopes[$k = "\0$scope\0$name"] ?? $propertyScopes[$k = "\0*\0$name"] ?? $k = $name;
if ($k === $key && (null !== $readonlyScope || !\array_key_exists($k, $properties))) {
$skippedProperties[$k] = true;
}
}
foreach (LazyObjectRegistry::$classResetters[$class] as $reset) {
$reset($instance, $skippedProperties, $onlyProperties);
}
$this->status = self::STATUS_INITIALIZED_FULL === $this->status ? self::STATUS_UNINITIALIZED_FULL : self::STATUS_UNINITIALIZED_PARTIAL;
}
}

30
vendor/symfony/var-exporter/Internal/LazyObjectTrait.php vendored
View File

@ -1,30 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter\Internal;
if (\PHP_VERSION_ID >= 80300) {
/**
* @internal
*/
trait LazyObjectTrait
{
private readonly LazyObjectState $lazyObjectState;
}
} else {
/**
* @internal
*/
trait LazyObjectTrait
{
private LazyObjectState $lazyObjectState;
}
}

391
vendor/symfony/var-exporter/LazyGhostTrait.php vendored
View File

@ -1,391 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter;
use Symfony\Component\VarExporter\Internal\Hydrator;
use Symfony\Component\VarExporter\Internal\LazyObjectRegistry as Registry;
use Symfony\Component\VarExporter\Internal\LazyObjectState;
use Symfony\Component\VarExporter\Internal\LazyObjectTrait;
trait LazyGhostTrait
{
use LazyObjectTrait;
/**
* Creates a lazy-loading ghost instance.
*
* When the initializer is a closure, it should initialize all properties at
* once and is given the instance to initialize as argument.
*
* When the initializer is an array of closures, it should be indexed by
* properties and closures should accept 4 arguments: the instance to
* initialize, the property to initialize, its write-scope, and its default
* value. Each closure should return the value of the corresponding property.
* The special "\0" key can be used to define a closure that returns all
* properties at once when full-initialization is needed; it takes the
* instance and its default properties as arguments.
*
* Properties should be indexed by their array-cast name, see
* https://php.net/manual/language.types.array#language.types.array.casting
*
* @param (\Closure(static):void
* |array<string, \Closure(static, string, ?string, mixed):mixed>
* |array{"\0": \Closure(static, array<string, mixed>):array<string, mixed>}) $initializer
* @param array<string, true>|null $skippedProperties An array indexed by the properties to skip, aka the ones
* that the initializer doesn't set when its a closure
* @param static|null $instance
*/
public static function createLazyGhost(\Closure|array $initializer, array $skippedProperties = null, object $instance = null): static
{
$onlyProperties = null === $skippedProperties && \is_array($initializer) ? $initializer : null;
if (self::class !== $class = $instance ? $instance::class : static::class) {
$skippedProperties["\0".self::class."\0lazyObjectState"] = true;
} elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
}
$instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
Registry::$defaultProperties[$class] ??= (array) $instance;
$instance->lazyObjectState = new LazyObjectState($initializer, $skippedProperties ??= []);
foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
$reset($instance, $skippedProperties, $onlyProperties);
}
return $instance;
}
/**
* Returns whether the object is initialized.
*
* @param $partial Whether partially initialized objects should be considered as initialized
*/
public function isLazyObjectInitialized(bool $partial = false): bool
{
if (!$state = $this->lazyObjectState ?? null) {
return true;
}
if (!\is_array($state->initializer)) {
return LazyObjectState::STATUS_INITIALIZED_FULL === $state->status;
}
$class = $this::class;
$properties = (array) $this;
if ($partial) {
return (bool) array_intersect_key($state->initializer, $properties);
}
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
foreach ($state->initializer as $key => $initializer) {
if (!\array_key_exists($key, $properties) && isset($propertyScopes[$key])) {
return false;
}
}
return true;
}
/**
* Forces initialization of a lazy object and returns it.
*/
public function initializeLazyObject(): static
{
if (!$state = $this->lazyObjectState ?? null) {
return $this;
}
if (!\is_array($state->initializer)) {
if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
$state->initialize($this, '', null);
}
return $this;
}
$values = isset($state->initializer["\0"]) ? null : [];
$class = $this::class;
$properties = (array) $this;
$propertyScopes = Hydrator::$propertyScopes[$class] ??= Hydrator::getPropertyScopes($class);
foreach ($state->initializer as $key => $initializer) {
if (\array_key_exists($key, $properties) || ![$scope, $name, $readonlyScope] = $propertyScopes[$key] ?? null) {
continue;
}
$scope = $readonlyScope ?? ('*' !== $scope ? $scope : $class);
if (null === $values) {
if (!\is_array($values = ($state->initializer["\0"])($this, Registry::$defaultProperties[$class]))) {
throw new \TypeError(sprintf('The lazy-initializer defined for instance of "%s" must return an array, got "%s".', $class, get_debug_type($values)));
}
if (\array_key_exists($key, $properties = (array) $this)) {
continue;
}
}
if (\array_key_exists($key, $values)) {
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
$accessor['set']($this, $name, $properties[$key] = $values[$key]);
} else {
$state->initialize($this, $name, $scope);
$properties = (array) $this;
}
}
return $this;
}
/**
* @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
*/
public function resetLazyObject(): bool
{
if (!$state = $this->lazyObjectState ?? null) {
return false;
}
if (LazyObjectState::STATUS_UNINITIALIZED_FULL !== $state->status) {
$state->reset($this);
}
return true;
}
public function &__get($name): mixed
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name);
$state = $this->lazyObjectState ?? null;
if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
&& LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
) {
goto get_in_scope;
}
}
if ($parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get']) {
if (2 === $parent) {
return parent::__get($name);
}
$value = parent::__get($name);
return $value;
}
if (null === $class) {
$frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $this::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
}
get_in_scope:
try {
if (null === $scope) {
if (null === $readonlyScope) {
return $this->$name;
}
$value = $this->$name;
return $value;
}
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
return $accessor['get']($this, $name, null !== $readonlyScope);
} catch (\Error $e) {
if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
throw $e;
}
try {
if (null === $scope) {
$this->$name = [];
return $this->$name;
}
$accessor['set']($this, $name, []);
return $accessor['get']($this, $name, null !== $readonlyScope);
} catch (\Error) {
throw $e;
}
}
}
public function __set($name, $value): void
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
$state = $this->lazyObjectState ?? null;
if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
$state->initialize($this, $name, $readonlyScope ?? $scope);
}
goto set_in_scope;
}
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
parent::__set($name, $value);
return;
}
set_in_scope:
if (null === $scope) {
$this->$name = $value;
} else {
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
$accessor['set']($this, $name, $value);
}
}
public function __isset($name): bool
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name);
$state = $this->lazyObjectState ?? null;
if ($state && (null === $scope || isset($propertyScopes["\0$scope\0$name"]))
&& LazyObjectState::STATUS_UNINITIALIZED_PARTIAL !== $state->initialize($this, $name, $readonlyScope ?? $scope)
) {
goto isset_in_scope;
}
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
return parent::__isset($name);
}
isset_in_scope:
if (null === $scope) {
return isset($this->$name);
}
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
return $accessor['isset']($this, $name);
}
public function __unset($name): void
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
$state = $this->lazyObjectState ?? null;
if ($state && ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"]))) {
if (LazyObjectState::STATUS_UNINITIALIZED_FULL === $state->status) {
$state->initialize($this, $name, $readonlyScope ?? $scope);
}
goto unset_in_scope;
}
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
parent::__unset($name);
return;
}
unset_in_scope:
if (null === $scope) {
unset($this->$name);
} else {
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
$accessor['unset']($this, $name);
}
}
public function __clone(): void
{
if ($state = $this->lazyObjectState ?? null) {
$this->lazyObjectState = clone $state;
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
parent::__clone();
}
}
public function __serialize(): array
{
$class = self::class;
if ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
$properties = parent::__serialize();
} else {
$this->initializeLazyObject();
$properties = (array) $this;
}
unset($properties["\0$class\0lazyObjectState"]);
if (Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
return $properties;
}
$scope = get_parent_class($class);
$data = [];
foreach (parent::__sleep() as $name) {
$value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
if (null === $k) {
trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
} else {
$data[$k] = $value;
}
}
return $data;
}
public function __destruct()
{
$state = $this->lazyObjectState ?? null;
if ($state && \in_array($state->status, [LazyObjectState::STATUS_UNINITIALIZED_FULL, LazyObjectState::STATUS_UNINITIALIZED_PARTIAL], true)) {
return;
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
parent::__destruct();
}
}
private function setLazyObjectAsInitialized(bool $initialized): void
{
$state = $this->lazyObjectState ?? null;
if ($state && !\is_array($state->initializer)) {
$state->status = $initialized ? LazyObjectState::STATUS_INITIALIZED_FULL : LazyObjectState::STATUS_UNINITIALIZED_FULL;
}
}
}

32
vendor/symfony/var-exporter/LazyObjectInterface.php vendored
View File

@ -1,32 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter;
interface LazyObjectInterface
{
/**
* Returns whether the object is initialized.
*
* @param $partial Whether partially initialized objects should be considered as initialized
*/
public function isLazyObjectInitialized(bool $partial = false): bool;
/**
* Forces initialization of a lazy object and returns it.
*/
public function initializeLazyObject(): object;
/**
* @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
*/
public function resetLazyObject(): bool;
}

347
vendor/symfony/var-exporter/LazyProxyTrait.php vendored
View File

@ -1,347 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter;
use Symfony\Component\VarExporter\Hydrator as PublicHydrator;
use Symfony\Component\VarExporter\Internal\Hydrator;
use Symfony\Component\VarExporter\Internal\LazyObjectRegistry as Registry;
use Symfony\Component\VarExporter\Internal\LazyObjectState;
use Symfony\Component\VarExporter\Internal\LazyObjectTrait;
trait LazyProxyTrait
{
use LazyObjectTrait;
/**
* Creates a lazy-loading virtual proxy.
*
* @param \Closure():object $initializer Returns the proxied object
* @param static|null $instance
*/
public static function createLazyProxy(\Closure $initializer, object $instance = null): static
{
if (self::class !== $class = $instance ? $instance::class : static::class) {
$skippedProperties = ["\0".self::class."\0lazyObjectState" => true];
} elseif (\defined($class.'::LAZY_OBJECT_PROPERTY_SCOPES')) {
Hydrator::$propertyScopes[$class] ??= $class::LAZY_OBJECT_PROPERTY_SCOPES;
}
$instance ??= (Registry::$classReflectors[$class] ??= new \ReflectionClass($class))->newInstanceWithoutConstructor();
$instance->lazyObjectState = new LazyObjectState($initializer);
foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
$reset($instance, $skippedProperties ??= []);
}
return $instance;
}
/**
* Returns whether the object is initialized.
*
* @param $partial Whether partially initialized objects should be considered as initialized
*/
public function isLazyObjectInitialized(bool $partial = false): bool
{
return !isset($this->lazyObjectState) || isset($this->lazyObjectState->realInstance) || Registry::$noInitializerState === $this->lazyObjectState->initializer;
}
/**
* Forces initialization of a lazy object and returns it.
*/
public function initializeLazyObject(): parent
{
if ($state = $this->lazyObjectState ?? null) {
return $state->realInstance ??= ($state->initializer)();
}
return $this;
}
/**
* @return bool Returns false when the object cannot be reset, ie when it's not a lazy object
*/
public function resetLazyObject(): bool
{
if (!isset($this->lazyObjectState) || Registry::$noInitializerState === $this->lazyObjectState->initializer) {
return false;
}
unset($this->lazyObjectState->realInstance);
return true;
}
public function &__get($name): mixed
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
$instance = $this;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name);
if (null === $scope || isset($propertyScopes["\0$scope\0$name"])) {
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
}
$parent = 2;
goto get_in_scope;
}
}
$parent = (Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['get'];
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
} else {
if (2 === $parent) {
return parent::__get($name);
}
$value = parent::__get($name);
return $value;
}
if (!$parent && null === $class && !\array_key_exists($name, (array) $instance)) {
$frame = debug_backtrace(\DEBUG_BACKTRACE_IGNORE_ARGS, 1)[0];
trigger_error(sprintf('Undefined property: %s::$%s in %s on line %s', $instance::class, $name, $frame['file'], $frame['line']), \E_USER_NOTICE);
}
get_in_scope:
try {
if (null === $scope) {
if (null === $readonlyScope && 1 !== $parent) {
return $instance->$name;
}
$value = $instance->$name;
return $value;
}
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
return $accessor['get']($instance, $name, null !== $readonlyScope || 1 === $parent);
} catch (\Error $e) {
if (\Error::class !== $e::class || !str_starts_with($e->getMessage(), 'Cannot access uninitialized non-nullable property')) {
throw $e;
}
try {
if (null === $scope) {
$instance->$name = [];
return $instance->$name;
}
$accessor['set']($instance, $name, []);
return $accessor['get']($instance, $name, null !== $readonlyScope || 1 === $parent);
} catch (\Error) {
throw $e;
}
}
}
public function __set($name, $value): void
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
$instance = $this;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
if ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"])) {
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
}
goto set_in_scope;
}
}
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
} elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['set']) {
parent::__set($name, $value);
return;
}
set_in_scope:
if (null === $scope) {
$instance->$name = $value;
} else {
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
$accessor['set']($instance, $name, $value);
}
}
public function __isset($name): bool
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
$instance = $this;
if ([$class] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name);
if (null === $scope || isset($propertyScopes["\0$scope\0$name"])) {
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
}
goto isset_in_scope;
}
}
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
} elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['isset']) {
return parent::__isset($name);
}
isset_in_scope:
if (null === $scope) {
return isset($instance->$name);
}
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
return $accessor['isset']($instance, $name);
}
public function __unset($name): void
{
$propertyScopes = Hydrator::$propertyScopes[$this::class] ??= Hydrator::getPropertyScopes($this::class);
$scope = null;
$instance = $this;
if ([$class, , $readonlyScope] = $propertyScopes[$name] ?? null) {
$scope = Registry::getScope($propertyScopes, $class, $name, $readonlyScope);
if ($readonlyScope === $scope || isset($propertyScopes["\0$scope\0$name"])) {
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
}
goto unset_in_scope;
}
}
if ($state = $this->lazyObjectState ?? null) {
$instance = $state->realInstance ??= ($state->initializer)();
} elseif ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['unset']) {
parent::__unset($name);
return;
}
unset_in_scope:
if (null === $scope) {
unset($instance->$name);
} else {
$accessor = Registry::$classAccessors[$scope] ??= Registry::getClassAccessors($scope);
$accessor['unset']($instance, $name);
}
}
public function __clone(): void
{
if (!isset($this->lazyObjectState)) {
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['clone']) {
parent::__clone();
}
return;
}
$this->lazyObjectState = clone $this->lazyObjectState;
if (isset($this->lazyObjectState->realInstance)) {
$this->lazyObjectState->realInstance = clone $this->lazyObjectState->realInstance;
}
}
public function __serialize(): array
{
$class = self::class;
$state = $this->lazyObjectState ?? null;
if (!$state && (Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['serialize']) {
$properties = parent::__serialize();
} else {
$properties = (array) $this;
if ($state) {
unset($properties["\0$class\0lazyObjectState"]);
$properties["\0$class\0lazyObjectReal"] = $state->realInstance ??= ($state->initializer)();
}
}
if ($state || Registry::$parentMethods[$class]['serialize'] || !Registry::$parentMethods[$class]['sleep']) {
return $properties;
}
$scope = get_parent_class($class);
$data = [];
foreach (parent::__sleep() as $name) {
$value = $properties[$k = $name] ?? $properties[$k = "\0*\0$name"] ?? $properties[$k = "\0$scope\0$name"] ?? $k = null;
if (null === $k) {
trigger_error(sprintf('serialize(): "%s" returned as member variable from __sleep() but does not exist', $name), \E_USER_NOTICE);
} else {
$data[$k] = $value;
}
}
return $data;
}
public function __unserialize(array $data): void
{
$class = self::class;
if ($instance = $data["\0$class\0lazyObjectReal"] ?? null) {
unset($data["\0$class\0lazyObjectReal"]);
foreach (Registry::$classResetters[$class] ??= Registry::getClassResetters($class) as $reset) {
$reset($this, $data);
}
if ($data) {
PublicHydrator::hydrate($this, $data);
}
$this->lazyObjectState = new LazyObjectState(Registry::$noInitializerState ??= static fn () => throw new \LogicException('Lazy proxy has no initializer.'));
$this->lazyObjectState->realInstance = $instance;
} elseif ((Registry::$parentMethods[$class] ??= Registry::getParentMethods($class))['unserialize']) {
parent::__unserialize($data);
} else {
PublicHydrator::hydrate($this, $data);
if (Registry::$parentMethods[$class]['wakeup']) {
parent::__wakeup();
}
}
}
public function __destruct()
{
if (isset($this->lazyObjectState)) {
return;
}
if ((Registry::$parentMethods[self::class] ??= Registry::getParentMethods(self::class))['destruct']) {
parent::__destruct();
}
}
}

365
vendor/symfony/var-exporter/ProxyHelper.php vendored
View File

@ -1,365 +0,0 @@
<?php
/*
* This file is part of the Symfony package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Component\VarExporter;
use Symfony\Component\VarExporter\Exception\LogicException;
use Symfony\Component\VarExporter\Internal\Hydrator;
use Symfony\Component\VarExporter\Internal\LazyObjectRegistry;
/**
* @author Nicolas Grekas <p@tchwork.com>
*/
final class ProxyHelper
{
/**
* Helps generate lazy-loading ghost objects.
*
* @throws LogicException When the class is incompatible with ghost objects
*/
public static function generateLazyGhost(\ReflectionClass $class): string
{
if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class->isReadOnly()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is readonly.', $class->name));
}
if ($class->isFinal()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is final.', $class->name));
}
if ($class->isInterface() || $class->isAbstract()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: "%s" is not a concrete class.', $class->name));
}
if (\stdClass::class !== $class->name && $class->isInternal()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" is internal.', $class->name));
}
if ($class->hasMethod('__get') && 'mixed' !== (self::exportType($class->getMethod('__get')) ?? 'mixed')) {
throw new LogicException(sprintf('Cannot generate lazy ghost: return type of method "%s::__get()" should be "mixed".', $class->name));
}
static $traitMethods;
$traitMethods ??= (new \ReflectionClass(LazyGhostTrait::class))->getMethods();
foreach ($traitMethods as $method) {
if ($class->hasMethod($method->name) && $class->getMethod($method->name)->isFinal()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: method "%s::%s()" is final.', $class->name, $method->name));
}
}
$parent = $class;
while ($parent = $parent->getParentClass()) {
if (\stdClass::class !== $parent->name && $parent->isInternal()) {
throw new LogicException(sprintf('Cannot generate lazy ghost: class "%s" extends "%s" which is internal.', $class->name, $parent->name));
}
}
$propertyScopes = self::exportPropertyScopes($class->name);
return <<<EOPHP
extends \\{$class->name} implements \Symfony\Component\VarExporter\LazyObjectInterface
{
use \Symfony\Component\VarExporter\LazyGhostTrait;
private const LAZY_OBJECT_PROPERTY_SCOPES = {$propertyScopes};
}
// Help opcache.preload discover always-needed symbols
class_exists(\Symfony\Component\VarExporter\Internal\Hydrator::class);
class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectRegistry::class);
class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);
EOPHP;
}
/**
* Helps generate lazy-loading virtual proxies.
*
* @param \ReflectionClass[] $interfaces
*
* @throws LogicException When the class is incompatible with virtual proxies
*/
public static function generateLazyProxy(?\ReflectionClass $class, array $interfaces = []): string
{
if (!class_exists($class?->name ?? \stdClass::class, false)) {
throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not a class.', $class->name));
}
if ($class?->isFinal()) {
throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is final.', $class->name));
}
if (\PHP_VERSION_ID >= 80200 && \PHP_VERSION_ID < 80300 && $class?->isReadOnly()) {
throw new LogicException(sprintf('Cannot generate lazy proxy: class "%s" is readonly.', $class->name));
}
$methodReflectors = [$class?->getMethods(\ReflectionMethod::IS_PUBLIC | \ReflectionMethod::IS_PROTECTED) ?? []];
foreach ($interfaces as $interface) {
if (!$interface->isInterface()) {
throw new LogicException(sprintf('Cannot generate lazy proxy: "%s" is not an interface.', $interface->name));
}
$methodReflectors[] = $interface->getMethods();
}
$methodReflectors = array_merge(...$methodReflectors);
$extendsInternalClass = false;
if ($parent = $class) {
do {
$extendsInternalClass = \stdClass::class !== $parent->name && $parent->isInternal();
} while (!$extendsInternalClass && $parent = $parent->getParentClass());
}
$methodsHaveToBeProxied = $extendsInternalClass;
$methods = [];
foreach ($methodReflectors as $method) {
if ('__get' !== strtolower($method->name) || 'mixed' === ($type = self::exportType($method) ?? 'mixed')) {
continue;
}
$methodsHaveToBeProxied = true;
$trait = new \ReflectionMethod(LazyProxyTrait::class, '__get');
$body = \array_slice(file($trait->getFileName()), $trait->getStartLine() - 1, $trait->getEndLine() - $trait->getStartLine());
$body[0] = str_replace('): mixed', '): '.$type, $body[0]);
$methods['__get'] = strtr(implode('', $body).' }', [
'Hydrator' => '\\'.Hydrator::class,
'Registry' => '\\'.LazyObjectRegistry::class,
]);
break;
}
foreach ($methodReflectors as $method) {
if (($method->isStatic() && !$method->isAbstract()) || isset($methods[$lcName = strtolower($method->name)])) {
continue;
}
if ($method->isFinal()) {
if ($extendsInternalClass || $methodsHaveToBeProxied || method_exists(LazyProxyTrait::class, $method->name)) {
throw new LogicException(sprintf('Cannot generate lazy proxy: method "%s::%s()" is final.', $class->name, $method->name));
}
continue;
}
if (method_exists(LazyProxyTrait::class, $method->name) || ($method->isProtected() && !$method->isAbstract())) {
continue;
}
$signature = self::exportSignature($method, true, $args);
$parentCall = $method->isAbstract() ? "throw new \BadMethodCallException('Cannot forward abstract method \"{$method->class}::{$method->name}()\".')" : "parent::{$method->name}({$args})";
if ($method->isStatic()) {
$body = " $parentCall;";
} elseif (str_ends_with($signature, '): never') || str_ends_with($signature, '): void')) {
$body = <<<EOPHP
if (isset(\$this->lazyObjectState)) {
(\$this->lazyObjectState->realInstance ??= (\$this->lazyObjectState->initializer)())->{$method->name}({$args});
} else {
{$parentCall};
}
EOPHP;
} else {
if (!$methodsHaveToBeProxied && !$method->isAbstract()) {
// Skip proxying methods that might return $this
foreach (preg_split('/[()|&]++/', self::exportType($method) ?? 'static') as $type) {
if (\in_array($type = ltrim($type, '?'), ['static', 'object'], true)) {
continue 2;
}
foreach ([$class, ...$interfaces] as $r) {
if ($r && is_a($r->name, $type, true)) {
continue 3;
}
}
}
}
$body = <<<EOPHP
if (isset(\$this->lazyObjectState)) {
return (\$this->lazyObjectState->realInstance ??= (\$this->lazyObjectState->initializer)())->{$method->name}({$args});
}
return {$parentCall};
EOPHP;
}
$methods[$lcName] = " {$signature}\n {\n{$body}\n }";
}
$types = $interfaces = array_unique(array_column($interfaces, 'name'));
$interfaces[] = LazyObjectInterface::class;
$interfaces = implode(', \\', $interfaces);
$parent = $class ? ' extends \\'.$class->name : '';
array_unshift($types, $class ? 'parent' : '');
$type = ltrim(implode('&\\', $types), '&');
if (!$class) {
$trait = new \ReflectionMethod(LazyProxyTrait::class, 'initializeLazyObject');
$body = \array_slice(file($trait->getFileName()), $trait->getStartLine() - 1, $trait->getEndLine() - $trait->getStartLine());
$body[0] = str_replace('): parent', '): '.$type, $body[0]);
$methods = ['initializeLazyObject' => implode('', $body).' }'] + $methods;
}
$body = $methods ? "\n".implode("\n\n", $methods)."\n" : '';
$propertyScopes = $class ? self::exportPropertyScopes($class->name) : '[]';
return <<<EOPHP
{$parent} implements \\{$interfaces}
{
use \Symfony\Component\VarExporter\LazyProxyTrait;
private const LAZY_OBJECT_PROPERTY_SCOPES = {$propertyScopes};
{$body}}
// Help opcache.preload discover always-needed symbols
class_exists(\Symfony\Component\VarExporter\Internal\Hydrator::class);
class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectRegistry::class);
class_exists(\Symfony\Component\VarExporter\Internal\LazyObjectState::class);
EOPHP;
}
public static function exportSignature(\ReflectionFunctionAbstract $function, bool $withParameterTypes = true, string &$args = null): string
{
$hasByRef = false;
$args = '';
$param = null;
$parameters = [];
foreach ($function->getParameters() as $param) {
$parameters[] = ($param->getAttributes(\SensitiveParameter::class) ? '#[\SensitiveParameter] ' : '')
.($withParameterTypes && $param->hasType() ? self::exportType($param).' ' : '')
.($param->isPassedByReference() ? '&' : '')
.($param->isVariadic() ? '...' : '').'$'.$param->name
.($param->isOptional() && !$param->isVariadic() ? ' = '.self::exportDefault($param) : '');
$hasByRef = $hasByRef || $param->isPassedByReference();
$args .= ($param->isVariadic() ? '...$' : '$').$param->name.', ';
}
if (!$param || !$hasByRef) {
$args = '...\func_get_args()';
} elseif ($param->isVariadic()) {
$args = substr($args, 0, -2);
} else {
$args .= sprintf('...\array_slice(\func_get_args(), %d)', \count($parameters));
}
$signature = 'function '.($function->returnsReference() ? '&' : '')
.($function->isClosure() ? '' : $function->name).'('.implode(', ', $parameters).')';
if ($function instanceof \ReflectionMethod) {
$signature = ($function->isPublic() ? 'public ' : ($function->isProtected() ? 'protected ' : 'private '))
.($function->isStatic() ? 'static ' : '').$signature;
}
if ($function->hasReturnType()) {
$signature .= ': '.self::exportType($function);
}
static $getPrototype;
$getPrototype ??= (new \ReflectionMethod(\ReflectionMethod::class, 'getPrototype'))->invoke(...);
while ($function) {
if ($function->hasTentativeReturnType()) {
return '#[\ReturnTypeWillChange] '.$signature;
}
try {
$function = $function instanceof \ReflectionMethod && $function->isAbstract() ? false : $getPrototype($function);
} catch (\ReflectionException) {
break;
}
}
return $signature;
}
public static function exportType(\ReflectionFunctionAbstract|\ReflectionProperty|\ReflectionParameter $owner, bool $noBuiltin = false, \ReflectionType $type = null): ?string
{
if (!$type ??= $owner instanceof \ReflectionFunctionAbstract ? $owner->getReturnType() : $owner->getType()) {
return null;
}
$class = null;
$types = [];
if ($type instanceof \ReflectionUnionType) {
$reflectionTypes = $type->getTypes();
$glue = '|';
} elseif ($type instanceof \ReflectionIntersectionType) {
$reflectionTypes = $type->getTypes();
$glue = '&';
} else {
$reflectionTypes = [$type];
$glue = null;
}
foreach ($reflectionTypes as $type) {
if ($type instanceof \ReflectionIntersectionType) {
if ('' !== $name = '('.self::exportType($owner, $noBuiltin, $type).')') {
$types[] = $name;
}
continue;
}
$name = $type->getName();
if ($noBuiltin && $type->isBuiltin()) {
continue;
}
if (\in_array($name, ['parent', 'self'], true) && $class ??= $owner->getDeclaringClass()) {
$name = 'parent' === $name ? ($class->getParentClass() ?: null)?->name ?? 'parent' : $class->name;
}
$types[] = ($noBuiltin || $type->isBuiltin() || 'static' === $name ? '' : '\\').$name;
}
if (!$types) {
return '';
}
if (null === $glue) {
return (!$noBuiltin && $type->allowsNull() && 'mixed' !== $name ? '?' : '').$types[0];
}
sort($types);
return implode($glue, $types);
}
private static function exportPropertyScopes(string $parent): string
{
$propertyScopes = Hydrator::$propertyScopes[$parent] ??= Hydrator::getPropertyScopes($parent);
uksort($propertyScopes, 'strnatcmp');
$propertyScopes = VarExporter::export($propertyScopes);
$propertyScopes = str_replace(VarExporter::export($parent), 'parent::class', $propertyScopes);
$propertyScopes = preg_replace("/(?|(,)\n( ) |\n |,\n (\]))/", '$1$2', $propertyScopes);
$propertyScopes = str_replace("\n", "\n ", $propertyScopes);
return $propertyScopes;
}
private static function exportDefault(\ReflectionParameter $param): string
{
$default = rtrim(substr(explode('$'.$param->name.' = ', (string) $param, 2)[1] ?? '', 0, -2));
if (\in_array($default, ['<default>', 'NULL'], true)) {
return 'null';
}
if (str_ends_with($default, "...'") && preg_match("/^'(?:[^'\\\\]*+(?:\\\\.)*+)*+'$/", $default)) {
return VarExporter::export($param->getDefaultValue());
}
$regexp = "/(\"(?:[^\"\\\\]*+(?:\\\\.)*+)*+\"|'(?:[^'\\\\]*+(?:\\\\.)*+)*+')/";
$parts = preg_split($regexp, $default, -1, \PREG_SPLIT_DELIM_CAPTURE | \PREG_SPLIT_NO_EMPTY);
$regexp = '/([\[\( ]|^)([a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*+(?:\\\\[a-zA-Z0-9_\x7f-\xff]++)*+)(?!: )/';
$callback = (false !== strpbrk($default, "\\:('") && $class = $param->getDeclaringClass())
? fn ($m) => $m[1].match ($m[2]) {
'new', 'false', 'true', 'null' => $m[2],
'NULL' => 'null',
'self' => '\\'.$class->name,
'namespace\\parent',
'parent' => ($parent = $class->getParentClass()) ? '\\'.$parent->name : 'parent',
default => '\\'.$m[2],
}
: fn ($m) => $m[1].match ($m[2]) {
'new', 'false', 'true', 'null', 'self', 'parent' => $m[2],
'NULL' => 'null',
default => '\\'.$m[2],
};
return implode('', array_map(fn ($part) => match ($part[0]) {
'"' => $part, // for internal classes only
"'" => false !== strpbrk($part, "\\\0\r\n") ? '"'.substr(str_replace(['$', "\0", "\r", "\n"], ['\$', '\0', '\r', '\n'], $part), 1, -1).'"' : $part,
default => preg_replace_callback($regexp, $callback, $part),
}, $parts));
}
}

1
vendor/w7corp/easywechat/docs/.npmrc vendored
View File

@ -1 +0,0 @@
auto-install-peers=true

44
vendor/w7corp/easywechat/docs/src/4.x/client.md vendored
View File

@ -1,44 +0,0 @@
# API 调用
该方法将 API 交由开发者自行调用，微信有部分新的接口4.x并未全部兼容支持,可以使用该方案去自行封装接口：
例如URL Link接口
```php
$api = $app->getClient();
$response = $api->httpPostJson('wxa/generate_urllink',[
'path' => 'pages/index/index',
'is_expire' => true,
'expire_type' => 1,
'expire_interval' => 1
]);
```
## 语法说明
```php
httpGet(string $uri, array $query = [])
httpPostJson(string $uri, array $data = [], array $query = [])
```
### GET
```php
$response = $api->httpGet('/cgi-bin/user/list', [
'next_openid' => 'OPENID1',
]);
```
### POST
```php
$response = $api->httpPostJson('/cgi-bin/user/info/updateremark', [
"openid" => "oDF3iY9ffA-hqb2vVvbr7qxf6A0Q",
"remark" => "pangzi"
]);
```

32
vendor/w7corp/easywechat/docs/src/6.x/pay/media.md vendored
View File

@ -1,32 +0,0 @@
## 文件上传
由于微信 v3 对文件类上传使用特殊的签名机制，参见：[微信支付 - 图片上传API](https://pay.weixin.qq.com/wiki/doc/apiv3/apis/chapter2_1_1.shtml)。
因此，我们提供了一个媒体上传方法，方便开发者使用。
```php
$path = '/path/to/your/files/demo.jpg';
$api->uploadMedia('/v3/marketing/favor/media/image-upload', $path);
```
## 自定义 meta 信息
部分接口使用的签名 meta 不一致，所以可以自行传入：
```php
$url = '/v3/...';
$path = '/path/to/your/files/demo.jpg';
$meta = [
'bank_type' => 'CFT',
'filename' => 'demo.jpg',
'sha256' => 'xxxxxxxxxxx',
];
$api->uploadMedia($url, $path, $meta);
```
## 关于 sha256
- 文件，用 `hash_file('sha256', $path)` 计算
- 字符串，用 `hash('sha256', $string)` 计算

15
vendor/w7corp/easywechat/src/Kernel/Contracts/JsApiTicket.php vendored
View File

@ -1,15 +0,0 @@
<?php
declare(strict_types=1);
namespace EasyWeChat\Kernel\Contracts;
interface JsApiTicket
{
public function getTicket(): string;
/**
* @return array<string,mixed>
*/
public function configSignature(string $url, string $nonce, int $timestamp): array;
}

164
vendor/w7corp/easywechat/src/OpenWork/JsApiTicket.php vendored
View File

@ -1,164 +0,0 @@
<?php
declare(strict_types=1);
namespace EasyWeChat\OpenWork;
use EasyWeChat\Kernel\Exceptions\HttpException;
use function intval;
use function is_string;
use Psr\SimpleCache\CacheInterface;
use Psr\SimpleCache\InvalidArgumentException;
use function sprintf;
use Symfony\Component\Cache\Adapter\FilesystemAdapter;
use Symfony\Component\Cache\Psr16Cache;
use Symfony\Component\HttpClient\HttpClient;
use Symfony\Contracts\HttpClient\Exception\ClientExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\DecodingExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\RedirectionExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\ServerExceptionInterface;
use Symfony\Contracts\HttpClient\Exception\TransportExceptionInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;
class JsApiTicket
{
protected HttpClientInterface $httpClient;
protected CacheInterface $cache;
public function __construct(
protected string $corpId,
protected ?string $key = null,
?CacheInterface $cache = null,
?HttpClientInterface $httpClient = null
) {
$this->httpClient = $httpClient ?? HttpClient::create(['base_uri' => 'https://qyapi.weixin.qq.com/']);
$this->cache = $cache ?? new Psr16Cache(new FilesystemAdapter(namespace: 'easywechat', defaultLifetime: 1500));
}
/**
* @return array<string, mixed>
*
* @throws RedirectionExceptionInterface
* @throws DecodingExceptionInterface
* @throws ClientExceptionInterface
* @throws InvalidArgumentException
* @throws HttpException
* @throws TransportExceptionInterface
* @throws ServerExceptionInterface
*/
public function createConfigSignature(string $nonce, int $timestamp, string $url, array $jsApiList = [], bool $debug = false, bool $beta = true): array
{
return [
'appId' => $this->corpId,
'nonceStr' => $nonce,
'timestamp' => $timestamp,
'url' => $url,
'signature' => $this->getTicketSignature($this->getTicket(), $nonce, $timestamp, $url),
'jsApiList' => $jsApiList,
'debug' => $debug,
'beta' => $beta,
];
}
public function getTicketSignature(string $ticket, string $nonce, int $timestamp, string $url): string
{
return sha1(sprintf('jsapi_ticket=%s&noncestr=%s&timestamp=%s&url=%s', $ticket, $nonce, $timestamp, $url));
}
/**
* @throws RedirectionExceptionInterface
* @throws DecodingExceptionInterface
* @throws ClientExceptionInterface
* @throws InvalidArgumentException
* @throws TransportExceptionInterface
* @throws HttpException
* @throws ServerExceptionInterface
*/
public function getTicket(): string
{
$key = $this->getKey();
$ticket = $this->cache->get($key);
if ((bool) $ticket && is_string($ticket)) {
return $ticket;
}
$response = $this->httpClient->request('GET', '/cgi-bin/get_jsapi_ticket')->toArray(false);
if (empty($response['ticket'])) {
throw new HttpException('Failed to get jssdk ticket: '.json_encode($response, JSON_UNESCAPED_UNICODE));
}
$this->cache->set($key, $response['ticket'], intval($response['expires_in']));
return $response['ticket'];
}
public function setKey(string $key): static
{
$this->key = $key;
return $this;
}
public function getKey(): string
{
return $this->key ?? $this->key = sprintf('open_work.jsapi_ticket.%s', $this->corpId);
}
/**
* @throws ClientExceptionInterface
* @throws DecodingExceptionInterface
* @throws HttpException
* @throws InvalidArgumentException
* @throws RedirectionExceptionInterface
* @throws ServerExceptionInterface
* @throws TransportExceptionInterface
*/
public function createAgentConfigSignature(int $agentId, string $nonce, int $timestamp, string $url, array $jsApiList = []): array
{
return [
'corpid' => $this->corpId,
'agentid' => $agentId,
'nonceStr' => $nonce,
'timestamp' => $timestamp,
'signature' => $this->getTicketSignature($this->getAgentTicket($agentId), $nonce, $timestamp, $url),
'jsApiList' => $jsApiList,
];
}
/**
* @throws RedirectionExceptionInterface
* @throws DecodingExceptionInterface
* @throws InvalidArgumentException
* @throws ClientExceptionInterface
* @throws HttpException
* @throws TransportExceptionInterface
* @throws ServerExceptionInterface
*/
public function getAgentTicket(int $agentId): string
{
$key = $this->getAgentKey($agentId);
$ticket = $this->cache->get($key);
if ((bool) $ticket && is_string($ticket)) {
return $ticket;
}
$response = $this->httpClient->request('GET', '/cgi-bin/ticket/get', ['query' => ['type' => 'agent_config']])->toArray(false);
if (empty($response['ticket'])) {
throw new HttpException('Failed to get jssdk agentTicket: '.json_encode($response, JSON_UNESCAPED_UNICODE));
}
$this->cache->set($key, $response['ticket'], intval($response['expires_in']));
return $response['ticket'];
}
public function getAgentKey(int $agentId): string
{
return sprintf('%s.%s', $this->getKey(), $agentId);
}
}

15
vendor/w7corp/easywechat/src/Pay/Contracts/Validator.php vendored
View File

@ -1,15 +0,0 @@
<?php
declare(strict_types=1);
namespace EasyWeChat\Pay\Contracts;
use Psr\Http\Message\MessageInterface;
interface Validator
{
/**
* @throws \EasyWeChat\Pay\Exceptions\InvalidSignatureException if signature validate failed.
*/
public function validate(MessageInterface $message): void;
}

9
vendor/w7corp/easywechat/src/Pay/Exceptions/InvalidSignatureException.php vendored
View File

@ -1,9 +0,0 @@
<?php
namespace EasyWeChat\Pay\Exceptions;
use EasyWeChat\Kernel\Exceptions\RuntimeException;
class InvalidSignatureException extends RuntimeException
{
}

71
vendor/w7corp/easywechat/src/Pay/Validator.php vendored
View File

@ -1,71 +0,0 @@
<?php
declare(strict_types=1);
namespace EasyWeChat\Pay;
use EasyWeChat\Kernel\Exceptions\InvalidConfigException;
use EasyWeChat\Pay\Contracts\Merchant as MerchantInterface;
use EasyWeChat\Pay\Exceptions\InvalidSignatureException;
use Psr\Http\Message\MessageInterface;
class Validator implements \EasyWeChat\Pay\Contracts\Validator
{
public const MAX_ALLOWED_CLOCK_OFFSET = 300;
public const HEADER_TIMESTAMP = 'Wechatpay-Timestamp';
public const HEADER_NONCE = 'Wechatpay-Nonce';
public const HEADER_SERIAL = 'Wechatpay-Serial';
public const HEADER_SIGNATURE = 'Wechatpay-Signature';
public function __construct(protected MerchantInterface $merchant)
{
}
/**
* @throws \EasyWeChat\Kernel\Exceptions\InvalidConfigException
* @throws \EasyWeChat\Pay\Exceptions\InvalidSignatureException
*/
public function validate(MessageInterface $message): void
{
foreach ([self::HEADER_SIGNATURE, self::HEADER_TIMESTAMP, self::HEADER_SERIAL, self::HEADER_NONCE] as $header) {
if (! $message->hasHeader($header)) {
throw new InvalidSignatureException("Missing Header: {$header}");
}
}
[$timestamp] = $message->getHeader(self::HEADER_TIMESTAMP);
[$nonce] = $message->getHeader(self::HEADER_NONCE);
[$serial] = $message->getHeader(self::HEADER_SERIAL);
[$signature] = $message->getHeader(self::HEADER_SIGNATURE);
$body = (string) $message->getBody();
$message = "{$timestamp}\n{$nonce}\n{$body}\n";
if (\time() - \intval($timestamp) > self::MAX_ALLOWED_CLOCK_OFFSET) {
throw new InvalidSignatureException('Clock Offset Exceeded');
}
$publicKey = $this->merchant->getPlatformCert($serial);
if (! $publicKey) {
throw new InvalidConfigException(
"No platform certs found for serial: {$serial},
please download from wechat pay and set it in merchant config with key `certs`."
);
}
if (false === \openssl_verify(
$message,
base64_decode($signature),
strval($publicKey),
OPENSSL_ALGO_SHA256
)) {
throw new InvalidSignatureException('Invalid Signature');
}
}
}