.github/workflows/build.yml 0000644 00000001205 15073164670 0011772 0 ustar 00 name: build
on: [push]
jobs:
run:
runs-on: ubuntu-latest
strategy:
matrix:
php-versions: ['7.3', '7.4', '8.0']
name: Testing on PHP ${{ matrix.php-versions }}
steps:
- uses: actions/checkout@v2
- name: setup
uses: shivammathur/setup-php@v2
with:
php-version: ${{ matrix.php-versions }}
extensions: mbstring,bcmath
tools: phpunit,composer
- name: install deps
run: composer install -o -q
- name: run phpunit
run: vendor/bin/phpunit
- name: run phpstan
run: vendor/bin/phpstan analyze --no-progress --level=5 src/ .gitignore 0000644 00000000102 15073164670 0006536 0 ustar 00 .DS_Store
composer.lock
vendor/
dev/
.idea/
.phpunit.result.cache
LICENSE 0000644 00000002066 15073164670 0005566 0 ustar 00 The MIT License (MIT)
Copyright (c) 2019 Oliver Vogel
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. README.md 0000755 00000006632 15073164670 0006046 0 ustar 00 # A class to detect mime types of given contents
Detecting MIME Content-type in PHP is easy with [mime_content_type](https://www.php.net/manual/en/function.mime-content-type.php) or [Fileinfo](https://www.php.net/manual/en/book.fileinfo.php). But Fileinfo as an extension is sometimes not available on the server. The function `mime_content_type` wants a path to the filesystem as argument and doesn't process if we only have a string value. This package makes it easy to detect the mime types of the content of a given file or string, without any extension dependencies. Here's an example:
```php
use Intervention\MimeSniffer\MimeSniffer;
use Intervention\MimeSniffer\Types\ImageJpeg;
// detect given string
$sniffer = MimeSniffer::createFromString($content);
// or detect given file
$sniffer = MimeSniffer::createFromFilename('image.jpg');
// returns object of detected type
$type = $sniffer->getType();
$bool = $type->isBinary(); // check if we have binary data
$bool = $type->isImage(); // check if we are dealing with an image
$bool = $type->isVideo(); // check video data was detected
$bool = $type->isAudio(); // check if we have detected audio data
$bool = $type->isArchive(); // check if an archive was detected
$type = (string) $type; // cast type to string (e.g. "image/jpeg")
// you can also check, if the content matches a specific type
$bool = $sniffer->matches(new ImageJpeg);
// or check, if the content matches an array of types
$bool = $sniffer->matches([ImageJpeg::class, ImageGif::class]);
// or check, if the content matches an array of type objects
$bool = $sniffer->matches([new ImageJpeg, $type]);
```
If your prefer non-static initialization:
```php
use Intervention\MimeSniffer\MimeSniffer;
// create instance with constructor
$sniffer = new MimeSniffer($content);
// with setter for given content
$type = $sniffer->setFromString($other_content)->getType();
// or with setter for filename
$type = $sniffer->setFromFilename('images/image.jpg')->getType();
```
**Currently only the following file types can be detected. More will be added in a next release.**
### Images
- Image encoded as JPEG raw or in the JFIF or Exif file format
- Image file encoded in the Graphics Interchange Format (GIF)
- Image encoded in the Portable Network Graphics format (PNG)
- Image encoded as BMP file, a bitmap format
- Image encoded in High Efficiency Image File Format (HEIC/HEIF)
- Icon encoded in ICO file format
- Image in Google WebP image format
- Scalable Vector Graphics (SVG)
- Tagged Image File Format (TIFF)
- Image encoded Photoshop Document file format (PSD)
### Archives
- GZIP compressed
- ZIP file
- RAR archive
- TAR file
### Videos
- AVI
- MPEG-1 and MPEG-2 video
- MKV media container
### Audio
- MP3 file
- FLAC file
### Other
- PDF document
- OGG media container
- SQLite Database
- application/octet-stream (default binary)
- text/plain (default)
## Installation
Install the package easily via composer:
```bash
composer require intervention/mimesniffer
```
## Contributing
Contributions are welcome. Please note the following guidelines before submiting your pull request.
- Follow [PSR-2](http://www.php-fig.org/psr/psr-2/) coding standards.
- Write tests for new functions and added features
## License
Licensed under the [MIT License](http://opensource.org/licenses/MIT).
Copyright 2019 [Oliver Vogel](https://olivervogel.com/)
composer.json 0000644 00000001430 15073164670 0007275 0 ustar 00 {
"name": "intervention/mimesniffer",
"description": "PHP MIME Type Sniffer",
"homepage": "http://intervention.io/",
"keywords": ["mime", "type", "sniffer", "detector"],
"license": "MIT",
"authors": [
{
"name": "Oliver Vogel",
"email": "oliver@olivervogel.com",
"homepage": "https://olivervogel.com/"
}
],
"require": {
"php": "^7.3|^8.0"
},
"require-dev": {
"phpunit/phpunit": "^9.0",
"phpstan/phpstan": "^0.12.11"
},
"autoload": {
"psr-4": {
"Intervention\\MimeSniffer\\": "src"
}
},
"autoload-dev": {
"psr-4": {
"Intervention\\MimeSniffer\\Test\\": "tests"
}
},
"minimum-stability": "stable"
}
phpunit.xml 0000644 00000001035 15073164670 0006765 0 ustar 00
./tests/
src/AbstractBinaryType.php 0000644 00000001024 15073164670 0011624 0 ustar 00 pattern, $this->prepareContent($content)) === 1;
}
/**
* Determine if the detected type is an image
*
* @return boolean
*/
public function isImage(): bool
{
return substr($this->name, 0, 5) === 'image';
}
/**
* Determine if the detected type is an video
*
* @return boolean
*/
public function isVideo(): bool
{
return substr($this->name, 0, 5) === 'video';
}
/**
* Determine if the detected type is an audio file
*
* @return boolean
*/
public function isAudio(): bool
{
return substr($this->name, 0, 5) === 'audio';
}
/**
* Determine if the detected type is an archive
*
* @return boolean
*/
public function isArchive(): bool
{
return in_array($this->name, [
'application/zip',
'application/x-rar-compressed',
'application/x-tar',
'application/gzip',
]);
}
/**
* Prepare content (can be extended by child classes)
*
* @param string $content
* @return string
*/
public function prepareContent(string $content): string
{
return substr($content, 0, 1024);
}
/**
* Determine of current type is binary
*
* @return boolean
*/
public function isBinary(): bool
{
return false;
}
/**
* Cast type to string
*
* @return string
*/
public function __toString(): string
{
return $this->name;
}
}
src/Exceptions/NotMatchingException.php 0000644 00000000240 15073164670 0014264 0 ustar 00 setFromString($content);
}
/**
* Create new instance from given string
*
* @param string $content
*
* @return MimeSniffer
*/
public static function createFromString(string $content): MimeSniffer
{
return new self($content);
}
/**
* Load contents of given string into instance
*
* @param string $content
*
* @return MimeSniffer
*/
public function setFromString(string $content): MimeSniffer
{
$this->content = strval($content);
return $this;
}
/**
* Create a new instance and load contents of given filename
*
* @param string $filename
*
* @return MimeSniffer
*/
public static function createFromFilename(string $filename): MimeSniffer
{
return (new self())->setFromFilename($filename);
}
/**
* Load contents of given filename in current instance
*
* @param string $filename
*
* @return MimeSniffer
*/
public function setFromFilename(string $filename): MimeSniffer
{
$fp = fopen($filename, 'r');
$this->setFromString(fread($fp, 1024));
fclose($fp);
return $this;
}
/**
* Return detected type
*
* @return AbstractType
*/
public function getType(): AbstractType
{
foreach ($this->getTypeClassnames() as $classname) {
$type = new $classname();
if ($type->matches($this->content)) {
return $type;
}
}
$binaryType = new Types\ApplicationOctetStream();
if ($this->matches($binaryType)) {
return $binaryType;
}
return new Types\TextPlain();
}
/**
* Determine if content matches the given type
* or any if the given types in array
*
* @param AbstractType|array $types AbstractType or array of AbstractTypes
* @return boolean
*/
public function matches($types): bool
{
if (! is_array($types)) {
$types = [$types];
}
$types = array_map(function ($value) {
if (is_a($value, AbstractType::class)) {
return $value;
}
if (class_exists($value)) {
return new $value();
}
}, $types);
$types = array_filter($types, function ($type) {
return is_a($type, AbstractType::class);
});
foreach ($types as $type) {
if ($type->matches($this->content)) {
return true;
}
}
return false;
}
/**
* Return array of type classnames
*
* @return array
*/
private function getTypeClassnames(): array
{
$files = array_diff(scandir(__DIR__ . '/Types'), ['.', '..']);
$classnames = array_map(function ($filename) {
return "Intervention\\MimeSniffer\\Types\\" . substr($filename, 0, -4);
}, $files);
return array_filter($classnames, function ($classname) {
return ! in_array($classname, [
Types\ApplicationOctetStream::class,
Types\TextPlain::class,
]);
});
}
}
src/Types/ApplicationGzip.php 0000644 00000000556 15073164670 0012264 0 ustar 00 ]*\?>.*)?]*>/is";
}
src/Types/ImageTiff.php 0000644 00000000561 15073164670 0011016 0 ustar 00 getMockForAbstractClass(AbstractBinaryType::class);
$this->assertEquals(1024, strlen($type->prepareContent($content)));
$this->assertEquals('78787878', substr($type->prepareContent($content), 0, 8));
}
public function testIsBinary()
{
$type = $this->getMockForAbstractClass(AbstractBinaryType::class);
$this->assertTrue($type->isBinary());
}
}
tests/AbstractTypeTest.php 0000644 00000002141 15073164670 0011673 0 ustar 00 getMockForAbstractClass(AbstractType::class);
$this->assertEquals('', $type);
}
public function testMatches()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->matches('test'));
}
public function testIsImage()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->isImage());
}
public function testPrepareContent()
{
$content = '';
for ($i = 0; $i < 2048; $i++) {
$content .= 'x';
}
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertEquals(1024, strlen($type->prepareContent($content)));
}
public function testIsBinary()
{
$type = $this->getMockForAbstractClass(AbstractType::class);
$this->assertFalse($type->isBinary());
}
}
tests/ApplicationGzipTest.php 0000644 00000001232 15073164670 0012363 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/gzip');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationGzip::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationOggTest.php 0000644 00000001226 15073164670 0012171 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/ogg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationOgg::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationPdfTest.php 0000644 00000001226 15073164670 0012166 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/pdf');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationPdf::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/ApplicationRarTest.php 0000644 00000001231 15073164670 0012175 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/rar');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationRar::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/ApplicationSqliteTest.php 0000644 00000001104 15073164670 0012711 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.sqlite');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationSqlite::class, $this->type);
}
}
tests/ApplicationTarTest.php 0000644 00000001236 15073164670 0012204 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.tar');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationTar::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/ApplicationZipTest.php 0000644 00000001231 15073164670 0012213 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ApplicationZip::class, $this->type);
}
public function testIsArchive()
{
$this->assertTrue($this->type->isArchive());
}
}
tests/AudioFlacTest.php 0000644 00000001210 15073164670 0011111 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/flac');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioFlac::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
}
tests/AudioMpegId3v2Test.php 0000644 00000001221 15073164670 0011746 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mp3_id3v2');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioMpeg::class, $this->type);
}
public function testIsAudio()
{
$this->assertTrue($this->type->isAudio());
}
}
tests/AudioMpegTest.php 0000644 00000001214 15073164670 0011140 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mp3_id3v1');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(AudioMpeg::class, $this->type);
}
public function testIsAudio()
{
$this->assertTrue($this->type->isAudio());
}
}
tests/ImageBmpTest.php 0000644 00000001210 15073164670 0010743 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.bmp');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageBmp::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageGifTest.php 0000644 00000001210 15073164670 0010732 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageGif::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageHeicTest.php 0000644 00000001207 15073164670 0011103 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/heic');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageHeic::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageHeifTest.php 0000644 00000001207 15073164670 0011106 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/heif');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageHeif::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageIcoTest.php 0000644 00000001210 15073164670 0010737 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.ico');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageIco::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageJpegTest.php 0000644 00000001213 15073164670 0011115 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.jpg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageJpeg::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImagePngTest.php 0000644 00000001210 15073164670 0010751 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.png');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImagePng::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImagePsdTest.php 0000644 00000001203 15073164670 0010755 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/psd');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImagePsd::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageSvgTest.php 0000644 00000002242 15073164670 0010772 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.svg');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageSvg::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
public function testPlainXmlIsNotSvg()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.xml');
$this->assertInstanceOf(TextPlain::class, $sniffer->getType());
}
public function testSvgWithoutXmlTag()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/svg');
$this->assertInstanceOf(ImageSvg::class, $sniffer->getType());
}
}
tests/ImageTiffTest.php 0000644 00000001207 15073164670 0011123 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/tiff');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageTiff::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/ImageWebpTest.php 0000644 00000001214 15073164670 0011126 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.webp');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(ImageWebp::class, $this->type);
}
public function testIsImage()
{
$this->assertTrue($this->type->isImage());
}
}
tests/MimeSnifferTest.php 0000644 00000005303 15073164670 0011475 0 ustar 00 assertInstanceOf(MimeSniffer::class, $sniffer);
$sniffer = new MimeSniffer();
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testCreateFromString()
{
$sniffer = MimeSniffer::createFromString('foo');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testCreateFromFilename()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.jpg');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testSetFromString()
{
$sniffer = new MimeSniffer();
$sniffer = $sniffer->setFromString('foo');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testSetFromFilename()
{
$sniffer = new MimeSniffer();
$sniffer = $sniffer->setFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->assertInstanceOf(MimeSniffer::class, $sniffer);
}
public function testMatchesType()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->assertTrue($sniffer->matches(new ImageGif()));
$this->assertFalse($sniffer->matches(new ImageJpeg()));
}
public function testMatchesArray()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/files/test.gif');
$this->assertTrue($sniffer->matches([new ImageJpeg(), new ImagePng(), new ImageGif()]));
$this->assertFalse($sniffer->matches([new ImageJpeg(), new ImagePng()]));
$this->assertTrue($sniffer->matches([ImageJpeg::class, ImagePng::class, ImageGif::class]));
$this->assertFalse($sniffer->matches([ImageJpeg::class, ImagePng::class]));
}
public function testMatchesBogus()
{
$sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/zip');
$this->assertFalse($sniffer->matches('foo'));
$this->assertFalse($sniffer->matches(['foo', 'bar']));
$this->assertFalse($sniffer->matches([]));
$this->assertFalse($sniffer->matches(null));
$this->assertTrue($sniffer->matches(['foo', ApplicationZip::class]));
}
}
tests/VideoMpegTest.php 0000644 00000001360 15073164670 0011147 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mpeg-video');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoMpeg::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/VideoXmatroskaTest.php 0000644 00000001370 15073164670 0012231 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/mkv');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoXmatroska::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/VideoXmsvideoTest.php 0000644 00000001365 15073164670 0012062 0 ustar 00 sniffer = MimeSniffer::createFromFilename(__DIR__ . '/../tests/stubs/avi');
$this->type = $this->sniffer->getType();
}
public function testType()
{
$this->assertInstanceOf(VideoXmsvideo::class, $this->type);
}
public function testIsImage()
{
$this->assertFalse($this->type->isImage());
}
public function testIsVideo()
{
$this->assertTrue($this->type->isVideo());
}
}
tests/files/test.bin 0000644 00000000400 15073164670 0010464 0 ustar 00
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ tests/files/test.bmp 0000644 00000001070 15073164670 0010476 0 ustar 00 BM8 6 ( pppppppppppppppppppppppppppppppppppp`< <`ppppppp T$ $ Tppppp`$ $`pppp< <pppp pppp pppp pppp pppp< <pppp`$ $`ppppp T$ $ Tppppppp`< <`pppppppppppppppppppppppppppppppppppp tests/files/test.gif 0000644 00000001120 15073164670 0010461 0 ustar 00 GIF89a 9KcBO_EQ]mcI
jaK$6zefxj쬺,YwYxoܽx|mUx*VUUU˫ʼ~|o⮯^̫]ef^x*Yvfxͫ,eYvWnzz^2 x۫ugf |=gۼxUfՖVfmm5yw6[UxU^j.ʲʺYfg ju^UVٕufxmm[^Ϳzmm^>u32ڳ3*2ʫYffWu~Wwz[wUe[W 2+nfݟwV궶m]UW_{xx+͵Vm]6kŕgoVykuvy̪l̪ 7m+2+.YVfYefxlw^o^lǯ_ ͪuUUVx33,g|lٵ*k,|6[m^o[un=+*kUU]xʺ˲̳jϭ [|<|ݖ][eUVmejUU[Wyzm}/*˼]Ul*fVfkloyvתe^3UeY/Umx˺7 Y^2˺.jmʪ6ݗx˶uUmYzY[~ |ŵVx˳NjʺʪfYuv|o7
=g*NjǏzm˼_/7o7UՙoegNJʬ̻6y
lͪ*ʬeUUeue]m]ǯ 7Uz+e]UW2[v]ךʭ{,۳*ykj ? jg tests/files/test.png 0000644 00000000577 15073164670 0010517 0 ustar 00 PNG
IHDR 2 2 ? FIDATx=P*
- *+=,*or?w>|3zDF K5rĈ`
M
RpG%[[Ɉ5H6"Y `;~
OB<`x'L
v0B>젲 vpɜ{ H=S > .?
r Y
z -
1
Y j; !57% tests/files/test.svg 0000644 00000016243 15073164670 0010527 0 ustar 00
tests/files/test.tar 0000644 00000024000 15073164670 0010504 0 ustar 00 foo.json 0000644 0001750 0001750 00000000076 13513647427 012135 0 ustar oliver oliver {
"require": {
"intervention/image": "^1"
}
}
tests/files/test.txt 0000644 00000000004 15073164670 0010533 0 ustar 00 test tests/files/test.webp 0000644 00000000314 15073164670 0010655 0 ustar 00 RIFF WEBPVP8 * %tN
ҿ n6[@ t7U'~L,6h{\` Wi+P\);
ahј 0x*l }!q>PPSDٞ\vC . Z[
B% ¼2 tests/files/test.xml 0000644 00000000536 15073164670 0010526 0 ustar 00
http://intervention.io/
tests/stubs/avi 0000644 00000000020 15073164670 0007551 0 ustar 00 RIFFAVI tests/stubs/flac 0000644 00000000010 15073164670 0007676 0 ustar 00 fLaC tests/stubs/gzip 0000644 00000000003 15073164670 0007744 0 ustar 00 tests/stubs/heic 0000644 00000000170 15073164670 0007710 0 ustar 00 ftypheic mif1miafMiHBheic
meta "hdlr pict $dinf dref url pi tests/stubs/heif 0000644 00000000100 15073164670 0007704 0 ustar 00 ftypmif1 mif1heic meta !hdlr pict tests/stubs/mkv 0000644 00000000010 15073164670 0007566 0 ustar 00 Eߣ tests/stubs/mp3_id3v1 0000644 00000000004 15073164670 0010501 0 ustar 00 tests/stubs/mp3_id3v2 0000644 00000000006 15073164670 0010504 0 ustar 00 ID3 tests/stubs/mpeg-video 0000644 00000000010 15073164670 0011025 0 ustar 00 tests/stubs/ogg 0000644 00000000010 15073164670 0007545 0 ustar 00 OggS tests/stubs/pdf 0000644 00000000006 15073164670 0007547 0 ustar 00 %PDF- tests/stubs/psd 0000644 00000000005 15073164670 0007563 0 ustar 00 8BPS tests/stubs/rar 0000644 00000000007 15073164670 0007563 0 ustar 00 Rar! tests/stubs/svg 0000644 00000000227 15073164670 0007602 0 ustar 00
tests/stubs/tiff 0000644 00000000004 15073164670 0007724 0 ustar 00 II* tests/stubs/zip 0000644 00000000004 15073164670 0007576 0 ustar 00 PK