Initial commit

full-size-image-links/full-size-image-links.php

@@ -0,0 +1,114 @@
+<?php
+/*
+Plugin Name: Full Size Image Links
+Plugin URI: https://meowapps.com
+Description: Link to full-size media files from galleries. Blatently ripped from Gallery Custom Links by Jordy Meow
+Version: 1.0.0
+Author: Zach Isbach, Jordy Meow
+Author URI: https://meowapps.com
+Text Domain: full-size-image-links
+Domain Path: /languages
+
+:icensed under the MIT license:
+http://www.opensource.org/licenses/mit-license.php
+*/
+
+require_once 'vendor/autoload.php';
+
+use DiDom\Document;
+use DiDom\Element;
+
+new Full_Size_Image_Links();
+
+class Full_Size_Image_Links {	
+	public function __construct() {
+		add_filter( 'the_content', array( $this, 'linkify' ), 20 );
+	}
+	
+	function get_pathinfo_from_image_src( $image_src ) {
+		$uploads = wp_upload_dir();
+		$uploads_url = trailingslashit( $uploads['baseurl'] );
+		if ( strpos( $image_src, $uploads_url ) === 0 )
+			return ltrim( substr( $image_src, strlen( $uploads_url ) ), '/');
+		else if ( strpos( $image_src, wp_make_link_relative( $uploads_url ) ) === 0 )
+			return ltrim( substr( $image_src, strlen( wp_make_link_relative( $uploads_url ) ) ), '/');
+		$img_info = parse_url( $image_src );
+		return ltrim( $img_info['path'], '/' );
+	}
+		
+	function resolve_image_id( $url ) {
+		global $wpdb;
+		$pattern = '/[_-]\d+x\d+(?=\.[a-z]{3,4}$)/';
+		$url = preg_replace( $pattern, '', $url );
+		$url = $this->get_pathinfo_from_image_src( $url );
+		$query = $wpdb->prepare( "SELECT ID FROM $wpdb->posts WHERE guid LIKE '%s'", '%' . $url . '%' );
+		$attachment = $wpdb->get_col( $query );
+		return empty( $attachment ) ? null : $attachment[0];
+	}
+		
+	function linkify( $buffer ) {
+		if (!isset( $buffer ) || trim( $buffer ) === '' )
+			return $buffer;
+		$html = new Document();
+		$html->preserveWhiteSpace();
+		$html->loadHtml( $buffer, 0 );
+		$hasChanges = false;
+		$classes = apply_filters( 'gallery_custom_links_classes', array( '.gallery', '.wp-block-gallery' ) );
+		foreach ( $classes as $class ) {
+			foreach ( $html->find( $class . ' img' ) as $element )
+				$hasChanges = $this->linkify_element( $element ) || $hasChanges;
+		}
+		return $hasChanges ? $html->html() : $buffer;
+	}
+		
+	function linkify_element( $element ) {
+		$classes = $element->attr('class');
+		$mediaId = null;
+
+		// Check if the wp-image-xxx class exists
+		if ( preg_match( '/wp-image-([0-9]{1,10})/i', $classes, $matches ) )
+			$mediaId = $matches[1];
+		// Otherwise, resolve the ID from the URL
+		else {
+			$url = $element->attr('src');
+			$mediaId = $this->resolve_image_id( $url );
+		}
+
+		if ( $mediaId ) {
+			$url = wp_get_attachment_url($mediaId);
+			$parent = $element->parent();
+
+			// Modify an existing link tag
+			$potentialLinkNode = $parent;
+			$maxDepth = 10;
+			do {
+				if ( $potentialLinkNode->tag === 'a' ) {
+					$potentialLinkNode->attr( 'href', $url );
+					$class = $potentialLinkNode->attr( 'class' );
+					$potentialLinkNode->attr( 'class', $class );
+					return true;
+				}
+				if ( method_exists( $potentialLinkNode, 'parent' ) )
+					$potentialLinkNode = $potentialLinkNode->parent();
+				else
+					break;
+			}
+			while ( $potentialLinkNode && $maxDepth-- >= 0 );
+
+			// Insert a new link tag
+			if ( $parent->tag === 'figure' )
+				$parent = $parent->parent();
+			$a = new Element('a');
+			$a->attr( 'href', $url );
+			$a->appendChild( $parent->children() );
+			foreach( $parent->children() as $img ) {
+				$img->remove();
+			}
+			$parent->appendChild( $a );
+			return true;
+		}
+		return false;
+	}
+}
+
+?>

full-size-image-links/vendor/autoload.php

@@ -0,0 +1,7 @@
+<?php
+
+// autoload.php @generated by Composer
+
+require_once __DIR__ . '/composer/autoload_real.php';
+
+return ComposerAutoloaderInit2605e89cef9fc84e4fbf6431ef455676::getLoader();

full-size-image-links/vendor/composer/ClassLoader.php

@@ -0,0 +1,445 @@
+<?php
+
+/*
+ * This file is part of Composer.
+ *
+ * (c) Nils Adermann <naderman@naderman.de>
+ *     Jordi Boggiano <j.boggiano@seld.be>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Composer\Autoload;
+
+/**
+ * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
+ *
+ *     $loader = new \Composer\Autoload\ClassLoader();
+ *
+ *     // register classes with namespaces
+ *     $loader->add('Symfony\Component', __DIR__.'/component');
+ *     $loader->add('Symfony',           __DIR__.'/framework');
+ *
+ *     // activate the autoloader
+ *     $loader->register();
+ *
+ *     // to enable searching the include path (eg. for PEAR packages)
+ *     $loader->setUseIncludePath(true);
+ *
+ * In this example, if you try to use a class in the Symfony\Component
+ * namespace or one of its children (Symfony\Component\Console for instance),
+ * the autoloader will first look for the class under the component/
+ * directory, and it will then fallback to the framework/ directory if not
+ * found before giving up.
+ *
+ * This class is loosely based on the Symfony UniversalClassLoader.
+ *
+ * @author Fabien Potencier <fabien@symfony.com>
+ * @author Jordi Boggiano <j.boggiano@seld.be>
+ * @see    http://www.php-fig.org/psr/psr-0/
+ * @see    http://www.php-fig.org/psr/psr-4/
+ */
+class ClassLoader
+{
+    // PSR-4
+    private $prefixLengthsPsr4 = array();
+    private $prefixDirsPsr4 = array();
+    private $fallbackDirsPsr4 = array();
+
+    // PSR-0
+    private $prefixesPsr0 = array();
+    private $fallbackDirsPsr0 = array();
+
+    private $useIncludePath = false;
+    private $classMap = array();
+    private $classMapAuthoritative = false;
+    private $missingClasses = array();
+    private $apcuPrefix;
+
+    public function getPrefixes()
+    {
+        if (!empty($this->prefixesPsr0)) {
+            return call_user_func_array('array_merge', $this->prefixesPsr0);
+        }
+
+        return array();
+    }
+
+    public function getPrefixesPsr4()
+    {
+        return $this->prefixDirsPsr4;
+    }
+
+    public function getFallbackDirs()
+    {
+        return $this->fallbackDirsPsr0;
+    }
+
+    public function getFallbackDirsPsr4()
+    {
+        return $this->fallbackDirsPsr4;
+    }
+
+    public function getClassMap()
+    {
+        return $this->classMap;
+    }
+
+    /**
+     * @param array $classMap Class to filename map
+     */
+    public function addClassMap(array $classMap)
+    {
+        if ($this->classMap) {
+            $this->classMap = array_merge($this->classMap, $classMap);
+        } else {
+            $this->classMap = $classMap;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix, either
+     * appending or prepending to the ones previously set for this prefix.
+     *
+     * @param string       $prefix  The prefix
+     * @param array|string $paths   The PSR-0 root directories
+     * @param bool         $prepend Whether to prepend the directories
+     */
+    public function add($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            if ($prepend) {
+                $this->fallbackDirsPsr0 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr0
+                );
+            } else {
+                $this->fallbackDirsPsr0 = array_merge(
+                    $this->fallbackDirsPsr0,
+                    (array) $paths
+                );
+            }
+
+            return;
+        }
+
+        $first = $prefix[0];
+        if (!isset($this->prefixesPsr0[$first][$prefix])) {
+            $this->prefixesPsr0[$first][$prefix] = (array) $paths;
+
+            return;
+        }
+        if ($prepend) {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixesPsr0[$first][$prefix]
+            );
+        } else {
+            $this->prefixesPsr0[$first][$prefix] = array_merge(
+                $this->prefixesPsr0[$first][$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace, either
+     * appending or prepending to the ones previously set for this namespace.
+     *
+     * @param string       $prefix  The prefix/namespace, with trailing '\\'
+     * @param array|string $paths   The PSR-4 base directories
+     * @param bool         $prepend Whether to prepend the directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function addPsr4($prefix, $paths, $prepend = false)
+    {
+        if (!$prefix) {
+            // Register directories for the root namespace.
+            if ($prepend) {
+                $this->fallbackDirsPsr4 = array_merge(
+                    (array) $paths,
+                    $this->fallbackDirsPsr4
+                );
+            } else {
+                $this->fallbackDirsPsr4 = array_merge(
+                    $this->fallbackDirsPsr4,
+                    (array) $paths
+                );
+            }
+        } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
+            // Register directories for a new namespace.
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        } elseif ($prepend) {
+            // Prepend directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                (array) $paths,
+                $this->prefixDirsPsr4[$prefix]
+            );
+        } else {
+            // Append directories for an already registered namespace.
+            $this->prefixDirsPsr4[$prefix] = array_merge(
+                $this->prefixDirsPsr4[$prefix],
+                (array) $paths
+            );
+        }
+    }
+
+    /**
+     * Registers a set of PSR-0 directories for a given prefix,
+     * replacing any others previously set for this prefix.
+     *
+     * @param string       $prefix The prefix
+     * @param array|string $paths  The PSR-0 base directories
+     */
+    public function set($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr0 = (array) $paths;
+        } else {
+            $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Registers a set of PSR-4 directories for a given namespace,
+     * replacing any others previously set for this namespace.
+     *
+     * @param string       $prefix The prefix/namespace, with trailing '\\'
+     * @param array|string $paths  The PSR-4 base directories
+     *
+     * @throws \InvalidArgumentException
+     */
+    public function setPsr4($prefix, $paths)
+    {
+        if (!$prefix) {
+            $this->fallbackDirsPsr4 = (array) $paths;
+        } else {
+            $length = strlen($prefix);
+            if ('\\' !== $prefix[$length - 1]) {
+                throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
+            }
+            $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
+            $this->prefixDirsPsr4[$prefix] = (array) $paths;
+        }
+    }
+
+    /**
+     * Turns on searching the include path for class files.
+     *
+     * @param bool $useIncludePath
+     */
+    public function setUseIncludePath($useIncludePath)
+    {
+        $this->useIncludePath = $useIncludePath;
+    }
+
+    /**
+     * Can be used to check if the autoloader uses the include path to check
+     * for classes.
+     *
+     * @return bool
+     */
+    public function getUseIncludePath()
+    {
+        return $this->useIncludePath;
+    }
+
+    /**
+     * Turns off searching the prefix and fallback directories for classes
+     * that have not been registered with the class map.
+     *
+     * @param bool $classMapAuthoritative
+     */
+    public function setClassMapAuthoritative($classMapAuthoritative)
+    {
+        $this->classMapAuthoritative = $classMapAuthoritative;
+    }
+
+    /**
+     * Should class lookup fail if not found in the current class map?
+     *
+     * @return bool
+     */
+    public function isClassMapAuthoritative()
+    {
+        return $this->classMapAuthoritative;
+    }
+
+    /**
+     * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
+     *
+     * @param string|null $apcuPrefix
+     */
+    public function setApcuPrefix($apcuPrefix)
+    {
+        $this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null;
+    }
+
+    /**
+     * The APCu prefix in use, or null if APCu caching is not enabled.
+     *
+     * @return string|null
+     */
+    public function getApcuPrefix()
+    {
+        return $this->apcuPrefix;
+    }
+
+    /**
+     * Registers this instance as an autoloader.
+     *
+     * @param bool $prepend Whether to prepend the autoloader or not
+     */
+    public function register($prepend = false)
+    {
+        spl_autoload_register(array($this, 'loadClass'), true, $prepend);
+    }
+
+    /**
+     * Unregisters this instance as an autoloader.
+     */
+    public function unregister()
+    {
+        spl_autoload_unregister(array($this, 'loadClass'));
+    }
+
+    /**
+     * Loads the given class or interface.
+     *
+     * @param  string    $class The name of the class
+     * @return bool|null True if loaded, null otherwise
+     */
+    public function loadClass($class)
+    {
+        if ($file = $this->findFile($class)) {
+            includeFile($file);
+
+            return true;
+        }
+    }
+
+    /**
+     * Finds the path to the file where the class is defined.
+     *
+     * @param string $class The name of the class
+     *
+     * @return string|false The path if found, false otherwise
+     */
+    public function findFile($class)
+    {
+        // class map lookup
+        if (isset($this->classMap[$class])) {
+            return $this->classMap[$class];
+        }
+        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
+            return false;
+        }
+        if (null !== $this->apcuPrefix) {
+            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
+            if ($hit) {
+                return $file;
+            }
+        }
+
+        $file = $this->findFileWithExtension($class, '.php');
+
+        // Search for Hack files if we are running on HHVM
+        if (false === $file && defined('HHVM_VERSION')) {
+            $file = $this->findFileWithExtension($class, '.hh');
+        }
+
+        if (null !== $this->apcuPrefix) {
+            apcu_add($this->apcuPrefix.$class, $file);
+        }
+
+        if (false === $file) {
+            // Remember that this class does not exist.
+            $this->missingClasses[$class] = true;
+        }
+
+        return $file;
+    }
+
+    private function findFileWithExtension($class, $ext)
+    {
+        // PSR-4 lookup
+        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
+
+        $first = $class[0];
+        if (isset($this->prefixLengthsPsr4[$first])) {
+            $subPath = $class;
+            while (false !== $lastPos = strrpos($subPath, '\\')) {
+                $subPath = substr($subPath, 0, $lastPos);
+                $search = $subPath . '\\';
+                if (isset($this->prefixDirsPsr4[$search])) {
+                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
+                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
+                        if (file_exists($file = $dir . $pathEnd)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-4 fallback dirs
+        foreach ($this->fallbackDirsPsr4 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 lookup
+        if (false !== $pos = strrpos($class, '\\')) {
+            // namespaced class name
+            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
+                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
+        } else {
+            // PEAR-like class name
+            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
+        }
+
+        if (isset($this->prefixesPsr0[$first])) {
+            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
+                if (0 === strpos($class, $prefix)) {
+                    foreach ($dirs as $dir) {
+                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                            return $file;
+                        }
+                    }
+                }
+            }
+        }
+
+        // PSR-0 fallback dirs
+        foreach ($this->fallbackDirsPsr0 as $dir) {
+            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
+                return $file;
+            }
+        }
+
+        // PSR-0 include paths.
+        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
+            return $file;
+        }
+
+        return false;
+    }
+}
+
+/**
+ * Scope isolated include.
+ *
+ * Prevents access to $this/self from included files.
+ */
+function includeFile($file)
+{
+    include $file;
+}

full-size-image-links/vendor/composer/LICENSE

@@ -0,0 +1,21 @@
+
+Copyright (c) Nils Adermann, Jordi Boggiano
+
+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.
+

full-size-image-links/vendor/composer/autoload_classmap.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_classmap.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

full-size-image-links/vendor/composer/autoload_namespaces.php

@@ -0,0 +1,9 @@
+<?php
+
+// autoload_namespaces.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+);

full-size-image-links/vendor/composer/autoload_psr4.php

@@ -0,0 +1,10 @@
+<?php
+
+// autoload_psr4.php @generated by Composer
+
+$vendorDir = dirname(dirname(__FILE__));
+$baseDir = dirname($vendorDir);
+
+return array(
+    'DiDom\\' => array($vendorDir . '/imangazaliev/didom/src/DiDom'),
+);

full-size-image-links/vendor/composer/autoload_real.php

@@ -0,0 +1,52 @@
+<?php
+
+// autoload_real.php @generated by Composer
+
+class ComposerAutoloaderInit2605e89cef9fc84e4fbf6431ef455676
+{
+    private static $loader;
+
+    public static function loadClassLoader($class)
+    {
+        if ('Composer\Autoload\ClassLoader' === $class) {
+            require __DIR__ . '/ClassLoader.php';
+        }
+    }
+
+    public static function getLoader()
+    {
+        if (null !== self::$loader) {
+            return self::$loader;
+        }
+
+        spl_autoload_register(array('ComposerAutoloaderInit2605e89cef9fc84e4fbf6431ef455676', 'loadClassLoader'), true, true);
+        self::$loader = $loader = new \Composer\Autoload\ClassLoader();
+        spl_autoload_unregister(array('ComposerAutoloaderInit2605e89cef9fc84e4fbf6431ef455676', 'loadClassLoader'));
+
+        $useStaticLoader = PHP_VERSION_ID >= 50600 && !defined('HHVM_VERSION') && (!function_exists('zend_loader_file_encoded') || !zend_loader_file_encoded());
+        if ($useStaticLoader) {
+            require_once __DIR__ . '/autoload_static.php';
+
+            call_user_func(\Composer\Autoload\ComposerStaticInit2605e89cef9fc84e4fbf6431ef455676::getInitializer($loader));
+        } else {
+            $map = require __DIR__ . '/autoload_namespaces.php';
+            foreach ($map as $namespace => $path) {
+                $loader->set($namespace, $path);
+            }
+
+            $map = require __DIR__ . '/autoload_psr4.php';
+            foreach ($map as $namespace => $path) {
+                $loader->setPsr4($namespace, $path);
+            }
+
+            $classMap = require __DIR__ . '/autoload_classmap.php';
+            if ($classMap) {
+                $loader->addClassMap($classMap);
+            }
+        }
+
+        $loader->register(true);
+
+        return $loader;
+    }
+}

full-size-image-links/vendor/composer/autoload_static.php

@@ -0,0 +1,31 @@
+<?php
+
+// autoload_static.php @generated by Composer
+
+namespace Composer\Autoload;
+
+class ComposerStaticInit2605e89cef9fc84e4fbf6431ef455676
+{
+    public static $prefixLengthsPsr4 = array (
+        'D' => 
+        array (
+            'DiDom\\' => 6,
+        ),
+    );
+
+    public static $prefixDirsPsr4 = array (
+        'DiDom\\' => 
+        array (
+            0 => __DIR__ . '/..' . '/imangazaliev/didom/src/DiDom',
+        ),
+    );
+
+    public static function getInitializer(ClassLoader $loader)
+    {
+        return \Closure::bind(function () use ($loader) {
+            $loader->prefixLengthsPsr4 = ComposerStaticInit2605e89cef9fc84e4fbf6431ef455676::$prefixLengthsPsr4;
+            $loader->prefixDirsPsr4 = ComposerStaticInit2605e89cef9fc84e4fbf6431ef455676::$prefixDirsPsr4;
+
+        }, null, ClassLoader::class);
+    }
+}

full-size-image-links/vendor/composer/installed.json

@@ -0,0 +1,53 @@
+[
+    {
+        "name": "imangazaliev/didom",
+        "version": "1.14.1",
+        "version_normalized": "1.14.1.0",
+        "source": {
+            "type": "git",
+            "url": "https://github.com/Imangazaliev/DiDOM.git",
+            "reference": "a8389cc26897f6bb8843363b4ea16e7ef16fb3c3"
+        },
+        "dist": {
+            "type": "zip",
+            "url": "https://api.github.com/repos/Imangazaliev/DiDOM/zipball/a8389cc26897f6bb8843363b4ea16e7ef16fb3c3",
+            "reference": "a8389cc26897f6bb8843363b4ea16e7ef16fb3c3",
+            "shasum": ""
+        },
+        "require": {
+            "ext-dom": "*",
+            "ext-iconv": "*",
+            "php": ">=5.4"
+        },
+        "require-dev": {
+            "friendsofphp/php-cs-fixer": "2.9",
+            "phpunit/phpunit": "^4.8"
+        },
+        "time": "2019-01-17T11:01:36+00:00",
+        "type": "library",
+        "installation-source": "dist",
+        "autoload": {
+            "psr-4": {
+                "DiDom\\": "src/DiDom/"
+            }
+        },
+        "notification-url": "https://packagist.org/downloads/",
+        "license": [
+            "MIT"
+        ],
+        "authors": [
+            {
+                "name": "Imangazaliev Muhammad",
+                "email": "imangazalievm@gmail.com"
+            }
+        ],
+        "description": "Simple and fast HTML parser",
+        "homepage": "https://github.com/Imangazaliev/DiDOM",
+        "keywords": [
+            "didom",
+            "html",
+            "parser",
+            "xml"
+        ]
+    }
+]

full-size-image-links/vendor/imangazaliev/didom/.php_cs

@@ -0,0 +1,207 @@
+<?php
+
+use PhpCsFixer\Config;
+use PhpCsFixer\Finder;
+
+require __DIR__.'/vendor/autoload.php';
+
+$fixers = [
+    // PHP arrays should be declared using the short syntax
+    'array_syntax' => ['syntax' => 'short'],
+
+    // There MUST be one blank line after the namespace declaration
+    'blank_line_after_namespace' => true,
+
+    // Ensure there is no code on the same line as the PHP open tag and it is followed by a blank line
+    'blank_line_after_opening_tag' => true,
+
+    // An empty line feed should precede a return statement
+    'blank_line_before_return' => true,
+
+    // The body of each structure MUST be enclosed by braces
+    // Braces should be properly placed
+    // Body of braces should be properly indented
+    'braces' => true,
+
+    // A single space should be between cast and variable
+    'cast_spaces' => true,
+
+    // Whitespace around the key words of a class, trait or interfaces definition should be one space
+    'class_definition' => true,
+
+    // The keyword elseif should be used instead of else if so that all control keywords look like single words
+    'elseif' => true,
+
+    // PHP code MUST use only UTF-8 without BOM (remove BOM)
+    'encoding' => true,
+
+    // PHP code must use the long <?php tags or short-echo <?= tags and not other tag variations
+    'full_opening_tag' => true,
+
+    // Spaces should be properly placed in a function declaration
+    'function_declaration' => true,
+
+    // Add missing space between function's argument and its typehint
+    'function_typehint_space' => true,
+
+    // Include/Require and file path should be divided with a single space
+    // File path should not be placed under brackets
+    'include' => true,
+
+    // Code MUST use configured indentation type
+    'indentation_type' => true,
+
+    // All PHP files must use same line ending
+    'line_ending' => true,
+
+    // The PHP constants true, false, and null MUST be in lower case
+    'lowercase_constants' => true,
+
+    // PHP keywords MUST be in lower case
+    'lowercase_keywords' => true,
+
+    // In method arguments and method call, there MUST NOT be a space before each comma and there MUST be one space after each comma
+    'method_argument_space' => true,
+
+    // Methods must be separated with one blank line
+    'method_separation' => true,
+
+    // There should be no empty lines after class opening brace
+    'no_blank_lines_after_class_opening' => true,
+
+    // There should not be blank lines between docblock and the documented element
+    'no_blank_lines_after_phpdoc' => true,
+
+    // The closing PHP tag MUST be omitted from files containing only PHP
+    'no_closing_tag' => true,
+
+    // Remove leading slashes in use clauses
+    'no_leading_import_slash' => true,
+
+    // The namespace declaration line shouldn't contain leading whitespace
+    'no_leading_namespace_whitespace' => true,
+
+    // Multi-line whitespace before closing semicolon are prohibited
+    'no_multiline_whitespace_before_semicolons' => true,
+
+    // Single-line whitespace before closing semicolon are prohibited
+    'no_singleline_whitespace_before_semicolons' => true,
+
+    // There MUST NOT be a space after the opening parenthesis
+    // There MUST NOT be a space before the closing parenthesis
+    'no_spaces_inside_parenthesis' => true,
+
+    // Remove trailing commas in list function calls
+    'no_trailing_comma_in_list_call' => true,
+
+    // PHP single-line arrays should not have trailing comma
+    'no_trailing_comma_in_singleline_array' => true,
+
+    // Remove trailing commas in list function calls
+    'no_trailing_whitespace' => true,
+
+    // Unused use statements must be removed
+    'no_unused_imports' => true,
+
+    // Remove trailing whitespace at the end of blank lines
+    'no_whitespace_in_blank_line' => true,
+
+    // All instances created with new keyword must be followed by braces
+    'new_with_braces' => true,
+
+    // There should not be space before or after object T_OBJECT_OPERATOR ->
+    'object_operator_without_whitespace' => true,
+
+    // Ordering use statements
+    'ordered_imports' => true,
+
+    // All items of the given phpdoc tags must be aligned vertically
+    // defaults to ['param', 'return', 'throws', 'type', 'var']
+    // 'phpdoc_align' => true,
+
+    // Docblocks should have the same indentation as the documented subject
+    'phpdoc_indent' => true,
+
+    // Fix PHPDoc inline tags, make inheritdoc always inline
+    'phpdoc_inline_tag' => true,
+
+    // @access annotations should be omitted from phpdocs
+    'phpdoc_no_access' => true,
+
+    // @return void and @return null annotations should be omitted from phpdocs
+    'phpdoc_no_empty_return' => true,
+
+    // @package and @subpackage annotations should be omitted from phpdocs
+    'phpdoc_no_package' => true,
+
+    // Scalar types should always be written in the same form
+    // int not integer, bool not boolean, float not real or double
+    'phpdoc_scalar' => true,
+
+    // Annotations in phpdocs should be grouped together so that annotations of the same type immediately follow each other,
+    // and annotations of a different type are separated by a single blank line
+    'phpdoc_separation' => true,
+
+    // Phpdocs summary should end in either a full stop, exclamation mark, or question mark
+    'phpdoc_summary' => true,
+
+    // Docblocks should only be used on structural elements
+    'phpdoc_to_comment' => true,
+
+    // Phpdocs should start and end with content, excluding the very first and last line of the docblocks
+    'phpdoc_trim' => true,
+
+    // @var and @type annotations should not contain the variable name
+    'phpdoc_var_without_name' => true,
+
+    // Pre incrementation/decrementation should be used if possible
+    'pre_increment' => true,
+
+    // A PHP file without end tag must always end with a single empty line feed
+    'single_blank_line_at_eof' => true,
+
+    // There should be exactly one blank line before a namespace declaration
+    'single_blank_line_before_namespace' => true,
+
+    // There MUST be one use keyword per declaration
+    'single_import_per_statement' => true,
+
+    // Each namespace use MUST go on its own line and there MUST be one blank line after the use statements block
+    'single_line_after_imports' => true,
+
+    // Single-line comments and multi-line comments with only one line of actual content should use the // syntax
+    'single_line_comment_style' => true,
+
+    // Convert double quotes to single quotes for simple strings
+    'single_quote' => true,
+
+    // Replace all <> with !=
+    'standardize_not_equals' => true,
+
+    // Standardize spaces around ternary operator
+    'ternary_operator_spaces' => true,
+
+    // PHP multi-line arrays should have a trailing comma
+    'trailing_comma_in_multiline_array' => true,
+
+    // Unary operators should be placed adjacent to their operands
+    'unary_operator_spaces' => true,
+
+    // Visibility MUST be declared on all properties and methods;
+    // abstract and final MUST be declared before the visibility;
+    // static MUST be declared after the visibility
+    'visibility_required' => true,
+];
+
+$finder = Finder::create();
+
+$finder->files()->in([
+    'src',
+]);
+
+$config = Config::create()
+    ->setRules($fixers)
+    ->setFinder($finder)
+    ->setUsingCache(true);
+
+return $config;

full-size-image-links/vendor/imangazaliev/didom/.travis.yml

@@ -0,0 +1,20 @@
+language: php
+
+php:
+  - 5.4
+  - 5.5.9
+  - 5.5
+  - 5.6
+  - 7.0
+
+before_script:
+  - composer self-update
+  - composer install
+
+script:
+  - phpunit
+
+matrix:
+  allow_failures:
+    - php: 5.4
+    - php: 7.0

full-size-image-links/vendor/imangazaliev/didom/CHANGELOG.md

@@ -0,0 +1,211 @@
+### 1.13
+
+- Add `Element::outerHtml()` method
+- Add `Element::prependChild()` method
+- Add `Element::insertBefore()` and `Element::insertAfter()` methods
+- Add `Element::style()` method for more convenient inline styles manipulation
+- Add `Element::classes()` method for more convenient class manipulation
+
+### 1.12
+
+- Many fixes and improvements
+
+### 1.11.1
+
+- Fix bug with unregistered PHP functions in XPath in `Document::has()` and `Document::count()` methods
+
+### 1.11
+
+- Add `Element::isElementNode()` method
+- Add ability to retrieve only specific attributes in `Element::attributes()` method
+- Add `Element::removeAllAttributes()` method
+- Add ability to specify selector and node type in `Element::previousSibling()` and `Element::nextSibling()` methods
+- Add `Element::previousSiblings()` and `Element::nextSiblings()` methods
+- Many minor fixes and improvements
+
+### 1.10.6
+
+- Fix bug with XML document loading
+
+### v1.10.5
+
+- Fix issue #85
+
+### 1.10.4
+
+- Use `mb_convert_encoding()` in the Encoder if it is available
+
+### v1.10.3
+
+- Add `Element::removeChild()` and `Element::removeChildren()` methods
+- Fix bug in `Element::matches()` method
+- `Element::matches()` method now returns false if node is not `DOMElement`
+- Add `Element::hasChildren()` method
+
+### 1.10.2
+
+- Fix bug in setInnerHtml: can't rewrite existing content
+- Throw `InvalidSelectorException` instead of `InvalidArgumentException` when selector is empty
+
+### 1.10.1
+
+- Fix attributes `ends-with` XPath
+- Method `Element::matches()` now can check children nodes
+
+### 1.10
+
+- Fix HTML saving mechanism
+- Throw `InvalidSelectorException` instead of `RuntimeException` in Query class
+
+### 1.9.1
+
+- Add ability to search in owner document using current node as context
+- Bugs fixed
+
+### 1.9.0
+
+- Methods `Document::appendChild()` and `Element::appendChild()` now return appended node(s)
+- Add ability to search elements in context
+
+### 1.8.8
+
+- Bugs fixed
+
+### 1.8.7
+
+- Add `Element::getLineNo()` method
+
+### 1.8.6
+
+- Fix issue #55
+
+### 1.8.5
+
+- Add support of `DOMComment`
+
+### 1.8.4
+
+- Add ability to create an element by selector
+- Add closest method
+
+### 1.8.3
+
+- Add method `Element::isTextNode()`
+- Many minor fixes
+
+### 1.8.2
+
+- Add ability to check that element matches selector
+- Add ability counting nodes by selector
+- Many minor fixes
+
+### 1.8.1
+
+- Small fix
+
+### 1.8
+
+- Bug fixes
+- Add support of ~ selector
+- Add ability to direct search by CSS selector
+- Add setInnerHtml method
+- Add attributes method
+
+### 1.7.4
+
+- Add support of text nodes
+
+### 1.7.3
+
+- Bug fix
+
+### 1.7.2
+
+- Fixed behavior of nth-child pseudo class
+- Add nth-of-type pseudo class
+
+### 1.7.1
+
+- Add pseudo class has and more attribute options
+
+### 1.7.0
+
+- Bug fixes
+- Add methods `previousSibling`, `nextSibling`, `child`, `firstChild`, `lastChild`, `children`, `getDocument` to the Element
+- Changed behavior of parent method. Now it returns parent node instead of owner document
+
+### 1.6.8
+
+- Bug fix
+
+### 1.6.5
+
+- Added ability to get an element attribute by CSS selector
+
+### 1.6.4
+
+- Added handling of `DOMText` and `DOMAttr` in `Document::find()`
+
+### 1.6.3
+
+- Added ability to get inner HTML
+
+### 1.6.2
+
+- Added the ability to pass options when load HTML or XML
+
+### 1.6.1
+
+- Added the ability to pass an array of nodes to appendChild
+- Added the ability to pass options when converting to HTML or XML
+- Added the ability to add child elements to the element
+
+### 1.6
+
+- Added support for XML
+- Added the ability to search element by part of attribute name or value
+- Added support for pseudo-class "contains"
+- Added the ability to clone a node
+
+### 1.5.1
+
+- Added ability to remove and replace nodes
+- Added ability to specify encoding when converting the element into the document
+
+### 1.5
+
+- Fixed problem with incorrect encoding
+- Added ability to set the value of the element
+- Added ability to specify encoding when creating document
+
+### 1.4
+
+- Added the ability to specify the return type element (`DiDom\Element` or `DOMElement`)
+
+### 1.3.2
+
+- Bug fixed
+
+### 1.3.1
+
+- Bugs fixed
+- Added the ability to pass element attributes in the constructor
+
+### 1.3
+
+- Bugs fixed
+
+### 1.2
+
+- Bugs fixed
+- Added the ability to compare Element\Document
+- Added the ability to format HTML code of the document when outputting
+
+### 1.1
+
+- Added cache control
+- Converter from CSS to XPath replaced by faster
+
+### 1.0
+
+- First release

full-size-image-links/vendor/imangazaliev/didom/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Muhammad Imangazaliev
+
+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.

full-size-image-links/vendor/imangazaliev/didom/README-RU.md

@@ -0,0 +1,833 @@
+# DiDOM
+
+[![Build Status](https://codeship.com/projects/cf938980-36f0-0134-119e-36dc468776c7/status?branch=master)](https://codeship.com/projects/165662)
+[![Total Downloads](https://poser.pugx.org/imangazaliev/didom/downloads)](https://packagist.org/packages/imangazaliev/didom)
+[![Latest Stable Version](https://poser.pugx.org/imangazaliev/didom/v/stable)](https://packagist.org/packages/imangazaliev/didom)
+[![License](https://poser.pugx.org/imangazaliev/didom/license)](https://packagist.org/packages/imangazaliev/didom)
+
+[English version](README.md)
+
+DiDOM - простая и быстрая библиотека для парсинга HTML.
+
+## Содержание
+
+- [Установка](#Установка)
+- [Быстрый старт](#Быстрый-старт)
+- [Создание нового документа](#Создание-нового-документа)
+- [Поиск элементов](#Поиск-элементов)
+- [Проверка наличия элемента](#Проверка-наличия-элемента)
+- [Подсчет количества элементов](#Подсчет-количества-элементов)
+- [Поиск в элементе](#Поиск-в-элементе)
+- [Поддерживамые селекторы](#Поддерживамые-селекторы)
+- [Изменение содержимого](#Изменение-содержимого)
+- [Вывод содержимого](#Вывод-содержимого)
+- [Работа с элементами](#Работа-с-элементами)
+    - [Создание нового элемента](#Создание-нового-элемента)
+    - [Получение названия элемента](#Получение-названия-элемента)
+    - [Получение родительского элемента](#Получение-родительского-элемента)
+    - [Получение соседних элементов](#Получение-соседних-элементов)
+    - [Получение дочерних элементов](#Получение-соседних-элементов)
+    - [Получение документа](#Получение-документа)
+    - [Работа с атрибутами элемента](#Работа-с-атрибутами-элемента)
+    - [Сравнение элементов](#Сравнение-элементов)
+    - [Добавление дочерних элементов](#Добавление-дочерних-элементов)
+    - [Замена элемента](#Замена-элемента)
+    - [Удаление элемента](#Удаление-элемента)
+- [Работа с кэшем](#Работа-с-кэшем)
+- [Прочее](#Прочее)
+- [Сравнение с другими парсерами](#Сравнение-с-другими-парсерами)
+
+## Установка
+
+Для установки DiDOM выполните команду:
+
+    composer require imangazaliev/didom
+
+## Быстрый старт
+
+```php
+use DiDom\Document;
+
+$document = new Document('http://www.news.com/', true);
+
+$posts = $document->find('.post');
+
+foreach($posts as $post) {
+    echo $post->text(), "\n";
+}
+```
+
+## Создание нового документа
+
+DiDom позволяет загрузить HTML несколькими способами:
+
+##### Через конструктор
+
+```php
+// в первом параметре передается строка с HTML
+$document = new Document($html);
+
+// путь к файлу
+$document = new Document('page.html', true);
+
+// или URL
+$document = new Document('http://www.example.com/', true);
+
+// также можно создать документ из DOMDocument
+$domDocument = new DOMDocument();
+$document = new Document($domDocument);
+```
+
+Сигнатура:
+
+```php
+__construct($string = null, $isFile = false, $encoding = 'UTF-8', $type = Document::TYPE_HTML)
+```
+
+`$isFile` - указывает, что загружается файл. По умолчанию - `false`.
+
+`$encoding` - кодировка документа. По умолчанию - UTF-8.
+
+`$type` - тип документа (HTML - `Document::TYPE_HTML`, XML - `Document::TYPE_XML`). По умолчанию - `Document::TYPE_HTML`.
+
+##### Через отдельные методы
+
+```php
+$document = new Document();
+
+$document->loadHtml($html);
+
+$document->loadHtmlFile('page.html');
+
+$document->loadHtmlFile('http://www.example.com/');
+```
+
+Для загрузки XML есть соответствующие методы `loadXml` и `loadXmlFile`.
+
+При загрузке документа через эти методы, парсеру можно передать дополнительные [опции](http://php.net/manual/ru/libxml.constants.php):
+
+```php
+$document->loadHtml($html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
+$document->loadHtmlFile($url, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
+
+$document->loadXml($xml, LIBXML_PARSEHUGE);
+$document->loadXmlFile($url, LIBXML_PARSEHUGE);
+```
+
+## Поиск элементов
+
+В качестве выражения для поиска можно передать CSS-селектор или XPath. Для этого в первом параметре нужно передать само выражение, а во втором - его тип (по умолчанию - `Query::TYPE_CSS`):
+
+##### Через метод `find()`:
+
+```php
+use DiDom\Document;
+use DiDom\Query;
+
+...
+
+// CSS-селектор
+$posts = $document->find('.post');
+
+// эквивалентно
+$posts = $document->find('.post', Query::TYPE_CSS);
+
+// XPath-выражение
+$posts = $document->find("//div[contains(@class, 'post')]", Query::TYPE_XPATH);
+```
+
+Метод вернет массив с элементами (экземпляры класса `DiDom\Element`) или пустой массив, если не найден ни один элемент, соответствующий выражению.
+
+При желании можно получить массив узлов без преобразования в Element или текст (`DOMElement`/`DOMText`/`DOMComment`/`DOMAttr`, в зависимости от выражения), для этого необходимо передать в качестве третьего параметра `false`.
+
+##### Через метод `first()`:
+
+Возвращает первый найденный элемент или `null`, если не найдено ни одного элемента.
+
+Принимает те же параметры, что и метод `find()`.
+
+##### Через магический метод `__invoke()`:
+
+```php
+$posts = $document('.post');
+```
+
+Принимает те же параметры, что и метод `find()`.
+
+**Внимание:** использование данного метода нежелательно, т.к. в будущем он может быть удален.
+
+##### Через метод `xpath()`:
+
+```php
+$posts = $document->xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]");
+```
+
+## Проверка наличия элемента
+
+Проверить наличие элемента можно с помощью метода `has()`:
+
+```php
+if ($document->has('.post')) {
+    // код
+}
+```
+
+Если нужно проверить наличие элемента, а затем получить его, то можно сделать так:
+
+```php
+if ($document->has('.post')) {
+    $elements = $document->find('.post');
+
+    // код
+}
+```
+
+но быстрее так:
+
+```php
+$elements = $document->find('.post');
+
+if (count($elements) > 0) {
+    // код
+}
+```
+
+т.к. в первом случае выполняется два запроса.
+
+## Подсчет количества элементов
+
+Метод `count()` позволяет подсчитать количество дочерних элементов, соотвествующих селектору:
+
+```php
+// выведет количество ссылок в документе
+echo $document->count('a');
+```
+
+```php
+// выведет количество пунктов в списке
+echo $document->first('ul')->count('> li');
+```
+
+## Поиск в элементе
+
+Методы `find()`, `first()`, `xpath()`, `has()`, `count()` доступны также и для элемента.
+
+Пример:
+
+```php
+echo $document->find('nav')[0]->first('ul.menu')->xpath('//li')[0]->text();
+```
+
+#### Метод `findInDocument()`
+
+При изменении, замене или удалении элемента, найденного в другом элементе, документ не будет изменен. Данное поведение связано с тем, что в методе `find()` класса `Element` (а, соответственно, и в методах `first()` и `xpath`) создается новый документ, в котором и производится поиск.
+
+Для поиска элементов в исходном документе необходимо использовать методы `findInDocument()` и `firstInDocument()`:
+
+```php
+// ничего не выйдет
+$document->first('head')->first('title')->remove();
+
+// а вот так да
+$document->first('head')->firstInDocument('title')->remove();
+```
+
+**Внимание:** методы `findInDocument()` и `firstInDocument()` работают только для элементов, которые принадлежат какому-либо документу, либо созданых через `new Element(...)`. Если элемент не принадлежит к какому-либо документу, будет выброшено исключение `LogicException`;
+
+## Поддерживамые селекторы
+
+DiDom поддерживает поиск по:
+
+- тэгу
+- классу, идентификатору, имени и значению атрибута
+- псевдоклассам:
+    - first-, last-, nth-child
+    - empty и not-empty
+    - contains
+    - has
+
+```php
+// все ссылки
+$document->find('a');
+
+// любой элемент с id = "foo" и классом "bar"
+$document->find('#foo.bar');
+
+// любой элемент, у которого есть атрибут "name"
+$document->find('[name]');
+
+// эквивалентно
+$document->find('*[name]');
+
+// поле ввода с именем "foo"
+$document->find('input[name=foo]');
+$document->find('input[name=\'foo\']');
+$document->find('input[name="foo"]');
+
+// поле ввода с именем "foo" и значением "bar"
+$document->find('input[name="foo"][value="bar"]');
+
+// поле ввода, название которого НЕ равно "foo"
+$document->find('input[name!="foo"]');
+
+// любой элемент, у которого есть атрибут,
+// начинающийся с "data-" и равный "foo"
+$document->find('*[^data-=foo]');
+
+// все ссылки, у которых адрес начинается с https
+$document->find('a[href^=https]');
+
+// все изображения с расширением png
+$document->find('img[src$=png]');
+
+// все ссылки, содержащие в своем адресе строку "example.com"
+$document->find('a[href*=example.com]');
+
+// все ссылки, содержащие в атрибуте data-foo значение bar отделенное пробелом
+$document->find('a[data-foo~=bar]');
+
+// текст всех ссылок с классом "foo" (массив строк)
+$document->find('a.foo::text');
+
+// эквивалентно
+$document->find('a.foo::text()');
+
+// адрес и текст подсказки всех полей с классом "bar"
+$document->find('a.bar::attr(href|title)');
+
+// все ссылки, которые являются прямыми потомками текущего элемента
+$element->find('> a');
+```
+
+## Изменение содержимого
+
+### Изменение HTML
+
+```php
+$element->setInnerHtml('<a href="#">Foo</a>');
+```
+
+### Изменение значения
+
+```php
+$element->setValue('Foo');
+```
+
+## Вывод содержимого
+
+### Получение HTML
+
+##### Через метод `html()`:
+
+```php
+// HTML-код документа
+echo $document->html();
+
+// HTML-код элемента
+echo $document->first('.post')->html();
+```
+
+##### Приведение к строке:
+
+```php
+// HTML-код документа
+$html = (string) $document;
+
+// HTML-код элемента
+$html = (string) $document->first('.post');
+```
+
+**Внимание:** использование данного способа нежелательно, т.к. в будущем он может быть удален.
+
+##### Форматирование HTML при выводе
+
+```php
+echo $document->format()->html();
+```
+
+Метод `format()` отсутствует у элемента, поэтому, если нужно получить отформатированный HTML-код элемента, необходимо сначала преобразовать его в документ:
+
+```php
+$html = $element->toDocument()->format()->html();
+```
+
+#### Внутренний HTML
+
+```php
+$innerHtml = $element->innerHtml();
+```
+
+Метод `innerHtml()` отсутствует у документа, поэтому, если нужно получить внутренний HTML-код документа, необходимо сначала преобразовать его в элемент:
+
+```php
+$innerHtml = $document->toElement()->innerHtml();
+```
+
+### Получение XML
+
+```php
+// XML-код документа
+echo $document->xml();
+
+// XML-код элемента
+echo $document->first('book')->xml();
+```
+
+### Получение содержимого
+
+Возвращает текстовое содержимое узла и его потомков:
+
+```php
+echo $element->text();
+```
+
+## Создание нового элемента
+
+### Создание экземпляра класса
+
+```php
+use DiDom\Element;
+
+$element = new Element('span', 'Hello');
+
+// выведет "<span>Hello</span>"
+echo $element->html();
+```
+
+Первым параметром передается название элемента, вторым - его значение (необязательно), третьим - атрибуты элемента (необязательно).
+
+Пример создания элемента с атрибутами:
+
+```php
+$attributes = ['name' => 'description', 'placeholder' => 'Enter description of item'];
+
+$element = new Element('textarea', 'Text', $attributes);
+```
+
+Элемент можно создать и из экземпляра класса `DOMElement`:
+
+```php
+use DiDom\Element;
+use DOMElement;
+
+$domElement = new DOMElement('span', 'Hello');
+$element = new Element($domElement);
+```
+
+#### Изменение элемента, созданного из `DOMElement`
+
+Экземпляры класса `DOMElement`, созданные через конструктор (`new DOMElement(...)`), являются неизменяемыми, поэтому и элементы (экземпляры класса `DiDom\Element`), созданные из таких объектов, так же являются неизменяемыми.
+
+Пример:
+
+```php
+$element = new Element('span', 'Hello');
+
+// добавит атрибут "id" со значением "greeting"
+$element->attr('id', 'greeting');
+
+$domElement = new DOMElement('span', 'Hello');
+$element = new Element($domElement);
+
+// будет выброшено исключение
+// DOMException with message 'No Modification Allowed Error'
+$element->attr('id', 'greeting');
+```
+
+### С помощью метода `Document::createElement()`
+
+```php
+$document = new Document($html);
+
+$element = $document->createElement('span', 'Hello');
+```
+
+### С помощью CSS-селектора
+
+Первый параметр - селектор, второй - значение, третий - массив с атрибутами.
+
+Атрибуты элемента могут быть указаны как в селекторе, так и переданы отдельно в третьем параметре.
+
+Если название атрибута в массиве совпадает с названием атрибута из селектора, будет использовано значение, указанное в селекторе.
+
+```php
+$document = new Document($html);
+
+$element = $document->createElementBySelector('div.block', 'Foo', [
+    'id' => '#content',
+    'class' => '.container',
+]);
+```
+
+Можно так же использовать статический метод `createBySelector` класса `Element`:
+
+```php
+$element = Element::createBySelector('div.block', 'Foo', [
+     'id' => '#content',
+     'class' => '.container',
+ ]);
+```
+
+## Получение названия элемента
+
+```php
+$element->tag;
+```
+
+## Получение родительского элемента
+
+```php
+$element->parent();
+```
+
+Так же можно получить родительский элемент, соответствующий селектору:
+
+```php
+$element->closest('.foo');
+```
+
+Вернет родительский элемент, у которого есть класс `foo`. Если подходящий элемент не найден, метод вернет `null`.
+
+## Получение соседних элементов
+
+Первый аргумент - CSS-селектор, второй - тип узла (`DOMElement`, `DOMText` или `DOMComment`).
+
+Если оба аргумента опущены, будет осуществлен поиск узлов любого типа.
+
+Если селектор указан, а тип узла нет, будет использован тип `DOMElement`.
+
+**Внимание:** Селектор можно использовать только с типом `DOMElement`.
+
+```php
+// предыдущий элемент
+$item->previousSibling();
+
+// предыдущий элемент, соответствующий селектору
+$item->previousSibling('span');
+
+// предыдущий элемент типа DOMElement
+$item->previousSibling(null, 'DOMElement');
+
+// предыдущий элемент типа DOMComment
+$item->previousSibling(null, 'DOMComment');
+```
+
+```php
+// все предыдущие элементы
+$item->previousSiblings();
+
+// все предыдущие элементы, соответствующие селектору
+$item->previousSiblings('span');
+
+// все предыдущие элементы типа DOMElement
+$item->previousSiblings(null, 'DOMElement');
+
+// все предыдущие элементы типа DOMComment
+$item->previousSiblings(null, 'DOMComment');
+```
+
+```php
+// следующий элемент
+$item->nextSibling();
+
+// следующий элемент, соответствующий селектору
+$item->nextSibling('span');
+
+// следующий элемент типа DOMElement
+$item->nextSibling(null, 'DOMElement');
+
+// следующий элемент типа DOMComment
+$item->nextSibling(null, 'DOMComment');
+```
+
+```php
+// все последующие элементы
+$item->nextSiblings();
+
+// все последующие элементы, соответствующие селектору
+$item->nextSiblings('span');
+
+// все последующие элементы типа DOMElement
+$item->nextSiblings(null, 'DOMElement');
+
+// все последующие элементы типа DOMComment
+$item->nextSiblings(null, 'DOMComment');
+```
+
+## Получение дочерних элементов
+
+```php
+$html = '<div>Foo<span>Bar</span><!--Baz--></div>';
+
+$document = new Document($html);
+
+$div = $document->first('div');
+
+// элемент (DOMElement)
+// string(3) "Bar"
+var_dump($div->child(1)->text());
+
+// текстовый узел (DOMText)
+// string(3) "Foo"
+var_dump($div->firstChild()->text());
+
+// комментарий (DOMComment)
+// string(3) "Baz"
+var_dump($div->lastChild()->text());
+
+// array(3) { ... }
+var_dump($div->children());
+```
+
+## Получение документа
+
+```php
+$document = new Document($html);
+
+$element = $document->first('input[name=email]');
+
+$document2 = $element->getDocument();
+
+// bool(true)
+var_dump($document->is($document2));
+```
+
+## Работа с атрибутами элемента
+
+#### Создание/изменение атрибута
+
+##### Через метод `setAttribute`:
+```php
+$element->setAttribute('name', 'username');
+```
+
+##### Через метод `attr`:
+```php
+$element->attr('name', 'username');
+```
+
+##### Через магический метод `__set`:
+```php
+$element->name = 'username';
+```
+
+#### Получение значения атрибута
+
+##### Через метод `getAttribute`:
+```php
+$username = $element->getAttribute('value');
+```
+
+##### Через метод `attr`:
+```php
+$username = $element->attr('value');
+```
+
+##### Через магический метод `__get`:
+```php
+$username = $element->name;
+```
+
+Если атрибут не найден, вернет `null`.
+
+#### Проверка наличия атрибута
+
+##### Через метод `hasAttribute`:
+```php
+if ($element->hasAttribute('name')) {
+    // код
+}
+```
+
+##### Через магический метод `__isset`:
+```php
+if (isset($element->name)) {
+    // код
+}
+```
+
+#### Удаление атрибута:
+
+##### Через метод `removeAttribute`:
+```php
+$element->removeAttribute('name');
+```
+
+##### Через магический метод `__unset`:
+```php
+unset($element->name);
+```
+
+#### Получение всех атрибутов:
+
+```php
+var_dump($element->attributes());
+```
+
+#### Получение определенных атрибутов:
+
+```php
+var_dump($element->attributes(['name', 'type']));
+```
+
+#### Удаление всех атрибутов:
+
+```php
+$element->removeAllAttributes();
+```
+
+#### Удаление всех атрибутов, за исключением указанных:
+
+```php
+$element->removeAllAttributes(['name', 'type']);
+```
+
+## Сравнение элементов
+
+```php
+$element  = new Element('span', 'hello');
+$element2 = new Element('span', 'hello');
+
+// bool(true)
+var_dump($element->is($element));
+
+// bool(false)
+var_dump($element->is($element2));
+```
+
+## Добавление дочерних элементов
+
+```php
+$list = new Element('ul');
+
+$item = new Element('li', 'Item 1');
+
+$list->appendChild($item);
+
+$items = [
+    new Element('li', 'Item 2'),
+    new Element('li', 'Item 3'),
+];
+
+$list->appendChild($items);
+```
+
+## Замена элемента
+
+```php
+$title = new Element('title', 'foo');
+
+$document->first('title')->replace($title);
+```
+
+**Внимание:** заменить можно только те элементы, которые были найдены непосредственно в документе:
+
+```php
+// ничего не выйдет
+$document->first('head')->first('title')->replace($title);
+
+// а вот так да
+$document->first('head title')->replace($title);
+```
+
+Подробнее об этом в разделе [Поиск в элементе](#Поиск-в-элементе).
+
+## Удаление элемента
+
+```php
+$document->first('title')->remove();
+```
+
+**Внимание:** удалить можно только те элементы, которые были найдены непосредственно в документе:
+
+```php
+// ничего не выйдет
+$document->first('head')->first('title')->remove();
+
+// а вот так да
+$document->first('head title')->remove();
+```
+
+Подробнее об этом в разделе [Поиск в элементе](#Поиск-в-элементе).
+
+## Работа с кэшем
+
+Кэш - массив XPath-выражений, полученных из CSS.
+
+#### Получение кэша
+
+```php
+use DiDom\Query;
+
+...
+
+$xpath    = Query::compile('h2');
+$compiled = Query::getCompiled();
+
+// array('h2' => '//h2')
+var_dump($compiled);
+```
+
+#### Установка кэша
+
+```php
+Query::setCompiled(['h2' => '//h2']);
+```
+
+## Прочее
+
+#### `preserveWhiteSpace`
+
+По умолчанию сохранение пробелов между тегами отключено.
+
+Включать опцию `preserveWhiteSpace` следует до загрузки документа:
+
+```php
+$document = new Document();
+
+$document->preserveWhiteSpace();
+
+$document->loadXml($xml);
+```
+
+#### `matches`
+
+Возвращает `true`, если элемент соответсвует селектору:
+
+```php
+// вернет true, если элемент это div с идентификатором content
+$element->matches('div#content');
+
+// строгое соответствие
+// вернет true, если элемент это div с идентификатором content и ничего более
+// если у элемента будут какие-либо другие атрибуты, метод вернет false
+$element->matches('div#content', true);
+```
+
+#### `isElementNode`
+
+Проверяет, является ли элемент узлом типа DOMElement:
+
+```php
+$element->isElementNode();
+```
+
+#### `isTextNode`
+
+Проверяет, является ли элемент текстовым узлом (DOMText):
+
+```php
+$element->isTextNode();
+```
+
+#### `isCommentNode`
+
+Проверяет, является ли элемент комментарием (DOMComment):
+
+```php
+$element->isCommentNode();
+```
+
+## Сравнение с другими парсерами
+
+[Сравнение с другими парсерами](https://github.com/Imangazaliev/DiDOM/wiki/Сравнение-с-другими-парсерами-(1.6.3))

full-size-image-links/vendor/imangazaliev/didom/README.md

@@ -0,0 +1,675 @@
+# DiDOM
+
+[![Build Status](https://codeship.com/projects/cf938980-36f0-0134-119e-36dc468776c7/status?branch=master)](https://codeship.com/projects/165662)
+[![Total Downloads](https://poser.pugx.org/imangazaliev/didom/downloads)](https://packagist.org/packages/imangazaliev/didom)
+[![Latest Stable Version](https://poser.pugx.org/imangazaliev/didom/v/stable)](https://packagist.org/packages/imangazaliev/didom)
+[![License](https://poser.pugx.org/imangazaliev/didom/license)](https://packagist.org/packages/imangazaliev/didom)
+
+[README на русском](README-RU.md)
+
+DiDOM - simple and fast HTML parser.
+
+## Contents
+
+- [Installation](#installation)
+- [Quick start](#quick-start)
+- [Creating new document](#creating-new-document)
+- [Search for elements](#search-for-elements)
+- [Verify if element exists](#verify-if-element-exists)
+- [Search in element](#search-in-element)
+- [Supported selectors](#supported-selectors)
+- [Output](#output)
+- [Working with elements](#working-with-elements)
+    - [Creating a new element](#creating-a-new-element)
+    - [Getting the name of an element](#getting-the-name-of-an-element)
+    - [Getting parent element](#getting-parent-element)
+    - [Getting sibling elements](#getting-sibling-elements)
+    - [Getting the child elements](#getting-the-child-elements)
+    - [Getting document](#getting-document)
+    - [Working with element attributes](#working-with-element-attributes)
+    - [Comparing elements](#comparing-elements)
+    - [Adding a child element](#adding-a-child-element)
+    - [Replacing element](#replacing-element)
+    - [Removing element](#removing-element)
+- [Working with cache](#working-with-cache)
+- [Miscellaneous](#miscellaneous)
+- [Comparison with other parsers](#comparison-with-other-parsers)
+
+## Installation
+
+To install DiDOM run the command:
+
+    composer require imangazaliev/didom
+
+## Quick start
+
+```php
+use DiDom\Document;
+
+$document = new Document('http://www.news.com/', true);
+
+$posts = $document->find('.post');
+
+foreach($posts as $post) {
+    echo $post->text(), "\n";
+}
+```
+
+## Creating new document
+
+DiDom allows to load HTML in several ways:
+
+##### With constructor
+
+```php
+// the first parameter is a string with HTML
+$document = new Document($html);
+
+// file path
+$document = new Document('page.html', true);
+
+// or URL
+$document = new Document('http://www.example.com/', true);
+```
+
+The second parameter specifies if you need to load file. Default is `false`.
+
+Signature:
+
+```php
+__construct($string = null, $isFile = false, $encoding = 'UTF-8', $type = Document::TYPE_HTML)
+```
+
+`$string` - an HTML or XML string or a file path.
+
+`$isFile` - indicates that the first parameter is a path to a file.
+
+`$encoding` - the document encoding.
+
+`$type` - the document type (HTML - `Document::TYPE_HTML`, XML - `Document::TYPE_XML`).
+
+##### With separate methods
+
+```php
+$document = new Document();
+
+$document->loadHtml($html);
+
+$document->loadHtmlFile('page.html');
+
+$document->loadHtmlFile('http://www.example.com/');
+```
+
+There are two methods available for loading XML: `loadXml` and `loadXmlFile`.
+
+These methods accept additional [options](http://php.net/manual/en/libxml.constants.php):
+
+```php
+$document->loadHtml($html, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
+$document->loadHtmlFile($url, LIBXML_HTML_NOIMPLIED | LIBXML_HTML_NODEFDTD);
+
+$document->loadXml($xml, LIBXML_PARSEHUGE);
+$document->loadXmlFile($url, LIBXML_PARSEHUGE);
+```
+
+## Search for elements
+
+DiDOM accepts CSS selector or XPath as an expression for search. You need to path expression as the first parameter, and specify its type in the second one (default type is `Query::TYPE_CSS`):
+
+##### With method `find()`:
+
+```php
+use DiDom\Document;
+use DiDom\Query;
+
+...
+
+// CSS selector
+$posts = $document->find('.post');
+
+// XPath
+$posts = $document->find("//div[contains(@class, 'post')]", Query::TYPE_XPATH);
+```
+
+If the elements that match a given expression are found, then method returns an array of instances of `DiDom\Element`, otherwise - an empty array. You could also get an array of `DOMElement` objects. To get this, pass `false` as the third parameter.
+
+##### With magic method `__invoke()`:
+
+```php
+$posts = $document('.post');
+```
+
+**Warning:** using this method is undesirable because it may be removed in the future.
+
+##### With method `xpath()`:
+
+```php
+$posts = $document->xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]");
+```
+
+You can do search inside an element:
+
+```php
+echo $document->find('nav')[0]->first('ul.menu')->xpath('//li')[0]->text();
+```
+
+### Verify if element exists
+
+To verify if element exist use `has()` method:
+
+```php
+if ($document->has('.post')) {
+    // code
+}
+```
+
+If you need to check if element exist and then get it:
+
+```php
+if ($document->has('.post')) {
+    $elements = $document->find('.post');
+    // code
+}
+```
+
+but it would be faster like this:
+
+```php
+if (count($elements = $document->find('.post')) > 0) {
+    // code
+}
+```
+
+because in the first case it makes two queries.
+
+## Search in element
+
+Methods `find()`, `first()`, `xpath()`, `has()`, `count()` are available in Element too.
+
+Example:
+
+```php
+echo $document->find('nav')[0]->first('ul.menu')->xpath('//li')[0]->text();
+```
+
+#### Method `findInDocument()`
+
+If you change, replace, or remove an element that was found in another element, the document will not be changed. This happens because method `find()` of `Element` class (a, respectively, the `first ()` and `xpath` methods) creates a new document to search.
+
+To search for elements in the source document, you must use the methods `findInDocument()` and `firstInDocument()`:
+
+```php
+// nothing will happen
+$document->first('head')->first('title')->remove();
+
+// but this will do
+$document->first('head')->firstInDocument('title')->remove();
+```
+
+**Warning:** methods  `findInDocument()` and `firstInDocument()` work only for elements, which belong to a document, and for elements created via `new Element(...)`. If an element does not belong to a document, `LogicException` will be thrown;
+
+## Supported selectors
+
+DiDom supports search by:
+
+- tag
+- class, ID, name and value of an attribute
+- pseudo-classes:
+    - first-, last-, nth-child
+    - empty and not-empty
+    - contains
+    - has
+
+```php
+// all links
+$document->find('a');
+
+// any element with id = "foo" and "bar" class
+$document->find('#foo.bar');
+
+// any element with attribute "name"
+$document->find('[name]');
+// the same as
+$document->find('*[name]');
+
+// input field with the name "foo"
+$document->find('input[name=foo]');
+$document->find('input[name=\'bar\']');
+$document->find('input[name="baz"]');
+
+// any element that has an attribute starting with "data-" and the value "foo"
+$document->find('*[^data-=foo]');
+
+// all links starting with https
+$document->find('a[href^=https]');
+
+// all images with the extension png
+$document->find('img[src$=png]');
+
+// all links containing the string "example.com"
+$document->find('a[href*=example.com]');
+
+// text of the links with "foo" class
+$document->find('a.foo::text');
+
+// address and title of all the fields with "bar" class
+$document->find('a.bar::attr(href|title)');
+```
+
+## Output
+
+### Getting HTML
+
+##### With method `html()`:
+
+```php
+$posts = $document->find('.post');
+
+echo $posts[0]->html();
+```
+
+##### Casting to string:
+
+```php
+$html = (string) $posts[0];
+```
+
+##### Formatting HTML output
+
+```php
+$html = $document->format()->html();
+```
+
+An element does not have `format()` method, so if you need to output formatted HTML of the element, then first you have to convert it to a document:
+
+
+```php
+$html = $element->toDocument()->format()->html();
+```
+
+#### Inner HTML
+
+```php
+$innerHtml = $element->innerHtml();
+```
+
+Document does not have the method `innerHtml()`, therefore, if you need to get inner HTML of a document, convert it into an element first:
+
+```php
+$innerHtml = $document->toElement()->innerHtml();
+```
+
+### Getting XML
+
+```php
+echo $document->xml();
+
+echo $document->first('book')->xml();
+```
+
+### Getting content
+
+```php
+$posts = $document->find('.post');
+
+echo $posts[0]->text();
+```
+
+## Creating a new element
+
+### Creating an instance of the class
+
+```php
+use DiDom\Element;
+
+$element = new Element('span', 'Hello');
+
+// Outputs "<span>Hello</span>"
+echo $element->html();
+```
+
+First parameter is a name of an attribute, the second one is its value (optional), the third one is element attributes (optional).
+
+An example of creating an element with attributes:
+
+```php
+$attributes = ['name' => 'description', 'placeholder' => 'Enter description of item'];
+
+$element = new Element('textarea', 'Text', $attributes);
+```
+
+An element can be created from an instance of the class `DOMElement`:
+
+```php
+use DiDom\Element;
+use DOMElement;
+
+$domElement = new DOMElement('span', 'Hello');
+
+$element = new Element($domElement);
+```
+
+### Using the method `createElement`
+
+```php
+$document = new Document($html);
+
+$element = $document->createElement('span', 'Hello');
+```
+
+## Getting the name of an element
+
+```php
+$element->tag;
+```
+
+## Getting parent element
+
+```php
+$document = new Document($html);
+
+$input = $document->find('input[name=email]')[0];
+
+var_dump($input->parent());
+```
+
+## Getting sibling elements
+
+```php
+$document = new Document($html);
+
+$item = $document->find('ul.menu > li')[1];
+
+var_dump($item->previousSibling());
+
+var_dump($item->nextSibling());
+```
+
+## Getting the child elements
+
+```php
+$html = '<div>Foo<span>Bar</span><!--Baz--></div>';
+
+$document = new Document($html);
+
+$div = $document->first('div');
+
+// element node (DOMElement)
+// string(3) "Bar"
+var_dump($div->child(1)->text());
+
+// text node (DOMText)
+// string(3) "Foo"
+var_dump($div->firstChild()->text());
+
+// comment node (DOMComment)
+// string(3) "Baz"
+var_dump($div->lastChild()->text());
+
+// array(3) { ... }
+var_dump($div->children());
+```
+
+## Getting document
+
+```php
+$document = new Document($html);
+
+$element = $document->find('input[name=email]')[0];
+
+$document2 = $element->getDocument();
+
+// bool(true)
+var_dump($document->is($document2));
+```
+
+## Working with element attributes
+
+#### Creating/updating an attribute
+
+##### With method `setAttribute`:
+```php
+$element->setAttribute('name', 'username');
+```
+
+##### With method `attr`:
+```php
+$element->attr('name', 'username');
+```
+
+##### With magic method `__set`:
+```php
+$element->name = 'username';
+```
+
+#### Getting value of an attribute
+
+##### With method `getAttribute`:
+
+```php
+$username = $element->getAttribute('value');
+```
+
+##### With method `attr`:
+
+```php
+$username = $element->attr('value');
+```
+
+##### With magic method `__get`:
+
+```php
+$username = $element->name;
+```
+
+Returns `null` if attribute is not found.
+
+#### Verify if attribute exists
+
+##### With method `hasAttribute`:
+
+```php
+if ($element->hasAttribute('name')) {
+    // code
+}
+```
+
+##### With magic method `__isset`:
+
+```php
+if (isset($element->name)) {
+    // code
+}
+```
+
+#### Removing attribute:
+
+##### With method `removeAttribute`:
+
+```php
+$element->removeAttribute('name');
+```
+
+##### With magic method `__unset`:
+
+```php
+unset($element->name);
+```
+
+## Comparing elements
+
+```php
+$element  = new Element('span', 'hello');
+$element2 = new Element('span', 'hello');
+
+// bool(true)
+var_dump($element->is($element));
+
+// bool(false)
+var_dump($element->is($element2));
+```
+
+## Appending child elements
+
+```php
+$list = new Element('ul');
+
+$item = new Element('li', 'Item 1');
+
+$list->appendChild($item);
+
+$items = [
+    new Element('li', 'Item 2'),
+    new Element('li', 'Item 3'),
+];
+
+$list->appendChild($items);
+```
+
+## Adding a child element
+
+```php
+$list = new Element('ul');
+
+$item = new Element('li', 'Item 1');
+$items = [
+    new Element('li', 'Item 2'),
+    new Element('li', 'Item 3'),
+];
+
+$list->appendChild($item);
+$list->appendChild($items);
+```
+
+## Replacing element
+
+```php
+$element = new Element('span', 'hello');
+
+$document->find('.post')[0]->replace($element);
+```
+
+**Waning:** you can replace only those elements that were found directly in the document:
+
+```php
+// nothing will happen
+$document->first('head')->first('title')->replace($title);
+
+// but this will do
+$document->first('head title')->replace($title);
+```
+
+More about this in section [Search for elements](#search-for-elements).
+
+## Removing element
+
+```php
+$document->find('.post')[0]->remove();
+```
+
+**Warning:** you can remove only those elements that were found directly in the document:
+
+```php
+// nothing will happen
+$document->first('head')->first('title')->remove();
+
+// but this will do
+$document->first('head title')->remove();
+```
+
+More about this in section [Search for elements](#search-for-elements).
+
+## Working with cache
+
+Cache is an array of XPath expressions, that were converted from CSS.
+
+#### Getting from cache
+
+```php
+use DiDom\Query;
+
+...
+
+$xpath    = Query::compile('h2');
+$compiled = Query::getCompiled();
+
+// array('h2' => '//h2')
+var_dump($compiled);
+```
+
+#### Cache setting
+
+```php
+Query::setCompiled(['h2' => '//h2']);
+```
+
+## Miscellaneous
+
+#### `preserveWhiteSpace`
+
+By default, whitespace preserving is disabled.
+
+You can enable the `preserveWhiteSpace` option before loading the document:
+
+```php
+$document = new Document();
+
+$document->preserveWhiteSpace();
+
+$document->loadXml($xml);
+```
+
+#### `count`
+
+The `count ()` method counts children that match the selector:
+
+```php
+// prints the number of links in the document
+echo $document->count('a');
+```
+
+```php
+// prints the number of items in the list
+echo $document->first('ul')->count('li');
+```
+
+#### `matches`
+
+Returns `true` if the node matches the selector:
+
+```php
+$element->matches('div#content');
+
+// strict match
+// returns true if the element is a div with id equals content and nothing else
+// if the element has any other attributes the method returns false
+$element->matches('div#content', true);
+```
+
+#### `isElementNode`
+
+Checks whether an element is an element (DOMElement):
+
+```php
+$element->isElementNode();
+```
+
+#### `isTextNode`
+
+Checks whether an element is a text node (DOMText):
+
+```php
+$element->isTextNode();
+```
+
+#### `isCommentNode`
+
+Checks whether the element is a comment (DOMComment):
+
+```php
+$element->isCommentNode();
+```
+
+## Comparison with other parsers
+
+[Comparison with other parsers](https://github.com/Imangazaliev/DiDOM/wiki/Comparison-with-other-parsers-(1.0))

full-size-image-links/vendor/imangazaliev/didom/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "imangazaliev/didom",
+    "description": "Simple and fast HTML parser",
+    "type": "library",
+    "keywords": ["didom", "parser", "html", "xml"],
+    "license": "MIT",
+    "homepage": "https://github.com/Imangazaliev/DiDOM",
+    "authors": [
+        {
+            "name": "Imangazaliev Muhammad",
+            "email": "imangazalievm@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4",
+        "ext-dom": "*",
+        "ext-iconv": "*"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^4.8",
+        "friendsofphp/php-cs-fixer": "2.9"
+    },
+    "autoload": {
+        "psr-4": {
+            "DiDom\\": "src/DiDom/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": { 
+            "Tests\\": "tests/"
+        }
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/phpunit.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         bootstrap="tests/bootstrap.php"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false">
+    <testsuites>
+        <testsuite name="DiDom Test Suite">
+            <directory>./tests/</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/ClassAttribute.php

@@ -0,0 +1,269 @@
+<?php
+
+namespace DiDom;
+
+use InvalidArgumentException;
+
+class ClassAttribute
+{
+    /**
+     * The DOM element instance.
+     *
+     * @var \DiDom\Element
+     */
+    protected $element;
+
+    /**
+     * @var string
+     */
+    protected $classesString = '';
+
+    /**
+     * @var string[]
+     */
+    protected $classes = [];
+
+    /**
+     * Constructor.
+     *
+     * @param \DiDom\Element $element
+     *
+     * @throws \InvalidArgumentException if passed argument is not an element node
+     */
+    public function __construct(Element $element)
+    {
+        if (!$element->isElementNode()) {
+            throw new InvalidArgumentException(sprintf('The element must contain DOMElement node'));
+        }
+
+        $this->element = $element;
+
+        $this->parseClassAttribute();
+    }
+
+    /**
+     * Parses class attribute of the element.
+     */
+    protected function parseClassAttribute()
+    {
+        if (!$this->element->hasAttribute('class')) {
+            // possible if class attribute has been removed
+            if ($this->classesString !== '') {
+                $this->classesString = '';
+                $this->classes = [];
+            }
+
+            return;
+        }
+
+        // if class attribute is not changed
+        if ($this->element->getAttribute('class') === $this->classesString) {
+            return;
+        }
+
+        // save class attribute as is (without trimming)
+        $this->classesString = $this->element->getAttribute('class');
+
+        $classesString = trim($this->classesString);
+
+        if ($classesString === '') {
+            $this->classes = [];
+
+            return;
+        }
+
+        $classes = explode(' ', $classesString);
+
+        $classes = array_map('trim', $classes);
+        $classes = array_filter($classes);
+        $classes = array_unique($classes);
+
+        $this->classes = array_values($classes);
+    }
+
+    /**
+     * Updates class attribute of the element.
+     */
+    protected function updateClassAttribute()
+    {
+        $this->classesString = implode(' ', $this->classes);
+
+        $this->element->setAttribute('class', $this->classesString);
+    }
+
+    /**
+     * @param string $className
+     *
+     * @return \DiDom\ClassAttribute
+     *
+     * @throws \InvalidArgumentException if class name is not a string
+     */
+    public function add($className)
+    {
+        if (!is_string($className)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($className) ? get_class($className) : gettype($className))));
+        }
+
+        $this->parseClassAttribute();
+
+        if (in_array($className, $this->classes, true)) {
+            return $this;
+        }
+
+        $this->classes[] = $className;
+
+        $this->updateClassAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param array $classNames
+     *
+     * @return \DiDom\ClassAttribute
+     *
+     * @throws \InvalidArgumentException if class name is not a string
+     */
+    public function addMultiple(array $classNames)
+    {
+        $this->parseClassAttribute();
+
+        foreach ($classNames as $className) {
+            if (!is_string($className)) {
+                throw new InvalidArgumentException(sprintf('Class name must be a string, %s given', (is_object($className) ? get_class($className) : gettype($className))));
+            }
+
+            if (in_array($className, $this->classes, true)) {
+                continue;
+            }
+
+            $this->classes[] = $className;
+        }
+
+        $this->updateClassAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @return string[]
+     */
+    public function getAll()
+    {
+        $this->parseClassAttribute();
+
+        return $this->classes;
+    }
+
+    /**
+     * @param string $className
+     *
+     * @return bool
+     */
+    public function contains($className)
+    {
+        if (!is_string($className)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($className) ? get_class($className) : gettype($className))));
+        }
+
+        $this->parseClassAttribute();
+
+        return in_array($className, $this->classes, true);
+    }
+
+    /**
+     * @param string $className
+     *
+     * @return \DiDom\ClassAttribute
+     *
+     * @throws \InvalidArgumentException if class name is not a string
+     */
+    public function remove($className)
+    {
+        if (!is_string($className)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($className) ? get_class($className) : gettype($className))));
+        }
+
+        $this->parseClassAttribute();
+
+        $classIndex = array_search($className, $this->classes);
+
+        if ($classIndex === false) {
+            return $this;
+        }
+
+        unset($this->classes[$classIndex]);
+
+        $this->updateClassAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param array $classNames
+     *
+     * @return \DiDom\ClassAttribute
+     *
+     * @throws \InvalidArgumentException if class name is not a string
+     */
+    public function removeMultiple(array $classNames)
+    {
+        $this->parseClassAttribute();
+
+        foreach ($classNames as $className) {
+            if (!is_string($className)) {
+                throw new InvalidArgumentException(sprintf('Class name must be a string, %s given', (is_object($className) ? get_class($className) : gettype($className))));
+            }
+
+            $classIndex = array_search($className, $this->classes);
+
+            if ($classIndex === false) {
+                continue;
+            }
+
+            unset($this->classes[$classIndex]);
+        }
+
+        $this->updateClassAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param string[] $exclusions
+     *
+     * @return \DiDom\ClassAttribute
+     */
+    public function removeAll(array $exclusions = [])
+    {
+        $this->parseClassAttribute();
+
+        $preservedClasses = [];
+
+        foreach ($exclusions as $className) {
+            if (!is_string($className)) {
+                throw new InvalidArgumentException(sprintf('Class name must be a string, %s given', (is_object($className) ? get_class($className) : gettype($className))));
+            }
+
+            if (!in_array($className, $this->classes, true)) {
+                continue;
+            }
+
+            $preservedClasses[] = $className;
+        }
+
+        $this->classes = $preservedClasses;
+
+        $this->updateClassAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @return \DiDom\Element
+     */
+    public function getElement()
+    {
+        return $this->element;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Document.php

@@ -0,0 +1,700 @@
+<?php
+
+namespace DiDom;
+
+use DOMCdataSection;
+use DOMComment;
+use DOMDocument;
+use DOMElement;
+use DOMNode;
+use DOMText;
+use DOMXPath;
+use InvalidArgumentException;
+use RuntimeException;
+
+class Document
+{
+    /**
+     * Types of a document.
+     *
+     * @const string
+     */
+    const TYPE_HTML = 'html';
+    const TYPE_XML  = 'xml';
+
+    /**
+     * @var \DOMDocument
+     */
+    protected $document;
+
+    /**
+     * @var string
+     */
+    protected $type;
+
+    /**
+     * @var string
+     */
+    protected $encoding;
+
+    /**
+     * Constructor.
+     *
+     * @param string|null $string   An HTML or XML string or a file path
+     * @param bool        $isFile   Indicates that the first parameter is a path to a file
+     * @param string      $encoding The document encoding
+     * @param string      $type     The document type
+     *
+     * @throws \InvalidArgumentException if the passed encoding is not a string
+     */
+    public function __construct($string = null, $isFile = false, $encoding = 'UTF-8', $type = Document::TYPE_HTML)
+    {
+        if ($string instanceof DOMDocument) {
+            $this->document = $string;
+
+            return;
+        }
+
+        if (!is_string($encoding)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 3 to be string, %s given', __METHOD__, gettype($encoding)));
+        }
+
+        $this->encoding = $encoding;
+
+        $this->document = new DOMDocument('1.0', $encoding);
+
+        $this->preserveWhiteSpace(false);
+
+        if ($string !== null) {
+            $this->load($string, $isFile, $type);
+        }
+    }
+
+    /**
+     * Creates a new document.
+     *
+     * @param string|null $string   An HTML or XML string or a file path
+     * @param bool        $isFile   Indicates that the first parameter is a path to a file
+     * @param string      $encoding The document encoding
+     * @param string      $type     The document type
+     *
+     * @return \DiDom\Document
+     */
+    public static function create($string = null, $isFile = false, $encoding = 'UTF-8', $type = Document::TYPE_HTML)
+    {
+        return new Document($string, $isFile, $encoding, $type);
+    }
+
+    /**
+     * Creates a new element node.
+     *
+     * @param string      $name       The tag name of the element
+     * @param string|null $value      The value of the element
+     * @param array       $attributes The attributes of the element
+     *
+     * @return \DiDom\Element created element
+     */
+    public function createElement($name, $value = null, array $attributes = [])
+    {
+        $node = $this->document->createElement($name);
+
+        return new Element($node, $value, $attributes);
+    }
+
+    /**
+     * Creates a new element node by CSS selector.
+     *
+     * @param string      $selector
+     * @param string|null $value
+     * @param array       $attributes
+     *
+     * @return \DiDom\Element
+     */
+    public function createElementBySelector($selector, $value = null, array $attributes = [])
+    {
+        $segments = Query::getSegments($selector);
+
+        $name = array_key_exists('tag', $segments) ? $segments['tag'] : 'div';
+
+        if (array_key_exists('attributes', $segments)) {
+            $attributes = array_merge($attributes, $segments['attributes']);
+        }
+
+        if (array_key_exists('id', $segments)) {
+            $attributes['id'] = $segments['id'];
+        }
+
+        if (array_key_exists('classes', $segments)) {
+            $attributes['class'] = implode(' ', $segments['classes']);
+        }
+
+        return $this->createElement($name, $value, $attributes);
+    }
+
+    /**
+     * @param string $content
+     *
+     * @return Element
+     */
+    public function createTextNode($content)
+    {
+        return new Element(new DOMText($content));
+    }
+
+    /**
+     * @param string $data
+     *
+     * @return Element
+     */
+    public function createComment($data)
+    {
+        return new Element(new DOMComment($data));
+    }
+
+    /**
+     * @param string $data
+     *
+     * @return Element
+     */
+    public function createCdataSection($data)
+    {
+        return new Element(new DOMCdataSection($data));
+    }
+
+    /**
+     * Adds a new child at the end of the children.
+     *
+     * @param \DiDom\Element|\DOMNode|array $nodes The appended child
+     *
+     * @return \DiDom\Element|\DiDom\Element[]
+     *
+     * @throws \InvalidArgumentException if the passed argument is not an instance of \DOMNode or \DiDom\Element
+     */
+    public function appendChild($nodes)
+    {
+        $returnArray = true;
+
+        if (!is_array($nodes)) {
+            $nodes = [$nodes];
+
+            $returnArray = false;
+        }
+
+        $result = [];
+
+        foreach ($nodes as $node) {
+            if ($node instanceof Element) {
+                $node = $node->getNode();
+            }
+
+            if (!$node instanceof DOMNode) {
+                throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s\Element or DOMNode, %s given', __METHOD__, __NAMESPACE__, (is_object($node) ? get_class($node) : gettype($node))));
+            }
+
+            Errors::disable();
+
+            $cloned = $node->cloneNode(true);
+            $newNode = $this->document->importNode($cloned, true);
+
+            $result[] = $this->document->appendChild($newNode);
+
+            Errors::restore();
+        }
+
+        $result = array_map(function (DOMNode $node) {
+            return new Element($node);
+        }, $result);
+
+        return $returnArray ? $result : $result[0];
+    }
+
+    /**
+     * Set preserveWhiteSpace property.
+     *
+     * @param bool $value
+     *
+     * @return \DiDom\Document
+     */
+    public function preserveWhiteSpace($value = true)
+    {
+        if (!is_bool($value)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be boolean, %s given', __METHOD__, gettype($value)));
+        }
+
+        $this->document->preserveWhiteSpace = $value;
+
+        return $this;
+    }
+
+    /**
+     * Load HTML or XML.
+     *
+     * @param string   $string  HTML or XML string or file path
+     * @param bool     $isFile  Indicates that in first parameter was passed to the file path
+     * @param string   $type    Type of the document
+     * @param int|null $options Additional parameters
+     *
+     * @return \DiDom\Document
+     *
+     * @throws \InvalidArgumentException if first parameter is not a string
+     * @throws \InvalidArgumentException if document type parameter is not a string
+     * @throws \RuntimeException if document type is not HTML or XML
+     */
+    public function load($string, $isFile = false, $type = Document::TYPE_HTML, $options = null)
+    {
+        if (!is_string($string)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($string) ? get_class($string) : gettype($string))));
+        }
+
+        if (!is_string($type)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 3 to be string, %s given', __METHOD__, (is_object($type) ? get_class($type) : gettype($type))));
+        }
+
+        if (!in_array(strtolower($type), [Document::TYPE_HTML, Document::TYPE_XML], true)) {
+            throw new RuntimeException(sprintf('Document type must be "xml" or "html", %s given', $type));
+        }
+
+        if ($options === null) {
+            // LIBXML_HTML_NODEFDTD - prevents a default doctype being added when one is not found
+            $options = LIBXML_HTML_NODEFDTD;
+        }
+
+        if (!is_int($options)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 4 to be integer, %s given', __METHOD__, (is_object($options) ? get_class($options) : gettype($options))));
+        }
+
+        $string = trim($string);
+
+        if ($isFile) {
+            $string = $this->loadFile($string);
+        }
+
+        if (strtolower($type) === Document::TYPE_HTML) {
+            $string = Encoder::convertToHtmlEntities($string, $this->encoding);
+        }
+
+        $this->type = strtolower($type);
+
+        Errors::disable();
+
+        if ($this->type === Document::TYPE_HTML) {
+            $this->document->loadHtml($string, $options);
+        } else {
+            $this->document->loadXml($string, $options);
+        }
+
+        Errors::restore();
+
+        return $this;
+    }
+
+    /**
+     * Load HTML from a string.
+     *
+     * @param string   $html    The HTML string
+     * @param int|null $options Additional parameters
+     *
+     * @return \DiDom\Document
+     *
+     * @throws \InvalidArgumentException if the provided argument is not a string
+     */
+    public function loadHtml($html, $options = null)
+    {
+        return $this->load($html, false, Document::TYPE_HTML, $options);
+    }
+
+    /**
+     * Load HTML from a file.
+     *
+     * @param string   $filename The path to the HTML file
+     * @param int|null $options  Additional parameters
+     *
+     * @return \DiDom\Document
+     *
+     * @throws \InvalidArgumentException if the file path is not a string
+     * @throws \RuntimeException if the file does not exist
+     * @throws \RuntimeException if you are unable to load the file
+     */
+    public function loadHtmlFile($filename, $options = null)
+    {
+        return $this->load($filename, true, Document::TYPE_HTML, $options);
+    }
+
+    /**
+     * Load XML from a string.
+     *
+     * @param string   $xml     The XML string
+     * @param int|null $options Additional parameters
+     *
+     * @return \DiDom\Document
+     *
+     * @throws \InvalidArgumentException if the provided argument is not a string
+     */
+    public function loadXml($xml, $options = null)
+    {
+        return $this->load($xml, false, Document::TYPE_XML, $options);
+    }
+
+    /**
+     * Load XML from a file.
+     *
+     * @param string   $filename The path to the XML file
+     * @param int|null $options  Additional parameters
+     *
+     * @return \DiDom\Document
+     *
+     * @throws \InvalidArgumentException if the file path is not a string
+     * @throws \RuntimeException if the file does not exist
+     * @throws \RuntimeException if you are unable to load the file
+     */
+    public function loadXmlFile($filename, $options = null)
+    {
+        return $this->load($filename, true, Document::TYPE_XML, $options);
+    }
+
+    /**
+     * Reads entire file into a string.
+     *
+     * @param string $filename The path to the file
+     *
+     * @return string
+     *
+     * @throws \InvalidArgumentException if the file path is not a string
+     * @throws \RuntimeException if an error occurred
+     */
+    protected function loadFile($filename)
+    {
+        if (!is_string($filename)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, gettype($filename)));
+        }
+
+        try {
+            $content = file_get_contents($filename);
+        } catch (\Exception $exception) {
+            throw new RuntimeException(sprintf('Could not load file %s', $filename));
+        }
+
+        if ($content === false) {
+            throw new RuntimeException(sprintf('Could not load file %s', $filename));
+        }
+
+        return $content;
+    }
+
+    /**
+     * Checks the existence of the node.
+     *
+     * @param string $expression XPath expression or CSS selector
+     * @param string $type The type of the expression
+     *
+     * @return bool
+     */
+    public function has($expression, $type = Query::TYPE_CSS)
+    {
+        $expression = Query::compile($expression, $type);
+        $expression = sprintf('count(%s) > 0', $expression);
+
+        return $this->createXpath()->evaluate($expression);
+    }
+
+    /**
+     * Searches for an node in the DOM tree for a given XPath expression or a CSS selector.
+     *
+     * @param string           $expression  XPath expression or a CSS selector
+     * @param string           $type        The type of the expression
+     * @param bool             $wrapNode    Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     * @param \DOMElement|null $contextNode The node in which the search will be performed
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     *
+     * @throws InvalidArgumentException if context node is not \DOMElement
+     */
+    public function find($expression, $type = Query::TYPE_CSS, $wrapNode = true, $contextNode = null)
+    {
+        $expression = Query::compile($expression, $type);
+
+        if ($contextNode !== null) {
+            if ($contextNode instanceof Element) {
+                $contextNode = $contextNode->getNode();
+            }
+
+            if (!$contextNode instanceof DOMElement) {
+                throw new InvalidArgumentException(sprintf('Argument 4 passed to %s must be an instance of %s\Element or DOMElement, %s given', __METHOD__, __NAMESPACE__, (is_object($contextNode) ? get_class($contextNode) : gettype($contextNode))));
+            }
+
+            if ($type === Query::TYPE_CSS) {
+                $expression = '.' . $expression;
+            }
+        }
+
+        $nodeList = $this->createXpath()->query($expression, $contextNode);
+
+        $result = [];
+
+        if ($wrapNode) {
+            foreach ($nodeList as $node) {
+                $result[] = $this->wrapNode($node);
+            }
+        } else {
+            foreach ($nodeList as $node) {
+                $result[] = $node;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Searches for an node in the DOM tree and returns first element or null.
+     *
+     * @param string           $expression  XPath expression or a CSS selector
+     * @param string           $type        The type of the expression
+     * @param bool             $wrapNode    Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     * @param \DOMElement|null $contextNode The node in which the search will be performed
+     *
+     * @return \DiDom\Element|\DOMElement|null
+     */
+    public function first($expression, $type = Query::TYPE_CSS, $wrapNode = true, $contextNode = null)
+    {
+        $expression = Query::compile($expression, $type);
+
+        if ($contextNode !== null && $type === Query::TYPE_CSS) {
+            $expression = '.' . $expression;
+        }
+
+        $expression = sprintf('(%s)[1]', $expression);
+
+        $nodes = $this->find($expression, Query::TYPE_XPATH, false, $contextNode);
+
+        if (count($nodes) === 0) {
+            return null;
+        }
+
+        return $wrapNode ? $this->wrapNode($nodes[0]) : $nodes[0];
+    }
+
+    /**
+     * @param \DOMElement|\DOMText|\DOMAttr $node
+     *
+     * @return \DiDom\Element|string
+     *
+     * @throws InvalidArgumentException if node is not DOMElement, DOMText, DOMComment, DOMCdataSection or DOMAttr
+     */
+    protected function wrapNode($node)
+    {
+        switch (get_class($node)) {
+            case 'DOMElement':
+                return new Element($node);
+
+            case 'DOMText':
+                return $node->data;
+
+            case 'DOMComment':
+                return new Element($node);
+
+            case 'DOMCdataSection':
+                return new Element($node);
+
+            case 'DOMAttr':
+                return $node->value;
+        }
+
+        throw new InvalidArgumentException(sprintf('Unknown node type "%s"', get_class($node)));
+    }
+
+    /**
+     * Searches for a node in the DOM tree for a given XPath expression.
+     *
+     * @param string      $expression  XPath expression
+     * @param bool        $wrapNode    Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     * @param \DOMElement $contextNode The node in which the search will be performed
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     */
+    public function xpath($expression, $wrapNode = true, $contextNode = null)
+    {
+        return $this->find($expression, Query::TYPE_XPATH, $wrapNode, $contextNode);
+    }
+
+    /**
+     * Counts nodes for a given XPath expression or a CSS selector.
+     *
+     * @param string $expression XPath expression or CSS selector
+     * @param string $type The type of the expression
+     *
+     * @return int
+     */
+    public function count($expression, $type = Query::TYPE_CSS)
+    {
+        $expression = Query::compile($expression, $type);
+        $expression = sprintf('count(%s)', $expression);
+
+        return (int) $this->createXpath()->evaluate($expression);
+    }
+
+    /**
+     * @return DOMXPath
+     */
+    public function createXpath()
+    {
+        $xpath = new DOMXPath($this->document);
+
+        $xpath->registerNamespace('php', 'http://php.net/xpath');
+        $xpath->registerPhpFunctions();
+
+        return $xpath;
+    }
+
+    /**
+     * Dumps the internal document into a string using HTML formatting.
+     *
+     * @return string The document html
+     */
+    public function html()
+    {
+        return trim($this->document->saveHTML($this->document));
+    }
+
+    /**
+     * Dumps the internal document into a string using XML formatting.
+     *
+     * @param int $options Additional options
+     *
+     * @return string The document xml
+     */
+    public function xml($options = 0)
+    {
+        return trim($this->document->saveXML($this->document, $options));
+    }
+
+    /**
+     * Nicely formats output with indentation and extra space.
+     *
+     * @param bool $format Formats output if true
+     *
+     * @return \DiDom\Document
+     */
+    public function format($format = true)
+    {
+        if (!is_bool($format)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be boolean, %s given', __METHOD__, gettype($format)));
+        }
+
+        $this->document->formatOutput = $format;
+
+        return $this;
+    }
+
+    /**
+     * Get the text content of this node and its descendants.
+     *
+     * @return string
+     */
+    public function text()
+    {
+        return $this->getElement()->textContent;
+    }
+
+    /**
+     * Indicates if two documents are the same document.
+     *
+     * @param \DiDom\Document|\DOMDocument $document The compared document
+     *
+     * @return bool
+     *
+     * @throws \InvalidArgumentException if the provided argument is not an instance of \DOMDocument or \DiDom\Document
+     */
+    public function is($document)
+    {
+        if ($document instanceof Document) {
+            $element = $document->getElement();
+        } else {
+            if (!$document instanceof DOMDocument) {
+                throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s or DOMDocument, %s given', __METHOD__, __CLASS__, (is_object($document) ? get_class($document) : gettype($document))));
+            }
+
+            $element = $document->documentElement;
+        }
+
+        if ($element === null) {
+            return false;
+        }
+
+        return $this->getElement()->isSameNode($element);
+    }
+
+    /**
+     * Returns the type of the document (XML or HTML).
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->type;
+    }
+
+    /**
+     * Returns the encoding of the document (XML or HTML).
+     *
+     * @return string
+     */
+    public function getEncoding()
+    {
+        return $this->encoding;
+    }
+
+    /**
+     * @return \DOMDocument
+     */
+    public function getDocument()
+    {
+        return $this->document;
+    }
+
+    /**
+     * @return \DOMElement
+     */
+    public function getElement()
+    {
+        return $this->document->documentElement;
+    }
+
+    /**
+     * @return \DiDom\Element
+     */
+    public function toElement()
+    {
+        if ($this->document->documentElement === null) {
+            throw new RuntimeException('Cannot convert empty document to Element');
+        }
+
+        return new Element($this->document->documentElement);
+    }
+
+    /**
+     * Convert the document to its string representation.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->type === Document::TYPE_HTML ? $this->html() : $this->xml();
+    }
+
+    /**
+     * Searches for an node in the DOM tree for a given XPath expression or a CSS selector.
+     *
+     * @param string           $expression  XPath expression or a CSS selector
+     * @param string           $type        The type of the expression
+     * @param bool             $wrapNode    Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     * @param \DOMElement|null $contextNode The node in which the search will be performed
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     *
+     * @deprecated Not longer recommended, use Document::find() instead.
+     */
+    public function __invoke($expression, $type = Query::TYPE_CSS, $wrapNode = true, $contextNode = null)
+    {
+        return $this->find($expression, $type, $wrapNode, $contextNode);
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Element.php

@@ -0,0 +1,1477 @@
+<?php
+
+namespace DiDom;
+
+use DOMCdataSection;
+use DOMComment;
+use DOMDocument;
+use DOMElement;
+use DOMNode;
+use DOMText;
+use InvalidArgumentException;
+use LogicException;
+use RuntimeException;
+
+/**
+ * @property string $tag
+ */
+class Element
+{
+    /**
+     * The DOM element instance.
+     *
+     * @var \DOMElement|\DOMText|\DOMComment|\DOMCdataSection
+     */
+    protected $node;
+
+    /**
+     * @var \DiDom\ClassAttribute
+     */
+    protected $classAttribute;
+
+    /**
+     * @var \DiDom\StyleAttribute
+     */
+    protected $styleAttribute;
+
+    /**
+     * Constructor.
+     *
+     * @param \DOMElement|\DOMText|\DOMComment|\DOMCdataSection|string $tagName The tag name of the element
+     * @param string|null $value The value of the element
+     * @param array $attributes The attributes of the element
+     */
+    public function __construct($tagName, $value = null, array $attributes = [])
+    {
+        if (is_string($tagName)) {
+            $document = new DOMDocument('1.0', 'UTF-8');
+
+            $node = $document->createElement($tagName);
+
+            $this->setNode($node);
+        } else {
+            $this->setNode($tagName);
+        }
+
+        if ($value !== null) {
+            $this->setValue($value);
+        }
+
+        foreach ($attributes as $attrName => $attrValue) {
+            $this->setAttribute($attrName, $attrValue);
+        }
+    }
+
+    /**
+     * Creates a new element.
+     *
+     * @param \DOMNode|string $name The tag name of the element
+     * @param string|null $value The value of the element
+     * @param array  $attributes The attributes of the element
+     *
+     * @return \DiDom\Element
+     */
+    public static function create($name, $value = null, array $attributes = [])
+    {
+        return new Element($name, $value, $attributes);
+    }
+
+    /**
+     * Creates a new element node by CSS selector.
+     *
+     * @param string $selector
+     * @param string|null $value
+     * @param array $attributes
+     *
+     * @return \DiDom\Element
+     */
+    public static function createBySelector($selector, $value = null, array $attributes = [])
+    {
+        return Document::create()->createElementBySelector($selector, $value, $attributes);
+    }
+
+    /**
+     * Adds a new child at the start of the children.
+     *
+     * @param \DiDom\Element|\DOMNode|array $nodes The prepended child
+     *
+     * @return \DiDom\Element|\DiDom\Element[]
+     *
+     * @throws \LogicException if current node has no owner document
+     * @throws \InvalidArgumentException if the provided argument is not an instance of \DOMNode or \DiDom\Element
+     */
+    public function prependChild($nodes)
+    {
+        if ($this->node->ownerDocument === null) {
+            throw new LogicException('Can not prepend child to element without owner document');
+        }
+
+        $returnArray = true;
+
+        if (!is_array($nodes)) {
+            $nodes = [$nodes];
+
+            $returnArray = false;
+        }
+
+        $nodes = array_reverse($nodes);
+
+        $result = [];
+
+        $referenceNode = $this->node->firstChild;
+
+        foreach ($nodes as $node) {
+            $result[] = $this->insertBefore($node, $referenceNode);
+
+            $referenceNode = $this->node->firstChild;
+        }
+
+        return $returnArray ? $result : $result[0];
+    }
+
+    /**
+     * Adds a new child at the end of the children.
+     *
+     * @param \DiDom\Element|\DOMNode|array $nodes The appended child
+     *
+     * @return \DiDom\Element|\DiDom\Element[]
+     *
+     * @throws \LogicException if current node has no owner document
+     * @throws \InvalidArgumentException if the provided argument is not an instance of \DOMNode or \DiDom\Element
+     */
+    public function appendChild($nodes)
+    {
+        if ($this->node->ownerDocument === null) {
+            throw new LogicException('Can not append child to element without owner document');
+        }
+
+        $returnArray = true;
+
+        if (!is_array($nodes)) {
+            $nodes = [$nodes];
+
+            $returnArray = false;
+        }
+
+        $result = [];
+
+        Errors::disable();
+
+        foreach ($nodes as $node) {
+            if ($node instanceof Element) {
+                $node = $node->getNode();
+            }
+
+            if (!$node instanceof DOMNode) {
+                throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s\Element or DOMNode, %s given', __METHOD__, __NAMESPACE__, (is_object($node) ? get_class($node) : gettype($node))));
+            }
+
+            $clonedNode = $node->cloneNode(true);
+            $newNode = $this->node->ownerDocument->importNode($clonedNode, true);
+
+            $result[] = $this->node->appendChild($newNode);
+        }
+
+        Errors::restore();
+
+        $result = array_map(function (DOMNode $node) {
+            return new Element($node);
+        }, $result);
+
+        return $returnArray ? $result : $result[0];
+    }
+
+    /**
+     * Adds a new child before a reference node.
+     *
+     * @param \DiDom\Element|\DOMNode $node The new node
+     * @param \DiDom\Element|\DOMNode|null $referenceNode The reference node
+     *
+     * @return \DiDom\Element
+     *
+     * @throws \LogicException if current node has no owner document
+     * @throws \InvalidArgumentException if $node is not an instance of \DOMNode or \DiDom\Element
+     * @throws \InvalidArgumentException if $referenceNode is not an instance of \DOMNode or \DiDom\Element
+     */
+    public function insertBefore($node, $referenceNode = null)
+    {
+        if ($this->node->ownerDocument === null) {
+            throw new LogicException('Can not insert child to element without owner document');
+        }
+
+        if ($node instanceof Element) {
+            $node = $node->getNode();
+        }
+
+        if (!$node instanceof DOMNode) {
+            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s\Element or DOMNode, %s given', __METHOD__, __NAMESPACE__, (is_object($node) ? get_class($node) : gettype($node))));
+        }
+
+        if ($referenceNode !== null) {
+            if ($referenceNode instanceof Element) {
+                $referenceNode = $referenceNode->getNode();
+            }
+
+            if (!$referenceNode instanceof DOMNode) {
+                throw new InvalidArgumentException(sprintf('Argument 2 passed to %s must be an instance of %s\Element or DOMNode, %s given', __METHOD__, __NAMESPACE__, (is_object($referenceNode) ? get_class($referenceNode) : gettype($referenceNode))));
+            }
+        }
+
+        Errors::disable();
+
+        $clonedNode = $node->cloneNode(true);
+        $newNode = $this->node->ownerDocument->importNode($clonedNode, true);
+
+        $insertedNode = $this->node->insertBefore($newNode, $referenceNode);
+
+        Errors::restore();
+
+        return new Element($insertedNode);
+    }
+
+    /**
+     * Adds a new child after a reference node.
+     *
+     * @param \DiDom\Element|\DOMNode $node The new node
+     * @param \DiDom\Element|\DOMNode|null $referenceNode The reference node
+     *
+     * @return \DiDom\Element
+     *
+     * @throws \LogicException if current node has no owner document
+     * @throws \InvalidArgumentException if $node is not an instance of \DOMNode or \DiDom\Element
+     * @throws \InvalidArgumentException if $referenceNode is not an instance of \DOMNode or \DiDom\Element
+     */
+    public function insertAfter($node, $referenceNode = null)
+    {
+        if ($referenceNode === null) {
+            return $this->insertBefore($node);
+        }
+
+        if ($referenceNode instanceof Element) {
+            $referenceNode = $referenceNode->getNode();
+        }
+
+        if (!$referenceNode instanceof DOMNode) {
+            throw new InvalidArgumentException(sprintf('Argument 2 passed to %s must be an instance of %s\Element or DOMNode, %s given', __METHOD__, __NAMESPACE__, (is_object($referenceNode) ? get_class($referenceNode) : gettype($referenceNode))));
+        }
+
+        return $this->insertBefore($node, $referenceNode->nextSibling);
+    }
+
+    /**
+     * Checks the existence of the node.
+     *
+     * @param string $expression XPath expression or CSS selector
+     * @param string $type The type of the expression
+     *
+     * @return bool
+     */
+    public function has($expression, $type = Query::TYPE_CSS)
+    {
+        return $this->toDocument()->has($expression, $type);
+    }
+
+    /**
+     * Searches for an node in the DOM tree for a given XPath expression or a CSS selector.
+     *
+     * @param string $expression  XPath expression or a CSS selector
+     * @param string $type        The type of the expression
+     * @param bool   $wrapElement Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     */
+    public function find($expression, $type = Query::TYPE_CSS, $wrapElement = true)
+    {
+        return $this->toDocument()->find($expression, $type, $wrapElement);
+    }
+
+    /**
+     * Searches for an node in the owner document using current node as context.
+     *
+     * @param string $expression XPath expression or a CSS selector
+     * @param string $type       The type of the expression
+     * @param bool   $wrapNode   Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     *
+     * @throws \LogicException if current node has no owner document
+     */
+    public function findInDocument($expression, $type = Query::TYPE_CSS, $wrapNode = true)
+    {
+        $ownerDocument = $this->getDocument();
+
+        if ($ownerDocument === null) {
+            throw new LogicException('Can not search in context without owner document');
+        }
+
+        return $ownerDocument->find($expression, $type, $wrapNode, $this->node);
+    }
+
+    /**
+     * Searches for an node in the DOM tree and returns first element or null.
+     *
+     * @param string $expression XPath expression or a CSS selector
+     * @param string $type       The type of the expression
+     * @param bool   $wrapNode   Returns \DiDom\Element if true, otherwise \DOMElement
+     *
+     * @return \DiDom\Element|\DOMElement|null
+     */
+    public function first($expression, $type = Query::TYPE_CSS, $wrapNode = true)
+    {
+        return $this->toDocument()->first($expression, $type, $wrapNode);
+    }
+
+    /**
+     * Searches for an node in the owner document using current node as context and returns first element or null.
+     *
+     * @param string $expression XPath expression or a CSS selector
+     * @param string $type       The type of the expression
+     * @param bool   $wrapNode   Returns \DiDom\Element if true, otherwise \DOMElement
+     *
+     * @return \DiDom\Element|\DOMElement|null
+     */
+    public function firstInDocument($expression, $type = Query::TYPE_CSS, $wrapNode = true)
+    {
+        $ownerDocument = $this->getDocument();
+
+        if ($ownerDocument === null) {
+            throw new LogicException('Can not search in context without owner document');
+        }
+
+        return $ownerDocument->first($expression, $type, $wrapNode, $this->node);
+    }
+
+    /**
+     * Searches for an node in the DOM tree for a given XPath expression.
+     *
+     * @param string $expression XPath expression
+     * @param bool   $wrapNode Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     */
+    public function xpath($expression, $wrapNode = true)
+    {
+        return $this->find($expression, Query::TYPE_XPATH, $wrapNode);
+    }
+
+    /**
+     * Counts nodes for a given XPath expression or a CSS selector.
+     *
+     * @param string $expression XPath expression or CSS selector
+     * @param string $type The type of the expression
+     *
+     * @return int
+     */
+    public function count($expression, $type = Query::TYPE_CSS)
+    {
+        return $this->toDocument()->count($expression, $type);
+    }
+
+    /**
+     * Checks that the node matches selector.
+     *
+     * @param string $selector CSS selector
+     * @param bool $strict
+     *
+     * @return bool
+     *
+     * @throws \InvalidArgumentException if the tag name is not a string
+     * @throws \RuntimeException if the tag name is not specified in strict mode
+     */
+    public function matches($selector, $strict = false)
+    {
+        if (!is_string($selector)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, gettype($selector)));
+        }
+
+        if (!$this->node instanceof DOMElement) {
+            return false;
+        }
+
+        if ($selector === '*') {
+            return true;
+        }
+
+        if (!$strict) {
+            $innerHtml = $this->html();
+            $html = "<root>$innerHtml</root>";
+
+            $selector = 'root > ' . trim($selector);
+
+            $document = new Document();
+
+            $document->loadHtml($html, LIBXML_HTML_NODEFDTD | LIBXML_HTML_NOIMPLIED);
+
+            return $document->has($selector);
+        }
+
+        $segments = Query::getSegments($selector);
+
+        if (!array_key_exists('tag', $segments)) {
+            throw new RuntimeException(sprintf('Tag name must be specified in %s', $selector));
+        }
+
+        if ($segments['tag'] !== $this->tag && $segments['tag'] !== '*') {
+            return false;
+        }
+
+        $segments['id'] = array_key_exists('id', $segments) ? $segments['id'] : null;
+
+        if ($segments['id'] !== $this->getAttribute('id')) {
+            return false;
+        }
+
+        $classes = $this->hasAttribute('class') ? explode(' ', trim($this->getAttribute('class'))) : [];
+
+        $segments['classes'] = array_key_exists('classes', $segments) ? $segments['classes'] : [];
+
+        $diff1 = array_diff($segments['classes'], $classes);
+        $diff2 = array_diff($classes, $segments['classes']);
+
+        if (count($diff1) > 0 || count($diff2) > 0) {
+            return false;
+        }
+
+        $attributes = $this->attributes();
+
+        unset($attributes['id'], $attributes['class']);
+
+        $segments['attributes'] = array_key_exists('attributes', $segments) ? $segments['attributes'] : [];
+
+        $diff1 = array_diff_assoc($segments['attributes'], $attributes);
+        $diff2 = array_diff_assoc($attributes, $segments['attributes']);
+
+        // if the attributes are not equal
+        if (count($diff1) > 0 || count($diff2) > 0) {
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Determine if an attribute exists on the element.
+     *
+     * @param string $name The attribute name
+     *
+     * @return bool
+     */
+    public function hasAttribute($name)
+    {
+        return $this->node->hasAttribute($name);
+    }
+
+    /**
+     * Set an attribute on the element.
+     *
+     * @param string $name The attribute name
+     * @param string $value The attribute value
+     *
+     * @return \DiDom\Element
+     */
+    public function setAttribute($name, $value)
+    {
+        if (is_numeric($value)) {
+            $value = (string) $value;
+        }
+
+        if (!is_string($value) && $value !== null) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string or null, %s given', __METHOD__, (is_object($value) ? get_class($value) : gettype($value))));
+        }
+
+        $this->node->setAttribute($name, $value);
+
+        return $this;
+    }
+
+    /**
+     * Access to the element's attributes.
+     *
+     * @param string $name The attribute name
+     * @param string|null $default The value returned if the attribute does not exist
+     *
+     * @return string|null The value of the attribute or null if attribute does not exist
+     */
+    public function getAttribute($name, $default = null)
+    {
+        if ($this->hasAttribute($name)) {
+            return $this->node->getAttribute($name);
+        }
+
+        return $default;
+    }
+
+    /**
+     * Unset an attribute on the element.
+     *
+     * @param string $name The attribute name
+     *
+     * @return \DiDom\Element
+     */
+    public function removeAttribute($name)
+    {
+        $this->node->removeAttribute($name);
+
+        return $this;
+    }
+
+    /**
+     * Unset all attributes of the element.
+     *
+     * @param string[] $exclusions
+     *
+     * @return \DiDom\Element
+     */
+    public function removeAllAttributes(array $exclusions = [])
+    {
+        if (!$this->node instanceof DOMElement) {
+            return $this;
+        }
+
+        foreach ($this->attributes() as $name => $value) {
+            if (in_array($name, $exclusions, true)) {
+                continue;
+            }
+
+            $this->node->removeAttribute($name);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Alias for getAttribute and setAttribute methods.
+     *
+     * @param string $name The attribute name
+     * @param string|null $value The attribute value or null if the attribute does not exist
+     *
+     * @return string|null|\DiDom\Element
+     */
+    public function attr($name, $value = null)
+    {
+        if ($value === null) {
+            return $this->getAttribute($name);
+        }
+
+        return $this->setAttribute($name, $value);
+    }
+
+    /**
+     * Returns the node attributes or null, if it is not DOMElement.
+     *
+     * @param string[] $names
+     *
+     * @return array|null
+     */
+    public function attributes(array $names = null)
+    {
+        if (!$this->node instanceof DOMElement) {
+            return null;
+        }
+
+        if ($names === null) {
+            $result = [];
+
+            foreach ($this->node->attributes as $name => $attribute) {
+                $result[$name] = $attribute->value;
+            }
+
+            return $result;
+        }
+
+        $result = [];
+
+        foreach ($this->node->attributes as $name => $attribute) {
+            if (in_array($name, $names, true)) {
+                $result[$name] = $attribute->value;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @return \DiDom\ClassAttribute
+     *
+     * @throws \LogicException if the node is not an instance of \DOMElement
+     */
+    public function classes()
+    {
+        if ($this->classAttribute !== null) {
+            return $this->classAttribute;
+        }
+
+        if (!$this->isElementNode()) {
+            throw new LogicException('Class attribute is available only for element nodes');
+        }
+
+        $this->classAttribute = new ClassAttribute($this);
+
+        return $this->classAttribute;
+    }
+
+    /**
+     * @return \DiDom\StyleAttribute
+     *
+     * @throws \LogicException if the node is not an instance of \DOMElement
+     */
+    public function style()
+    {
+        if ($this->styleAttribute !== null) {
+            return $this->styleAttribute;
+        }
+
+        if (!$this->isElementNode()) {
+            throw new LogicException('Style attribute is available only for element nodes');
+        }
+
+        $this->styleAttribute = new StyleAttribute($this);
+
+        return $this->styleAttribute;
+    }
+
+    /**
+     * Dumps the node into a string using HTML formatting (including child nodes).
+     *
+     * @return string
+     */
+    public function html()
+    {
+        return $this->toDocument()->html();
+    }
+
+    /**
+     * Dumps the node into a string using HTML formatting (without child nodes).
+     *
+     * @return string
+     */
+    public function outerHtml()
+    {
+        $document = new DOMDocument();
+
+        $importedNode = $document->importNode($this->node);
+
+        return $document->saveHTML($importedNode);
+    }
+
+    /**
+     * Dumps the node descendants into a string using HTML formatting.
+     *
+     * @param string $delimiter
+     *
+     * @return string
+     */
+    public function innerHtml($delimiter = '')
+    {
+        $innerHtml = [];
+
+        foreach ($this->node->childNodes as $childNode) {
+            $innerHtml[] = $childNode->ownerDocument->saveHTML($childNode);
+        }
+
+        return implode($delimiter, $innerHtml);
+    }
+
+    /**
+     * Dumps the node descendants into a string using XML formatting.
+     *
+     * @param string $delimiter
+     *
+     * @return string
+     */
+    public function innerXml($delimiter = '')
+    {
+        $innerXml = [];
+
+        foreach ($this->node->childNodes as $childNode) {
+            $innerXml[] = $childNode->ownerDocument->saveXML($childNode);
+        }
+
+        return implode($delimiter, $innerXml);
+    }
+
+    /**
+     * Sets inner HTML.
+     *
+     * @param string $html
+     *
+     * @return \DiDom\Element
+     *
+     * @throws InvalidArgumentException if passed argument is not a string
+     */
+    public function setInnerHtml($html)
+    {
+        if (!is_string($html)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($html) ? get_class($html) : gettype($html))));
+        }
+
+        $this->removeChildren();
+
+        if ($html !== '') {
+            Errors::disable();
+
+            $html = "<htmlfragment>$html</htmlfragment>";
+
+            $document = new Document($html);
+
+            $fragment = $document->first('htmlfragment')->getNode();
+
+            foreach ($fragment->childNodes as $node) {
+                $newNode = $this->node->ownerDocument->importNode($node, true);
+
+                $this->node->appendChild($newNode);
+            }
+
+            Errors::restore();
+        }
+
+        return $this;
+    }
+
+    /**
+     * Dumps the node into a string using XML formatting.
+     *
+     * @param int $options Additional options
+     *
+     * @return string The node XML
+     */
+    public function xml($options = 0)
+    {
+        return $this->toDocument()->xml($options);
+    }
+
+    /**
+     * Get the text content of this node and its descendants.
+     *
+     * @return string The node value
+     */
+    public function text()
+    {
+        return $this->node->textContent;
+    }
+
+    /**
+     * Set the value of this node.
+     *
+     * @param string $value The new value of the node
+     *
+     * @return \DiDom\Element
+     *
+     * @throws \InvalidArgumentException if value is not string
+     */
+    public function setValue($value)
+    {
+        if (is_numeric($value)) {
+            $value = (string) $value;
+        }
+
+        if (!is_string($value) && $value !== null) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($value) ? get_class($value) : gettype($value))));
+        }
+
+        $this->node->nodeValue = $value;
+
+        return $this;
+    }
+
+    /**
+     * Returns true if current node is a DOMElement instance.
+     *
+     * @return bool
+     */
+    public function isElementNode()
+    {
+        return $this->node instanceof DOMElement;
+    }
+
+    /**
+     * Returns true if current node is a a DOMText instance.
+     *
+     * @return bool
+     */
+    public function isTextNode()
+    {
+        return $this->node instanceof DOMText;
+    }
+
+    /**
+     * Returns true if current node is a DOMComment instance.
+     *
+     * @return bool
+     */
+    public function isCommentNode()
+    {
+        return $this->node instanceof DOMComment;
+    }
+
+    /**
+     * Returns true if current node is a DOMCdataSection instance.
+     *
+     * @return bool
+     */
+    public function isCdataSectionNode()
+    {
+        return $this->node instanceof DOMCdataSection;
+    }
+
+    /**
+     * Indicates if two nodes are the same node.
+     *
+     * @param \DiDom\Element|\DOMNode $node
+     *
+     * @return bool
+     *
+     * @throws \InvalidArgumentException if the provided argument is not an instance of \DOMNode
+     */
+    public function is($node)
+    {
+        if ($node instanceof Element) {
+            $node = $node->getNode();
+        }
+
+        if (!$node instanceof DOMNode) {
+            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s or DOMNode, %s given', __METHOD__, __CLASS__, (is_object($node) ? get_class($node) : gettype($node))));
+        }
+
+        return $this->node->isSameNode($node);
+    }
+
+    /**
+     * @return \DiDom\Element|\DiDom\Document|null
+     */
+    public function parent()
+    {
+        if ($this->node->parentNode === null) {
+            return null;
+        }
+
+        if ($this->node->parentNode instanceof DOMDocument) {
+            return new Document($this->node->parentNode);
+        }
+
+        return new Element($this->node->parentNode);
+    }
+
+    /**
+     * Returns first parent node matches passed selector.
+     *
+     * @param string $selector
+     * @param bool $strict
+     *
+     * @return \DiDom\Element|null
+     */
+    public function closest($selector, $strict = false)
+    {
+        $node = $this;
+
+        while (true) {
+            $parent = $node->parent();
+
+            if ($parent === null || $parent instanceof Document) {
+                return null;
+            }
+
+            if ($parent->matches($selector, $strict)) {
+                return $parent;
+            }
+
+            $node = $parent;
+        }
+    }
+
+    /**
+     * @param string|null $selector
+     * @param string|null $nodeType
+     *
+     * @return \DiDom\Element|null
+     *
+     * @throws \InvalidArgumentException if node type is not string
+     * @throws \RuntimeException if node type is invalid
+     * @throws \LogicException if selector used with non DOMElement node type
+     */
+    public function previousSibling($selector = null, $nodeType = null)
+    {
+        if ($this->node->previousSibling === null) {
+            return null;
+        }
+
+        if ($selector === null && $nodeType === null) {
+            return new Element($this->node->previousSibling);
+        }
+
+        if ($selector !== null && $nodeType === null) {
+            $nodeType = 'DOMElement';
+        }
+
+        if (!is_string($nodeType)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, gettype($nodeType)));
+        }
+
+        $allowedTypes = ['DOMElement', 'DOMText', 'DOMComment', 'DOMCdataSection'];
+
+        if (!in_array($nodeType, $allowedTypes, true)) {
+            throw new RuntimeException(sprintf('Unknown node type "%s". Allowed types: %s', $nodeType, implode(', ', $allowedTypes)));
+        }
+
+        if ($selector !== null && $nodeType !== 'DOMElement') {
+            throw new LogicException(sprintf('Selector can be used only with DOMElement node type, %s given', $nodeType));
+        }
+
+        $node = $this->node->previousSibling;
+
+        while ($node !== null) {
+            if (get_class($node) !== $nodeType) {
+                $node = $node->previousSibling;
+
+                continue;
+            }
+
+            $element = new Element($node);
+
+            if ($selector === null) {
+                return $element;
+            }
+
+            if ($element->matches($selector)) {
+                return $element;
+            }
+
+            $node = $node->previousSibling;
+        }
+
+        return new Element($this->node->previousSibling);
+    }
+
+    /**
+     * @param string|null $selector
+     * @param string|null $nodeType
+     *
+     * @return \DiDom\Element[]
+     *
+     * @throws \InvalidArgumentException if node type is not string
+     * @throws \RuntimeException if node type is invalid
+     * @throws \LogicException if selector used with non DOMElement node type
+     */
+    public function previousSiblings($selector = null, $nodeType = null)
+    {
+        if ($this->node->previousSibling === null) {
+            return [];
+        }
+
+        if ($selector !== null && $nodeType === null) {
+            $nodeType = 'DOMElement';
+        }
+
+        if ($nodeType !== null) {
+            if (!is_string($nodeType)) {
+                throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, gettype($nodeType)));
+            }
+
+            $allowedTypes = ['DOMElement', 'DOMText', 'DOMComment', 'DOMCdataSection'];
+
+            if (!in_array($nodeType, $allowedTypes, true)) {
+                throw new RuntimeException(sprintf('Unknown node type "%s". Allowed types: %s', $nodeType, implode(', ', $allowedTypes)));
+            }
+        }
+
+        if ($selector !== null && $nodeType !== 'DOMElement') {
+            throw new LogicException(sprintf('Selector can be used only with DOMElement node type, %s given', $nodeType));
+        }
+
+        $result = [];
+
+        $node = $this->node->previousSibling;
+
+        while ($node !== null) {
+            $element = new Element($node);
+
+            if ($nodeType === null) {
+                $result[] = $element;
+
+                $node = $node->previousSibling;
+
+                continue;
+            }
+
+            if (get_class($node) !== $nodeType) {
+                $node = $node->previousSibling;
+
+                continue;
+            }
+
+            if ($selector === null) {
+                $result[] = $element;
+
+                $node = $node->previousSibling;
+
+                continue;
+            }
+
+            if ($element->matches($selector)) {
+                $result[] = $element;
+            }
+
+            $node = $node->previousSibling;
+        }
+
+        return array_reverse($result);
+    }
+
+    /**
+     * @param string|null $selector
+     * @param string|null $nodeType
+     *
+     * @return \DiDom\Element|null
+     *
+     * @throws \InvalidArgumentException if node type is not string
+     * @throws \RuntimeException if node type is invalid
+     * @throws \LogicException if selector used with non DOMElement node type
+     */
+    public function nextSibling($selector = null, $nodeType = null)
+    {
+        if ($this->node->nextSibling === null) {
+            return null;
+        }
+
+        if ($selector === null && $nodeType === null) {
+            return new Element($this->node->nextSibling);
+        }
+
+        if ($selector !== null && $nodeType === null) {
+            $nodeType = 'DOMElement';
+        }
+
+        if (!is_string($nodeType)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, gettype($nodeType)));
+        }
+
+        $allowedTypes = ['DOMElement', 'DOMText', 'DOMComment', 'DOMCdataSection'];
+
+        if (!in_array($nodeType, $allowedTypes, true)) {
+            throw new RuntimeException(sprintf('Unknown node type "%s". Allowed types: %s', $nodeType, implode(', ', $allowedTypes)));
+        }
+
+        if ($selector !== null && $nodeType !== 'DOMElement') {
+            throw new LogicException(sprintf('Selector can be used only with DOMElement node type, %s given', $nodeType));
+        }
+
+        $node = $this->node->nextSibling;
+
+        while ($node !== null) {
+            if (get_class($node) !== $nodeType) {
+                $node = $node->nextSibling;
+
+                continue;
+            }
+
+            $element = new Element($node);
+
+            if ($selector === null) {
+                return $element;
+            }
+
+            if ($element->matches($selector)) {
+                return $element;
+            }
+
+            $node = $node->nextSibling;
+        }
+
+        return null;
+    }
+
+    /**
+     * @param string|null $selector
+     * @param string $nodeType
+     *
+     * @return \DiDom\Element[]
+     *
+     * @throws \InvalidArgumentException if node type is not string
+     * @throws \RuntimeException if node type is invalid
+     * @throws \LogicException if selector used with non DOMElement node type
+     */
+    public function nextSiblings($selector = null, $nodeType = null)
+    {
+        if ($this->node->nextSibling === null) {
+            return [];
+        }
+
+        if ($selector !== null && $nodeType === null) {
+            $nodeType = 'DOMElement';
+        }
+
+        if ($nodeType !== null) {
+            if (!is_string($nodeType)) {
+                throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, gettype($nodeType)));
+            }
+
+            $allowedTypes = ['DOMElement', 'DOMText', 'DOMComment', 'DOMCdataSection'];
+
+            if (!in_array($nodeType, $allowedTypes, true)) {
+                throw new RuntimeException(sprintf('Unknown node type "%s". Allowed types: %s', $nodeType, implode(', ', $allowedTypes)));
+            }
+        }
+
+        if ($selector !== null && $nodeType !== 'DOMElement') {
+            throw new LogicException(sprintf('Selector can be used only with DOMElement node type, %s given', $nodeType));
+        }
+
+        $result = [];
+
+        $node = $this->node->nextSibling;
+
+        while ($node !== null) {
+            $element = new Element($node);
+
+            if ($nodeType === null) {
+                $result[] = $element;
+
+                $node = $node->nextSibling;
+
+                continue;
+            }
+
+            if (get_class($node) !== $nodeType) {
+                $node = $node->nextSibling;
+
+                continue;
+            }
+
+            if ($selector === null) {
+                $result[] = $element;
+
+                $node = $node->nextSibling;
+
+                continue;
+            }
+
+            if ($element->matches($selector)) {
+                $result[] = $element;
+            }
+
+            $node = $node->nextSibling;
+        }
+
+        return $result;
+    }
+
+    /**
+     * @param int $index
+     *
+     * @return \DiDom\Element|null
+     */
+    public function child($index)
+    {
+        $child = $this->node->childNodes->item($index);
+
+        return $child === null ? null : new Element($child);
+    }
+
+    /**
+     * @return \DiDom\Element|null
+     */
+    public function firstChild()
+    {
+        if ($this->node->firstChild === null) {
+            return null;
+        }
+
+        return new Element($this->node->firstChild);
+    }
+
+    /**
+     * @return \DiDom\Element|null
+     */
+    public function lastChild()
+    {
+        if ($this->node->lastChild === null) {
+            return null;
+        }
+
+        return new Element($this->node->lastChild);
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasChildren()
+    {
+        return $this->node->hasChildNodes();
+    }
+
+    /**
+     * @return \DiDom\Element[]
+     */
+    public function children()
+    {
+        $children = [];
+
+        foreach ($this->node->childNodes as $node) {
+            $children[] = new Element($node);
+        }
+
+        return $children;
+    }
+
+    /**
+     * Removes child from list of children.
+     *
+     * @param \DOMNode|\DiDom\Element $childNode
+     *
+     * @return \DiDom\Element the node that has been removed
+     */
+    public function removeChild($childNode)
+    {
+        if ($childNode instanceof Element) {
+            $childNode = $childNode->getNode();
+        }
+
+        if (!$childNode instanceof DOMNode) {
+            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s or DOMNode, %s given', __METHOD__, __CLASS__, (is_object($childNode) ? get_class($childNode) : gettype($childNode))));
+        }
+
+        $removedNode = $this->node->removeChild($childNode);
+
+        return new Element($removedNode);
+    }
+
+    /**
+     * Removes all child nodes.
+     *
+     * @return \DiDom\Element[] the nodes that has been removed
+     */
+    public function removeChildren()
+    {
+        // we need to collect child nodes to array
+        // because removing nodes from the DOMNodeList on iterating is not working
+        $childNodes = [];
+
+        foreach ($this->node->childNodes as $childNode) {
+            $childNodes[] = $childNode;
+        }
+
+        $removedNodes = [];
+
+        foreach ($childNodes as $childNode) {
+            $removedNode = $this->node->removeChild($childNode);
+
+            $removedNodes[] = new Element($removedNode);
+        }
+
+        return $removedNodes;
+    }
+
+    /**
+     * Removes current node from the parent.
+     *
+     * @return \DiDom\Element the node that has been removed
+     *
+     * @throws \LogicException if current node has no parent node
+     */
+    public function remove()
+    {
+        if ($this->node->parentNode === null) {
+            throw new LogicException('Can not remove element without parent node');
+        }
+
+        $removedNode = $this->node->parentNode->removeChild($this->node);
+
+        return new Element($removedNode);
+    }
+
+    /**
+     * Replaces a child.
+     *
+     * @param \DOMNode|\DiDom\Element $newNode The new node
+     * @param bool $clone Clone the node if true, otherwise move it
+     *
+     * @return \DiDom\Element The node that has been replaced
+     *
+     * @throws \LogicException if current node has no parent node
+     */
+    public function replace($newNode, $clone = true)
+    {
+        if ($this->node->parentNode === null) {
+            throw new LogicException('Can not replace element without parent node');
+        }
+
+        if ($newNode instanceof Element) {
+            $newNode = $newNode->getNode();
+        }
+
+        if (!$newNode instanceof DOMNode) {
+            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of %s or DOMNode, %s given', __METHOD__, __CLASS__, (is_object($newNode) ? get_class($newNode) : gettype($newNode))));
+        }
+
+        if ($clone) {
+            $newNode = $newNode->cloneNode(true);
+        }
+
+        if ($newNode->ownerDocument === null || !$this->getDocument()->is($newNode->ownerDocument)) {
+            $newNode = $this->node->ownerDocument->importNode($newNode, true);
+        }
+
+        $node = $this->node->parentNode->replaceChild($newNode, $this->node);
+
+        return new Element($node);
+    }
+
+    /**
+     * Get line number for a node.
+     *
+     * @return int
+     */
+    public function getLineNo()
+    {
+        return $this->node->getLineNo();
+    }
+
+    /**
+     * Clones a node.
+     *
+     * @param bool $deep Indicates whether to copy all descendant nodes
+     *
+     * @return \DiDom\Element The cloned node
+     */
+    public function cloneNode($deep = true)
+    {
+        return new Element($this->node->cloneNode($deep));
+    }
+
+    /**
+     * Sets current node instance.
+     *
+     * @param \DOMElement|\DOMText|\DOMComment|\DOMCdataSection $node
+     *
+     * @return \DiDom\Element
+     */
+    protected function setNode($node)
+    {
+        $allowedClasses = ['DOMElement', 'DOMText', 'DOMComment', 'DOMCdataSection'];
+
+        if (!is_object($node) || !in_array(get_class($node), $allowedClasses, true)) {
+            throw new InvalidArgumentException(sprintf('Argument 1 passed to %s must be an instance of DOMElement, DOMText, DOMComment or DOMCdataSection, %s given', __METHOD__, (is_object($node) ? get_class($node) : gettype($node))));
+        }
+
+        $this->node = $node;
+
+        return $this;
+    }
+
+    /**
+     * Returns current node instance.
+     *
+     * @return \DOMElement|\DOMText|\DOMComment|\DOMCdataSection
+     */
+    public function getNode()
+    {
+        return $this->node;
+    }
+
+    /**
+     * Returns the document associated with this node.
+     *
+     * @return \DiDom\Document|null
+     */
+    public function getDocument()
+    {
+        if ($this->node->ownerDocument === null) {
+            return null;
+        }
+
+        return new Document($this->node->ownerDocument);
+    }
+
+    /**
+     * Get the DOM document with the current element.
+     *
+     * @param string $encoding The document encoding
+     *
+     * @return \DiDom\Document
+     */
+    public function toDocument($encoding = 'UTF-8')
+    {
+        $document = new Document(null, false, $encoding);
+
+        $document->appendChild($this->node);
+
+        return $document;
+    }
+
+    /**
+     * Dynamically set an attribute on the element.
+     *
+     * @param string $name The attribute name
+     * @param mixed  $value The attribute value
+     *
+     * @return \DiDom\Element
+     */
+    public function __set($name, $value)
+    {
+        return $this->setAttribute($name, $value);
+    }
+
+    /**
+     * Dynamically access the element's attributes.
+     *
+     * @param string $name The attribute name
+     *
+     * @return string|null
+     */
+    public function __get($name)
+    {
+        if ($name === 'tag') {
+            return $this->node->tagName;
+        }
+
+        return $this->getAttribute($name);
+    }
+
+    /**
+     * Determine if an attribute exists on the element.
+     *
+     * @param string $name The attribute name
+     *
+     * @return bool
+     */
+    public function __isset($name)
+    {
+        return $this->hasAttribute($name);
+    }
+
+    /**
+     * Unset an attribute on the model.
+     *
+     * @param string $name The attribute name
+     */
+    public function __unset($name)
+    {
+        $this->removeAttribute($name);
+    }
+
+    /**
+     * Convert the element to its string representation.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->html();
+    }
+
+    /**
+     * Searches for an node in the DOM tree for a given XPath expression or a CSS selector.
+     *
+     * @param string $expression XPath expression or a CSS selector
+     * @param string $type       The type of the expression
+     * @param bool   $wrapNode   Returns array of \DiDom\Element if true, otherwise array of \DOMElement
+     *
+     * @return \DiDom\Element[]|\DOMElement[]
+     *
+     * @deprecated Not longer recommended, use Element::find() instead.
+     */
+    public function __invoke($expression, $type = Query::TYPE_CSS, $wrapNode = true)
+    {
+        return $this->find($expression, $type, $wrapNode);
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Encoder.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace DiDom;
+
+class Encoder
+{
+    /**
+     * @param string $string
+     * @param string $encoding
+     *
+     * @return string
+     */
+    public static function convertToHtmlEntities($string, $encoding)
+    {
+        if (function_exists('mb_convert_encoding')) {
+            return mb_convert_encoding($string, 'HTML-ENTITIES', $encoding);
+        }
+
+        if ('UTF-8' !== $encoding) {
+            $string = iconv($encoding, 'UTF-8//IGNORE', $string);
+        }
+
+        return preg_replace_callback('/[\x80-\xFF]+/', [__CLASS__, 'htmlEncodingCallback'], $string);
+    }
+
+    /**
+     * @param string[] $matches
+     *
+     * @return string
+     */
+    private static function htmlEncodingCallback($matches)
+    {
+        $characterIndex = 1;
+        $entities = '';
+
+        $codes = unpack('C*', htmlentities($matches[0], ENT_COMPAT, 'UTF-8'));
+
+        while (isset($codes[$characterIndex])) {
+            if (0x80 > $codes[$characterIndex]) {
+                $entities .= chr($codes[$characterIndex++]);
+
+                continue;
+            }
+
+            if (0xF0 <= $codes[$characterIndex]) {
+                $code = (($codes[$characterIndex++] - 0xF0) << 18) + (($codes[$characterIndex++] - 0x80) << 12) + (($codes[$characterIndex++] - 0x80) << 6) + $codes[$characterIndex++] - 0x80;
+            } elseif (0xE0 <= $codes[$characterIndex]) {
+                $code = (($codes[$characterIndex++] - 0xE0) << 12) + (($codes[$characterIndex++] - 0x80) << 6) + $codes[$characterIndex++] - 0x80;
+            } else {
+                $code = (($codes[$characterIndex++] - 0xC0) << 6) + $codes[$characterIndex++] - 0x80;
+            }
+
+            $entities .= '&#' . $code . ';';
+        }
+
+        return $entities;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Errors.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace DiDom;
+
+class Errors
+{
+    /**
+     * @var bool
+     */
+    protected static $internalErrors;
+
+    /**
+     * @var bool
+     */
+    protected static $disableEntities;
+
+    /**
+     * Disable error reporting.
+     */
+    public static function disable()
+    {
+        self::$internalErrors = libxml_use_internal_errors(true);
+        self::$disableEntities = libxml_disable_entity_loader(true);
+    }
+
+    /**
+     * Restore error reporting.
+     * 
+     * @param bool $clear
+     */
+    public static function restore($clear = true)
+    {
+        if ($clear) {
+            libxml_clear_errors();
+        }
+
+        libxml_use_internal_errors(self::$internalErrors);
+        libxml_disable_entity_loader(self::$disableEntities);
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Exceptions/InvalidSelectorException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace DiDom\Exceptions;
+
+use Exception;
+
+class InvalidSelectorException extends Exception
+{
+    //
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/Query.php

@@ -0,0 +1,559 @@
+<?php
+
+namespace DiDom;
+
+use DiDom\Exceptions\InvalidSelectorException;
+use InvalidArgumentException;
+use RuntimeException;
+
+class Query
+{
+    /**
+     * Types of expression.
+     *
+     * @const string
+     */
+    const TYPE_XPATH = 'XPATH';
+    const TYPE_CSS   = 'CSS';
+
+    /**
+     * @var array
+     */
+    protected static $compiled = [];
+
+    /**
+     * Converts a CSS selector into an XPath expression.
+     *
+     * @param string $expression XPath expression or CSS selector
+     * @param string $type The type of the expression
+     *
+     * @return string XPath expression
+     *
+     * @throws InvalidSelectorException if the expression is empty
+     */
+    public static function compile($expression, $type = self::TYPE_CSS)
+    {
+        if (!is_string($expression)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, gettype($expression)));
+        }
+
+        if (!is_string($type)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, gettype($type)));
+        }
+
+        if (strcasecmp($type, self::TYPE_XPATH) !== 0 && strcasecmp($type, self::TYPE_CSS) !== 0) {
+            throw new RuntimeException(sprintf('Unknown expression type "%s"', $type));
+        }
+
+        $expression = trim($expression);
+
+        if ($expression === '') {
+            throw new InvalidSelectorException('The expression must not be empty');
+        }
+
+        if (strcasecmp($type, self::TYPE_XPATH) === 0) {
+            return $expression;
+        }
+
+        if (!array_key_exists($expression, static::$compiled)) {
+            static::$compiled[$expression] = static::cssToXpath($expression);
+        }
+
+        return static::$compiled[$expression];
+    }
+
+    /**
+     * Converts a CSS selector into an XPath expression.
+     *
+     * @param string $selector A CSS selector
+     * @param string $prefix Specifies the nesting of nodes
+     *
+     * @return string XPath expression
+     */
+    public static function cssToXpath($selector, $prefix = '//')
+    {
+        $paths = [];
+
+        while ($selector !== '') {
+            list($xpath, $selector) = static::parseAndConvertSelector($selector, $prefix);
+
+            if (substr($selector, 0, 1) === ',') {
+                $selector = trim($selector, ', ');
+            }
+
+            $paths[] = $xpath;
+        }
+
+        return implode('|', $paths);
+    }
+
+    /**
+     * @param string $selector
+     * @param string $prefix
+     *
+     * @return array
+     */
+    protected static function parseAndConvertSelector($selector, $prefix = '//')
+    {
+        if (substr($selector, 0, 1) === '>') {
+            $prefix = '/';
+
+            $selector = ltrim($selector, '> ');
+        }
+
+        $segments = self::getSegments($selector);
+        $xpath = '';
+
+        while (count($segments) > 0) {
+            $xpath .= self::buildXpath($segments, $prefix);
+
+            $selector = trim(substr($selector, strlen($segments['selector'])));
+            $prefix = isset($segments['rel']) ? '/' : '//';
+
+            if ($selector === '' || substr($selector, 0, 2) === '::' || substr($selector, 0, 1) === ',') {
+                break;
+            }
+
+            $segments = self::getSegments($selector);
+        }
+
+        // if selector has property
+        if (substr($selector, 0, 2) === '::') {
+            $property = self::parseProperty($selector);
+            $propertyXpath = self::convertProperty($property['name'], $property['args']);
+
+            $selector = substr($selector, strlen($property['property']));
+            $selector = trim($selector);
+
+            $xpath .= '/' . $propertyXpath;
+        }
+
+        return [$xpath, $selector];
+    }
+
+    /**
+     * @param string $selector
+     *
+     * @return array
+     *
+     * @throws InvalidSelectorException
+     */
+    protected static function parseProperty($selector)
+    {
+        $name = '(?P<name>[\w\-]+)';
+        $args = '(?:\((?P<args>[^\)]+)?\))?';
+
+        $regexp = '/^::' . $name . $args . '/is';
+
+        if (preg_match($regexp, $selector, $matches) !== 1) {
+            throw new InvalidSelectorException(sprintf('Invalid property "%s"', $selector));
+        }
+
+        $result = [];
+
+        $result['property'] = $matches[0];
+        $result['name'] = $matches['name'];
+        $result['args'] = isset($matches['args']) ? explode(',', $matches['args']) : [];
+
+        $result['args'] = array_map('trim', $result['args']);
+
+        return $result;
+    }
+
+    /**
+     * @param string $name
+     * @param array  $args
+     *
+     * @return string
+     *
+     * @throws InvalidSelectorException if the passed property is unknown
+     */
+    protected static function convertProperty($name, array $args = [])
+    {
+        if ($name === 'text') {
+            return 'text()';
+        }
+
+        if ($name === 'attr') {
+            if (count($args) === 0) {
+                return '@*';
+            }
+
+            $attributes = [];
+
+            foreach ($args as $attribute) {
+                $attributes[] = sprintf('name() = "%s"', $attribute);
+            }
+
+            return sprintf('@*[%s]', implode(' or ', $attributes));
+        }
+
+        throw new InvalidSelectorException(sprintf('Unknown property "%s"', $name));
+    }
+
+    /**
+     * Converts a CSS pseudo-class into an XPath expression.
+     *
+     * @param string $pseudo Pseudo-class
+     * @param string $tagName
+     * @param array $parameters
+     *
+     * @return string
+     *
+     * @throws InvalidSelectorException if passed an unknown pseudo-class
+     */
+    protected static function convertPseudo($pseudo, &$tagName, array $parameters = [])
+    {
+        switch ($pseudo) {
+            case 'first-child':
+                return 'position() = 1';
+                break;
+            case 'last-child':
+                return 'position() = last()';
+                break;
+            case 'nth-child':
+                $xpath = sprintf('(name()="%s") and (%s)', $tagName, self::convertNthExpression($parameters[0]));
+                $tagName = '*';
+
+                return $xpath;
+                break;
+            case 'contains':
+                $string = trim($parameters[0], '\'"');
+
+                if (count($parameters) === 1) {
+                    return self::convertContains($string);
+                }
+
+                if ($parameters[1] !== 'true' && $parameters[1] !== 'false') {
+                    throw new InvalidSelectorException(sprintf('Parameter 2 of "contains" pseudo-class must be equal true or false, "%s" given', $parameters[1]));
+                }
+
+                $caseSensitive = $parameters[1] === 'true';
+
+                if (count($parameters) === 2) {
+                    return self::convertContains($string, $caseSensitive);
+                }
+
+                if ($parameters[2] !== 'true' && $parameters[2] !== 'false') {
+                    throw new InvalidSelectorException(sprintf('Parameter 3 of "contains" pseudo-class must be equal true or false, "%s" given', $parameters[2]));
+                }
+
+                $fullMatch = $parameters[2] === 'true';
+
+                return self::convertContains($string, $caseSensitive, $fullMatch);
+                break;
+            case 'has':
+                return self::cssToXpath($parameters[0], './/');
+                break;
+            case 'not':
+                return sprintf('not(self::%s)', self::cssToXpath($parameters[0], ''));
+                break;
+            case 'nth-of-type':
+                return self::convertNthExpression($parameters[0]);
+                break;
+            case 'empty':
+                return 'count(descendant::*) = 0';
+                break;
+            case 'not-empty':
+                return 'count(descendant::*) > 0';
+                break;
+        }
+
+        throw new InvalidSelectorException(sprintf('Unknown pseudo-class "%s"', $pseudo));
+    }
+
+    /**
+     * @param array $segments
+     * @param string $prefix Specifies the nesting of nodes
+     *
+     * @return string XPath expression
+     *
+     * @throws InvalidArgumentException if you neither specify tag name nor attributes
+     */
+    public static function buildXpath(array $segments, $prefix = '//')
+    {
+        $tagName = isset($segments['tag']) ? $segments['tag'] : '*';
+
+        $attributes = [];
+
+        // if the id attribute specified
+        if (isset($segments['id'])) {
+            $attributes[] = sprintf('@id="%s"', $segments['id']);
+        }
+
+        // if the class attribute specified
+        if (isset($segments['classes'])) {
+            foreach ($segments['classes'] as $class) {
+                $attributes[] = sprintf('contains(concat(" ", normalize-space(@class), " "), " %s ")', $class);
+            }
+        }
+
+        // if the attributes specified
+        if (isset($segments['attributes'])) {
+            foreach ($segments['attributes'] as $name => $value) {
+                $attributes[] = self::convertAttribute($name, $value);
+            }
+        }
+
+        // if the pseudo class specified
+        if (isset($segments['pseudo'])) {
+            $expression = isset($segments['expr']) ? trim($segments['expr']) : '';
+
+            $parameters = explode(',', $expression);
+            $parameters = array_map('trim', $parameters);
+
+            $attributes[] = self::convertPseudo($segments['pseudo'], $tagName, $parameters);
+        }
+
+        if (count($attributes) === 0 && !isset($segments['tag'])) {
+            throw new InvalidArgumentException('The array of segments must contain the name of the tag or at least one attribute');
+        }
+
+        $xpath = $prefix . $tagName;
+
+        if ($count = count($attributes)) {
+            $xpath .= ($count > 1) ? sprintf('[(%s)]', implode(') and (', $attributes)) : sprintf('[%s]', $attributes[0]);
+        }
+
+        return $xpath;
+    }
+
+    /**
+     * @param string $name  The attribute name
+     * @param string $value The attribute value
+     *
+     * @return string
+     */
+    protected static function convertAttribute($name, $value)
+    {
+        $isSimpleSelector = !in_array(substr($name, 0, 1), ['^', '!'], true);
+        $isSimpleSelector = $isSimpleSelector && (!in_array(substr($name, -1), ['^', '$', '*', '!', '~'], true));
+
+        if ($isSimpleSelector) {
+            // if specified only the attribute name
+            $xpath = $value === null ? '@'.$name : sprintf('@%s="%s"', $name, $value);
+
+            return $xpath;
+        }
+
+        // if the attribute name starts with ^
+        // example: *[^data-]
+        if (substr($name, 0, 1) === '^') {
+            $xpath = sprintf('@*[starts-with(name(), "%s")]', substr($name, 1));
+
+            return $value === null ? $xpath : sprintf('%s="%s"', $xpath, $value);
+        }
+
+        // if the attribute name starts with !
+        // example: input[!disabled]
+        if (substr($name, 0, 1) === '!') {
+            $xpath = sprintf('not(@%s)', substr($name, 1));
+
+            return $xpath;
+        }
+
+        $symbol = substr($name, -1);
+        $name = substr($name, 0, -1);
+
+        switch ($symbol) {
+            case '^':
+                $xpath = sprintf('starts-with(@%s, "%s")', $name, $value);
+                break;
+            case '$':
+                $xpath = sprintf('substring(@%s, string-length(@%s) - string-length("%s") + 1) = "%s"', $name, $name, $value, $value);
+                break;
+            case '*':
+                $xpath = sprintf('contains(@%s, "%s")', $name, $value);
+                break;
+            case '!':
+                $xpath = sprintf('not(@%s="%s")', $name, $value);
+                break;
+            case '~':
+                $xpath = sprintf('contains(concat(" ", normalize-space(@%s), " "), " %s ")', $name, $value);
+                break;
+        }
+
+        return $xpath;
+    }
+
+    /**
+     * Converts nth-expression into an XPath expression.
+     *
+     * @param string $expression nth-expression
+     *
+     * @return string
+     *
+     * @throws InvalidSelectorException if passed nth-child is empty
+     * @throws InvalidSelectorException if passed an unknown nth-child expression
+     */
+    protected static function convertNthExpression($expression)
+    {
+        if ($expression === '') {
+            throw new InvalidSelectorException('nth-child (or nth-last-child) expression must not be empty');
+        }
+
+        if ($expression === 'odd') {
+            return 'position() mod 2 = 1 and position() >= 1';
+        }
+
+        if ($expression === 'even') {
+            return 'position() mod 2 = 0 and position() >= 0';
+        }
+
+        if (is_numeric($expression)) {
+            return sprintf('position() = %d', $expression);
+        }
+
+        if (preg_match("/^(?P<mul>[0-9]?n)(?:(?P<sign>\+|\-)(?P<pos>[0-9]+))?$/is", $expression, $segments)) {
+            if (isset($segments['mul'])) {
+                $multiplier = $segments['mul'] === 'n' ? 1 : trim($segments['mul'], 'n');
+                $sign = (isset($segments['sign']) && $segments['sign'] === '+') ? '-' : '+';
+                $position = isset($segments['pos']) ? $segments['pos'] : 0;
+
+                return sprintf('(position() %s %d) mod %d = 0 and position() >= %d', $sign, $position, $multiplier, $position);
+            }
+        }
+
+        throw new InvalidSelectorException(sprintf('Invalid nth-child expression "%s"', $expression));
+    }
+
+    /**
+     * @param string $string
+     * @param bool   $caseSensitive
+     * @param bool   $fullMatch
+     *
+     * @return string
+     */
+    protected static function convertContains($string, $caseSensitive = true, $fullMatch = false)
+    {
+        if ($caseSensitive && $fullMatch) {
+            return sprintf('text() = "%s"', $string);
+        }
+
+        if ($caseSensitive && !$fullMatch) {
+            return sprintf('contains(text(), "%s")', $string);
+        }
+
+        $strToLowerFunction = function_exists('mb_strtolower') ? 'mb_strtolower' : 'strtolower';
+
+        if (!$caseSensitive && $fullMatch) {
+            return sprintf("php:functionString(\"{$strToLowerFunction}\", .) = php:functionString(\"{$strToLowerFunction}\", \"%s\")", $string);
+        }
+
+        // if !$caseSensitive and !$fullMatch
+        return sprintf("contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"%s\"))", $string);
+    }
+
+    /**
+     * Splits the CSS selector into parts (tag name, ID, classes, attributes, pseudo-class).
+     *
+     * @param string $selector CSS selector
+     *
+     * @return array
+     *
+     * @throws InvalidSelectorException if the selector is empty or not valid
+     */
+    public static function getSegments($selector)
+    {
+        $selector = trim($selector);
+
+        if ($selector === '') {
+            throw new InvalidSelectorException('The selector must not be empty');
+        }
+
+        $tag = '(?P<tag>[\*|\w|\-]+)?';
+        $id = '(?:#(?P<id>[\w|\-]+))?';
+        $classes = '(?P<classes>\.[\w|\-|\.]+)*';
+        $attrs = '(?P<attrs>(?:\[.+?\])*)?';
+        $name = '(?P<pseudo>[\w\-]+)';
+        $expr = '(?:\((?P<expr>[^\)]+)\))';
+        $pseudo = '(?::'.$name.$expr.'?)?';
+        $rel = '\s*(?P<rel>>)?';
+
+        $regexp = '/'.$tag.$id.$classes.$attrs.$pseudo.$rel.'/is';
+
+        if (preg_match($regexp, $selector, $segments)) {
+            if ($segments[0] === '') {
+                throw new InvalidSelectorException(sprintf('Invalid selector "%s"', $selector));
+            }
+
+            $result['selector'] = $segments[0];
+
+            if (isset($segments['tag']) && $segments['tag'] !== '') {
+                $result['tag'] = $segments['tag'];
+            }
+
+            // if the id attribute specified
+            if (isset($segments['id']) && $segments['id'] !== '') {
+                $result['id'] = $segments['id'];
+            }
+
+            // if the attributes specified
+            if (isset($segments['attrs'])) {
+                $attributes = trim($segments['attrs'], '[]');
+                $attributes = explode('][', $attributes);
+
+                foreach ($attributes as $attribute) {
+                    if ($attribute !== '') {
+                        list($name, $value) = array_pad(explode('=', $attribute, 2), 2, null);
+
+                        if ($name === '') {
+                            throw new InvalidSelectorException(sprintf('Invalid selector "%s": attribute name must not be empty', $selector));
+                        }
+
+                        // equal null if specified only the attribute name
+                        $result['attributes'][$name] = is_string($value) ? trim($value, '\'"') : null;
+                    }
+                }
+            }
+
+            // if the class attribute specified
+            if (isset($segments['classes'])) {
+                $classes = trim($segments['classes'], '.');
+                $classes = explode('.', $classes);
+
+                foreach ($classes as $class) {
+                    if ($class !== '') {
+                        $result['classes'][] = $class;
+                    }
+                }
+            }
+
+            // if the pseudo class specified
+            if (isset($segments['pseudo']) && $segments['pseudo'] !== '') {
+                $result['pseudo'] = $segments['pseudo'];
+
+                if (isset($segments['expr']) && $segments['expr'] !== '') {
+                    $result['expr'] = $segments['expr'];
+                }
+            }
+
+            // if it is a direct descendant
+            if (isset($segments['rel'])) {
+                $result['rel'] = $segments['rel'];
+            }
+
+            return $result;
+        }
+
+        throw new InvalidSelectorException(sprintf('Invalid selector "%s"', $selector));
+    }
+
+    /**
+     * @return array
+     */
+    public static function getCompiled()
+    {
+        return static::$compiled;
+    }
+
+    /**
+     * @param array $compiled
+     *
+     * @throws \InvalidArgumentException if the attributes is not an array
+     */
+    public static function setCompiled(array $compiled)
+    {
+        static::$compiled = $compiled;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/src/DiDom/StyleAttribute.php

@@ -0,0 +1,324 @@
+<?php
+
+namespace DiDom;
+
+use InvalidArgumentException;
+
+class StyleAttribute
+{
+    /**
+     * The DOM element instance.
+     *
+     * @var \DiDom\Element
+     */
+    protected $element;
+
+    /**
+     * @var string
+     */
+    protected $styleString = '';
+
+    /**
+     * @var array
+     */
+    protected $properties = [];
+
+    /**
+     * Constructor.
+     *
+     * @param \DiDom\Element $element
+     *
+     * @throws \InvalidArgumentException if passed argument is not an element node
+     */
+    public function __construct(Element $element)
+    {
+        if (!$element->isElementNode()) {
+            throw new InvalidArgumentException(sprintf('The element must contain DOMElement node'));
+        }
+
+        $this->element = $element;
+
+        $this->parseStyleAttribute();
+    }
+
+    /**
+     * Parses style attribute of the element.
+     */
+    protected function parseStyleAttribute()
+    {
+        if (!$this->element->hasAttribute('style')) {
+            // possible if style attribute has been removed
+            if ($this->styleString !== '') {
+                $this->styleString = '';
+                $this->properties = [];
+            }
+
+            return;
+        }
+
+        // if style attribute is not changed
+        if ($this->element->getAttribute('style') === $this->styleString) {
+            return;
+        }
+
+        // save style attribute as is (without trimming)
+        $this->styleString = $this->element->getAttribute('style');
+
+        $styleString = trim($this->styleString, ' ;');
+
+        if ($styleString === '') {
+            $this->properties = [];
+
+            return;
+        }
+
+        $properties = explode(';', $styleString);
+
+        foreach ($properties as $property) {
+            list($name, $value) = explode(':', $property);
+
+            $name = trim($name);
+            $value = trim($value);
+
+            $this->properties[$name] = $value;
+        }
+    }
+
+    /**
+     * Updates style attribute of the element.
+     */
+    protected function updateStyleAttribute()
+    {
+        $this->styleString = $this->buildStyleString();
+
+        $this->element->setAttribute('style', $this->styleString);
+    }
+
+    /**
+     * @return string
+     */
+    protected function buildStyleString()
+    {
+        $properties = [];
+
+        foreach ($this->properties as $propertyName => $value) {
+            $properties[] = $propertyName . ': ' . $value;
+        }
+
+        return implode('; ', $properties);
+    }
+
+    /**
+     * @param string $name
+     * @param string $value
+     *
+     * @return \DiDom\StyleAttribute
+     *
+     * @throws \InvalidArgumentException if property name is not a string
+     * @throws \InvalidArgumentException if property value is not a string
+     */
+    public function setProperty($name, $value)
+    {
+        if (!is_string($name)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($name) ? get_class($name) : gettype($name))));
+        }
+
+        if (!is_string($value)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 2 to be string, %s given', __METHOD__, (is_object($value) ? get_class($value) : gettype($value))));
+        }
+
+        $this->parseStyleAttribute();
+
+        $this->properties[$name] = $value;
+
+        $this->updateStyleAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param array $properties
+     *
+     * @return \DiDom\StyleAttribute
+     *
+     * @throws \InvalidArgumentException if property name is not a string
+     * @throws \InvalidArgumentException if property value is not a string
+     */
+    public function setMultipleProperties(array $properties)
+    {
+        $this->parseStyleAttribute();
+
+        foreach ($properties as $propertyName => $value) {
+            if (!is_string($propertyName)) {
+                throw new InvalidArgumentException(sprintf('Property name must be a string, %s given', (is_object($propertyName) ? get_class($propertyName) : gettype($propertyName))));
+            }
+
+            if (!is_string($value)) {
+                throw new InvalidArgumentException(sprintf('Property value must be a string, %s given', (is_object($value) ? get_class($value) : gettype($value))));
+            }
+
+            $this->properties[$propertyName] = $value;
+        }
+
+        $this->updateStyleAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     * @param mixed $default
+     *
+     * @return mixed
+     */
+    public function getProperty($name, $default = null)
+    {
+        if (!is_string($name)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($name) ? get_class($name) : gettype($name))));
+        }
+
+        $this->parseStyleAttribute();
+
+        if (!array_key_exists($name, $this->properties)) {
+            return $default;
+        }
+
+        return $this->properties[$name];
+    }
+
+    /**
+     * @param array $propertyNames
+     *
+     * @return mixed
+     *
+     * @throws \InvalidArgumentException if property name is not a string
+     */
+    public function getMultipleProperties(array $propertyNames)
+    {
+        $this->parseStyleAttribute();
+
+        $result = [];
+
+        foreach ($propertyNames as $propertyName) {
+            if (!is_string($propertyName)) {
+                throw new InvalidArgumentException(sprintf('Property name must be a string, %s given', (is_object($propertyName) ? get_class($propertyName) : gettype($propertyName))));
+            }
+
+            if (array_key_exists($propertyName, $this->properties)) {
+                $result[$propertyName] = $this->properties[$propertyName];
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * @return array
+     */
+    public function getAllProperties()
+    {
+        $this->parseStyleAttribute();
+
+        return $this->properties;
+    }
+
+    /**
+     * @param string $name
+     *
+     * @return bool
+     */
+    public function hasProperty($name)
+    {
+        if (!is_string($name)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($name) ? get_class($name) : gettype($name))));
+        }
+
+        $this->parseStyleAttribute();
+
+        return array_key_exists($name, $this->properties);
+    }
+
+    /**
+     * @param string $name
+     *
+     * @return \DiDom\StyleAttribute
+     *
+     * @throws \InvalidArgumentException if property name is not a string
+     */
+    public function removeProperty($name)
+    {
+        if (!is_string($name)) {
+            throw new InvalidArgumentException(sprintf('%s expects parameter 1 to be string, %s given', __METHOD__, (is_object($name) ? get_class($name) : gettype($name))));
+        }
+
+        $this->parseStyleAttribute();
+
+        unset($this->properties[$name]);
+
+        $this->updateStyleAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param array $propertyNames
+     *
+     * @return \DiDom\StyleAttribute
+     *
+     * @throws \InvalidArgumentException if property name is not a string
+     */
+    public function removeMultipleProperties(array $propertyNames)
+    {
+        $this->parseStyleAttribute();
+
+        foreach ($propertyNames as $propertyName) {
+            if (!is_string($propertyName)) {
+                throw new InvalidArgumentException(sprintf('Property name must be a string, %s given', (is_object($propertyName) ? get_class($propertyName) : gettype($propertyName))));
+            }
+
+            unset($this->properties[$propertyName]);
+        }
+
+        $this->updateStyleAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @param string[] $exclusions
+     *
+     * @return \DiDom\StyleAttribute
+     */
+    public function removeAllProperties(array $exclusions = [])
+    {
+        $this->parseStyleAttribute();
+
+        $preservedProperties = [];
+
+        foreach ($exclusions as $propertyName) {
+            if (!is_string($propertyName)) {
+                throw new InvalidArgumentException(sprintf('Property name must be a string, %s given', (is_object($propertyName) ? get_class($propertyName) : gettype($propertyName))));
+            }
+
+            if (!array_key_exists($propertyName, $this->properties)) {
+                continue;
+            }
+
+            $preservedProperties[$propertyName] = $this->properties[$propertyName];
+        }
+
+        $this->properties = $preservedProperties;
+
+        $this->updateStyleAttribute();
+
+        return $this;
+    }
+
+    /**
+     * @return \DiDom\Element
+     */
+    public function getElement()
+    {
+        return $this->element;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/ClassAttributeTest.php

@@ -0,0 +1,383 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Element;
+use DiDom\ClassAttribute;
+use Tests\TestCase;
+
+class ClassAttributeTest extends TestCase
+{
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The element must contain DOMElement node
+     */
+    public function testConstructorWithTextNode()
+    {
+        $element = new Element(new \DOMText('foo'));
+
+        new ClassAttribute($element);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The element must contain DOMElement node
+     */
+    public function testConstructorWithCommentNode()
+    {
+        $element = new Element(new \DOMComment('foo'));
+
+        new ClassAttribute($element);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\ClassAttribute::add expects parameter 1 to be string, NULL given
+     */
+    public function testAddWithInvalidClassName()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $classAttribute->add(null);
+    }
+
+    public function testAdd()
+    {
+        // without class attribute
+        $element = new Element('div', null);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals(null, $element->getAttribute('class'));
+
+        $classAttribute->add('foo');
+
+        $this->assertEquals('foo', $element->getAttribute('class'));
+
+        // with empty class attribute
+        $element = new Element('div', null, [
+            'class' => '',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('', $element->getAttribute('class'));
+
+        $classAttribute->add('foo');
+
+        $this->assertEquals('foo', $element->getAttribute('class'));
+
+        // class attribute with spaces
+        $element = new Element('div', null, [
+            'class' => '   ',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('   ', $element->getAttribute('class'));
+
+        $classAttribute->add('foo');
+
+        $this->assertEquals('foo', $element->getAttribute('class'));
+
+        // with not empty class attribute
+        $element = new Element('div', null, [
+            'class' => 'foo bar',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar', $element->getAttribute('class'));
+
+        $classAttribute->add('baz');
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        // with existing class name
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->add('bar');
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Class name must be a string, NULL given
+     */
+    public function testAddMultipleWithInvalidClassName()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $classAttribute->addMultiple(['bar', null]);
+    }
+
+    public function testAddMultiple()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo', $element->getAttribute('class'));
+
+        $classAttribute->addMultiple([
+            'bar', 'baz',
+        ]);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+    }
+
+    public function testGetAll()
+    {
+        // without class attribute
+        $element = new Element('div', null);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals([], $classAttribute->getAll());
+
+        // with empty class attribute
+        $element = new Element('div', null, [
+            'class' => '',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals([], $classAttribute->getAll());
+
+        // class attribute with spaces
+        $element = new Element('div', null, [
+            'class' => '   ',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals([], $classAttribute->getAll());
+
+        // one class
+        $element = new Element('div', null, [
+            'class' => 'foo',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals(['foo'], $classAttribute->getAll());
+
+        // several classes
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals(['foo', 'bar', 'baz'], $classAttribute->getAll());
+
+        // with multiple spaces between class names
+        $element = new Element('div', null, [
+            'class' => 'foo   bar   baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals(['foo', 'bar', 'baz'], $classAttribute->getAll());
+    }
+
+    public function testGetAllPropertiesAfterEmptyClassAttribute()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals(['foo', 'bar', 'baz'], $classAttribute->getAll());
+
+        $element->setAttribute('class', '');
+
+        $this->assertEquals([], $classAttribute->getAll());
+    }
+
+    public function testContains()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertTrue($classAttribute->contains('foo'));
+        $this->assertTrue($classAttribute->contains('bar'));
+        $this->assertFalse($classAttribute->contains('baz'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\ClassAttribute::remove expects parameter 1 to be string, NULL given
+     */
+    public function testRemoveWithInvalidClassName()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $classAttribute->remove(null);
+    }
+
+    public function testRemove()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->remove('bar');
+
+        $this->assertEquals('foo baz', $element->getAttribute('class'));
+
+        // with nonexistent class name
+        $element = new Element('div', null, [
+            'class' => 'foo bar',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar', $element->getAttribute('class'));
+
+        $classAttribute->remove('baz');
+
+        $this->assertEquals('foo bar', $element->getAttribute('class'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Class name must be a string, NULL given
+     */
+    public function testRemoveMultipleWithInvalidClassName()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $classAttribute->removeMultiple(['foo', null]);
+    }
+
+    public function testRemoveMultiple()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->removeMultiple(['foo', 'bar']);
+
+        $this->assertEquals('baz', $element->getAttribute('class'));
+
+        // with nonexistent class name
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->removeMultiple(['bar', 'qux']);
+
+        $this->assertEquals('foo baz', $element->getAttribute('class'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Class name must be a string, NULL given
+     */
+    public function testRemoveAllWithInvalidClassName()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $classAttribute->removeAll(['foo', null]);
+    }
+
+    public function testRemoveAll()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->removeAll();
+
+        $this->assertEquals('', $element->getAttribute('class'));
+    }
+
+    public function testRemoveAllWithExclusions()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->removeAll(['bar']);
+
+        $this->assertEquals('bar', $element->getAttribute('class'));
+
+        // with nonexistent class name
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertEquals('foo bar baz', $element->getAttribute('class'));
+
+        $classAttribute->removeAll(['bar', 'qux']);
+
+        $this->assertEquals('bar', $element->getAttribute('class'));
+    }
+
+    public function testGetElement()
+    {
+        $element = new Element('div', null, [
+            'class' => 'foo bar baz',
+        ]);
+
+        $classAttribute = new ClassAttribute($element);
+
+        $this->assertSame($element, $classAttribute->getElement());
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/DocumentTest.php

@@ -0,0 +1,772 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Document;
+use DiDom\Query;
+use Tests\TestCase;
+
+class DocumentTest extends TestCase
+{
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, array given
+     */
+    public function testConstructWithInvalidArgument()
+    {
+        new Document(array('foo'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::__construct expects parameter 3 to be string, NULL given
+     */
+    public function testConstructWithInvalidEncoding()
+    {
+        new Document(null, false, null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Could not load file path/to/file
+     */
+    public function testConstructWithNotExistingFile()
+    {
+        new Document('path/to/file', true);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 3 to be string, NULL given
+     */
+    public function testConstructorWithInvalidTypeOfDocumentTypeArgument()
+    {
+        new Document('foo', false, 'UTF-8', null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Document type must be "xml" or "html", bar given
+     */
+    public function testConstructorWithInvalidDocumentType()
+    {
+        new Document('foo', false, 'UTF-8', 'bar');
+    }
+
+    /**
+     * @dataProvider loadHtmlCharsetTests
+     */
+    public function testLoadHtmlCharset($html, $text)
+    {
+        $document = new Document($html, false, 'UTF-8');
+
+        $this->assertEquals($text, $document->first('div')->text());
+    }
+
+    public function loadHtmlCharsetTests()
+    {
+        return array(
+            array('<html><div class="foo">English language</html>', 'English language'),
+            array('<html><div class="foo">Русский язык</html>', 'Русский язык'),
+            array('<html><div class="foo">اللغة العربية</html>', 'اللغة العربية'),
+            array('<html><div class="foo">漢語</html>', '漢語'),
+            array('<html><div class="foo">Tiếng Việt</html>', 'Tiếng Việt'),
+        );
+    }
+
+    public function testCreate()
+    {
+        $this->assertInstanceOf('DiDom\Document', Document::create());
+    }
+
+    public function testCreateElement()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html, false);
+        $element  = $document->createElement('span', 'value');
+
+        $this->assertInstanceOf('DiDom\Element', $element);
+        $this->assertEquals('span', $element->getNode()->tagName);
+        $this->assertEquals('value', $element->getNode()->textContent);
+
+        $element = $document->createElement('span');
+        $this->assertEquals('', $element->text());
+
+        $element = $document->createElement('input', '', ['name' => 'username']);
+        $this->assertEquals('username', $element->getNode()->getAttribute('name'));
+    }
+
+    public function testCreateElementBySelector()
+    {
+        $document = new Document();
+
+        $element = $document->createElementBySelector('a.external-link[href=http://example.com]');
+
+        $this->assertEquals('a', $element->tag);
+        $this->assertEquals('', $element->text());
+        $this->assertEquals(['href' => 'http://example.com', 'class' => 'external-link'], $element->attributes());
+
+        $element = $document->createElementBySelector('#block', 'Foo');
+
+        $this->assertEquals('div', $element->tag);
+        $this->assertEquals('Foo', $element->text());
+        $this->assertEquals(['id' => 'block'], $element->attributes());
+
+        $element = $document->createElementBySelector('input', null, ['name' => 'name', 'placeholder' => 'Enter your name']);
+
+        $this->assertEquals('input', $element->tag);
+        $this->assertEquals('', $element->text());
+        $this->assertEquals(['name' => 'name', 'placeholder' => 'Enter your name'], $element->attributes());
+    }
+
+    public function testCreateTextNode()
+    {
+        $document = new Document();
+
+        $textNode = $document->createTextNode('foo bar baz');
+
+        $this->assertInstanceOf('DiDom\Element', $textNode);
+        $this->assertInstanceOf('DOMText', $textNode->getNode());
+        $this->assertEquals('foo bar baz', $textNode->text());
+    }
+
+    public function testCreateComment()
+    {
+        $document = new Document();
+
+        $comment = $document->createComment('foo bar baz');
+
+        $this->assertInstanceOf('DiDom\Element', $comment);
+        $this->assertInstanceOf('DOMComment', $comment->getNode());
+        $this->assertEquals('foo bar baz', $comment->text());
+    }
+
+    public function testCreateCDATASection()
+    {
+        $document = new Document();
+
+        $cdataSection = $document->createCdataSection('foo bar baz');
+
+        $this->assertInstanceOf('DiDom\Element', $cdataSection);
+        $this->assertInstanceOf('DOMCdataSection', $cdataSection->getNode());
+        $this->assertEquals('foo bar baz', $cdataSection->text());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Argument 1 passed to DiDom\Document::appendChild must be an instance of DiDom\Element or DOMNode, string given
+     */
+    public function testAppendChildWithInvalidArgument()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html);
+
+        $document->appendChild('foo');
+    }
+
+    public function testAppendChild()
+    {
+        $html = '<!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <title>Document</title>
+        </head>
+        <body>
+
+        </body>
+        </html>';
+
+        $document = new Document($html);
+
+        $this->assertCount(0, $document->find('span'));
+
+        $node = $document->createElement('span');
+        $appendedChild = $document->appendChild($node);
+
+        $this->assertCount(1, $document->find('span'));
+        $this->assertTrue($appendedChild->is($document->first('span')));
+
+        $appendedChild->remove();
+
+        $this->assertCount(0, $document->find('span'));
+
+        $nodes = [];
+        $nodes[] = $document->createElement('span');
+        $nodes[] = $document->createElement('span');
+
+        $appendedChildren = $document->appendChild($nodes);
+
+        $nodes = $document->find('span');
+
+        $this->assertCount(2, $appendedChildren);
+        $this->assertCount(2, $nodes);
+
+        foreach ($appendedChildren as $index => $child) {
+            $this->assertTrue($child->is($nodes[$index]));
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, NULL given
+     */
+    public function testLoadWithInvalidContentArgument()
+    {
+        $document = new Document();
+
+        $document->load(null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Could not load file path/to/file
+     */
+    public function testLoadWithNotExistingFile()
+    {
+        $document = new Document();
+
+        $document->load('path/to/file', true);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 3 to be string, NULL given
+     */
+    public function testLoadWithInvalidTypeOfDocumentTypeArgument()
+    {
+        $document = new Document();
+
+        $document->load('foo', false, null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Document type must be "xml" or "html", bar given
+     */
+    public function testLoadWithInvalidDocumentType()
+    {
+        $document = new Document();
+
+        $document->load('foo', false, 'bar');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 4 to be integer, string given
+     */
+    public function testLoadWithInvalidOptionsType()
+    {
+        $document = new Document();
+
+        $document->load('foo', false, 'html', 'bar');
+    }
+
+    public function testLoadHtmlDocument()
+    {
+        $html = '
+            <!DOCTYPE html>
+            <html>
+            <head>
+                <title>Document</title>
+            </head>
+            <body>
+                <div class="foo">Foo — Bar — Baz</div>
+            </body>
+            </html>
+        ';
+
+        $document = new Document();
+
+        $document->load($html, false, 'html');
+
+        $this->assertEquals('Foo — Bar — Baz', $document->first('.foo')->text());
+    }
+
+    public function testLoadXmlDocument()
+    {
+        $xml = '
+            <?xml version="1.0" encoding="UTF-8"?>
+            <root>
+                <foo>Foo — Bar — Baz</foo>
+            </root>
+        ';
+
+        $document = new Document();
+
+        $document->load($xml, false, 'xml');
+
+        $this->assertEquals('Foo — Bar — Baz', $document->first('foo')->text());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, NULL given
+     */
+    public function testLoadHtmlWithInvalidArgument()
+    {
+        $document = new Document();
+
+        $document->loadHtml(null);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, array given
+     */
+    public function testLoadHtmlFileWithInvalidArgument()
+    {
+        $document = new Document();
+
+        $document->loadHtmlFile(array('foo'));
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Could not load file path/to/file
+     */
+    public function testLoadHtmlFileWithNotExistingFile()
+    {
+        $document = new Document();
+
+        $document->loadHtmlFile('path/to/file');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, NULL given
+     */
+    public function testLoadXmlWithInvalidArgument()
+    {
+        $document = new Document();
+
+        $document->loadXml(null);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Document::load expects parameter 1 to be string, array given
+     */
+    public function testLoadXmlFileWithInvalidArgument()
+    {
+        $document = new Document();
+
+        $document->loadXmlFile(array('foo'));
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Could not load file path/to/file
+     */
+    public function testLoadXmlFileWithNotExistingFile()
+    {
+        $document = new Document();
+
+        $document->loadXmlFile('path/to/file');
+    }
+
+    public function testHas()
+    {
+        $document = new Document($this->loadFixture('posts.html'));
+
+        $this->assertTrue($document->has('.posts'));
+        $this->assertFalse($document->has('.fake'));
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testFind($html, $selector, $type, $count)
+    {
+        $document = new Document($html);
+        $elements = $document->find($selector, $type);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testFindAndReturnDomElement($html, $selector, $type, $count)
+    {
+        $document = new Document($html);
+        $elements = $document->find($selector, $type, false);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DOMElement', $element);
+        }
+    }
+
+    public function testFindWithContext()
+    {
+        $document = new Document($this->loadFixture('posts.html'));
+
+        $post = $document->find('.post')[1];
+        $title = $document->find('.post .title')[1];
+
+        $titleInContext = $document->find('.title', Query::TYPE_CSS, true, $post)[0];
+
+        $this->assertTrue($title->is($titleInContext));
+        $this->assertFalse($title->is($post->find('.title')[0]));
+    }
+
+    public function testFindText()
+    {
+        $html = $this->loadFixture('menu.html');
+
+        $document = new Document($html);
+        $texts = $document->find('//a/text()', Query::TYPE_XPATH);
+
+        $this->assertTrue(is_array($texts));
+        $this->assertEquals(3, count($texts));
+
+        $this->assertEquals(['Link 1', 'Link 2', 'Link 3'], $texts);
+    }
+
+    public function testFindComment()
+    {
+        $html = $this->loadFixture('menu.html');
+
+        $document = new Document($html);
+
+        $comment = $document->xpath('/html/body/ul/li/a/comment()');
+        $this->assertTrue($comment[0]->isCommentNode());
+        $this->assertTrue($comment[1]->isCommentNode());
+
+        $this->assertTrue(is_array($comment));
+        $this->assertEquals(2, count($comment));
+
+        $comment = $document->xpath('/html/body/comment()');
+        $this->assertTrue($comment[0]->isCommentNode());
+
+        $this->assertTrue(is_array($comment));
+        $this->assertEquals(1, count($comment));
+    }
+
+    public function testFindAttribute()
+    {
+        $html = $this->loadFixture('menu.html');
+
+        $document = new Document($html);
+        $links = $document->find('//a/@href', Query::TYPE_XPATH);
+
+        $this->assertTrue(is_array($links));
+        $this->assertEquals(3, count($links));
+
+        foreach ($links as $link) {
+            $this->assertEquals('http://example.com', $link);
+        }
+    }
+
+    public function findTests()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        return array(
+            array($html, '.post h2', Query::TYPE_CSS, 3),
+            array($html, '.fake h2', Query::TYPE_CSS, 0),
+            array($html, '.post h2, .post p', Query::TYPE_CSS, 6),
+            array($html, "//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]", Query::TYPE_XPATH, 3),
+        );
+    }
+
+    public function testFirst()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $items = $document->find('ul > li');
+
+        $this->assertEquals($items[0]->getNode(), $document->first('ul > li')->getNode());
+
+        $this->assertEquals('One', $document->first('ul > li::text'));
+
+        $document = new Document();
+
+        $this->assertNull($document->first('ul > li'));
+    }
+
+    public function testFirstWithContext()
+    {
+        $html = '
+            <div class="root">
+                <span>Foo</span>
+
+                <div><span>Bar</span></div>
+            </div>
+        ';
+
+        $document = new Document($html);
+
+        $div = $document->first('.root div');
+        $span = $document->first('.root div span');
+
+        $result = $document->first('span', Query::TYPE_CSS, true, $div);
+
+        $this->assertTrue($span->is($result));
+    }
+
+    public function testXpath()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html, false);
+        $elements = $document->xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]");
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals(3, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+
+    public function testCount()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $this->assertInternalType('int', $document->count('li'));
+        $this->assertEquals(3, $document->count('li'));
+
+        $document = new Document();
+
+        $this->assertInternalType('int', $document->count('li'));
+        $this->assertEquals(0, $document->count('li'));
+    }
+
+    public function testCreateXpath()
+    {
+        $document = new Document();
+
+        $xpath =$document->createXpath();
+
+        $this->assertInstanceOf('DOMXPath', $xpath);
+        $this->assertEquals($document->getDocument(), $xpath->document);
+    }
+
+    public function testHtml()
+    {
+        $html = '
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Document</title>
+</head>
+<body>
+English language <br>
+Русский язык <br>
+اللغة العربية <br>
+漢語 <br>
+Tiếng Việt <br>
+
+&lt; &gt;
+</body>
+</html>
+        ';
+
+        $document = new Document($html);
+
+        $this->assertEquals(trim($html), $document->html());
+    }
+
+    public function testXml()
+    {
+        $xml = $this->loadFixture('books.xml');
+        $document = new Document($xml, false, 'UTF-8', 'xml');
+
+        $this->assertTrue(is_string($document->xml()));
+    }
+
+    public function testXmlWithOptions()
+    {
+        $xml = '<foo><bar></bar></foo>';
+
+        $document = new Document();
+        $document->loadXml($xml);
+
+        $prolog = '<?xml version="1.0" encoding="UTF-8"?>'."\n";
+
+        $this->assertEquals($prolog.'<foo><bar/></foo>', $document->xml());
+        $this->assertEquals($prolog.'<foo><bar></bar></foo>', $document->xml(LIBXML_NOEMPTYTAG));
+    }
+
+    public function testFormat()
+    {
+        $html = $this->loadFixture('posts.html');
+        $document = new Document($html, false);
+
+        $this->assertFalse($document->getDocument()->formatOutput);
+
+        $document->format();
+
+        $this->assertTrue($document->getDocument()->formatOutput);
+    }
+
+    public function testText()
+    {
+        $html = '<html>foo</html>';
+        $document = new Document($html, false);
+
+        $this->assertEquals('foo', $document->text());
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     */
+    public function testIsWithInvalidArgument()
+    {
+        $document = new Document();
+        $document->is(null);
+    }
+
+    public function testIs()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html, false);
+        $document2 = new Document($html, false);
+
+        $this->assertTrue($document->is($document));
+        $this->assertFalse($document->is($document2));
+    }
+
+    public function testIsWithEmptyDocument()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html, false);
+        $document2 = new Document();
+
+        $this->assertFalse($document->is($document2));
+    }
+
+    public function testGetType()
+    {
+        // empty document
+
+        $document = new Document();
+
+        $this->assertNull($document->getType());
+
+        // html
+
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html);
+        $this->assertEquals('html', $document->getType());
+
+        $document = new Document();
+        $document->loadHtml($html);
+        $this->assertEquals('html', $document->getType());
+
+        $document = new Document();
+        $document->load($html, false, 'html');
+        $this->assertEquals('html', $document->getType());
+
+        // xml
+
+        $xml = $this->loadFixture('books.xml');
+
+        $document = new Document($xml, false, 'UTF-8', 'xml');
+        $this->assertEquals('xml', $document->getType());
+
+        $document = new Document();
+        $document->loadXml($xml);
+        $this->assertEquals('xml', $document->getType());
+
+        $document = new Document();
+        $document->load($xml, false, 'xml');
+        $this->assertEquals('xml', $document->getType());
+    }
+
+    public function testGetEncoding()
+    {
+        $document = new Document();
+
+        $this->assertEquals('UTF-8', $document->getEncoding());
+
+        $document = new Document(null, false, 'CP-1251');
+
+        $this->assertEquals('CP-1251', $document->getEncoding());
+    }
+
+    public function testGetDocument()
+    {
+        $domDocument = new \DOMDocument();
+        $document = new Document($domDocument);
+
+        $this->assertEquals($domDocument, $document->getDocument());
+    }
+
+    public function testGetElement()
+    {
+        $html = $this->loadFixture('posts.html');
+        $document = new Document($html, false);
+
+        $this->assertInstanceOf('DOMElement', $document->getElement());
+    }
+
+    /**
+     * @expectedException RuntimeException
+     */
+    public function testEmptyDocumentToElement()
+    {
+        $document = new Document();
+
+        $document->toElement();
+    }
+
+    public function testToElement()
+    {
+        $html = $this->loadFixture('posts.html');
+        $document = new Document($html, false);
+
+        $this->assertInstanceOf('DiDom\Element', $document->toElement());
+    }
+
+    public function testToStringHtml()
+    {
+        $html = $this->loadFixture('posts.html');
+        $document = new Document($html, false);
+
+        $this->assertEquals($document->html(), $document->__toString());
+    }
+
+    public function testToStringXml()
+    {
+        $xml = $this->loadFixture('books.xml');
+        $document = new Document($xml, false, 'UTF-8', 'xml');
+
+        $this->assertEquals($document->xml(), $document->__toString());
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testInvoke($html, $selector, $type, $count)
+    {
+        $document = new Document($html, false);
+        $elements = $document($selector, $type);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/ElementTest.php

@@ -0,0 +1,2094 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Document;
+use DiDom\Element;
+use DiDom\Query;
+use Tests\TestCase;
+
+class ElementTest extends TestCase
+{
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testConstructorWithNullTagName()
+    {
+        new Element(null);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testConstructorWithInvalidTagNameType()
+    {
+        new Element([]);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testConstructorWithInvalidObject()
+    {
+        new Element(new \StdClass());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testConstructorWithInvalidValue()
+    {
+        new Element('span', []);
+    }
+
+    public function testConstructorWithInvalidAttributes()
+    {
+        if (PHP_VERSION_ID >= 70000) {
+            $this->setExpectedException('TypeError');
+        } else {
+            $this->setExpectedException('PHPUnit_Framework_Error');
+        }
+
+        new Element('span', 'Foo', null);
+    }
+
+    public function testConstructor()
+    {
+        $element = new Element('input', null, ['name' => 'username', 'value' => 'John']);
+
+        $this->assertEquals('input', $element->getNode()->tagName);
+        $this->assertEquals('username', $element->getNode()->getAttribute('name'));
+        $this->assertEquals('John', $element->getNode()->getAttribute('value'));
+
+        // create from DOMElement
+        $node = new \DOMElement('span', 'Foo');
+        $element = new Element($node);
+
+        $this->assertEquals($node, $element->getNode());
+
+        // create from DOMText
+        $node = new \DOMText('Foo');
+        $element = new Element($node);
+
+        $this->assertEquals($node, $element->getNode());
+
+        // create from DOMComment
+        $node = new \DOMComment('Foo');
+        $element = new Element($node);
+
+        $this->assertEquals($node, $element->getNode());
+    }
+
+    public function testCreate()
+    {
+        $element = Element::create('span', 'Foo', ['class' => 'bar']);
+
+        $this->assertEquals('span', $element->tag);
+        $this->assertEquals('Foo', $element->text());
+        $this->assertEquals(['class' => 'bar'], $element->attributes());
+    }
+
+    public function testCreateBySelector()
+    {
+        $element = Element::createBySelector('li.item.active', 'Foo', ['data-id' => 1]);
+
+        $this->assertEquals('li', $element->tag);
+        $this->assertEquals('Foo', $element->text());
+        $this->assertEquals(['class' => 'item active', 'data-id' => 1], $element->attributes());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPrependChildWithInvalidArgument()
+    {
+        $element = new Element('span', 'hello');
+
+        $element->prependChild('foo');
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Can not prepend child to element without owner document
+     */
+    public function testPrependChildWithoutParentNode()
+    {
+        $element = new Element(new \DOMElement('div'));
+
+        $element->prependChild(new Element('div'));
+    }
+
+    public function testPrependChild()
+    {
+        $list = new Element('ul');
+
+        $this->assertEquals(0, $list->getNode()->childNodes->length);
+
+        $item = new Element('li', 'bar');
+
+        $prependedChild = $list->prependChild($item);
+
+        $this->assertEquals(1, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $prependedChild);
+        $this->assertEquals('bar', $prependedChild->getNode()->textContent);
+
+        $item = new Element('li', 'foo');
+
+        $prependedChild = $list->prependChild($item);
+
+        $this->assertEquals(2, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $prependedChild);
+        $this->assertEquals('foo', $prependedChild->getNode()->textContent);
+
+        $this->assertEquals('foo', $list->getNode()->childNodes->item(0)->textContent);
+        $this->assertEquals('bar', $list->getNode()->childNodes->item(1)->textContent);
+    }
+
+    public function testPrependChildWithArrayOfNodes()
+    {
+        $list = new Element('ul');
+
+        $prependedChild = $list->prependChild(new Element('li', 'foo'));
+
+        $this->assertEquals(1, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $prependedChild);
+        $this->assertEquals('foo', $prependedChild->getNode()->textContent);
+
+        $items = [];
+
+        $items[] = new Element('li', 'bar');
+        $items[] = new Element('li', 'baz');
+
+        $appendedChildren = $list->prependChild($items);
+
+        $this->assertCount(2, $appendedChildren);
+        $this->assertEquals(3, $list->getNode()->childNodes->length);
+
+        foreach ($appendedChildren as $appendedChild) {
+            $this->assertInstanceOf('DiDom\Element', $appendedChild);
+        }
+
+        foreach (['bar', 'baz', 'foo'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testAppendChildWithInvalidArgument()
+    {
+        $element = new Element('span', 'hello');
+
+        $element->appendChild('foo');
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Can not append child to element without owner document
+     */
+    public function testAppendChildWithoutParentNode()
+    {
+        $element = new Element(new \DOMElement('div'));
+
+        $element->appendChild(new Element('div'));
+    }
+
+    public function testAppendChild()
+    {
+        $list = new Element('ul');
+
+        $this->assertEquals(0, $list->getNode()->childNodes->length);
+
+        $item = new Element('li', 'foo');
+        $appendedChild = $list->appendChild($item);
+
+        $this->assertEquals(1, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $appendedChild);
+        $this->assertEquals('foo', $appendedChild->getNode()->textContent);
+
+        $item = new Element('li', 'bar');
+        $appendedChild = $list->appendChild($item);
+
+        $this->assertEquals(2, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $appendedChild);
+        $this->assertEquals('bar', $appendedChild->getNode()->textContent);
+
+        $this->assertEquals('foo', $list->getNode()->childNodes->item(0)->textContent);
+        $this->assertEquals('bar', $list->getNode()->childNodes->item(1)->textContent);
+    }
+
+    public function testAppendChildWithArray()
+    {
+        $list = new Element('ul');
+
+        $appendedChild = $list->appendChild(new Element('li', 'foo'));
+
+        $this->assertEquals(1, $list->getNode()->childNodes->length);
+        $this->assertInstanceOf('DiDom\Element', $appendedChild);
+        $this->assertEquals('foo', $appendedChild->getNode()->textContent);
+
+        $items = [];
+
+        $items[] = new Element('li', 'bar');
+        $items[] = new Element('li', 'baz');
+
+        $appendedChildren = $list->appendChild($items);
+
+        $this->assertCount(2, $appendedChildren);
+        $this->assertEquals(3, $list->getNode()->childNodes->length);
+
+        foreach ($appendedChildren as $appendedChild) {
+            $this->assertInstanceOf('DiDom\Element', $appendedChild);
+        }
+
+        foreach (['foo', 'bar', 'baz'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testInsertBeforeWithInvalidNodeArgument()
+    {
+        $list = new Element('ul');
+
+        $list->insertBefore('foo');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Argument 2 passed to DiDom\Element::insertBefore must be an instance of DiDom\Element or DOMNode, string given
+     */
+    public function testInsertBeforeWithInvalidReferenceNodeArgument()
+    {
+        $list = new Element('ul');
+
+        $list->insertBefore(new Element('li', 'foo'), 'foo');
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Can not insert child to element without owner document
+     */
+    public function testInsertBeforeWithoutParentNode()
+    {
+        $list = new Element(new \DOMElement('ul'));
+
+        $list->insertBefore(new Element('li', 'foo'));
+    }
+
+    public function testInsertBefore()
+    {
+        $list = new Element('ul');
+
+        $insertedNode = $list->insertBefore(new Element('li', 'qux'));
+
+        $this->assertInstanceOf('DiDom\Element', $insertedNode);
+        $this->assertEquals('qux', $insertedNode->getNode()->textContent);
+
+        foreach (['qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertBefore(new Element('li', 'foo'), $list->getNode()->childNodes->item(0));
+
+        foreach (['foo', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertBefore(new Element('li', 'baz'), $list->getNode()->childNodes->item(1));
+
+        foreach (['foo', 'baz', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertBefore(new Element('li', 'bar'), $list->getNode()->childNodes->item(1));
+
+        foreach (['foo', 'bar', 'baz', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    public function testInsertBeforeWithoutReferenceNode()
+    {
+        $list = new Element('ul');
+
+        $list->insertBefore(new Element('li', 'foo'));
+        $list->insertBefore(new Element('li', 'bar'));
+
+        foreach (['foo', 'bar'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testInsertAfterWithInvalidNodeArgument()
+    {
+        $list = new Element('ul');
+
+        $list->insertAfter('foo');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Argument 2 passed to DiDom\Element::insertAfter must be an instance of DiDom\Element or DOMNode, string given
+     */
+    public function testInsertAfterWithInvalidReferenceNodeArgument()
+    {
+        $list = new Element('ul');
+
+        $list->insertAfter(new Element('li', 'foo'), 'foo');
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Can not insert child to element without owner document
+     */
+    public function testInsertAfterWithoutParentNode()
+    {
+        $list = new Element(new \DOMElement('ul'));
+
+        $list->insertAfter(new Element('li', 'foo'));
+    }
+
+    public function testInsertAfter()
+    {
+        $list = new Element('ul');
+
+        $insertedNode = $list->insertAfter(new Element('li', 'foo'));
+
+        $this->assertInstanceOf('DiDom\Element', $insertedNode);
+        $this->assertEquals('foo', $insertedNode->getNode()->textContent);
+
+        foreach (['foo'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertAfter(new Element('li', 'qux'), $list->getNode()->childNodes->item(0));
+
+        foreach (['foo', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertAfter(new Element('li', 'bar'), $list->getNode()->childNodes->item(0));
+
+        foreach (['foo', 'bar', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+
+        $list->insertAfter(new Element('li', 'baz'), $list->getNode()->childNodes->item(1));
+
+        foreach (['foo', 'bar', 'baz', 'qux'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    public function testInsertAfterWithoutReferenceNode()
+    {
+        $list = new Element('ul');
+
+        $list->insertAfter(new Element('li', 'foo'));
+        $list->insertAfter(new Element('li', 'bar'));
+
+        foreach (['foo', 'bar'] as $index => $value) {
+            $this->assertEquals($value, $list->getNode()->childNodes->item($index)->textContent);
+        }
+    }
+
+    public function testHas()
+    {
+        $document = new \DOMDocument();
+        $document->loadHTML('<div><span class="foo">bar</span></div>');
+
+        $node = $document->getElementsByTagName('div')->item(0);
+        $element = new Element($node);
+
+        $this->assertTrue($element->has('.foo'));
+        $this->assertFalse($element->has('.bar'));
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testFind($html, $selector, $type, $count)
+    {
+        $document = new \DOMDocument();
+        $document->loadHTML($html);
+
+        $domElement = $document->getElementsByTagName('body')->item(0);
+        $element = new Element($domElement);
+
+        $elements = $element->find($selector, $type);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testFindInDocumentWithoutOwnerDocument()
+    {
+        $element = new Element(new \DOMElement('div'));
+
+        $element->findInDocument('.foo');
+    }
+
+    public function testFindInDocument()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html);
+
+        $items = $document->find('li');
+        $list = $document->first('ul');
+
+        foreach ($list->find('li') as $index => $item) {
+            $this->assertFalse($item->is($items[$index]));
+        }
+
+        foreach ($list->findInDocument('li') as $index => $item) {
+            $this->assertTrue($item->is($items[$index]));
+        }
+
+        $this->assertCount(3, $document->find('li'));
+
+        $list->findInDocument('li')[0]->remove();
+
+        $this->assertCount(2, $document->find('li'));
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testFirstInDocumentWithoutOwnerDocument()
+    {
+        $element = new Element(new \DOMElement('div'));
+
+        $element->firstInDocument('.foo');
+    }
+
+    public function testFirstInDocument()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html);
+
+        $item = $document->first('li');
+        $list = $document->first('ul');
+
+        $this->assertFalse($item->is($list->first('li')));
+        $this->assertTrue($item->is($list->firstInDocument('li')));
+
+        $this->assertCount(3, $document->find('li'));
+
+        $list->findInDocument('li')[0]->remove();
+
+        $this->assertCount(2, $document->find('li'));
+    }
+
+    public function testFirst()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(0);
+
+        $this->assertEquals($item, $list->first('li')->getNode());
+
+        $list = new Element('ul');
+
+        $this->assertNull($list->first('li'));
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testFindAndReturnDomElement($html, $selector, $type, $count)
+    {
+        $document = new \DOMDocument();
+        $document->loadHTML($html);
+
+        $node = $document->getElementsByTagName('body')->item(0);
+        $element = new Element($node);
+
+        $elements = $element->find($selector, $type, false);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DOMElement', $element);
+        }
+    }
+
+    public function findTests()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        return array(
+            array($html, '.post h2', Query::TYPE_CSS, 3),
+            array($html, '.fake h2', Query::TYPE_CSS, 0),
+            array($html, '.post h2, .post p', Query::TYPE_CSS, 6),
+            array($html, "//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]", Query::TYPE_XPATH, 3),
+        );
+    }
+
+    public function testXpath()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new \DOMDocument();
+        $document->loadHTML($html);
+
+        $node = $document->getElementsByTagName('body')->item(0);
+        $element = new Element($node);
+
+        $elements = $element->xpath("//*[contains(concat(' ', normalize-space(@class), ' '), ' post ')]");
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals(3, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+
+    public function testCount()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+        $list = $document->first('ul');
+
+        $this->assertEquals(3, $list->count('li'));
+
+        $document = new Element('ul');
+
+        $this->assertEquals(0, $document->count('li'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testMatchesWithInvalidSelectorType()
+    {
+        $element = new Element('p');
+
+        $element->matches(null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testMatchesStrictWithoutTagName()
+    {
+        $element = new Element('ul', null, ['id' => 'foo', 'class' => 'bar baz']);
+
+        $element->matches('#foo.bar.baz', true);
+    }
+
+    public function testMatches()
+    {
+        $element = new Element('ul', null, ['id' => 'foo', 'class' => 'bar baz']);
+
+        $this->assertTrue($element->matches('ul'));
+        $this->assertTrue($element->matches('#foo'));
+        $this->assertTrue($element->matches('.bar'));
+        $this->assertTrue($element->matches('ul#foo.bar.baz'));
+        $this->assertFalse($element->matches('a#foo.bar.baz'));
+
+        // strict
+        $this->assertTrue($element->matches('ul#foo.bar.baz', true));
+        $this->assertFalse($element->matches('ul#foo.bar', true));
+        $this->assertFalse($element->matches('ul#foo', true));
+        $this->assertFalse($element->matches('ul.bar.baz', true));
+        $this->assertFalse($element->matches('ul.bar.baz', true));
+
+        $element = new Element('p');
+
+        $this->assertTrue($element->matches('p', true));
+
+        $html = '<!DOCTYPE html>
+        <html lang="en">
+        <head>
+            <meta charset="UTF-8">
+            <title>Document</title>
+        </head>
+        <body>
+            <a href="#"><img src="foo.jpg" alt="Foo"></a>
+        </body>
+        </html>';
+
+        $document = new Document($html, false);
+        $anchor = $document->first('a');
+
+        $this->assertTrue($anchor->matches('a:has(img[src$=".jpg"])'));
+        $this->assertTrue($anchor->matches('a img'));
+        $this->assertFalse($anchor->matches('a img[alt="Bar"]'));
+        $this->assertFalse($anchor->matches('img'));
+
+        $textNode = new \DOMText('Foo');
+        $element = new Element($textNode);
+
+        $this->assertFalse($element->matches('#foo'));
+
+        $commentNode = new \DOMComment('Foo');
+        $element = new Element($commentNode);
+
+        $this->assertFalse($element->matches('#foo'));
+    }
+
+    public function testHasAttribute()
+    {
+        $node = $this->createDomElement('input');
+        $element = new Element($node);
+
+        $this->assertFalse($element->hasAttribute('value'));
+
+        $node->setAttribute('value', 'test');
+
+        $this->assertTrue($element->hasAttribute('value'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testSetAttributeWithInvalidValue()
+    {
+        $element = new Element('input');
+        $element->setAttribute('value', []);
+    }
+
+    public function testSetAttribute()
+    {
+        $node = $this->createDomElement('input');
+
+        $element = new Element($node);
+
+        $element->setAttribute('value', 'foo');
+        $this->assertEquals('foo', $element->getNode()->getAttribute('value'));
+
+        $element->setAttribute('value', 10);
+        $this->assertEquals('10', $element->getNode()->getAttribute('value'));
+
+        $element->setAttribute('value', 3.14);
+        $this->assertEquals('3.14', $element->getNode()->getAttribute('value'));
+    }
+
+    public function testGetAttribute()
+    {
+        $node = $this->createDomElement('input');
+
+        $element = new Element($node);
+
+        $this->assertEquals(null, $element->getAttribute('value'));
+        $this->assertEquals('default', $element->getAttribute('value', 'default'));
+
+        $node->setAttribute('value', 'test');
+
+        $this->assertEquals('test', $element->getAttribute('value'));
+    }
+
+    public function testRemoveAttribute()
+    {
+        $domElement = $this->createDomElement('input', null, ['name' => 'username']);
+
+        $element = new Element($domElement);
+
+        $this->assertTrue($element->getNode()->hasAttribute('name'));
+
+        $result = $element->removeAttribute('name');
+
+        $this->assertEquals(0, $element->getNode()->attributes->length);
+        $this->assertFalse($element->getNode()->hasAttribute('name'));
+        $this->assertEquals($result, $element);
+    }
+
+    public function testRemoveAllAttributes()
+    {
+        $attributes = ['type' => 'text', 'name' => 'username'];
+
+        $domElement = $this->createDomElement('input', null, $attributes);
+
+        $element = new Element($domElement);
+
+        $result = $element->removeAllAttributes();
+
+        $this->assertEquals(0, $element->getNode()->attributes->length);
+        $this->assertEquals($result, $element);
+    }
+
+    public function testRemoveAllAttributesWithExclusion()
+    {
+        $attributes = ['type' => 'text', 'name' => 'username'];
+
+        $domElement = $this->createDomElement('input', null, $attributes);
+
+        $element = new Element($domElement);
+
+        $element->removeAllAttributes(['name']);
+
+        $this->assertEquals(1, $element->getNode()->attributes->length);
+        $this->assertEquals('username', $element->getNode()->getAttribute('name'));
+    }
+
+    public function testAttrSet()
+    {
+        $element = new Element('input');
+
+        $element->attr('name', 'username');
+
+        $this->assertEquals('username', $element->getNode()->getAttribute('name'));
+    }
+
+    public function testAttrGet()
+    {
+        $element = new Element('input', null, ['name' => 'username']);
+
+        $this->assertEquals('username', $element->attr('name'));
+    }
+
+    public function testAttributes()
+    {
+        $attributes = ['type' => 'text', 'name' => 'username', 'value' => 'John'];
+
+        $domElement = $this->createDomElement('input', null, $attributes);
+
+        $element = new Element($domElement);
+
+        $this->assertEquals($attributes, $element->attributes());
+        $this->assertEquals(['name' => 'username', 'value' => 'John'], $element->attributes(['name', 'value']));
+    }
+
+
+    public function testAttributesWithText()
+    {
+        $element = new Element(new \DOMText('Foo'));
+
+        $this->assertNull($element->attributes());
+    }
+
+
+    public function testAttributesWithComment()
+    {
+        $element = new Element(new \DOMComment('Foo'));
+
+        $this->assertNull($element->attributes());
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Style attribute is available only for element nodes
+     */
+    public function testStyleWithTextNode()
+    {
+        $element = new Element(new \DOMText('foo'));
+
+        $element->style();
+    }
+
+    /**
+     * @expectedException \LogicException
+     * @expectedExceptionMessage Style attribute is available only for element nodes
+     */
+    public function testStyleWithCommentNode()
+    {
+        $element = new Element(new \DOMComment('foo'));
+
+        $element->style();
+    }
+
+    public function testStyle()
+    {
+        $element = new Element('div');
+
+        $styleAttribute = $element->style();
+
+        $this->assertInstanceOf('DiDom\\StyleAttribute', $styleAttribute);
+        $this->assertSame($element, $styleAttribute->getElement());
+
+        $this->assertSame($styleAttribute, $element->style());
+
+        $element2 = new Element('div');
+
+        $this->assertNotSame($element->style(), $element2->style());
+    }
+
+    public function testHtml()
+    {
+        $element = new Element('span', 'hello');
+
+        $this->assertEquals('<span>hello</span>', $element->html());
+    }
+
+    public function testOuterHtml()
+    {
+        $innerHtml = 'Plain text <span>Lorem ipsum.</span><span>Lorem ipsum.</span>';
+        $html = "<div id=\"foo\" class=\"bar baz\">$innerHtml</div>";
+
+        $document = new Document($html);
+
+        $this->assertEquals('<div id="foo" class="bar baz"></div>', $document->first('#foo')->outerHtml());
+    }
+
+    public function testInnerHtml()
+    {
+        $innerHtml = ' Plain text <span>Lorem ipsum.</span><span>Lorem ipsum.</span>';
+        $html = "<div id=\"root\">$innerHtml</div>";
+
+        $document = new Document($html);
+
+        $this->assertEquals($innerHtml, $document->first('#root')->innerHtml());
+
+        $html = '
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>Document</title>
+</head>
+<body>
+English language <br>
+Русский язык <br>
+اللغة العربية <br>
+漢語 <br>
+Tiếng Việt <br>
+
+&lt; &gt;
+</body>
+</html>
+        ';
+
+        $expectedContent = '
+English language <br>
+Русский язык <br>
+اللغة العربية <br>
+漢語 <br>
+Tiếng Việt <br>
+
+&lt; &gt;
+';
+
+        $document = new Document($html);
+
+        $this->assertEquals($expectedContent, $document->first('body')->innerHtml());
+    }
+
+    public function testInnerHtmlOnXmlElement()
+    {
+        $innerXml = 'Plain text <span>Lorem <single-tag/> ipsum.</span><span>Lorem ipsum.</span>';
+        $xml = "<div id=\"root\">$innerXml</div>";
+
+        $document = new Document($xml, false, 'UTF-8', Document::TYPE_XML);
+
+        $expectedXml = 'Plain text <span>Lorem <single-tag></single-tag> ipsum.</span><span>Lorem ipsum.</span>';
+
+        $this->assertEquals($expectedXml, $document->first('#root')->innerHtml());
+    }
+
+    public function testInnerXml()
+    {
+        $innerXml = 'Plain text <span>Lorem <single-tag/> ipsum.</span><span>Lorem ipsum.</span>';
+        $xml = "<div id=\"root\">$innerXml</div>";
+
+        $document = new Document($xml, false, 'UTF-8', Document::TYPE_XML);
+
+        $this->assertEquals($innerXml, $document->first('#root')->innerXml());
+    }
+
+    public function testSetInnerHtml()
+    {
+        $list = new Element('ul');
+
+        $html = '<li>One</li><li>Two</li><li>Three</li>';
+
+        $this->assertEquals($list, $list->setInnerHtml($html));
+        $this->assertEquals(['One', 'Two', 'Three'], $list->find('li::text'));
+
+        // check inner HTML rewrite works
+
+        $html = '<li>Foo</li><li>Bar</li><li>Baz</li>';
+
+        $this->assertEquals($list, $list->setInnerHtml($html));
+        $this->assertEquals(['Foo', 'Bar', 'Baz'], $list->find('li::text'));
+
+        $html = '<div id="root"></div>';
+        $innerHtml = ' Plain text <span>Lorem ipsum.</span><span>Lorem ipsum.</span>';
+
+        $document = new Document($html, false);
+
+        $document->first('#root')->setInnerHtml($innerHtml);
+
+        $this->assertEquals($innerHtml, $document->first('#root')->innerHtml());
+    }
+
+    public function testXml()
+    {
+        $element = new Element('span', 'hello');
+
+        $prolog = '<?xml version="1.0" encoding="UTF-8"?>'."\n";
+
+        $this->assertEquals($prolog.'<span>hello</span>', $element->xml());
+    }
+
+    public function testXmlWithOptions()
+    {
+        $html = '<html><body><span></span></body></html>';
+
+        $document = new Document();
+        $document->loadHtml($html);
+
+        $element = $document->find('span')[0];
+
+        $prolog = '<?xml version="1.0" encoding="UTF-8"?>'."\n";
+
+        $this->assertEquals($prolog.'<span/>', $element->xml());
+        $this->assertEquals($prolog.'<span></span>', $element->xml(LIBXML_NOEMPTYTAG));
+    }
+
+    public function testGetText()
+    {
+        $element = new Element('span', 'hello');
+
+        $this->assertEquals('hello', $element->text());
+    }
+
+    public function testSetValue()
+    {
+        $element = new Element('span', 'hello');
+        $element->setValue('test');
+
+        $this->assertEquals('test', $element->text());
+    }
+
+    public function testIsElementNode()
+    {
+        $element = new Element('div');
+
+        $element->setInnerHtml(' Foo <span>Bar</span><!-- Baz -->');
+
+        $children = $element->children();
+
+        $this->assertFalse($children[0]->isElementNode());
+        $this->assertTrue($children[1]->isElementNode());
+        $this->assertFalse($children[2]->isElementNode());
+    }
+
+    public function testIsTextNode()
+    {
+        $element = new Element('div');
+
+        $element->setInnerHtml(' Foo <span>Bar</span><!-- Baz -->');
+
+        $children = $element->children();
+
+        $this->assertTrue($children[0]->isTextNode());
+        $this->assertFalse($children[1]->isTextNode());
+        $this->assertFalse($children[2]->isTextNode());
+    }
+
+    public function testIsCommentNode()
+    {
+        $element = new Element('div');
+
+        $element->setInnerHtml(' Foo <span>Bar</span><!-- Baz -->');
+
+        $children = $element->children();
+
+        $this->assertFalse($children[0]->isCommentNode());
+        $this->assertFalse($children[1]->isCommentNode());
+        $this->assertTrue($children[2]->isCommentNode());
+    }
+
+    public function testIs()
+    {
+        $element  = new Element('span', 'hello');
+        $element2 = new Element('span', 'hello');
+
+        $this->assertTrue($element->is($element));
+        $this->assertFalse($element->is($element2));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testIsWithInvalidArgument()
+    {
+        $element = new Element('span', 'hello');
+        $element->is(null);
+    }
+
+    public function testParent()
+    {
+        $html = $this->loadFixture('posts.html');
+        $document = new Document($html, false);
+        $element = $document->createElement('span', 'value');
+
+        $this->assertEquals($document->getDocument(), $element->getDocument()->getDocument());
+    }
+
+    public function testClosest()
+    {
+        // without body and html tags
+        $html = '
+            <nav>
+                <ul class="menu">
+                    <li><a href="#">Foo</a></li>
+                    <li><a href="#">Bar</a></li>
+                    <li><a href="#">Baz</a></li>
+                </ul>
+            </nav>
+        ';
+
+        $document = new Document($html);
+
+        $menu = $document->first('.menu');
+        $link = $document->first('a');
+
+        $this->assertNull($link->closest('.unknown-class'));
+        $this->assertEquals($menu, $link->closest('.menu'));
+
+        $html = '<!DOCTYPE html>
+        <html>
+        <body>
+            <nav></nav>
+            <ul class="menu">
+                <li><a href="#">Foo</a></li>
+                <li><a href="#">Bar</a></li>
+                <li><a href="#">Baz</a></li>
+            </ul>
+        </body>
+        </html>';
+
+        $document = new Document($html);
+
+        $this->assertNull($document->first('ul.menu')->closest('nav'));
+    }
+
+    // =========================
+    // previousSibling
+    // =========================
+
+    public function testPreviousSibling()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul')->getNode();
+
+        $item = $list->childNodes->item(0);
+        $item = new Element($item);
+
+        $this->assertNull($item->previousSibling());
+
+        $item = $list->childNodes->item(1);
+        $item = new Element($item);
+
+        $expectedNode = $list->childNodes->item(0);
+
+        $this->assertEquals($expectedNode, $item->previousSibling()->getNode());
+    }
+
+    public function testPreviousSiblingWithTextNode()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->first('span');
+
+        $expectedNode = $span->getNode()->previousSibling;
+
+        $this->assertEquals($expectedNode, $span->previousSibling()->getNode());
+    }
+
+    public function testPreviousSiblingWithCommentNode()
+    {
+        $html = '<p><!-- Foo --><span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->first('span');
+
+        $expectedNode = $span->getNode()->previousSibling;
+
+        $this->assertEquals($expectedNode, $span->previousSibling()->getNode());
+    }
+
+    public function testPreviousSiblingWithSelector()
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(4);
+        $item = new Element($item);
+
+        $expectedNode = $list->getNode()->childNodes->item(2);
+
+        $this->assertEquals($expectedNode, $item->previousSibling('li:has(a[href$=".com"])')->getNode());
+    }
+
+    public function testPreviousSiblingWithNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $document->find('span')[1];
+
+        $expectedNode = $paragraph->getNode()->childNodes->item(1);
+        $this->assertEquals($expectedNode, $span->previousSibling(null, 'DOMElement')->getNode());
+
+        $expectedNode = $paragraph->getNode()->childNodes->item(2);
+        $this->assertEquals($expectedNode, $span->previousSibling(null, 'DOMComment')->getNode());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPreviousSiblingWithInvalidTypeOfNodeTypeArgument()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[1];
+
+        $span->previousSibling(null, []);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testPreviousSiblingWithInvalidNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[1];
+
+        $span->previousSibling(null, 'foo');
+    }
+
+    /**
+     * @dataProvider previousSiblingWithSelectorAndNotDomElementNodeTypeDataProvider
+     *
+     * @expectedException \LogicException
+     */
+    public function testPreviousSiblingWithSelectorAndNotDomElement($nodeType)
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(4);
+        $item = new Element($item);
+
+        $item->previousSibling('li:has(a[href$=".com"])', $nodeType);
+    }
+
+    public function previousSiblingWithSelectorAndNotDomElementNodeTypeDataProvider()
+    {
+        return [['DOMText'], ['DOMComment']];
+    }
+
+    // =========================
+    // previousSiblings
+    // =========================
+
+    public function testPreviousSiblings()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $paragraph->find('span')[1];
+
+        $childNodes = $paragraph->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(0),
+            $childNodes->item(1),
+            $childNodes->item(2),
+        ];
+
+        $previousSiblings = $span->previousSiblings();
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+    }
+
+    public function testPreviousSiblingsWithSelector()
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(4);
+        $item = new Element($item);
+
+        $childNodes = $list->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(0),
+            $childNodes->item(1),
+            $childNodes->item(2),
+        ];
+
+        $previousSiblings = $item->previousSiblings('li:has(a[href$=".com"])');
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+    }
+
+    public function testPreviousSiblingsWithNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $document->find('span')[1];
+
+        $childNodes = $paragraph->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(1),
+        ];
+
+        $previousSiblings = $span->previousSiblings(null, 'DOMElement');
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+
+        $expectedResult = [
+            $childNodes->item(2),
+        ];
+
+        $previousSiblings = $span->previousSiblings(null, 'DOMComment');
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testPreviousSiblingsWithInvalidTypeOfNodeTypeArgument()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[1];
+
+        $span->previousSiblings(null, []);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testPreviousSiblingsWithInvalidNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[1];
+
+        $span->previousSibling(null, 'foo');
+    }
+
+    /**
+     * @dataProvider previousSiblingsWithSelectorAndNotDomElementNodeTypeDataProvider
+     *
+     * @expectedException \LogicException
+     */
+    public function testPreviousSiblingsWithSelectorAndNotDomElement($nodeType)
+    {
+        $html =
+            '<ul>'.
+            '<li><a href="https://amazon.com">Amazon</a></li>'.
+            '<li><a href="https://facebook.com">Facebook</a></li>'.
+            '<li><a href="https://google.com">Google</a></li>'.
+            '<li><a href="https://www.w3.org">W3C</a></li>'.
+            '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(4);
+        $item = new Element($item);
+
+        $item->previousSiblings('li:has(a[href$=".com"])', $nodeType);
+    }
+
+    public function previousSiblingsWithSelectorAndNotDomElementNodeTypeDataProvider()
+    {
+        return [['DOMText'], ['DOMComment']];
+    }
+
+    // =========================
+    // nextSibling
+    // =========================
+
+    public function testNextSibling()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(2);
+        $item = new Element($item);
+
+        $this->assertNull($item->nextSibling());
+
+        $item = $list->getNode()->childNodes->item(0);
+        $item = new Element($item);
+
+        $expectedNode = $list->getNode()->childNodes->item(1);
+
+        $this->assertEquals($expectedNode, $item->nextSibling()->getNode());
+    }
+
+    public function testNextSiblingWithTextNode()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $paragraph->first('span');
+
+        $expectedNode = $span->getNode()->nextSibling;
+
+        $this->assertEquals($expectedNode, $span->nextSibling()->getNode());
+    }
+
+    public function testNextSiblingWithCommentNode()
+    {
+        $html = '<p>Foo <span>Bar</span><!-- Baz --></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $paragraph->first('span');
+
+        $expectedNode = $span->getNode()->nextSibling;
+
+        $this->assertEquals($expectedNode, $span->nextSibling()->getNode());
+    }
+
+    public function testNextSiblingWithSelector()
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(0);
+        $item = new Element($item);
+
+        $expectedNode = $list->getNode()->childNodes->item(3);
+
+        $this->assertEquals($expectedNode, $item->nextSibling('li:has(a[href$=".org"])')->getNode());
+    }
+
+    public function testNextSiblingWithNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz <!--qwe--><span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $document->find('span')[0];
+
+        $expectedNode = $paragraph->getNode()->childNodes->item(4);
+        $this->assertEquals($expectedNode, $span->nextSibling(null, 'DOMElement')->getNode());
+
+        $expectedNode = $paragraph->getNode()->childNodes->item(3);
+        $this->assertEquals($expectedNode, $span->nextSibling(null, 'DOMComment')->getNode());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testNextSiblingWithInvalidTypeOfNodeTypeArgument()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz <!--qwe--><span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[0];
+
+        $span->nextSibling(null, []);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testNextSiblingWithInvalidNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz <!--qwe--><span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[0];
+
+        $span->nextSibling(null, 'foo');
+    }
+
+    /**
+     * @dataProvider nextSiblingWithSelectorAndNotDomElementNodeTypeDataProvider
+     *
+     * @expectedException \LogicException
+     */
+    public function testNextSiblingWithSelectorAndNotDomElement($nodeType)
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(0);
+        $item = new Element($item);
+
+        $item->nextSibling('li:has(a[href$=".com"])', $nodeType);
+    }
+
+    public function nextSiblingWithSelectorAndNotDomElementNodeTypeDataProvider()
+    {
+        return [['DOMText'], ['DOMComment']];
+    }
+
+    // =========================
+    // nextSiblings
+    // =========================
+
+    public function testNextSiblings()
+    {
+        $html = '<p>Foo <span>Bar</span> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $paragraph->find('span')[0];
+
+        $childNodes = $paragraph->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(2),
+            $childNodes->item(3),
+        ];
+
+        $nextSiblings = $span->nextSiblings();
+
+        $this->assertCount(count($expectedResult), $nextSiblings);
+
+        foreach ($nextSiblings as $index => $nextSibling) {
+            $this->assertEquals($expectedResult[$index], $nextSibling->getNode());
+        }
+    }
+
+    public function testNextSiblingsWithSelector()
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(0);
+        $item = new Element($item);
+
+        $childNodes = $list->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(1),
+            $childNodes->item(2),
+        ];
+
+        $nextSiblings = $item->nextSiblings('li:has(a[href$=".com"])');
+
+        $this->assertCount(count($expectedResult), $nextSiblings);
+
+        foreach ($nextSiblings as $index => $nextSibling) {
+            $this->assertEquals($expectedResult[$index], $nextSibling->getNode());
+        }
+    }
+
+    public function testNextSiblingsWithNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+        $span = $document->find('span')[0];
+
+        $childNodes = $paragraph->getNode()->childNodes;
+
+        $expectedResult = [
+            $childNodes->item(4),
+        ];
+
+        $previousSiblings = $span->nextSiblings(null, 'DOMElement');
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+
+        $expectedResult = [
+            $childNodes->item(2),
+        ];
+
+        $previousSiblings = $span->nextSiblings(null, 'DOMComment');
+
+        $this->assertCount(count($expectedResult), $previousSiblings);
+
+        foreach ($previousSiblings as $index => $previousSibling) {
+            $this->assertEquals($expectedResult[$index], $previousSibling->getNode());
+        }
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testNextSiblingsWithInvalidTypeOfNodeTypeArgument()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[0];
+
+        $span->nextSiblings(null, []);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     */
+    public function testNextSiblingsWithInvalidNodeType()
+    {
+        $html = '<p>Foo <span>Bar</span><!--qwe--> Baz <span>Qux</span></p>';
+
+        $document = new Document($html, false);
+
+        $span = $document->find('span')[0];
+
+        $span->nextSiblings(null, 'foo');
+    }
+
+    /**
+     * @dataProvider nextSiblingsWithSelectorAndNotDomElementNodeTypeDataProvider
+     *
+     * @expectedException \LogicException
+     */
+    public function testNextSiblingsWithSelectorAndNotDomElement($nodeType)
+    {
+        $html =
+            '<ul>'.
+                '<li><a href="https://amazon.com">Amazon</a></li>'.
+                '<li><a href="https://facebook.com">Facebook</a></li>'.
+                '<li><a href="https://google.com">Google</a></li>'.
+                '<li><a href="https://www.w3.org">W3C</a></li>'.
+                '<li><a href="https://wikipedia.org">Wikipedia</a></li>'.
+            '</ul>'
+        ;
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $item = $list->getNode()->childNodes->item(0);
+        $item = new Element($item);
+
+        $item->nextSiblings('li:has(a[href$=".com"])', $nodeType);
+    }
+
+    public function nextSiblingsWithSelectorAndNotDomElementNodeTypeDataProvider()
+    {
+        return [['DOMText'], ['DOMComment']];
+    }
+
+    public function testChild()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $this->assertEquals($list->getNode()->childNodes->item(0), $list->child(0)->getNode());
+        $this->assertEquals($list->getNode()->childNodes->item(2), $list->child(2)->getNode());
+        $this->assertNull($list->child(3));
+
+        // with text nodes
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+
+        $child = $paragraph->getNode()->childNodes->item(0);
+
+        $this->assertEquals($child, $paragraph->child(0)->getNode());
+    }
+
+    public function testFirstChild()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $this->assertEquals($list->getNode()->firstChild, $list->firstChild()->getNode());
+
+        $list = new Element('ul');
+
+        $this->assertNull($list->firstChild());
+
+        // with text nodes
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+
+        $firstChild = $paragraph->getNode()->firstChild;
+
+        $this->assertEquals($firstChild, $paragraph->firstChild()->getNode());
+    }
+
+    public function testLastChild()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+        $list = $document->first('ul');
+
+        $this->assertEquals($list->getNode()->lastChild, $list->lastChild()->getNode());
+
+        $list = new Element('ul');
+
+        $this->assertNull($list->lastChild());
+
+        // with text nodes
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+        $paragraph = $document->first('p');
+
+        $lastChild = $paragraph->getNode()->lastChild;
+
+        $this->assertEquals($lastChild, $paragraph->lastChild()->getNode());
+    }
+
+    public function testHasChildren()
+    {
+        $html = '
+            <p class="element"><br></p>
+            <p class="text">Foo</p>
+            <p class="comment"><!-- Foo --></p>
+            <p class="empty"></p>
+        ';
+
+        $document = new Document($html);
+
+        $this->assertTrue($document->first('.element')->hasChildren());
+        $this->assertTrue($document->first('.text')->hasChildren());
+        $this->assertTrue($document->first('.comment')->hasChildren());
+        $this->assertFalse($document->first('.empty')->hasChildren());
+    }
+
+    public function testChildren()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $list = $document->first('ul');
+
+        $children = $list->children();
+
+        foreach ($list->getNode()->childNodes as $index => $node) {
+            $this->assertEquals($node, $children[$index]->getNode());
+        }
+
+        // with text nodes
+        $html = '<p>Foo <span>Bar</span> Baz</p>';
+
+        $document = new Document($html, false);
+
+        $paragraph = $document->first('p');
+
+        $children = $paragraph->children();
+
+        foreach ($paragraph->getNode()->childNodes as $index => $node) {
+            $this->assertEquals($node, $children[$index]->getNode());
+        }
+    }
+
+    public function testParentWithoutOwner()
+    {
+        $element = new Element(new \DOMElement('span', 'hello'));
+
+        $this->assertNull($element->parent());
+    }
+
+    public function testRemoveChild()
+    {
+        $html = '<div><span>Foo</span></div>';
+        $document = new Document($html, false);
+
+        $div = $document->first('div');
+        $span = $document->first('span');
+
+        $this->assertEquals($span->getNode(), $div->removeChild($span)->getNode());
+        $this->assertCount(0, $document->find('span'));
+    }
+
+    public function testRemoveChildren()
+    {
+        $html = '<div><span>Foo</span>Bar<!-- Baz --></div>';
+        $document = new Document($html, false);
+
+        $div = $document->first('div');
+        $span = $document->first('span');
+
+        $childNodes = $div->children();
+        $removedNodes = $div->removeChildren();
+
+        foreach ($childNodes as $index => $childNode) {
+            $this->assertEquals($childNode->getNode(), $removedNodes[$index]->getNode());
+        }
+
+        $this->assertCount(0, $document->find('span'));
+    }
+
+    public function testRemove()
+    {
+        $html = '<div><span>Foo</span></div>';
+        $document = new Document($html, false);
+
+        $span = $document->first('span');
+
+        $this->assertEquals($span->getNode(), $span->remove()->getNode());
+        $this->assertCount(0, $document->find('span'));
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testRemoveWithoutParentNode()
+    {
+        $element = new Element('div', 'Foo');
+
+        $element->remove();
+    }
+
+    public function testReplace()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $first = $document->find('li')[0];
+        $third = $document->find('li')[2];
+
+        $this->assertEquals($first->getNode(), $first->replace($third)->getNode());
+        $this->assertEquals($third->getNode(), $document->find('li')[0]->getNode());
+        $this->assertCount(3, $document->find('li'));
+
+        // replace without cloning
+        $document = new Document($html, false);
+
+        $first = $document->find('li')[0];
+        $third = $document->find('li')[2];
+
+        $this->assertEquals($first->getNode(), $first->replace($third, false)->getNode());
+        $this->assertEquals($third->getNode(), $document->find('li')[0]->getNode());
+        $this->assertCount(2, $document->find('li'));
+    }
+
+    public function testReplaceToNewElement()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $first = $document->find('li')[0];
+
+        $newElement = new Element('li', 'Foo');
+
+        $this->assertEquals($first->getNode(), $first->replace($newElement)->getNode());
+        $this->assertEquals('Foo', $document->find('li')[0]->text());
+        $this->assertCount(3, $document->find('li'));
+
+        // replace with new node
+        $html = '<span>Foo <a href="#">Bar</a> Baz</span>';
+
+        $document = new Document($html, false);
+
+        $anchor = $document->first('a');
+
+        $textNode = new \DOMText($anchor->text());
+
+        $anchor->replace($textNode);
+    }
+
+    public function testReplaceWithDifferentDocuments()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+        $document2 = new Document($html, false);
+
+        $first = $document->find('li')[0];
+        $third = $document2->find('li')[2];
+
+        $first->replace($third);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testReplaceWithInvalidArgument()
+    {
+        $html = '<ul><li>One</li><li>Two</li><li>Three</li></ul>';
+
+        $document = new Document($html, false);
+
+        $document->find('li')[0]->replace(null);
+    }
+
+    /**
+     * @expectedException \LogicException
+     */
+    public function testReplaceElementWithoutParentNode()
+    {
+        $element = new Element('div', 'Foo');
+
+        $element->replace(new Element('div', 'Bar'));
+    }
+
+    public function testGetLineNo()
+    {
+        $element = new Element('div');
+
+        $this->assertEquals(0, $element->getLineNo());
+
+        $html = '<ul>
+            <li>One</li>
+            <li>Two</li>
+            <li>Three</li>
+        </ul>';
+
+        $document = new Document($html, false);
+
+        $this->assertEquals(4, $document->find('li')[2]->getLineNo());
+    }
+
+    public function testCloneNode()
+    {
+        $element = new Element('input');
+
+        $cloned = $element->cloneNode(true);
+
+        $this->assertFalse($element->is($cloned));
+    }
+
+    public function testGetNode()
+    {
+        $node = $this->createDomElement('input');
+        $element = new Element($node);
+
+        $this->assertEquals($node, $element->getNode());
+    }
+
+    public function testGetDocument()
+    {
+        $html = $this->loadFixture('posts.html');
+
+        $document = new Document($html, false);
+        $element = $document->createElement('span', 'value');
+
+        $this->assertEquals($document->getDocument(), $element->getDocument()->getDocument());
+    }
+
+    public function testToDocument()
+    {
+        $element = new Element('input');
+
+        $document = $element->toDocument();
+
+        $this->assertInstanceOf('DiDom\Document', $document);
+        $this->assertEquals('UTF-8', $document->getDocument()->encoding);
+
+        $document = $element->toDocument('CP1251');
+
+        $this->assertEquals('CP1251', $document->getDocument()->encoding);
+    }
+
+    public function testSetMagicMethod()
+    {
+        $node = $this->createDomElement('input');
+
+        $element = new Element($node);
+        $element->name = 'username';
+
+        $this->assertEquals('username', $element->getNode()->getAttribute('name'));
+    }
+
+    public function testGetMagicMethod()
+    {
+        $element = new Element('input', null, ['name' => 'username']);
+
+        $this->assertEquals('username', $element->name);
+    }
+
+    public function testIssetMagicMethod()
+    {
+        $node = $this->createDomElement('input');
+        $element = new Element($node);
+
+        $this->assertFalse(isset($element->value));
+
+        $node->setAttribute('value', 'test');
+        $element = new Element($node);
+
+        $this->assertTrue(isset($element->value));
+    }
+
+    public function testUnsetMagicMethod()
+    {
+        $element = new Element('input', null, ['name' => 'username']);
+
+        $this->assertTrue($element->hasAttribute('name'));
+
+        unset($element->name);
+
+        $this->assertFalse($element->hasAttribute('name'));
+    }
+
+    public function testToString()
+    {
+        $element = new Element('span', 'hello');
+
+        $this->assertEquals($element->html(), $element->__toString());
+    }
+
+    /**
+     * @dataProvider findTests
+     */
+    public function testInvoke($html, $selector, $type, $count)
+    {
+        $document = new \DOMDocument();
+        $document->loadHTML($html);
+
+        $node = $document->getElementsByTagName('body')->item(0);
+        $element = new Element($node);
+
+        $elements = $element($selector, $type);
+
+        $this->assertTrue(is_array($elements));
+        $this->assertEquals($count, count($elements));
+
+        foreach ($elements as $element) {
+            $this->assertInstanceOf('DiDom\Element', $element);
+        }
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/QueryTest.php

@@ -0,0 +1,425 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Query;
+use Tests\TestCase;
+
+class QueryTest extends TestCase
+{
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Query::compile expects parameter 1 to be string, NULL given
+     */
+    public function testCompileWithNonStringExpression()
+    {
+        Query::compile(null);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\Query::compile expects parameter 2 to be string, NULL given
+     */
+    public function testCompileWithNonStringExpressionType()
+    {
+        Query::compile('h1', null);
+    }
+
+    /**
+     * @expectedException \RuntimeException
+     * @expectedExceptionMessage Unknown expression type "foo"
+     */
+    public function testCompileWithUnknownExpressionType()
+    {
+        Query::compile('h1', 'foo');
+    }
+
+    /**
+     * @dataProvider compileCssTests
+     */
+    public function testCompileCssSelector($selector, $xpath)
+    {
+        $this->assertEquals($xpath, Query::compile($selector));
+    }
+
+    /**
+     * @dataProvider getSegmentsTests
+     */
+    public function testGetSegments($selector, $segments)
+    {
+        $this->assertEquals($segments, Query::getSegments($selector));
+    }
+
+    /**
+     * @dataProvider buildXpathTests
+     */
+    public function testBuildXpath($segments, $xpath)
+    {
+        $this->assertEquals($xpath, Query::buildXpath($segments));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     */
+    public function testBuildXpathWithEmptyArray()
+    {
+        Query::buildXpath([]);
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage The expression must not be empty
+     */
+    public function testCompileWithEmptyXpathExpression()
+    {
+        Query::compile('', Query::TYPE_XPATH);
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage The expression must not be empty
+     */
+    public function testCompileWithEmptyCssExpression()
+    {
+        Query::compile('', Query::TYPE_CSS);
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage The selector must not be empty
+     */
+    public function testGetSegmentsWithEmptySelector()
+    {
+        Query::getSegments('');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Invalid selector "input[=foo]": attribute name must not be empty
+     */
+    public function testEmptyAttributeName()
+    {
+        Query::compile('input[=foo]');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Unknown pseudo-class "unknown-pseudo-class"
+     */
+    public function testUnknownPseudoClass()
+    {
+        Query::compile('li:unknown-pseudo-class');
+    }
+
+    /**
+     * @dataProvider containsInvalidCaseSensitiveParameterDataProvider
+     */
+    public function testContainsInvalidCaseSensitiveParameter($caseSensitive)
+    {
+        $message = sprintf('Parameter 2 of "contains" pseudo-class must be equal true or false, "%s" given', $caseSensitive);
+
+        $this->setExpectedException('DiDom\Exceptions\InvalidSelectorException', $message);
+
+        Query::compile("a:contains('Log in', {$caseSensitive})");
+    }
+
+    public function containsInvalidCaseSensitiveParameterDataProvider()
+    {
+        return [
+            ['foo'],
+            ['TRUE'],
+            ['FALSE'],
+        ];
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage nth-child (or nth-last-child) expression must not be empty
+     */
+    public function testEmptyNthExpression()
+    {
+        Query::compile('li:nth-child()');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Invalid property "::"
+     */
+    public function testEmptyProperty()
+    {
+        Query::compile('li::');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Unknown property "foo"
+     */
+    public function testInvalidProperty()
+    {
+        Query::compile('li::foo');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Invalid nth-child expression "foo"
+     */
+    public function testUnknownNthExpression()
+    {
+        Query::compile('li:nth-child(foo)');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Invalid selector "."
+     */
+    public function testGetSegmentsWithEmptyClassName()
+    {
+        Query::getSegments('.');
+    }
+
+    /**
+     * @expectedException \DiDom\Exceptions\InvalidSelectorException
+     * @expectedExceptionMessage Invalid selector "."
+     */
+    public function testCompilehWithEmptyClassName()
+    {
+        Query::compile('span.');
+    }
+
+    public function testCompileXpath()
+    {
+        $this->assertEquals('//div', Query::compile('//div', Query::TYPE_XPATH));
+    }
+
+    public function testSetCompiledInvalidArgumentType()
+    {
+        if (PHP_VERSION_ID >= 70000) {
+            $this->setExpectedException('TypeError');
+        } else {
+            $this->setExpectedException('PHPUnit_Framework_Error');
+        }
+
+        Query::setCompiled(null);
+    }
+
+    public function testSetCompiled()
+    {
+        $xpath = "//*[@id='foo']//*[contains(concat(' ', normalize-space(@class), ' '), ' bar ')]//baz";
+        $compiled = ['#foo .bar baz' => $xpath];
+
+        Query::setCompiled($compiled);
+
+        $this->assertEquals($compiled, Query::getCompiled());
+    }
+
+    public function testGetCompiled()
+    {
+        Query::setCompiled([]);
+
+        $selector = '#foo .bar baz';
+        $xpath = '//*[@id="foo"]//*[contains(concat(" ", normalize-space(@class), " "), " bar ")]//baz';
+        $compiled = [$selector => $xpath];
+
+        Query::compile($selector);
+
+        $this->assertEquals($compiled, Query::getCompiled());
+    }
+
+    public function compileCssTests()
+    {
+        $compiled = [
+            ['a', '//a'],
+            ['foo bar baz', '//foo//bar//baz'],
+            ['foo > bar > baz', '//foo/bar/baz'],
+            ['#foo', '//*[@id="foo"]'],
+            ['.bar', '//*[contains(concat(" ", normalize-space(@class), " "), " bar ")]'],
+            ['*[foo=bar]', '//*[@foo="bar"]'],
+            ['*[foo="bar"]', '//*[@foo="bar"]'],
+            ['*[foo=\'bar\']', '//*[@foo="bar"]'],
+            ['select[name=category] option[selected=selected]', '//select[@name="category"]//option[@selected="selected"]'],
+            ['*[^data-]', '//*[@*[starts-with(name(), "data-")]]'],
+            ['*[^data-=foo]', '//*[@*[starts-with(name(), "data-")]="foo"]'],
+            ['a[href^=https]', '//a[starts-with(@href, "https")]'],
+            ['img[src$=png]', '//img[substring(@src, string-length(@src) - string-length("png") + 1) = "png"]'],
+            ['a[href*=example.com]', '//a[contains(@href, "example.com")]'],
+            ['script[!src]', '//script[not(@src)]'],
+            ['a[href!="http://foo.com/"]', '//a[not(@href="http://foo.com/")]'],
+            ['a[foo~="bar"]', '//a[contains(concat(" ", normalize-space(@foo), " "), " bar ")]'],
+            ['input, textarea, select', '//input|//textarea|//select'],
+            ['input[name="name"], textarea[name="description"], select[name="type"]', '//input[@name="name"]|//textarea[@name="description"]|//select[@name="type"]'],
+            ['li:first-child', '//li[position() = 1]'],
+            ['li:last-child', '//li[position() = last()]'],
+            ['*:not(a[href*="example.com"])', '//*[not(self::a[contains(@href, "example.com")])]'],
+            ['ul:empty', '//ul[count(descendant::*) = 0]'],
+            ['ul:not-empty', '//ul[count(descendant::*) > 0]'],
+            ['li:nth-child(odd)', '//*[(name()="li") and (position() mod 2 = 1 and position() >= 1)]'],
+            ['li:nth-child(even)', '//*[(name()="li") and (position() mod 2 = 0 and position() >= 0)]'],
+            ['li:nth-child(3)', '//*[(name()="li") and (position() = 3)]'],
+            ['li:nth-child(-3)', '//*[(name()="li") and (position() = -3)]'],
+            ['li:nth-child(3n)', '//*[(name()="li") and ((position() + 0) mod 3 = 0 and position() >= 0)]'],
+            ['li:nth-child(3n+1)', '//*[(name()="li") and ((position() - 1) mod 3 = 0 and position() >= 1)]'],
+            ['li:nth-child(3n-1)', '//*[(name()="li") and ((position() + 1) mod 3 = 0 and position() >= 1)]'],
+            ['li:nth-child(n+3)', '//*[(name()="li") and ((position() - 3) mod 1 = 0 and position() >= 3)]'],
+            ['li:nth-child(n-3)', '//*[(name()="li") and ((position() + 3) mod 1 = 0 and position() >= 3)]'],
+            ['li:nth-of-type(odd)', '//li[position() mod 2 = 1 and position() >= 1]'],
+            ['li:nth-of-type(even)', '//li[position() mod 2 = 0 and position() >= 0]'],
+            ['li:nth-of-type(3)', '//li[position() = 3]'],
+            ['li:nth-of-type(-3)', '//li[position() = -3]'],
+            ['li:nth-of-type(3n)', '//li[(position() + 0) mod 3 = 0 and position() >= 0]'],
+            ['li:nth-of-type(3n+1)', '//li[(position() - 1) mod 3 = 0 and position() >= 1]'],
+            ['li:nth-of-type(3n-1)', '//li[(position() + 1) mod 3 = 0 and position() >= 1]'],
+            ['li:nth-of-type(n+3)', '//li[(position() - 3) mod 1 = 0 and position() >= 3]'],
+            ['li:nth-of-type(n-3)', '//li[(position() + 3) mod 1 = 0 and position() >= 3]'],
+            ['ul:has(li.item)', '//ul[.//li[contains(concat(" ", normalize-space(@class), " "), " item ")]]'],
+            ['form[name=register]:has(input[name=foo])', '//form[(@name="register") and (.//input[@name="foo"])]'],
+            ['ul li a::text', '//ul//li//a/text()'],
+            ['ul li a::text()', '//ul//li//a/text()'],
+            ['ul li a::attr(href)', '//ul//li//a/@*[name() = "href"]'],
+            ['ul li a::attr(href, title)', '//ul//li//a/@*[name() = "href" or name() = "title"]'],
+            ['> ul li a', '/ul//li//a'],
+        ];
+
+        $compiled = array_merge($compiled, $this->getContainsPseudoClassTests());
+        $compiled = array_merge($compiled, $this->getPropertiesTests());
+
+        $compiled = array_merge($compiled, [
+            ['a[title="foo, bar::baz"]', '//a[@title="foo, bar::baz"]'],
+        ]);
+
+        return $compiled;
+    }
+
+    private function getContainsPseudoClassTests()
+    {
+        $strToLowerFunction = function_exists('mb_strtolower') ? 'mb_strtolower' : 'strtolower';
+
+        $containsXpath = [
+            // caseSensitive = true, fullMatch = false
+            ['li:contains(foo)', '//li[contains(text(), "foo")]'],
+            ['li:contains("foo")', '//li[contains(text(), "foo")]'],
+            ['li:contains(\'foo\')', '//li[contains(text(), "foo")]'],
+
+            // caseSensitive = true, fullMatch = false
+            ['li:contains(foo, true)', '//li[contains(text(), "foo")]'],
+            ['li:contains("foo", true)', '//li[contains(text(), "foo")]'],
+            ['li:contains(\'foo\', true)', '//li[contains(text(), "foo")]'],
+
+            // caseSensitive = true, fullMatch = false
+            ['li:contains(foo, true, false)', '//li[contains(text(), "foo")]'],
+            ['li:contains("foo", true, false)', '//li[contains(text(), "foo")]'],
+            ['li:contains(\'foo\', true, false)', '//li[contains(text(), "foo")]'],
+
+            // caseSensitive = true, fullMatch = true
+            ['li:contains(foo, true, true)', '//li[text() = "foo"]'],
+            ['li:contains("foo", true, true)', '//li[text() = "foo"]'],
+            ['li:contains(\'foo\', true, true)', '//li[text() = "foo"]'],
+
+            // caseSensitive = false, fullMatch = false
+            ['li:contains(foo, false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+            ['li:contains("foo", false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+            ['li:contains(\'foo\', false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+
+            // caseSensitive = false, fullMatch = false
+            ['li:contains(foo, false, false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+            ['li:contains("foo", false, false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+            ['li:contains(\'foo\', false, false)', "//li[contains(php:functionString(\"{$strToLowerFunction}\", .), php:functionString(\"{$strToLowerFunction}\", \"foo\"))]"],
+
+            // caseSensitive = false, fullMatch = true
+            ['li:contains(foo, false, true)', "//li[php:functionString(\"{$strToLowerFunction}\", .) = php:functionString(\"{$strToLowerFunction}\", \"foo\")]"],
+            ['li:contains("foo", false, true)', "//li[php:functionString(\"{$strToLowerFunction}\", .) = php:functionString(\"{$strToLowerFunction}\", \"foo\")]"],
+            ['li:contains(\'foo\', false, true)', "//li[php:functionString(\"{$strToLowerFunction}\", .) = php:functionString(\"{$strToLowerFunction}\", \"foo\")]"],
+        ];
+
+        return $containsXpath;
+    }
+
+    private function getPropertiesTests()
+    {
+        return [
+            ['a::text', '//a/text()'],
+            ['a::text()', '//a/text()'],
+            ['a::attr', '//a/@*'],
+            ['a::attr()', '//a/@*'],
+            ['a::attr(href)', '//a/@*[name() = "href"]'],
+            ['a::attr(href,title)', '//a/@*[name() = "href" or name() = "title"]'],
+            ['a::attr(href, title)', '//a/@*[name() = "href" or name() = "title"]'],
+        ];
+    }
+
+    public function buildXpathTests()
+    {
+        $xpath = [
+            '//a',
+            '//*[@id="foo"]',
+            '//a[@id="foo"]',
+            '//a[contains(concat(" ", normalize-space(@class), " "), " foo ")]',
+            '//a[(contains(concat(" ", normalize-space(@class), " "), " foo ")) and (contains(concat(" ", normalize-space(@class), " "), " bar "))]',
+            '//a[@href]',
+            '//a[@href="http://example.com/"]',
+            '//a[(@href="http://example.com/") and (@title="Example Domain")]',
+            '//a[(@target="_blank") and (starts-with(@href, "https"))]',
+            '//a[substring(@href, string-length(@href) - string-length(".com") + 1) = ".com"]',
+            '//a[contains(@href, "example")]',
+            '//a[not(@href="http://foo.com/")]',
+            '//script[not(@src)]',
+            '//li[position() = 1]',
+            '//*[(@id="id") and (contains(concat(" ", normalize-space(@class), " "), " foo ")) and (@name="value") and (position() = 1)]',
+        ];
+
+        $segments = [
+            ['tag' => 'a'],
+            ['id' => 'foo'],
+            ['tag' => 'a', 'id' => 'foo'],
+            ['tag' => 'a', 'classes' => ['foo']],
+            ['tag' => 'a', 'classes' => ['foo', 'bar']],
+            ['tag' => 'a', 'attributes' => ['href' => null]],
+            ['tag' => 'a', 'attributes' => ['href' => 'http://example.com/']],
+            ['tag' => 'a', 'attributes' => ['href' => 'http://example.com/', 'title' => 'Example Domain']],
+            ['tag' => 'a', 'attributes' => ['target' => '_blank', 'href^' => 'https']],
+            ['tag' => 'a', 'attributes' => ['href$' => '.com']],
+            ['tag' => 'a', 'attributes' => ['href*' => 'example']],
+            ['tag' => 'a', 'attributes' => ['href!' => 'http://foo.com/']],
+            ['tag' => 'script', 'attributes' => ['!src' => null]],
+            ['tag' => 'li', 'pseudo' => 'first-child'],
+            ['tag' => '*', 'id' => 'id', 'classes' => ['foo'], 'attributes' => ['name' => 'value'], 'pseudo' => 'first-child', 'rel' => '>'],
+        ];
+
+        $parameters = [];
+
+        foreach ($segments as $index => $segment) {
+            $parameters[] = [$segment, $xpath[$index]];
+        }
+
+        return $parameters;
+    }
+
+    public function getSegmentsTests()
+    {
+        $segments = [
+            ['selector' => 'a', 'tag' => 'a'],
+            ['selector' => '#foo', 'id' => 'foo'],
+            ['selector' => 'a#foo', 'tag' => 'a', 'id' => 'foo'],
+            ['selector' => 'a.foo', 'tag' => 'a', 'classes' => ['foo']],
+            ['selector' => 'a.foo.bar', 'tag' => 'a', 'classes' => ['foo', 'bar']],
+            ['selector' => 'a[href]', 'tag' => 'a', 'attributes' => ['href' => null]],
+            ['selector' => 'a[href=http://example.com/]', 'tag' => 'a', 'attributes' => ['href' => 'http://example.com/']],
+            ['selector' => 'a[href="http://example.com/"]', 'tag' => 'a', 'attributes' => ['href' => 'http://example.com/']],
+            ['selector' => 'a[href=\'http://example.com/\']', 'tag' => 'a', 'attributes' => ['href' => 'http://example.com/']],
+            ['selector' => 'a[href=http://example.com/][title=Example Domain]', 'tag' => 'a', 'attributes' => ['href' => 'http://example.com/', 'title' => 'Example Domain']],
+            ['selector' => 'a[href=http://example.com/][href=http://example.com/404]', 'tag' => 'a', 'attributes' => ['href' => 'http://example.com/404']],
+            ['selector' => 'a[href^=https]', 'tag' => 'a', 'attributes' => ['href^' => 'https']],
+            ['selector' => 'li:first-child', 'tag' => 'li', 'pseudo' => 'first-child'],
+            ['selector' => 'ul >', 'tag' => 'ul', 'rel' => '>'],
+            ['selector' => '#id.foo[name=value]:first-child >', 'id' => 'id', 'classes' => ['foo'], 'attributes' => ['name' => 'value'], 'pseudo' => 'first-child', 'rel' => '>'],
+            ['selector' => 'li.bar:nth-child(2n)', 'tag' => 'li', 'classes' => ['bar'], 'pseudo' => 'nth-child', 'expr' => '2n'],
+        ];
+
+        $parameters = [];
+
+        foreach ($segments as $segment) {
+            $parameters[] = [$segment['selector'], $segment];
+        }
+
+        return $parameters;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/SelectorTest.php

@@ -0,0 +1,327 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Document;
+use Tests\TestCase;
+
+class SelectorTest extends TestCase
+{
+    public function testTag()
+    {
+        $html = '
+            <ul id="first">
+                <li><a href="#">Item 1</a></li>
+                <li><a href="#">Item 2</a></li>
+                <li><a href="#">Item 3</a></li>
+            </ul>
+            <ol id="second">
+                <li><a href="#">Item 1</a></li>
+                <li><a href="#">Item 2</a></li>
+                <li><a href="#">Item 3</a></li>
+            </ol>
+        ';
+
+        $document = new Document($html);
+
+        $expected = ['Item 1', 'Item 2', 'Item 3', 'Item 1', 'Item 2', 'Item 3'];
+
+        $result = [];
+
+        foreach ($document->find('li') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testNestedTag()
+    {
+        $html = '
+            <ul id="first">
+                <li><a href="#">Item 1</a></li>
+                <li><a href="#">Item 2</a></li>
+                <li><a href="#">Item 3</a></li>
+            </ul>
+            <ol id="second">
+                <li><a href="#">Item 1</a></li>
+                <li><a href="#">Item 2</a></li>
+                <li><a href="#">Item 3</a></li>
+            </ol>
+        ';
+
+        $document = new Document($html);
+
+        $expected = ['Item 1', 'Item 2', 'Item 3'];
+
+        $result = [];
+
+        foreach ($document->find('ul a') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testDirectChild()
+    {
+        $html = '
+            <div>
+                <p><span>Lorem ipsum.</span></p>
+                <span>Lorem ipsum.</span>
+            </div>
+        ';
+
+        $document = new Document($html);
+
+        $expected = ['Lorem ipsum.'];
+
+        $result = [];
+
+        foreach ($document->find('div > span') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testId()
+    {
+        $html = '
+            <span>Lorem ipsum dolor.</span>
+            <span id="second">Tenetur totam, nostrum.</span>
+            <span>Iste, doloremque, praesentium.</span>
+        ';
+
+        $document = new Document($html);
+
+        $expected = ['Tenetur totam, nostrum.'];
+
+        $result = [];
+
+        foreach ($document->find('#second') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testClass()
+    {
+        $html = '
+            <span class="odd first">Lorem ipsum dolor.</span>
+            <span class="even second">Tenetur totam, nostrum.</span>
+            <span class="odd third">Iste, doloremque, praesentium.</span>
+        ';
+
+        $document = new Document($html);
+
+        $expected = ['Lorem ipsum dolor.', 'Iste, doloremque, praesentium.'];
+
+        $result = [];
+
+        foreach ($document->find('.odd') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        $expected = ['Iste, doloremque, praesentium.'];
+
+        $result = [];
+
+        foreach ($document->find('.odd.third') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    public function testAttributes()
+    {
+        $html = '
+            <ul class="links">
+                <li>
+                    <a href="https://foo.com" title="Foo" target="_blank">Foo</a>
+                    <a href="http://bar.com" title="Bar" rel="noreferrer">Bar</a>
+                    <a href="https://baz.org" title="Baz" rel="nofollow noreferrer">Baz</a>
+                    <a href="http://qux.org" title="Qux" target="_blank" rel="nofollow">Qux</a>
+                </li>
+            </ul>
+        ';
+
+        $document = new Document($html);
+
+        // has attribute
+
+        $expected = ['Foo', 'Qux'];
+
+        $result = [];
+
+        foreach ($document->find('a[target]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // has no attribute
+
+        $expected = ['Bar', 'Baz'];
+
+        $result = [];
+
+        foreach ($document->find('a[!target]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // equals
+
+        $expected = ['Baz'];
+
+        $result = [];
+
+        foreach ($document->find('a[href="https://baz.org"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // not equals
+
+        $expected = ['Foo', 'Bar', 'Qux'];
+
+        $result = [];
+
+        foreach ($document->find('a[href!="https://baz.org"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // starts with
+
+        $expected = ['Foo', 'Baz'];
+
+        $result = [];
+
+        foreach ($document->find('a[href^="https"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // ends with
+
+        $expected = ['Baz', 'Qux'];
+
+        $result = [];
+
+        foreach ($document->find('a[href$="org"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // contains word
+
+        $expected = ['Bar', 'Baz'];
+
+        $result = [];
+
+        foreach ($document->find('a[rel~="noreferrer"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+        $this->assertEquals([], $document->find('a[rel~="noref"]'));
+
+        // contains substring
+
+        $expected = ['Bar', 'Baz'];
+
+        $result = [];
+
+        foreach ($document->find('a[href*="ba"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+
+        // multiple attribute conditions
+
+        $expected = ['Qux'];
+
+        $result = [];
+
+        foreach ($document->find('a[target="_blank"][rel="nofollow"]') as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expected, $result);
+    }
+
+    /**
+     * @param $selector
+     * @param $expectedResult
+     *
+     * @dataProvider containsPseudoClassTests
+     */
+    public function testContainsPseudoClass($selector, $expectedResult)
+    {
+        $html = '
+            <ul class="links">
+                <li>
+                    <a href="https://foo.com" title="Foo" target="_blank">Foo</a>
+                    <a href="http://bar.com" title="Bar" rel="noreferrer">Bar</a>
+                    <a href="https://baz.org" title="Baz" rel="nofollow noreferrer">Baz</a>
+                    <a href="http://qux.org" title="Qux" target="_blank" rel="nofollow">Qux</a>
+                    <a href="https://foobar.com" title="FooBar" target="_blank">FooBar</a>
+                </li>
+            </ul>
+        ';
+
+        $document = new Document($html);
+
+        $result = [];
+
+        foreach ($document->find($selector) as $element) {
+            $result[] = $element->text();
+        }
+
+        $this->assertEquals($expectedResult, $result);
+    }
+
+    public function containsPseudoClassTests()
+    {
+        return [
+            ['a:contains(Baz)', ['Baz']],
+            ['a:contains(a)', ['Bar', 'Baz', 'FooBar']],
+            ['a:contains(Bar)', ['Bar', 'FooBar']],
+            ['a:contains(Bar, true, true)', ['Bar']],
+            ['a:contains(bar)', []],
+            ['a:contains(bar, false)', ['Bar', 'FooBar']],
+            ['a:contains(bar, false, true)', ['Bar']],
+        ];
+    }
+
+    public function testUnicodeSupport()
+    {
+        $html = '
+            <ul class="links">
+                <li>
+                    <a href="http://foo.com" title="Foo">Foo</a>
+                    <a href="http://example.com" title="Пример">Example</a>
+                    <a href="http://bar.com" title="Foo">Bar</a>
+                    <a href="http://example.ru" title="Example">Пример</a>
+                </li>
+            </ul>
+        ';
+
+        $document = new Document($html);
+
+        $this->assertEquals('Example', $document->first('a[title=Пример]')->text());
+        $this->assertEquals('Example', $document->first('a:contains(Пример)')->attr('title'));
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/DiDom/StyleAttributeTest.php

@@ -0,0 +1,515 @@
+<?php
+
+namespace Tests\DiDom;
+
+use DiDom\Element;
+use DiDom\StyleAttribute;
+use Tests\TestCase;
+
+class StyleAttributeTest extends TestCase
+{
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The element must contain DOMElement node
+     */
+    public function testConstructorWithTextNode()
+    {
+        $element = new Element(new \DOMText('foo'));
+
+        new StyleAttribute($element);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage The element must contain DOMElement node
+     */
+    public function testConstructorWithCommentNode()
+    {
+        $element = new Element(new \DOMComment('foo'));
+
+        new StyleAttribute($element);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\StyleAttribute::setProperty expects parameter 1 to be string, NULL given
+     */
+    public function testSetPropertyWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->setProperty(null, '16px');
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\StyleAttribute::setProperty expects parameter 2 to be string, NULL given
+     */
+    public function testSetPropertyWithInvalidPropertyValue()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->setProperty('font-size', null);
+    }
+
+    public function testSetProperty()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals('color: blue; border: 1px solid black', $element->getAttribute('style'));
+
+        $styleAttribute->setProperty('font-size', '16px');
+
+        $this->assertEquals('color: blue; border: 1px solid black; font-size: 16px', $element->getAttribute('style'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Property name must be a string, integer given
+     */
+    public function testSetMultiplePropertiesWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->setMultipleProperties([
+            'width' => '50px',
+            'height',
+        ]);
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Property value must be a string, NULL given
+     */
+    public function testSetMultiplePropertiesWithInvalidPropertyValue()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->setMultipleProperties([
+            'width' => '50px',
+            'height' => null,
+        ]);
+    }
+
+    public function testSetMultipleProperties()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals('color: blue; border: 1px solid black', $element->getAttribute('style'));
+
+        $styleAttribute->setMultipleProperties([
+            'font-size' => '16px',
+            'font-family' => 'Times',
+        ]);
+
+        $this->assertEquals('color: blue; border: 1px solid black; font-size: 16px; font-family: Times', $element->getAttribute('style'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\StyleAttribute::getProperty expects parameter 1 to be string, NULL given
+     */
+    public function testGetPropertyWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->getProperty(null);
+    }
+
+    /**
+     * @param string $styleString
+     * @param string $propertyName
+     * @param string $expectedResult
+     *
+     * @dataProvider getPropertyDataProvider
+     */
+    public function testGetProperty($styleString, $propertyName, $expectedResult)
+    {
+        $element = new Element('div', null, [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($expectedResult, $styleAttribute->getProperty($propertyName));
+    }
+
+    public function getPropertyDataProvider()
+    {
+        return [
+            [
+                'color: blue; font-size: 16px; border: 1px solid black',
+                'font-size',
+                '16px',
+            ],
+            [
+                'color: blue; font-size: 16px; border: 1px solid black;',
+                'font-size',
+                '16px',
+            ],
+            [
+                'color: blue; font-size: 16px; border: 1px solid black;',
+                'foo',
+                null,
+            ],
+        ];
+    }
+
+    public function testGetPropertyWithDefaultValue()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertNull($styleAttribute->getProperty('font-size'));
+        $this->assertEquals('16px', $styleAttribute->getProperty('font-size', '16px'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Property name must be a string, NULL given
+     */
+    public function testGetMultiplePropertiesWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->getMultipleProperties(['color', null]);
+    }
+
+    /**
+     * @param string $styleString
+     * @param array $propertyNames
+     * @param string $expectedResult
+     *
+     * @dataProvider getMultiplePropertiesDataProvider
+     */
+    public function testGetMultipleProperties($styleString, $propertyNames, $expectedResult)
+    {
+        $element = new Element('div', null, [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($expectedResult, $styleAttribute->getMultipleProperties($propertyNames));
+    }
+
+    public function getMultiplePropertiesDataProvider()
+    {
+        return [
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                ['font-size'],
+                [
+                    'font-size' => '16px',
+                ],
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                ['font-size', 'border'],
+                [
+                    'font-size' => '16px',
+                    'border' => '1px solid black',
+                ],
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                ['font-size', 'border', 'width'],
+                [
+                    'font-size' => '16px',
+                    'border' => '1px solid black',
+                ],
+            ],
+        ];
+    }
+
+    /**
+     * @param string $styleString
+     * @param string $expectedResult
+     *
+     * @dataProvider getAllPropertiesDataProvider
+     */
+    public function testGetAllProperties($styleString, $expectedResult)
+    {
+        $element = new Element('div', null, [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($expectedResult, $styleAttribute->getAllProperties());
+    }
+
+    public function getAllPropertiesDataProvider()
+    {
+        return [
+            [
+                '',
+                [],
+            ],
+            [
+                'color: blue; font-size: 16px; border: 1px solid black',
+                [
+                    'color' => 'blue',
+                    'font-size' => '16px',
+                    'border' => '1px solid black',
+                ],
+            ],
+            [
+                'color: blue; font-size: 16px; border: 1px solid black',
+                [
+                    'color' => 'blue',
+                    'font-size' => '16px',
+                    'border' => '1px solid black',
+                ],
+            ],
+        ];
+    }
+
+    public function testGetAllPropertiesAfterEmptyStyleAttribute()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals(['color' => 'blue'], $styleAttribute->getAllProperties());
+
+        $element->setAttribute('style', '');
+
+        $this->assertEquals([], $styleAttribute->getAllProperties());
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\StyleAttribute::hasProperty expects parameter 1 to be string, NULL given
+     */
+    public function testHasPropertyWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->hasProperty(null);
+    }
+
+    public function testHasProperty()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertTrue($styleAttribute->hasProperty('color'));
+        $this->assertFalse($styleAttribute->hasProperty('width'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage DiDom\StyleAttribute::removeProperty expects parameter 1 to be string, NULL given
+     */
+    public function testRemovePropertyWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->removeProperty(null);
+    }
+
+    public function testRemoveProperty()
+    {
+        $styleString = 'color: blue; font-size: 16px; border: 1px solid black';
+
+        $element = new Element('span', 'foo', [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($styleString, $element->getAttribute('style'));
+
+        $styleAttribute->removeProperty('font-size');
+
+        $this->assertEquals('color: blue; border: 1px solid black', $element->getAttribute('style'));
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Property name must be a string, NULL given
+     */
+    public function testRemoveMultiplePropertiesWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->removeMultipleProperties(['color', null]);
+    }
+
+    /**
+     * @param string $styleString
+     * @param array $propertyNames
+     * @param string $expectedResult
+     *
+     * @dataProvider removeMultiplePropertiesDataProvider
+     */
+    public function testRemoveMultipleProperties($styleString, $propertyNames, $expectedResult)
+    {
+        $element = new Element('div', null, [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($styleString, $element->getAttribute('style'));
+
+        $styleAttribute->removeMultipleProperties($propertyNames);
+
+        $this->assertEquals($expectedResult, $element->getAttribute('style'));
+    }
+
+    public function removeMultiplePropertiesDataProvider()
+    {
+        return [
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size',
+                ],
+                'color: blue; font-family: Times; border: 1px solid black',
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size', 'border',
+                ],
+                'color: blue; font-family: Times',
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size', 'border', 'width',
+                ],
+                'color: blue; font-family: Times',
+            ],
+        ];
+    }
+
+    /**
+     * @expectedException \InvalidArgumentException
+     * @expectedExceptionMessage Property name must be a string, NULL given
+     */
+    public function testRemoveAllPropertiesWithInvalidPropertyName()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; border: 1px solid black',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $styleAttribute->removeAllProperties(['color', null]);
+    }
+
+    /**
+     * @param string $styleString
+     * @param array $exclusions
+     * @param string $expectedResult
+     *
+     * @dataProvider removeAllPropertiesDataProvider
+     */
+    public function testRemoveAllProperties($styleString, $exclusions, $expectedResult)
+    {
+        $element = new Element('div', null, [
+            'style' => $styleString,
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertEquals($styleString, $element->getAttribute('style'));
+
+        $styleAttribute->removeAllProperties($exclusions);
+
+        $this->assertEquals($expectedResult, $element->getAttribute('style'));
+    }
+
+    public function removeAllPropertiesDataProvider()
+    {
+        return [
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size',
+                ],
+                'font-size: 16px',
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size', 'border',
+                ],
+                'font-size: 16px; border: 1px solid black',
+            ],
+            [
+                'color: blue; font-size: 16px; font-family: Times; border: 1px solid black',
+                [
+                    'font-size', 'border', 'width',
+                ],
+                'font-size: 16px; border: 1px solid black',
+            ],
+        ];
+    }
+
+    public function testGetElement()
+    {
+        $element = new Element('div', null, [
+            'style' => 'color: blue; font-size: 16px',
+        ]);
+
+        $styleAttribute = new StyleAttribute($element);
+
+        $this->assertSame($element, $styleAttribute->getElement());
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/TestCase.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Tests;
+
+use PHPUnit_Framework_TestCase;
+use DOMDocument;
+use Exception;
+
+class TestCase extends PHPUnit_Framework_TestCase
+{
+    protected function tearDown()
+    {
+        if (class_exists('Mockery')) {
+            \Mockery::close();
+        }
+    }
+
+    protected function loadFixture($filename)
+    {
+        $path = __DIR__.'/fixtures/'.$filename;
+
+        if (file_exists($path)) {
+            return file_get_contents($path);
+        }
+
+        throw new Exception(sprintf('Fixture "%s" does not exist', $filename));
+    }
+
+    protected function createDomElement($name, $value = null, $attributes = [])
+    {
+        $document = new DOMDocument('1.0', 'UTF-8');
+        $node = $document->createElement($name, $value);
+
+        foreach ($attributes as $name => $value) {
+            $node->setAttribute($name, $value);
+        }
+
+        return $node;
+    }
+}

full-size-image-links/vendor/imangazaliev/didom/tests/bootstrap.php

@@ -0,0 +1,7 @@
+<?php
+
+ini_set('error_reporting', E_ALL);
+ini_set('display_errors', 1);
+ini_set('display_startup_errors', 1);
+
+require __DIR__.'/../vendor/autoload.php';

full-size-image-links/vendor/imangazaliev/didom/tests/fixtures/books.xml

@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<catalog>
+   <book id="bk101">
+      <author>Gambardella, Matthew</author>
+      <title>XML Developer's Guide</title>
+      <genre>Computer</genre>
+      <price>44.95</price>
+      <publish_date>2000-10-01</publish_date>
+      <description>An in-depth look at creating applications 
+      with XML.</description>
+   </book>
+   <book id="bk102">
+      <author>Ralls, Kim</author>
+      <title>Midnight Rain</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2000-12-16</publish_date>
+      <description>A former architect battles corporate zombies, 
+      an evil sorceress, and her own childhood to become queen 
+      of the world.</description>
+   </book>
+   <book id="bk103">
+      <author>Corets, Eva</author>
+      <title>Maeve Ascendant</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2000-11-17</publish_date>
+      <description>After the collapse of a nanotechnology 
+      society in England, the young survivors lay the 
+      foundation for a new society.</description>
+   </book>
+   <book id="bk104">
+      <author>Corets, Eva</author>
+      <title>Oberon's Legacy</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2001-03-10</publish_date>
+      <description>In post-apocalypse England, the mysterious 
+      agent known only as Oberon helps to create a new life 
+      for the inhabitants of London. Sequel to Maeve 
+      Ascendant.</description>
+   </book>
+   <book id="bk105">
+      <author>Corets, Eva</author>
+      <title>The Sundered Grail</title>
+      <genre>Fantasy</genre>
+      <price>5.95</price>
+      <publish_date>2001-09-10</publish_date>
+      <description>The two daughters of Maeve, half-sisters, 
+      battle one another for control of England. Sequel to 
+      Oberon's Legacy.</description>
+   </book>
+   <book id="bk106">
+      <author>Randall, Cynthia</author>
+      <title>Lover Birds</title>
+      <genre>Romance</genre>
+      <price>4.95</price>
+      <publish_date>2000-09-02</publish_date>
+      <description>When Carla meets Paul at an ornithology 
+      conference, tempers fly as feathers get ruffled.</description>
+   </book>
+   <book id="bk107">
+      <author>Thurman, Paula</author>
+      <title>Splish Splash</title>
+      <genre>Romance</genre>
+      <price>4.95</price>
+      <publish_date>2000-11-02</publish_date>
+      <description>A deep sea diver finds true love twenty 
+      thousand leagues beneath the sea.</description>
+   </book>
+   <book id="bk108">
+      <author>Knorr, Stefan</author>
+      <title>Creepy Crawlies</title>
+      <genre>Horror</genre>
+      <price>4.95</price>
+      <publish_date>2000-12-06</publish_date>
+      <description>An anthology of horror stories about roaches,
+      centipedes, scorpions  and other insects.</description>
+   </book>
+   <book id="bk109">
+      <author>Kress, Peter</author>
+      <title>Paradox Lost</title>
+      <genre>Science Fiction</genre>
+      <price>6.95</price>
+      <publish_date>2000-11-02</publish_date>
+      <description>After an inadvertant trip through a Heisenberg
+      Uncertainty Device, James Salway discovers the problems 
+      of being quantum.</description>
+   </book>
+   <book id="bk110">
+      <author>O'Brien, Tim</author>
+      <title>Microsoft .NET: The Programming Bible</title>
+      <genre>Computer</genre>
+      <price>36.95</price>
+      <publish_date>2000-12-09</publish_date>
+      <description>Microsoft's .NET initiative is explored in 
+      detail in this deep programmer's reference.</description>
+   </book>
+   <book id="bk111">
+      <author>O'Brien, Tim</author>
+      <title>MSXML3: A Comprehensive Guide</title>
+      <genre>Computer</genre>
+      <price>36.95</price>
+      <publish_date>2000-12-01</publish_date>
+      <description>The Microsoft MSXML3 parser is covered in 
+      detail, with attention to XML DOM interfaces, XSLT processing, 
+      SAX and more.</description>
+   </book>
+   <book id="bk112">
+      <author>Galos, Mike</author>
+      <title>Visual Studio 7: A Comprehensive Guide</title>
+      <genre>Computer</genre>
+      <price>49.95</price>
+      <publish_date>2001-04-16</publish_date>
+      <description>Microsoft Visual Studio 7 is explored in depth,
+      looking at how Visual Basic, Visual C++, C#, and ASP+ are 
+      integrated into a comprehensive development 
+      environment.</description>
+   </book>
+</catalog>

full-size-image-links/vendor/imangazaliev/didom/tests/fixtures/menu.html

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Document</title>
+</head>
+<body>
+    <ul>
+        <li><a href="http://example.com">Link 1</a></li>
+        <li><a href="http://example.com">Link 2<!--- Comment 1 ---></a></li>
+        <li><a href="http://example.com">Link 3<!--- Comment 2 ---></a></li>
+    </ul>
+    <!--- Comment --->
+</body>
+</html>

full-size-image-links/vendor/imangazaliev/didom/tests/fixtures/posts.html

@@ -0,0 +1,25 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Posts</title>
+</head>
+<body>
+    <h1 class="title">Posts</h1>
+    
+    <div class="posts">
+        <div class="post">
+            <h2 class="title">Lorem ipsum dolor sit amet.</h2>
+            <p class="body">Lorem ipsum dolor sit amet, consectetur adipisicing elit. Inventore autem, in accusamus doloremque temporibus dolorem.</p>
+        </div>
+        <div class="post">
+            <h2 class="title">Distinctio nisi ab in facere.</h2>
+            <p class="body">Possimus adipisci atque voluptate non, voluptatum quam, saepe architecto repellat eum quaerat sed nam, quos.</p>
+        </div>
+        <div class="post">
+            <h2 class="title">Consequatur eligendi praesentium voluptatem incidunt.</h2>
+            <p class="body">Ad magnam optio maxime cupiditate eos eum. Perferendis voluptatum atque et nobis, facilis iusto! Ipsam.</p>
+        </div>
+    </div>
+</body>
+</html>