installed plugin Infinite Uploads version 2.0.8

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/AbstractConfigurationProvider.php

@@ -0,0 +1,133 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+/**
+ * A configuration provider is a function that returns a promise that is
+ * fulfilled with a configuration object. This class provides base functionality
+ * usable by specific configuration provider implementations
+ */
+abstract class AbstractConfigurationProvider
+{
+    const ENV_PROFILE = 'AWS_PROFILE';
+    const ENV_CONFIG_FILE = 'AWS_CONFIG_FILE';
+    public static $cacheKey;
+    protected static $interfaceClass;
+    protected static $exceptionClass;
+    /**
+     * Wraps a config provider and saves provided configuration in an
+     * instance of Aws\CacheInterface. Forwards calls when no config found
+     * in cache and updates cache with the results.
+     *
+     * @param callable $provider Configuration provider function to wrap
+     * @param CacheInterface $cache Cache to store configuration
+     * @param string|null $cacheKey (optional) Cache key to use
+     *
+     * @return callable
+     */
+    public static function cache(callable $provider, \UglyRobot\Infinite_Uploads\Aws\CacheInterface $cache, $cacheKey = null)
+    {
+        $cacheKey = $cacheKey ?: static::$cacheKey;
+        return function () use($provider, $cache, $cacheKey) {
+            $found = $cache->get($cacheKey);
+            if ($found instanceof static::$interfaceClass) {
+                return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($found);
+            }
+            return $provider()->then(function ($config) use($cache, $cacheKey) {
+                $cache->set($cacheKey, $config);
+                return $config;
+            });
+        };
+    }
+    /**
+     * Creates an aggregate configuration provider that invokes the provided
+     * variadic providers one after the other until a provider returns
+     * configuration.
+     *
+     * @return callable
+     */
+    public static function chain()
+    {
+        $links = func_get_args();
+        if (empty($links)) {
+            throw new \InvalidArgumentException('No providers in chain');
+        }
+        return function () use($links) {
+            /** @var callable $parent */
+            $parent = array_shift($links);
+            $promise = $parent();
+            while ($next = array_shift($links)) {
+                $promise = $promise->otherwise($next);
+            }
+            return $promise;
+        };
+    }
+    /**
+     * Gets the environment's HOME directory if available.
+     *
+     * @return null|string
+     */
+    protected static function getHomeDir()
+    {
+        // On Linux/Unix-like systems, use the HOME environment variable
+        if ($homeDir = getenv('HOME')) {
+            return $homeDir;
+        }
+        // Get the HOMEDRIVE and HOMEPATH values for Windows hosts
+        $homeDrive = getenv('HOMEDRIVE');
+        $homePath = getenv('HOMEPATH');
+        return $homeDrive && $homePath ? $homeDrive . $homePath : null;
+    }
+    /**
+     * Gets default config file location from environment, falling back to aws
+     * default location
+     *
+     * @return string
+     */
+    protected static function getDefaultConfigFilename()
+    {
+        if ($filename = getenv(self::ENV_CONFIG_FILE)) {
+            return $filename;
+        }
+        return self::getHomeDir() . '/.aws/config';
+    }
+    /**
+     * Wraps a config provider and caches previously provided configuration.
+     *
+     * @param callable $provider Config provider function to wrap.
+     *
+     * @return callable
+     */
+    public static function memoize(callable $provider)
+    {
+        return function () use($provider) {
+            static $result;
+            static $isConstant;
+            // Constant config will be returned constantly.
+            if ($isConstant) {
+                return $result;
+            }
+            // Create the initial promise that will be used as the cached value
+            if (null === $result) {
+                $result = $provider();
+            }
+            // Return config and set flag that provider is already set
+            return $result->then(function ($config) use(&$isConstant) {
+                $isConstant = true;
+                return $config;
+            });
+        };
+    }
+    /**
+     * Reject promise with standardized exception.
+     *
+     * @param $msg
+     * @return Promise\RejectedPromise
+     */
+    protected static function reject($msg)
+    {
+        $exceptionClass = static::$exceptionClass;
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\RejectedPromise(new $exceptionClass($msg));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/AbstractModel.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Base class that is used by most API shapes
+ */
+abstract class AbstractModel implements \ArrayAccess
+{
+    /** @var array */
+    protected $definition;
+    /** @var ShapeMap */
+    protected $shapeMap;
+    /**
+     * @param array    $definition Service description
+     * @param ShapeMap $shapeMap   Shapemap used for creating shapes
+     */
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $this->definition = $definition;
+        $this->shapeMap = $shapeMap;
+    }
+    public function toArray()
+    {
+        return $this->definition;
+    }
+    public function offsetGet($offset)
+    {
+        return isset($this->definition[$offset]) ? $this->definition[$offset] : null;
+    }
+    public function offsetSet($offset, $value)
+    {
+        $this->definition[$offset] = $value;
+    }
+    public function offsetExists($offset)
+    {
+        return isset($this->definition[$offset]);
+    }
+    public function offsetUnset($offset)
+    {
+        unset($this->definition[$offset]);
+    }
+    protected function shapeAt($key)
+    {
+        if (!isset($this->definition[$key])) {
+            throw new \InvalidArgumentException('Expected shape definition at ' . $key);
+        }
+        return $this->shapeFor($this->definition[$key]);
+    }
+    protected function shapeFor(array $definition)
+    {
+        return isset($definition['shape']) ? $this->shapeMap->resolve($definition) : \UglyRobot\Infinite_Uploads\Aws\Api\Shape::create($definition, $this->shapeMap);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ApiProvider.php

@@ -0,0 +1,212 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\UnresolvedApiException;
+/**
+ * API providers.
+ *
+ * An API provider is a function that accepts a type, service, and version and
+ * returns an array of API data on success or NULL if no API data can be created
+ * for the provided arguments.
+ *
+ * You can wrap your calls to an API provider with the
+ * {@see ApiProvider::resolve} method to ensure that API data is created. If the
+ * API data is not created, then the resolve() method will throw a
+ * {@see Aws\Exception\UnresolvedApiException}.
+ *
+ *     use Aws\Api\ApiProvider;
+ *     $provider = ApiProvider::defaultProvider();
+ *     // Returns an array or NULL.
+ *     $data = $provider('api', 's3', '2006-03-01');
+ *     // Returns an array or throws.
+ *     $data = ApiProvider::resolve($provider, 'api', 'elasticfood', '2020-01-01');
+ *
+ * You can compose multiple providers into a single provider using
+ * {@see Aws\or_chain}. This method accepts providers as arguments and
+ * returns a new function that will invoke each provider until a non-null value
+ * is returned.
+ *
+ *     $a = ApiProvider::filesystem(sys_get_temp_dir() . '/aws-beta-models');
+ *     $b = ApiProvider::manifest();
+ *
+ *     $c = \Aws\or_chain($a, $b);
+ *     $data = $c('api', 'betaservice', '2015-08-08'); // $a handles this.
+ *     $data = $c('api', 's3', '2006-03-01');          // $b handles this.
+ *     $data = $c('api', 'invalid', '2014-12-15');     // Neither handles this.
+ */
+class ApiProvider
+{
+    /** @var array A map of public API type names to their file suffix. */
+    private static $typeMap = ['api' => 'api-2', 'paginator' => 'paginators-1', 'waiter' => 'waiters-2', 'docs' => 'docs-2'];
+    /** @var array API manifest */
+    private $manifest;
+    /** @var string The directory containing service models. */
+    private $modelsDir;
+    /**
+     * Resolves an API provider and ensures a non-null return value.
+     *
+     * @param callable $provider Provider function to invoke.
+     * @param string   $type     Type of data ('api', 'waiter', 'paginator').
+     * @param string   $service  Service name.
+     * @param string   $version  API version.
+     *
+     * @return array
+     * @throws UnresolvedApiException
+     */
+    public static function resolve(callable $provider, $type, $service, $version)
+    {
+        // Execute the provider and return the result, if there is one.
+        $result = $provider($type, $service, $version);
+        if (is_array($result)) {
+            if (!isset($result['metadata']['serviceIdentifier'])) {
+                $result['metadata']['serviceIdentifier'] = $service;
+            }
+            return $result;
+        }
+        // Throw an exception with a message depending on the inputs.
+        if (!isset(self::$typeMap[$type])) {
+            $msg = "The type must be one of: " . implode(', ', self::$typeMap);
+        } elseif ($service) {
+            $msg = "The {$service} service does not have version: {$version}.";
+        } else {
+            $msg = "You must specify a service name to retrieve its API data.";
+        }
+        throw new \UglyRobot\Infinite_Uploads\Aws\Exception\UnresolvedApiException($msg);
+    }
+    /**
+     * Default SDK API provider.
+     *
+     * This provider loads pre-built manifest data from the `data` directory.
+     *
+     * @return self
+     */
+    public static function defaultProvider()
+    {
+        return new self(__DIR__ . '/../data', \UglyRobot\Infinite_Uploads\Aws\manifest());
+    }
+    /**
+     * Loads API data after resolving the version to the latest, compatible,
+     * available version based on the provided manifest data.
+     *
+     * Manifest data is essentially an associative array of service names to
+     * associative arrays of API version aliases.
+     *
+     * [
+     *   ...
+     *   'ec2' => [
+     *     'latest'     => '2014-10-01',
+     *     '2014-10-01' => '2014-10-01',
+     *     '2014-09-01' => '2014-10-01',
+     *     '2014-06-15' => '2014-10-01',
+     *     ...
+     *   ],
+     *   'ecs' => [...],
+     *   'elasticache' => [...],
+     *   ...
+     * ]
+     *
+     * @param string $dir      Directory containing service models.
+     * @param array  $manifest The API version manifest data.
+     *
+     * @return self
+     */
+    public static function manifest($dir, array $manifest)
+    {
+        return new self($dir, $manifest);
+    }
+    /**
+     * Loads API data from the specified directory.
+     *
+     * If "latest" is specified as the version, this provider must glob the
+     * directory to find which is the latest available version.
+     *
+     * @param string $dir Directory containing service models.
+     *
+     * @return self
+     * @throws \InvalidArgumentException if the provided `$dir` is invalid.
+     */
+    public static function filesystem($dir)
+    {
+        return new self($dir);
+    }
+    /**
+     * Retrieves a list of valid versions for the specified service.
+     *
+     * @param string $service Service name
+     *
+     * @return array
+     */
+    public function getVersions($service)
+    {
+        if (!isset($this->manifest)) {
+            $this->buildVersionsList($service);
+        }
+        if (!isset($this->manifest[$service]['versions'])) {
+            return [];
+        }
+        return array_values(array_unique($this->manifest[$service]['versions']));
+    }
+    /**
+     * Execute the provider.
+     *
+     * @param string $type    Type of data ('api', 'waiter', 'paginator').
+     * @param string $service Service name.
+     * @param string $version API version.
+     *
+     * @return array|null
+     */
+    public function __invoke($type, $service, $version)
+    {
+        // Resolve the type or return null.
+        if (isset(self::$typeMap[$type])) {
+            $type = self::$typeMap[$type];
+        } else {
+            return null;
+        }
+        // Resolve the version or return null.
+        if (!isset($this->manifest)) {
+            $this->buildVersionsList($service);
+        }
+        if (!isset($this->manifest[$service]['versions'][$version])) {
+            return null;
+        }
+        $version = $this->manifest[$service]['versions'][$version];
+        $path = "{$this->modelsDir}/{$service}/{$version}/{$type}.json";
+        try {
+            return \UglyRobot\Infinite_Uploads\Aws\load_compiled_json($path);
+        } catch (\InvalidArgumentException $e) {
+            return null;
+        }
+    }
+    /**
+     * @param string $modelsDir Directory containing service models.
+     * @param array  $manifest  The API version manifest data.
+     */
+    private function __construct($modelsDir, array $manifest = null)
+    {
+        $this->manifest = $manifest;
+        $this->modelsDir = rtrim($modelsDir, '/');
+        if (!is_dir($this->modelsDir)) {
+            throw new \InvalidArgumentException("The specified models directory, {$modelsDir}, was not found.");
+        }
+    }
+    /**
+     * Build the versions list for the specified service by globbing the dir.
+     */
+    private function buildVersionsList($service)
+    {
+        $dir = "{$this->modelsDir}/{$service}/";
+        if (!is_dir($dir)) {
+            return;
+        }
+        // Get versions, remove . and .., and sort in descending order.
+        $results = array_diff(scandir($dir, SCANDIR_SORT_DESCENDING), ['..', '.']);
+        if (!$results) {
+            $this->manifest[$service] = ['versions' => []];
+        } else {
+            $this->manifest[$service] = ['versions' => ['latest' => $results[0]]];
+            $this->manifest[$service]['versions'] += array_combine($results, $results);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/DateTimeResult.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException;
+use Exception;
+/**
+ * DateTime overrides that make DateTime work more seamlessly as a string,
+ * with JSON documents, and with JMESPath.
+ */
+class DateTimeResult extends \DateTime implements \JsonSerializable
+{
+    /**
+     * Create a new DateTimeResult from a unix timestamp.
+     * The Unix epoch (or Unix time or POSIX time or Unix
+     * timestamp) is the number of seconds that have elapsed since
+     * January 1, 1970 (midnight UTC/GMT).
+     * @param $unixTimestamp
+     *
+     * @return DateTimeResult
+     * @throws Exception
+     */
+    public static function fromEpoch($unixTimestamp)
+    {
+        return new self(gmdate('c', $unixTimestamp));
+    }
+    /**
+     * @param $iso8601Timestamp
+     *
+     * @return DateTimeResult
+     */
+    public static function fromISO8601($iso8601Timestamp)
+    {
+        if (is_numeric($iso8601Timestamp) || !is_string($iso8601Timestamp)) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Invalid timestamp value passed to DateTimeResult::fromISO8601');
+        }
+        return new \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult($iso8601Timestamp);
+    }
+    /**
+     * Create a new DateTimeResult from an unknown timestamp.
+     *
+     * @param $timestamp
+     *
+     * @return DateTimeResult
+     * @throws ParserException|Exception
+     */
+    public static function fromTimestamp($timestamp, $expectedFormat = null)
+    {
+        if (empty($timestamp)) {
+            return self::fromEpoch(0);
+        }
+        if (!(is_string($timestamp) || is_numeric($timestamp))) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp');
+        }
+        try {
+            if ($expectedFormat == 'iso8601') {
+                try {
+                    return self::fromISO8601($timestamp);
+                } catch (Exception $exception) {
+                    return self::fromEpoch($timestamp);
+                }
+            } else {
+                if ($expectedFormat == 'unixTimestamp') {
+                    try {
+                        return self::fromEpoch($timestamp);
+                    } catch (Exception $exception) {
+                        return self::fromISO8601($timestamp);
+                    }
+                } else {
+                    if (\UglyRobot\Infinite_Uploads\Aws\is_valid_epoch($timestamp)) {
+                        return self::fromEpoch($timestamp);
+                    }
+                }
+            }
+            return self::fromISO8601($timestamp);
+        } catch (Exception $exception) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Invalid timestamp value passed to DateTimeResult::fromTimestamp');
+        }
+    }
+    /**
+     * Serialize the DateTimeResult as an ISO 8601 date string.
+     *
+     * @return string
+     */
+    public function __toString()
+    {
+        return $this->format('c');
+    }
+    /**
+     * Serialize the date as an ISO 8601 date when serializing as JSON.
+     *
+     * @return mixed|string
+     */
+    public function jsonSerialize()
+    {
+        return (string) $this;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/DocModel.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Encapsulates the documentation strings for a given service-version and
+ * provides methods for extracting the desired parts related to a service,
+ * operation, error, or shape (i.e., parameter).
+ */
+class DocModel
+{
+    /** @var array */
+    private $docs;
+    /**
+     * @param array $docs
+     *
+     * @throws \RuntimeException
+     */
+    public function __construct(array $docs)
+    {
+        if (!extension_loaded('tidy')) {
+            throw new \RuntimeException('The "tidy" PHP extension is required.');
+        }
+        $this->docs = $docs;
+    }
+    /**
+     * Convert the doc model to an array.
+     *
+     * @return array
+     */
+    public function toArray()
+    {
+        return $this->docs;
+    }
+    /**
+     * Retrieves documentation about the service.
+     *
+     * @return null|string
+     */
+    public function getServiceDocs()
+    {
+        return isset($this->docs['service']) ? $this->docs['service'] : null;
+    }
+    /**
+     * Retrieves documentation about an operation.
+     *
+     * @param string $operation Name of the operation
+     *
+     * @return null|string
+     */
+    public function getOperationDocs($operation)
+    {
+        return isset($this->docs['operations'][$operation]) ? $this->docs['operations'][$operation] : null;
+    }
+    /**
+     * Retrieves documentation about an error.
+     *
+     * @param string $error Name of the error
+     *
+     * @return null|string
+     */
+    public function getErrorDocs($error)
+    {
+        return isset($this->docs['shapes'][$error]['base']) ? $this->docs['shapes'][$error]['base'] : null;
+    }
+    /**
+     * Retrieves documentation about a shape, specific to the context.
+     *
+     * @param string $shapeName  Name of the shape.
+     * @param string $parentName Name of the parent/context shape.
+     * @param string $ref        Name used by the context to reference the shape.
+     *
+     * @return null|string
+     */
+    public function getShapeDocs($shapeName, $parentName, $ref)
+    {
+        if (!isset($this->docs['shapes'][$shapeName])) {
+            return '';
+        }
+        $result = '';
+        $d = $this->docs['shapes'][$shapeName];
+        if (isset($d['refs']["{$parentName}\${$ref}"])) {
+            $result = $d['refs']["{$parentName}\${$ref}"];
+        } elseif (isset($d['base'])) {
+            $result = $d['base'];
+        }
+        if (isset($d['append'])) {
+            $result .= $d['append'];
+        }
+        return $this->clean($result);
+    }
+    private function clean($content)
+    {
+        if (!$content) {
+            return '';
+        }
+        $tidy = new \tidy();
+        $tidy->parseString($content, ['indent' => true, 'doctype' => 'omit', 'output-html' => true, 'show-body-only' => true, 'drop-empty-paras' => true, 'drop-font-tags' => true, 'drop-proprietary-attributes' => true, 'hide-comments' => true, 'logical-emphasis' => true]);
+        $tidy->cleanRepair();
+        return (string) $content;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ErrorParser/AbstractErrorParser.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\MetadataParserTrait;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\PayloadParserTrait;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+abstract class AbstractErrorParser
+{
+    use MetadataParserTrait;
+    use PayloadParserTrait;
+    /**
+     * @var Service
+     */
+    protected $api;
+    /**
+     * @param Service $api
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api = null)
+    {
+        $this->api = $api;
+    }
+    protected abstract function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member);
+    protected function extractPayload(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        if ($member instanceof StructureShape) {
+            // Structure members parse top-level data into a specific key.
+            return $this->payload($response, $member);
+        } else {
+            // Streaming data is just the stream from the response body.
+            return $response->getBody();
+        }
+    }
+    protected function populateShape(array &$data, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\CommandInterface $command = null)
+    {
+        $data['body'] = [];
+        if (!empty($command) && !empty($this->api)) {
+            // If modeled error code is indicated, check for known error shape
+            if (!empty($data['code'])) {
+                $errors = $this->api->getOperation($command->getName())->getErrors();
+                foreach ($errors as $key => $error) {
+                    // If error code matches a known error shape, populate the body
+                    if ($data['code'] == $error['name'] && $error instanceof StructureShape) {
+                        $modeledError = $error;
+                        $data['body'] = $this->extractPayload($modeledError, $response);
+                        $data['error_shape'] = $modeledError;
+                        foreach ($error->getMembers() as $name => $member) {
+                            switch ($member['location']) {
+                                case 'header':
+                                    $this->extractHeader($name, $member, $response, $data['body']);
+                                    break;
+                                case 'headers':
+                                    $this->extractHeaders($name, $member, $response, $data['body']);
+                                    break;
+                                case 'statusCode':
+                                    $this->extractStatus($name, $response, $data['body']);
+                                    break;
+                            }
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        return $data;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ErrorParser/JsonParserTrait.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\PayloadParserTrait;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Provides basic JSON error parsing functionality.
+ */
+trait JsonParserTrait
+{
+    use PayloadParserTrait;
+    private function genericHandler(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        $code = (string) $response->getStatusCode();
+        return ['request_id' => (string) $response->getHeaderLine('x-amzn-requestid'), 'code' => null, 'message' => null, 'type' => $code[0] == '4' ? 'client' : 'server', 'parsed' => $this->parseJson($response->getBody(), $response)];
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member)
+    {
+        $jsonBody = $this->parseJson($response->getBody(), $response);
+        if ($jsonBody) {
+            return $this->parser->parse($member, $jsonBody);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ErrorParser/JsonRpcErrorParser.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Parsers JSON-RPC errors.
+ */
+class JsonRpcErrorParser extends \UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser\AbstractErrorParser
+{
+    use JsonParserTrait;
+    private $parser;
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api = null, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser();
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\CommandInterface $command = null)
+    {
+        $data = $this->genericHandler($response);
+        // Make the casing consistent across services.
+        if ($data['parsed']) {
+            $data['parsed'] = array_change_key_case($data['parsed']);
+        }
+        if (isset($data['parsed']['__type'])) {
+            $parts = explode('#', $data['parsed']['__type']);
+            $data['code'] = isset($parts[1]) ? $parts[1] : $parts[0];
+            $data['message'] = isset($data['parsed']['message']) ? $data['parsed']['message'] : null;
+        }
+        $this->populateShape($data, $response, $command);
+        return $data;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ErrorParser/RestJsonErrorParser.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Parses JSON-REST errors.
+ */
+class RestJsonErrorParser extends \UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser\AbstractErrorParser
+{
+    use JsonParserTrait;
+    private $parser;
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api = null, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser();
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\CommandInterface $command = null)
+    {
+        $data = $this->genericHandler($response);
+        // Merge in error data from the JSON body
+        if ($json = $data['parsed']) {
+            $data = array_replace($data, $json);
+        }
+        // Correct error type from services like Amazon Glacier
+        if (!empty($data['type'])) {
+            $data['type'] = strtolower($data['type']);
+        }
+        // Retrieve the error code from services like Amazon Elastic Transcoder
+        if ($code = $response->getHeaderLine('x-amzn-errortype')) {
+            $colon = strpos($code, ':');
+            $data['code'] = $colon ? substr($code, 0, $colon) : $code;
+        }
+        // Retrieve error message directly
+        $data['message'] = isset($data['parsed']['message']) ? $data['parsed']['message'] : (isset($data['parsed']['Message']) ? $data['parsed']['Message'] : null);
+        $this->populateShape($data, $response, $command);
+        return $data;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ErrorParser/XmlErrorParser.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\PayloadParserTrait;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Parses XML errors.
+ */
+class XmlErrorParser extends \UglyRobot\Infinite_Uploads\Aws\Api\ErrorParser\AbstractErrorParser
+{
+    use PayloadParserTrait;
+    protected $parser;
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api = null, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser();
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\CommandInterface $command = null)
+    {
+        $code = (string) $response->getStatusCode();
+        $data = ['type' => $code[0] == '4' ? 'client' : 'server', 'request_id' => null, 'code' => null, 'message' => null, 'parsed' => null];
+        $body = $response->getBody();
+        if ($body->getSize() > 0) {
+            $this->parseBody($this->parseXml($body, $response), $data);
+        } else {
+            $this->parseHeaders($response, $data);
+        }
+        $this->populateShape($data, $response, $command);
+        return $data;
+    }
+    private function parseHeaders(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, array &$data)
+    {
+        if ($response->getStatusCode() == '404') {
+            $data['code'] = 'NotFound';
+        }
+        $data['message'] = $response->getStatusCode() . ' ' . $response->getReasonPhrase();
+        if ($requestId = $response->getHeaderLine('x-amz-request-id')) {
+            $data['request_id'] = $requestId;
+            $data['message'] .= " (Request-ID: {$requestId})";
+        }
+    }
+    private function parseBody(\SimpleXMLElement $body, array &$data)
+    {
+        $data['parsed'] = $body;
+        $prefix = $this->registerNamespacePrefix($body);
+        if ($tempXml = $body->xpath("//{$prefix}Code[1]")) {
+            $data['code'] = (string) $tempXml[0];
+        }
+        if ($tempXml = $body->xpath("//{$prefix}Message[1]")) {
+            $data['message'] = (string) $tempXml[0];
+        }
+        $tempXml = $body->xpath("//{$prefix}RequestId[1]");
+        if (isset($tempXml[0])) {
+            $data['request_id'] = (string) $tempXml[0];
+        }
+    }
+    protected function registerNamespacePrefix(\SimpleXMLElement $element)
+    {
+        $namespaces = $element->getDocNamespaces();
+        if (!isset($namespaces[''])) {
+            return '';
+        }
+        // Account for the default namespace being defined and PHP not
+        // being able to handle it :(.
+        $element->registerXPathNamespace('ns', $namespaces['']);
+        return 'ns:';
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member)
+    {
+        $xmlBody = $this->parseXml($response->getBody(), $response);
+        $prefix = $this->registerNamespacePrefix($xmlBody);
+        $errorBody = $xmlBody->xpath("//{$prefix}Error");
+        if (is_array($errorBody) && !empty($errorBody[0])) {
+            return $this->parser->parse($member, $errorBody[0]);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ListShape.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Represents a list shape.
+ */
+class ListShape extends \UglyRobot\Infinite_Uploads\Aws\Api\Shape
+{
+    private $member;
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'list';
+        parent::__construct($definition, $shapeMap);
+    }
+    /**
+     * @return Shape
+     * @throws \RuntimeException if no member is specified
+     */
+    public function getMember()
+    {
+        if (!$this->member) {
+            if (!isset($this->definition['member'])) {
+                throw new \RuntimeException('No member attribute specified');
+            }
+            $this->member = \UglyRobot\Infinite_Uploads\Aws\Api\Shape::create($this->definition['member'], $this->shapeMap);
+        }
+        return $this->member;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/MapShape.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Represents a map shape.
+ */
+class MapShape extends \UglyRobot\Infinite_Uploads\Aws\Api\Shape
+{
+    /** @var Shape */
+    private $value;
+    /** @var Shape */
+    private $key;
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'map';
+        parent::__construct($definition, $shapeMap);
+    }
+    /**
+     * @return Shape
+     * @throws \RuntimeException if no value is specified
+     */
+    public function getValue()
+    {
+        if (!$this->value) {
+            if (!isset($this->definition['value'])) {
+                throw new \RuntimeException('No value specified');
+            }
+            $this->value = \UglyRobot\Infinite_Uploads\Aws\Api\Shape::create($this->definition['value'], $this->shapeMap);
+        }
+        return $this->value;
+    }
+    /**
+     * @return Shape
+     */
+    public function getKey()
+    {
+        if (!$this->key) {
+            $this->key = isset($this->definition['key']) ? \UglyRobot\Infinite_Uploads\Aws\Api\Shape::create($this->definition['key'], $this->shapeMap) : new \UglyRobot\Infinite_Uploads\Aws\Api\Shape(['type' => 'string'], $this->shapeMap);
+        }
+        return $this->key;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Operation.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Represents an API operation.
+ */
+class Operation extends \UglyRobot\Infinite_Uploads\Aws\Api\AbstractModel
+{
+    private $input;
+    private $output;
+    private $errors;
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'structure';
+        if (!isset($definition['http']['method'])) {
+            $definition['http']['method'] = 'POST';
+        }
+        if (!isset($definition['http']['requestUri'])) {
+            $definition['http']['requestUri'] = '/';
+        }
+        parent::__construct($definition, $shapeMap);
+    }
+    /**
+     * Returns an associative array of the HTTP attribute of the operation:
+     *
+     * - method: HTTP method of the operation
+     * - requestUri: URI of the request (can include URI template placeholders)
+     *
+     * @return array
+     */
+    public function getHttp()
+    {
+        return $this->definition['http'];
+    }
+    /**
+     * Get the input shape of the operation.
+     *
+     * @return StructureShape
+     */
+    public function getInput()
+    {
+        if (!$this->input) {
+            if ($input = $this['input']) {
+                $this->input = $this->shapeFor($input);
+            } else {
+                $this->input = new \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape([], $this->shapeMap);
+            }
+        }
+        return $this->input;
+    }
+    /**
+     * Get the output shape of the operation.
+     *
+     * @return StructureShape
+     */
+    public function getOutput()
+    {
+        if (!$this->output) {
+            if ($output = $this['output']) {
+                $this->output = $this->shapeFor($output);
+            } else {
+                $this->output = new \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape([], $this->shapeMap);
+            }
+        }
+        return $this->output;
+    }
+    /**
+     * Get an array of operation error shapes.
+     *
+     * @return Shape[]
+     */
+    public function getErrors()
+    {
+        if ($this->errors === null) {
+            if ($errors = $this['errors']) {
+                foreach ($errors as $key => $error) {
+                    $errors[$key] = $this->shapeFor($error);
+                }
+                $this->errors = $errors;
+            } else {
+                $this->errors = [];
+            }
+        }
+        return $this->errors;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/AbstractParser.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal
+ */
+abstract class AbstractParser
+{
+    /** @var \Aws\Api\Service Representation of the service API*/
+    protected $api;
+    /** @var callable */
+    protected $parser;
+    /**
+     * @param Service $api Service description.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api)
+    {
+        $this->api = $api;
+    }
+    /**
+     * @param CommandInterface  $command  Command that was executed.
+     * @param ResponseInterface $response Response that was received.
+     *
+     * @return ResultInterface
+     */
+    public abstract function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response);
+    public abstract function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/AbstractRestParser.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Result;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * @internal
+ */
+abstract class AbstractRestParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractParser
+{
+    use PayloadParserTrait;
+    /**
+     * Parses a payload from a response.
+     *
+     * @param ResponseInterface $response Response to parse.
+     * @param StructureShape    $member   Member to parse
+     * @param array             $result   Result value
+     *
+     * @return mixed
+     */
+    protected abstract function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array &$result);
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        $output = $this->api->getOperation($command->getName())->getOutput();
+        $result = [];
+        if ($payload = $output['payload']) {
+            $this->extractPayload($payload, $output, $response, $result);
+        }
+        foreach ($output->getMembers() as $name => $member) {
+            switch ($member['location']) {
+                case 'header':
+                    $this->extractHeader($name, $member, $response, $result);
+                    break;
+                case 'headers':
+                    $this->extractHeaders($name, $member, $response, $result);
+                    break;
+                case 'statusCode':
+                    $this->extractStatus($name, $response, $result);
+                    break;
+            }
+        }
+        if (!$payload && $response->getBody()->getSize() > 0 && count($output->getMembers()) > 0) {
+            // if no payload was found, then parse the contents of the body
+            $this->payload($response, $output, $result);
+        }
+        return new \UglyRobot\Infinite_Uploads\Aws\Result($result);
+    }
+    private function extractPayload($payload, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $output, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, array &$result)
+    {
+        $member = $output->getMember($payload);
+        if (!empty($member['eventstream'])) {
+            $result[$payload] = new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\EventParsingIterator($response->getBody(), $member, $this);
+        } else {
+            if ($member instanceof StructureShape) {
+                // Structure members parse top-level data into a specific key.
+                $result[$payload] = [];
+                $this->payload($response, $member, $result[$payload]);
+            } else {
+                // Streaming data is just the stream from the response body.
+                $result[$payload] = $response->getBody();
+            }
+        }
+    }
+    /**
+     * Extract a single header from the response into the result.
+     */
+    private function extractHeader($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, &$result)
+    {
+        $value = $response->getHeaderLine($shape['locationName'] ?: $name);
+        switch ($shape->getType()) {
+            case 'float':
+            case 'double':
+                $value = (double) $value;
+                break;
+            case 'long':
+                $value = (int) $value;
+                break;
+            case 'boolean':
+                $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+                break;
+            case 'blob':
+                $value = base64_decode($value);
+                break;
+            case 'timestamp':
+                try {
+                    $value = \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult::fromTimestamp($value, !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null);
+                    break;
+                } catch (\Exception $e) {
+                    // If the value cannot be parsed, then do not add it to the
+                    // output structure.
+                    return;
+                }
+            case 'string':
+                try {
+                    if ($shape['jsonvalue']) {
+                        $value = $this->parseJson(base64_decode($value), $response);
+                    }
+                    // If value is not set, do not add to output structure.
+                    if (!isset($value)) {
+                        return;
+                    }
+                    break;
+                } catch (\Exception $e) {
+                    //If the value cannot be parsed, then do not add it to the
+                    //output structure.
+                    return;
+                }
+        }
+        $result[$name] = $value;
+    }
+    /**
+     * Extract a map of headers with an optional prefix from the response.
+     */
+    private function extractHeaders($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, &$result)
+    {
+        // Check if the headers are prefixed by a location name
+        $result[$name] = [];
+        $prefix = $shape['locationName'];
+        $prefixLen = strlen($prefix);
+        foreach ($response->getHeaders() as $k => $values) {
+            if (!$prefixLen) {
+                $result[$name][$k] = implode(', ', $values);
+            } elseif (stripos($k, $prefix) === 0) {
+                $result[$name][substr($k, $prefixLen)] = implode(', ', $values);
+            }
+        }
+    }
+    /**
+     * Places the status code of the response into the result array.
+     */
+    private function extractStatus($name, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, array &$result)
+    {
+        $result[$name] = (int) $response->getStatusCode();
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/Crc32ValidatingParser.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+/**
+ * @internal Decorates a parser and validates the x-amz-crc32 header.
+ */
+class Crc32ValidatingParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractParser
+{
+    /**
+     * @param callable $parser Parser to wrap.
+     */
+    public function __construct(callable $parser)
+    {
+        $this->parser = $parser;
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        if ($expected = $response->getHeaderLine('x-amz-crc32')) {
+            $hash = hexdec(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\hash($response->getBody(), 'crc32b'));
+            if ($expected != $hash) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Exception\AwsException("crc32 mismatch. Expected {$expected}, found {$hash}.", $command, ['code' => 'ClientChecksumMismatch', 'connection_error' => true, 'response' => $response]);
+            }
+        }
+        $fn = $this->parser;
+        return $fn($command, $response);
+    }
+    public function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response)
+    {
+        return $this->parser->parseMemberFromStream($stream, $member, $response);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/DecodingEventStreamIterator.php

@@ -0,0 +1,241 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use Iterator;
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException;
+/**
+ * @internal Implements a decoder for a binary encoded event stream that will
+ * decode, validate, and provide individual events from the stream.
+ */
+class DecodingEventStreamIterator implements \Iterator
+{
+    const HEADERS = 'headers';
+    const PAYLOAD = 'payload';
+    const LENGTH_TOTAL = 'total_length';
+    const LENGTH_HEADERS = 'headers_length';
+    const CRC_PRELUDE = 'prelude_crc';
+    const BYTES_PRELUDE = 12;
+    const BYTES_TRAILING = 4;
+    private static $preludeFormat = [self::LENGTH_TOTAL => 'decodeUint32', self::LENGTH_HEADERS => 'decodeUint32', self::CRC_PRELUDE => 'decodeUint32'];
+    private static $lengthFormatMap = [1 => 'decodeUint8', 2 => 'decodeUint16', 4 => 'decodeUint32', 8 => 'decodeUint64'];
+    private static $headerTypeMap = [0 => 'decodeBooleanTrue', 1 => 'decodeBooleanFalse', 2 => 'decodeInt8', 3 => 'decodeInt16', 4 => 'decodeInt32', 5 => 'decodeInt64', 6 => 'decodeBytes', 7 => 'decodeString', 8 => 'decodeTimestamp', 9 => 'decodeUuid'];
+    /** @var StreamInterface Stream of eventstream shape to parse. */
+    private $stream;
+    /** @var array Currently parsed event. */
+    private $currentEvent;
+    /** @var int Current in-order event key. */
+    private $key;
+    /** @var resource|\HashContext CRC32 hash context for event validation */
+    private $hashContext;
+    /** @var int $currentPosition */
+    private $currentPosition;
+    /**
+     * DecodingEventStreamIterator constructor.
+     *
+     * @param StreamInterface $stream
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream)
+    {
+        $this->stream = $stream;
+        $this->rewind();
+    }
+    private function parseHeaders($headerBytes)
+    {
+        $headers = [];
+        $bytesRead = 0;
+        while ($bytesRead < $headerBytes) {
+            list($key, $numBytes) = $this->decodeString(1);
+            $bytesRead += $numBytes;
+            list($type, $numBytes) = $this->decodeUint8();
+            $bytesRead += $numBytes;
+            $f = self::$headerTypeMap[$type];
+            list($value, $numBytes) = $this->{$f}();
+            $bytesRead += $numBytes;
+            if (isset($headers[$key])) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Duplicate key in event headers.');
+            }
+            $headers[$key] = $value;
+        }
+        return [$headers, $bytesRead];
+    }
+    private function parsePrelude()
+    {
+        $prelude = [];
+        $bytesRead = 0;
+        $calculatedCrc = null;
+        foreach (self::$preludeFormat as $key => $decodeFunction) {
+            if ($key === self::CRC_PRELUDE) {
+                $hashCopy = hash_copy($this->hashContext);
+                $calculatedCrc = hash_final($this->hashContext, true);
+                $this->hashContext = $hashCopy;
+            }
+            list($value, $numBytes) = $this->{$decodeFunction}();
+            $bytesRead += $numBytes;
+            $prelude[$key] = $value;
+        }
+        if (unpack('N', $calculatedCrc)[1] !== $prelude[self::CRC_PRELUDE]) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Prelude checksum mismatch.');
+        }
+        return [$prelude, $bytesRead];
+    }
+    private function parseEvent()
+    {
+        $event = [];
+        if ($this->stream->tell() < $this->stream->getSize()) {
+            $this->hashContext = hash_init('crc32b');
+            $bytesLeft = $this->stream->getSize() - $this->stream->tell();
+            list($prelude, $numBytes) = $this->parsePrelude();
+            if ($prelude[self::LENGTH_TOTAL] > $bytesLeft) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Message length too long.');
+            }
+            $bytesLeft -= $numBytes;
+            if ($prelude[self::LENGTH_HEADERS] > $bytesLeft) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Headers length too long.');
+            }
+            list($event[self::HEADERS], $numBytes) = $this->parseHeaders($prelude[self::LENGTH_HEADERS]);
+            $event[self::PAYLOAD] = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($this->readAndHashBytes($prelude[self::LENGTH_TOTAL] - self::BYTES_PRELUDE - $numBytes - self::BYTES_TRAILING));
+            $calculatedCrc = hash_final($this->hashContext, true);
+            $messageCrc = $this->stream->read(4);
+            if ($calculatedCrc !== $messageCrc) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Message checksum mismatch.');
+            }
+        }
+        return $event;
+    }
+    // Iterator Functionality
+    /**
+     * @return array
+     */
+    public function current()
+    {
+        return $this->currentEvent;
+    }
+    /**
+     * @return int
+     */
+    public function key()
+    {
+        return $this->key;
+    }
+    public function next()
+    {
+        $this->currentPosition = $this->stream->tell();
+        if ($this->valid()) {
+            $this->key++;
+            $this->currentEvent = $this->parseEvent();
+        }
+    }
+    public function rewind()
+    {
+        $this->stream->rewind();
+        $this->key = 0;
+        $this->currentPosition = 0;
+        $this->currentEvent = $this->parseEvent();
+    }
+    /**
+     * @return bool
+     */
+    public function valid()
+    {
+        return $this->currentPosition < $this->stream->getSize();
+    }
+    // Decoding Utilities
+    private function readAndHashBytes($num)
+    {
+        $bytes = $this->stream->read($num);
+        hash_update($this->hashContext, $bytes);
+        return $bytes;
+    }
+    private function decodeBooleanTrue()
+    {
+        return [true, 0];
+    }
+    private function decodeBooleanFalse()
+    {
+        return [false, 0];
+    }
+    private function uintToInt($val, $size)
+    {
+        $signedCap = pow(2, $size - 1);
+        if ($val > $signedCap) {
+            $val -= 2 * $signedCap;
+        }
+        return $val;
+    }
+    private function decodeInt8()
+    {
+        $val = (int) unpack('C', $this->readAndHashBytes(1))[1];
+        return [$this->uintToInt($val, 8), 1];
+    }
+    private function decodeUint8()
+    {
+        return [unpack('C', $this->readAndHashBytes(1))[1], 1];
+    }
+    private function decodeInt16()
+    {
+        $val = (int) unpack('n', $this->readAndHashBytes(2))[1];
+        return [$this->uintToInt($val, 16), 2];
+    }
+    private function decodeUint16()
+    {
+        return [unpack('n', $this->readAndHashBytes(2))[1], 2];
+    }
+    private function decodeInt32()
+    {
+        $val = (int) unpack('N', $this->readAndHashBytes(4))[1];
+        return [$this->uintToInt($val, 32), 4];
+    }
+    private function decodeUint32()
+    {
+        return [unpack('N', $this->readAndHashBytes(4))[1], 4];
+    }
+    private function decodeInt64()
+    {
+        $val = $this->unpackInt64($this->readAndHashBytes(8))[1];
+        return [$this->uintToInt($val, 64), 8];
+    }
+    private function decodeUint64()
+    {
+        return [$this->unpackInt64($this->readAndHashBytes(8))[1], 8];
+    }
+    private function unpackInt64($bytes)
+    {
+        if (version_compare(PHP_VERSION, '5.6.3', '<')) {
+            $d = unpack('N2', $bytes);
+            return [1 => $d[1] << 32 | $d[2]];
+        }
+        return unpack('J', $bytes);
+    }
+    private function decodeBytes($lengthBytes = 2)
+    {
+        if (!isset(self::$lengthFormatMap[$lengthBytes])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Undefined variable length format.');
+        }
+        $f = self::$lengthFormatMap[$lengthBytes];
+        list($len, $bytes) = $this->{$f}();
+        return [$this->readAndHashBytes($len), $len + $bytes];
+    }
+    private function decodeString($lengthBytes = 2)
+    {
+        if (!isset(self::$lengthFormatMap[$lengthBytes])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Undefined variable length format.');
+        }
+        $f = self::$lengthFormatMap[$lengthBytes];
+        list($len, $bytes) = $this->{$f}();
+        return [$this->readAndHashBytes($len), $len + $bytes];
+    }
+    private function decodeTimestamp()
+    {
+        list($val, $bytes) = $this->decodeInt64();
+        return [\UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult::createFromFormat('U.u', $val / 1000), $bytes];
+    }
+    private function decodeUuid()
+    {
+        $val = unpack('H32', $this->readAndHashBytes(16))[1];
+        return [substr($val, 0, 8) . '-' . substr($val, 8, 4) . '-' . substr($val, 12, 4) . '-' . substr($val, 16, 4) . '-' . substr($val, 20, 12), 16];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/EventParsingIterator.php

@@ -0,0 +1,81 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use Iterator;
+use UglyRobot\Infinite_Uploads\Aws\Exception\EventStreamDataException;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal Implements a decoder for a binary encoded event stream that will
+ * decode, validate, and provide individual events from the stream.
+ */
+class EventParsingIterator implements \Iterator
+{
+    /** @var StreamInterface */
+    private $decodingIterator;
+    /** @var StructureShape */
+    private $shape;
+    /** @var AbstractParser */
+    private $parser;
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractParser $parser)
+    {
+        $this->decodingIterator = new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\DecodingEventStreamIterator($stream);
+        $this->shape = $shape;
+        $this->parser = $parser;
+    }
+    public function current()
+    {
+        return $this->parseEvent($this->decodingIterator->current());
+    }
+    public function key()
+    {
+        return $this->decodingIterator->key();
+    }
+    public function next()
+    {
+        $this->decodingIterator->next();
+    }
+    public function rewind()
+    {
+        $this->decodingIterator->rewind();
+    }
+    public function valid()
+    {
+        return $this->decodingIterator->valid();
+    }
+    private function parseEvent(array $event)
+    {
+        if (!empty($event['headers'][':message-type'])) {
+            if ($event['headers'][':message-type'] === 'error') {
+                return $this->parseError($event);
+            }
+            if ($event['headers'][':message-type'] !== 'event') {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Failed to parse unknown message type.');
+            }
+        }
+        if (empty($event['headers'][':event-type'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Failed to parse without event type.');
+        }
+        $eventShape = $this->shape->getMember($event['headers'][':event-type']);
+        $parsedEvent = [];
+        foreach ($eventShape['members'] as $shape => $details) {
+            if (!empty($details['eventpayload'])) {
+                $payloadShape = $eventShape->getMember($shape);
+                if ($payloadShape['type'] === 'blob') {
+                    $parsedEvent[$shape] = $event['payload'];
+                } else {
+                    $parsedEvent[$shape] = $this->parser->parseMemberFromStream($event['payload'], $payloadShape, null);
+                }
+            } else {
+                $parsedEvent[$shape] = $event['headers'][$shape];
+            }
+        }
+        return [$event['headers'][':event-type'] => $parsedEvent];
+    }
+    private function parseError(array $event)
+    {
+        throw new \UglyRobot\Infinite_Uploads\Aws\Exception\EventStreamDataException($event['headers'][':error-code'], $event['headers'][':error-message']);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/Exception/ParserException.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception;
+
+use UglyRobot\Infinite_Uploads\Aws\HasMonitoringEventsTrait;
+use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+class ParserException extends \RuntimeException implements \UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface, \UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface
+{
+    use HasMonitoringEventsTrait;
+    private $errorCode;
+    private $requestId;
+    private $response;
+    public function __construct($message = '', $code = 0, $previous = null, array $context = [])
+    {
+        $this->errorCode = isset($context['error_code']) ? $context['error_code'] : null;
+        $this->requestId = isset($context['request_id']) ? $context['request_id'] : null;
+        $this->response = isset($context['response']) ? $context['response'] : null;
+        parent::__construct($message, $code, $previous);
+    }
+    /**
+     * Get the error code, if any.
+     *
+     * @return string|null
+     */
+    public function getErrorCode()
+    {
+        return $this->errorCode;
+    }
+    /**
+     * Get the request ID, if any.
+     *
+     * @return string|null
+     */
+    public function getRequestId()
+    {
+        return $this->requestId;
+    }
+    /**
+     * Get the received HTTP response if any.
+     *
+     * @return ResponseInterface|null
+     */
+    public function getResponse()
+    {
+        return $this->response;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/JsonParser.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+/**
+ * @internal Implements standard JSON parsing.
+ */
+class JsonParser
+{
+    public function parse(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        if ($value === null) {
+            return $value;
+        }
+        switch ($shape['type']) {
+            case 'structure':
+                $target = [];
+                foreach ($shape->getMembers() as $name => $member) {
+                    $locationName = $member['locationName'] ?: $name;
+                    if (isset($value[$locationName])) {
+                        $target[$name] = $this->parse($member, $value[$locationName]);
+                    }
+                }
+                return $target;
+            case 'list':
+                $member = $shape->getMember();
+                $target = [];
+                foreach ($value as $v) {
+                    $target[] = $this->parse($member, $v);
+                }
+                return $target;
+            case 'map':
+                $values = $shape->getValue();
+                $target = [];
+                foreach ($value as $k => $v) {
+                    $target[$k] = $this->parse($values, $v);
+                }
+                return $target;
+            case 'timestamp':
+                return \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult::fromTimestamp($value, !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null);
+            case 'blob':
+                return base64_decode($value);
+            default:
+                return $value;
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/JsonRpcParser.php

@@ -0,0 +1,36 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Result;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal Implements JSON-RPC parsing (e.g., DynamoDB)
+ */
+class JsonRpcParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractParser
+{
+    use PayloadParserTrait;
+    /**
+     * @param Service    $api    Service description
+     * @param JsonParser $parser JSON body builder
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser();
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        $operation = $this->api->getOperation($command->getName());
+        $result = null === $operation['output'] ? null : $this->parseMemberFromStream($response->getBody(), $operation->getOutput(), $response);
+        return new \UglyRobot\Infinite_Uploads\Aws\Result($result ?: []);
+    }
+    public function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response)
+    {
+        return $this->parser->parse($member, $this->parseJson($stream, $response));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/MetadataParserTrait.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+trait MetadataParserTrait
+{
+    /**
+     * Extract a single header from the response into the result.
+     */
+    protected function extractHeader($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, &$result)
+    {
+        $value = $response->getHeaderLine($shape['locationName'] ?: $name);
+        switch ($shape->getType()) {
+            case 'float':
+            case 'double':
+                $value = (double) $value;
+                break;
+            case 'long':
+                $value = (int) $value;
+                break;
+            case 'boolean':
+                $value = filter_var($value, FILTER_VALIDATE_BOOLEAN);
+                break;
+            case 'blob':
+                $value = base64_decode($value);
+                break;
+            case 'timestamp':
+                try {
+                    $value = \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult::fromTimestamp($value, !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null);
+                    break;
+                } catch (\Exception $e) {
+                    // If the value cannot be parsed, then do not add it to the
+                    // output structure.
+                    return;
+                }
+            case 'string':
+                if ($shape['jsonvalue']) {
+                    $value = $this->parseJson(base64_decode($value), $response);
+                }
+                break;
+        }
+        $result[$name] = $value;
+    }
+    /**
+     * Extract a map of headers with an optional prefix from the response.
+     */
+    protected function extractHeaders($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, &$result)
+    {
+        // Check if the headers are prefixed by a location name
+        $result[$name] = [];
+        $prefix = $shape['locationName'];
+        $prefixLen = strlen($prefix);
+        foreach ($response->getHeaders() as $k => $values) {
+            if (!$prefixLen) {
+                $result[$name][$k] = implode(', ', $values);
+            } elseif (stripos($k, $prefix) === 0) {
+                $result[$name][substr($k, $prefixLen)] = implode(', ', $values);
+            }
+        }
+    }
+    /**
+     * Places the status code of the response into the result array.
+     */
+    protected function extractStatus($name, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, array &$result)
+    {
+        $result[$name] = (int) $response->getStatusCode();
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/PayloadParserTrait.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+trait PayloadParserTrait
+{
+    /**
+     * @param string $json
+     *
+     * @throws ParserException
+     *
+     * @return array
+     */
+    private function parseJson($json, $response)
+    {
+        $jsonPayload = json_decode($json, true);
+        if (JSON_ERROR_NONE !== json_last_error()) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Error parsing JSON: ' . json_last_error_msg(), 0, null, ['response' => $response]);
+        }
+        return $jsonPayload;
+    }
+    /**
+     * @param string $xml
+     *
+     * @throws ParserException
+     *
+     * @return \SimpleXMLElement
+     */
+    protected function parseXml($xml, $response)
+    {
+        $priorSetting = libxml_use_internal_errors(true);
+        try {
+            libxml_clear_errors();
+            $xmlPayload = new \SimpleXMLElement($xml);
+            if ($error = libxml_get_last_error()) {
+                throw new \RuntimeException($error->message);
+            }
+        } catch (\Exception $e) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException("Error parsing XML: {$e->getMessage()}", 0, $e, ['response' => $response]);
+        } finally {
+            libxml_use_internal_errors($priorSetting);
+        }
+        return $xmlPayload;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/QueryParser.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Result;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal Parses query (XML) responses (e.g., EC2, SQS, and many others)
+ */
+class QueryParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractParser
+{
+    use PayloadParserTrait;
+    /** @var bool */
+    private $honorResultWrapper;
+    /**
+     * @param Service   $api                Service description
+     * @param XmlParser $xmlParser          Optional XML parser
+     * @param bool      $honorResultWrapper Set to false to disable the peeling
+     *                                      back of result wrappers from the
+     *                                      output structure.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser $xmlParser = null, $honorResultWrapper = true)
+    {
+        parent::__construct($api);
+        $this->parser = $xmlParser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser();
+        $this->honorResultWrapper = $honorResultWrapper;
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command, \UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response)
+    {
+        $output = $this->api->getOperation($command->getName())->getOutput();
+        $xml = $this->parseXml($response->getBody(), $response);
+        if ($this->honorResultWrapper && $output['resultWrapper']) {
+            $xml = $xml->{$output['resultWrapper']};
+        }
+        return new \UglyRobot\Infinite_Uploads\Aws\Result($this->parser->parse($output, $xml));
+    }
+    public function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response)
+    {
+        $xml = $this->parseXml($stream, $response);
+        return $this->parser->parse($member, $xml);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/RestJsonParser.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal Implements REST-JSON parsing (e.g., Glacier, Elastic Transcoder)
+ */
+class RestJsonParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractRestParser
+{
+    use PayloadParserTrait;
+    /**
+     * @param Service    $api    Service description
+     * @param JsonParser $parser JSON body builder
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\JsonParser();
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array &$result)
+    {
+        $jsonBody = $this->parseJson($response->getBody(), $response);
+        if ($jsonBody) {
+            $result += $this->parser->parse($member, $jsonBody);
+        }
+    }
+    public function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response)
+    {
+        $jsonBody = $this->parseJson($stream, $response);
+        if ($jsonBody) {
+            return $this->parser->parse($member, $jsonBody);
+        }
+        return [];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/RestXmlParser.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+/**
+ * @internal Implements REST-XML parsing (e.g., S3, CloudFront, etc...)
+ */
+class RestXmlParser extends \UglyRobot\Infinite_Uploads\Aws\Api\Parser\AbstractRestParser
+{
+    use PayloadParserTrait;
+    /**
+     * @param Service   $api    Service description
+     * @param XmlParser $parser XML body parser
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser $parser = null)
+    {
+        parent::__construct($api);
+        $this->parser = $parser ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\XmlParser();
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array &$result)
+    {
+        $result += $this->parseMemberFromStream($response->getBody(), $member, $response);
+    }
+    public function parseMemberFromStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $stream, \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, $response)
+    {
+        $xml = $this->parseXml($stream, $response);
+        return $this->parser->parse($member, $xml);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Parser/XmlParser.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Parser;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\Aws\Api\ListShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\MapShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+/**
+ * @internal Implements standard XML parsing for REST-XML and Query protocols.
+ */
+class XmlParser
+{
+    public function parse(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, \SimpleXMLElement $value)
+    {
+        return $this->dispatch($shape, $value);
+    }
+    private function dispatch($shape, \SimpleXMLElement $value)
+    {
+        static $methods = ['structure' => 'parse_structure', 'list' => 'parse_list', 'map' => 'parse_map', 'blob' => 'parse_blob', 'boolean' => 'parse_boolean', 'integer' => 'parse_integer', 'float' => 'parse_float', 'double' => 'parse_float', 'timestamp' => 'parse_timestamp'];
+        $type = $shape['type'];
+        if (isset($methods[$type])) {
+            return $this->{$methods[$type]}($shape, $value);
+        }
+        return (string) $value;
+    }
+    private function parse_structure(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, \SimpleXMLElement $value)
+    {
+        $target = [];
+        foreach ($shape->getMembers() as $name => $member) {
+            // Extract the name of the XML node
+            $node = $this->memberKey($member, $name);
+            if (isset($value->{$node})) {
+                $target[$name] = $this->dispatch($member, $value->{$node});
+            } else {
+                $memberShape = $shape->getMember($name);
+                if (!empty($memberShape['xmlAttribute'])) {
+                    $target[$name] = $this->parse_xml_attribute($shape, $memberShape, $value);
+                }
+            }
+        }
+        return $target;
+    }
+    private function memberKey(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name)
+    {
+        if (null !== $shape['locationName']) {
+            return $shape['locationName'];
+        }
+        if ($shape instanceof ListShape && $shape['flattened']) {
+            return $shape->getMember()['locationName'] ?: $name;
+        }
+        return $name;
+    }
+    private function parse_list(\UglyRobot\Infinite_Uploads\Aws\Api\ListShape $shape, \SimpleXMLElement $value)
+    {
+        $target = [];
+        $member = $shape->getMember();
+        if (!$shape['flattened']) {
+            $value = $value->{$member['locationName'] ?: 'member'};
+        }
+        foreach ($value as $v) {
+            $target[] = $this->dispatch($member, $v);
+        }
+        return $target;
+    }
+    private function parse_map(\UglyRobot\Infinite_Uploads\Aws\Api\MapShape $shape, \SimpleXMLElement $value)
+    {
+        $target = [];
+        if (!$shape['flattened']) {
+            $value = $value->entry;
+        }
+        $mapKey = $shape->getKey();
+        $mapValue = $shape->getValue();
+        $keyName = $shape->getKey()['locationName'] ?: 'key';
+        $valueName = $shape->getValue()['locationName'] ?: 'value';
+        foreach ($value as $node) {
+            $key = $this->dispatch($mapKey, $node->{$keyName});
+            $value = $this->dispatch($mapValue, $node->{$valueName});
+            $target[$key] = $value;
+        }
+        return $target;
+    }
+    private function parse_blob(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        return base64_decode((string) $value);
+    }
+    private function parse_float(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        return (double) (string) $value;
+    }
+    private function parse_integer(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        return (int) (string) $value;
+    }
+    private function parse_boolean(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        return $value == 'true';
+    }
+    private function parse_timestamp(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        if (is_string($value) || is_int($value) || is_object($value) && method_exists($value, '__toString')) {
+            return \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult::fromTimestamp((string) $value, !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : null);
+        }
+        throw new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\Exception\ParserException('Invalid timestamp value passed to XmlParser::parse_timestamp');
+    }
+    private function parse_xml_attribute(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $memberShape, $value)
+    {
+        $namespace = $shape['xmlNamespace']['uri'] ? $shape['xmlNamespace']['uri'] : '';
+        $prefix = $shape['xmlNamespace']['prefix'] ? $shape['xmlNamespace']['prefix'] : '';
+        if (!empty($prefix)) {
+            $prefix .= ':';
+        }
+        $key = str_replace($prefix, '', $memberShape['locationName']);
+        $attributes = $value->attributes($namespace);
+        return isset($attributes[$key]) ? (string) $attributes[$key] : null;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/Ec2ParamBuilder.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\ListShape;
+/**
+ * @internal
+ */
+class Ec2ParamBuilder extends \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\QueryParamBuilder
+{
+    protected function queryName(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $default = null)
+    {
+        return $shape['queryName'] ?: ucfirst($shape['locationName']) ?: $default;
+    }
+    protected function isFlat(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape)
+    {
+        return false;
+    }
+    protected function format_list(\UglyRobot\Infinite_Uploads\Aws\Api\ListShape $shape, array $value, $prefix, &$query)
+    {
+        // Handle empty list serialization
+        if (!$value) {
+            $query[$prefix] = false;
+        } else {
+            $items = $shape->getMember();
+            foreach ($value as $k => $v) {
+                $this->format($items, $v, $prefix . '.' . ($k + 1), $query);
+            }
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/JsonBody.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape;
+/**
+ * Formats the JSON body of a JSON-REST or JSON-RPC operation.
+ * @internal
+ */
+class JsonBody
+{
+    private $api;
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api)
+    {
+        $this->api = $api;
+    }
+    /**
+     * Gets the JSON Content-Type header for a service API
+     *
+     * @param Service $service
+     *
+     * @return string
+     */
+    public static function getContentType(\UglyRobot\Infinite_Uploads\Aws\Api\Service $service)
+    {
+        return 'application/x-amz-json-' . number_format($service->getMetadata('jsonVersion'), 1);
+    }
+    /**
+     * Builds the JSON body based on an array of arguments.
+     *
+     * @param Shape $shape Operation being constructed
+     * @param array $args  Associative array of arguments
+     *
+     * @return string
+     */
+    public function build(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, array $args)
+    {
+        $result = json_encode($this->format($shape, $args));
+        return $result == '[]' ? '{}' : $result;
+    }
+    private function format(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        switch ($shape['type']) {
+            case 'structure':
+                $data = [];
+                foreach ($value as $k => $v) {
+                    if ($v !== null && $shape->hasMember($k)) {
+                        $valueShape = $shape->getMember($k);
+                        $data[$valueShape['locationName'] ?: $k] = $this->format($valueShape, $v);
+                    }
+                }
+                if (empty($data)) {
+                    return new \stdClass();
+                }
+                return $data;
+            case 'list':
+                $items = $shape->getMember();
+                foreach ($value as $k => $v) {
+                    $value[$k] = $this->format($items, $v);
+                }
+                return $value;
+            case 'map':
+                if (empty($value)) {
+                    return new \stdClass();
+                }
+                $values = $shape->getValue();
+                foreach ($value as $k => $v) {
+                    $value[$k] = $this->format($values, $v);
+                }
+                return $value;
+            case 'blob':
+                return base64_encode($value);
+            case 'timestamp':
+                $timestampFormat = !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : 'unixTimestamp';
+                return \UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape::format($value, $timestampFormat);
+            default:
+                return $value;
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/JsonRpcSerializer.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+/**
+ * Prepares a JSON-RPC request for transfer.
+ * @internal
+ */
+class JsonRpcSerializer
+{
+    /** @var JsonBody */
+    private $jsonFormatter;
+    /** @var string */
+    private $endpoint;
+    /** @var Service */
+    private $api;
+    /** @var string */
+    private $contentType;
+    /**
+     * @param Service  $api           Service description
+     * @param string   $endpoint      Endpoint to connect to
+     * @param JsonBody $jsonFormatter Optional JSON formatter to use
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint, \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\JsonBody $jsonFormatter = null)
+    {
+        $this->endpoint = $endpoint;
+        $this->api = $api;
+        $this->jsonFormatter = $jsonFormatter ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\JsonBody($this->api);
+        $this->contentType = \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\JsonBody::getContentType($api);
+    }
+    /**
+     * When invoked with an AWS command, returns a serialization array
+     * containing "method", "uri", "headers", and "body" key value pairs.
+     *
+     * @param CommandInterface $command
+     *
+     * @return RequestInterface
+     */
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command)
+    {
+        $name = $command->getName();
+        $operation = $this->api->getOperation($name);
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request($operation['http']['method'], $this->endpoint, ['X-Amz-Target' => $this->api->getMetadata('targetPrefix') . '.' . $name, 'Content-Type' => $this->contentType], $this->jsonFormatter->build($operation->getInput(), $command->toArray()));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/QueryParamBuilder.php

@@ -0,0 +1,112 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\ListShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\MapShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape;
+/**
+ * @internal
+ */
+class QueryParamBuilder
+{
+    private $methods;
+    protected function queryName(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $default = null)
+    {
+        if (null !== $shape['queryName']) {
+            return $shape['queryName'];
+        }
+        if (null !== $shape['locationName']) {
+            return $shape['locationName'];
+        }
+        if ($this->isFlat($shape) && !empty($shape['member']['locationName'])) {
+            return $shape['member']['locationName'];
+        }
+        return $default;
+    }
+    protected function isFlat(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape)
+    {
+        return $shape['flattened'] === true;
+    }
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, array $params)
+    {
+        if (!$this->methods) {
+            $this->methods = array_fill_keys(get_class_methods($this), true);
+        }
+        $query = [];
+        $this->format_structure($shape, $params, '', $query);
+        return $query;
+    }
+    protected function format(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value, $prefix, array &$query)
+    {
+        $type = 'format_' . $shape['type'];
+        if (isset($this->methods[$type])) {
+            $this->{$type}($shape, $value, $prefix, $query);
+        } else {
+            $query[$prefix] = (string) $value;
+        }
+    }
+    protected function format_structure(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, array $value, $prefix, &$query)
+    {
+        if ($prefix) {
+            $prefix .= '.';
+        }
+        foreach ($value as $k => $v) {
+            if ($shape->hasMember($k)) {
+                $member = $shape->getMember($k);
+                $this->format($member, $v, $prefix . $this->queryName($member, $k), $query);
+            }
+        }
+    }
+    protected function format_list(\UglyRobot\Infinite_Uploads\Aws\Api\ListShape $shape, array $value, $prefix, &$query)
+    {
+        // Handle empty list serialization
+        if (!$value) {
+            $query[$prefix] = '';
+            return;
+        }
+        $items = $shape->getMember();
+        if (!$this->isFlat($shape)) {
+            $locationName = $shape->getMember()['locationName'] ?: 'member';
+            $prefix .= ".{$locationName}";
+        } elseif ($name = $this->queryName($items)) {
+            $parts = explode('.', $prefix);
+            $parts[count($parts) - 1] = $name;
+            $prefix = implode('.', $parts);
+        }
+        foreach ($value as $k => $v) {
+            $this->format($items, $v, $prefix . '.' . ($k + 1), $query);
+        }
+    }
+    protected function format_map(\UglyRobot\Infinite_Uploads\Aws\Api\MapShape $shape, array $value, $prefix, array &$query)
+    {
+        $vals = $shape->getValue();
+        $keys = $shape->getKey();
+        if (!$this->isFlat($shape)) {
+            $prefix .= '.entry';
+        }
+        $i = 0;
+        $keyName = '%s.%d.' . $this->queryName($keys, 'key');
+        $valueName = '%s.%s.' . $this->queryName($vals, 'value');
+        foreach ($value as $k => $v) {
+            $i++;
+            $this->format($keys, $k, sprintf($keyName, $prefix, $i), $query);
+            $this->format($vals, $v, sprintf($valueName, $prefix, $i), $query);
+        }
+    }
+    protected function format_blob(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value, $prefix, array &$query)
+    {
+        $query[$prefix] = base64_encode($value);
+    }
+    protected function format_timestamp(\UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape $shape, $value, $prefix, array &$query)
+    {
+        $timestampFormat = !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : 'iso8601';
+        $query[$prefix] = \UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape::format($value, $timestampFormat);
+    }
+    protected function format_boolean(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value, $prefix, array &$query)
+    {
+        $query[$prefix] = $value ? 'true' : 'false';
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/QuerySerializer.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+/**
+ * Serializes a query protocol request.
+ * @internal
+ */
+class QuerySerializer
+{
+    private $endpoint;
+    private $api;
+    private $paramBuilder;
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint, callable $paramBuilder = null)
+    {
+        $this->api = $api;
+        $this->endpoint = $endpoint;
+        $this->paramBuilder = $paramBuilder ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\QueryParamBuilder();
+    }
+    /**
+     * When invoked with an AWS command, returns a serialization array
+     * containing "method", "uri", "headers", and "body" key value pairs.
+     *
+     * @param CommandInterface $command
+     *
+     * @return RequestInterface
+     */
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command)
+    {
+        $operation = $this->api->getOperation($command->getName());
+        $body = ['Action' => $command->getName(), 'Version' => $this->api->getMetadata('apiVersion')];
+        $params = $command->toArray();
+        // Only build up the parameters when there are parameters to build
+        if ($params) {
+            $body += call_user_func($this->paramBuilder, $operation->getInput(), $params);
+        }
+        $body = http_build_query($body, null, '&', PHP_QUERY_RFC3986);
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request('POST', $this->endpoint, ['Content-Length' => strlen($body), 'Content-Type' => 'application/x-www-form-urlencoded'], $body);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/RestJsonSerializer.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+/**
+ * Serializes requests for the REST-JSON protocol.
+ * @internal
+ */
+class RestJsonSerializer extends \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\RestSerializer
+{
+    /** @var JsonBody */
+    private $jsonFormatter;
+    /** @var string */
+    private $contentType;
+    /**
+     * @param Service  $api           Service API description
+     * @param string   $endpoint      Endpoint to connect to
+     * @param JsonBody $jsonFormatter Optional JSON formatter to use
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint, \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\JsonBody $jsonFormatter = null)
+    {
+        parent::__construct($api, $endpoint);
+        $this->contentType = 'application/json';
+        $this->jsonFormatter = $jsonFormatter ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\JsonBody($api);
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array $value, array &$opts)
+    {
+        $opts['headers']['Content-Type'] = $this->contentType;
+        $opts['body'] = (string) $this->jsonFormatter->build($member, $value);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/RestSerializer.php

@@ -0,0 +1,172 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\MapShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\Operation;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape;
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Uri;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\UriResolver;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+/**
+ * Serializes HTTP locations like header, uri, payload, etc...
+ * @internal
+ */
+abstract class RestSerializer
+{
+    /** @var Service */
+    private $api;
+    /** @var Psr7\Uri */
+    private $endpoint;
+    /**
+     * @param Service $api      Service API description
+     * @param string  $endpoint Endpoint to connect to
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint)
+    {
+        $this->api = $api;
+        $this->endpoint = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\uri_for($endpoint);
+    }
+    /**
+     * @param CommandInterface $command Command to serialized
+     *
+     * @return RequestInterface
+     */
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command)
+    {
+        $operation = $this->api->getOperation($command->getName());
+        $args = $command->toArray();
+        $opts = $this->serialize($operation, $args);
+        $uri = $this->buildEndpoint($operation, $args, $opts);
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request($operation['http']['method'], $uri, isset($opts['headers']) ? $opts['headers'] : [], isset($opts['body']) ? $opts['body'] : null);
+    }
+    /**
+     * Modifies a hash of request options for a payload body.
+     *
+     * @param StructureShape   $member  Member to serialize
+     * @param array            $value   Value to serialize
+     * @param array            $opts    Request options to modify.
+     */
+    protected abstract function payload(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array $value, array &$opts);
+    private function serialize(\UglyRobot\Infinite_Uploads\Aws\Api\Operation $operation, array $args)
+    {
+        $opts = [];
+        $input = $operation->getInput();
+        // Apply the payload trait if present
+        if ($payload = $input['payload']) {
+            $this->applyPayload($input, $payload, $args, $opts);
+        }
+        foreach ($args as $name => $value) {
+            if ($input->hasMember($name)) {
+                $member = $input->getMember($name);
+                $location = $member['location'];
+                if (!$payload && !$location) {
+                    $bodyMembers[$name] = $value;
+                } elseif ($location == 'header') {
+                    $this->applyHeader($name, $member, $value, $opts);
+                } elseif ($location == 'querystring') {
+                    $this->applyQuery($name, $member, $value, $opts);
+                } elseif ($location == 'headers') {
+                    $this->applyHeaderMap($name, $member, $value, $opts);
+                }
+            }
+        }
+        if (isset($bodyMembers)) {
+            $this->payload($operation->getInput(), $bodyMembers, $opts);
+        }
+        return $opts;
+    }
+    private function applyPayload(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $input, $name, array $args, array &$opts)
+    {
+        if (!isset($args[$name])) {
+            return;
+        }
+        $m = $input->getMember($name);
+        if ($m['streaming'] || ($m['type'] == 'string' || $m['type'] == 'blob')) {
+            // Streaming bodies or payloads that are strings are
+            // always just a stream of data.
+            $opts['body'] = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($args[$name]);
+            return;
+        }
+        $this->payload($m, $args[$name], $opts);
+    }
+    private function applyHeader($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $member, $value, array &$opts)
+    {
+        if ($member->getType() === 'timestamp') {
+            $timestampFormat = !empty($member['timestampFormat']) ? $member['timestampFormat'] : 'rfc822';
+            $value = \UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape::format($value, $timestampFormat);
+        }
+        if ($member['jsonvalue']) {
+            $value = json_encode($value);
+            if (empty($value) && JSON_ERROR_NONE !== json_last_error()) {
+                throw new \InvalidArgumentException('Unable to encode the provided value' . ' with \'json_encode\'. ' . json_last_error_msg());
+            }
+            $value = base64_encode($value);
+        }
+        $opts['headers'][$member['locationName'] ?: $name] = $value;
+    }
+    /**
+     * Note: This is currently only present in the Amazon S3 model.
+     */
+    private function applyHeaderMap($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $member, array $value, array &$opts)
+    {
+        $prefix = $member['locationName'];
+        foreach ($value as $k => $v) {
+            $opts['headers'][$prefix . $k] = $v;
+        }
+    }
+    private function applyQuery($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $member, $value, array &$opts)
+    {
+        if ($member instanceof MapShape) {
+            $opts['query'] = isset($opts['query']) && is_array($opts['query']) ? $opts['query'] + $value : $value;
+        } elseif ($value !== null) {
+            $type = $member->getType();
+            if ($type === 'boolean') {
+                $value = $value ? 'true' : 'false';
+            } elseif ($type === 'timestamp') {
+                $timestampFormat = !empty($member['timestampFormat']) ? $member['timestampFormat'] : 'iso8601';
+                $value = \UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape::format($value, $timestampFormat);
+            }
+            $opts['query'][$member['locationName'] ?: $name] = $value;
+        }
+    }
+    private function buildEndpoint(\UglyRobot\Infinite_Uploads\Aws\Api\Operation $operation, array $args, array $opts)
+    {
+        $varspecs = [];
+        // Create an associative array of varspecs used in expansions
+        foreach ($operation->getInput()->getMembers() as $name => $member) {
+            if ($member['location'] == 'uri') {
+                $varspecs[$member['locationName'] ?: $name] = isset($args[$name]) ? $args[$name] : null;
+            }
+        }
+        $relative = preg_replace_callback('/\\{([^\\}]+)\\}/', function (array $matches) use($varspecs) {
+            $isGreedy = substr($matches[1], -1, 1) == '+';
+            $k = $isGreedy ? substr($matches[1], 0, -1) : $matches[1];
+            if (!isset($varspecs[$k])) {
+                return '';
+            }
+            if ($isGreedy) {
+                return str_replace('%2F', '/', rawurlencode($varspecs[$k]));
+            }
+            return rawurlencode($varspecs[$k]);
+        }, $operation['http']['requestUri']);
+        // Add the query string variables or appending to one if needed.
+        if (!empty($opts['query'])) {
+            $append = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\build_query($opts['query']);
+            $relative .= strpos($relative, '?') ? "&{$append}" : "?{$append}";
+        }
+        // If endpoint has path, remove leading '/' to preserve URI resolution.
+        $path = $this->endpoint->getPath();
+        if ($path && $relative[0] === '/') {
+            $relative = substr($relative, 1);
+        }
+        // Expand path place holders using Amazon's slightly different URI
+        // template syntax.
+        return \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\UriResolver::resolve($this->endpoint, new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Uri($relative));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/RestXmlSerializer.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+/**
+ * @internal
+ */
+class RestXmlSerializer extends \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\RestSerializer
+{
+    /** @var XmlBody */
+    private $xmlBody;
+    /**
+     * @param Service $api      Service API description
+     * @param string  $endpoint Endpoint to connect to
+     * @param XmlBody $xmlBody  Optional XML formatter to use
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint, \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\XmlBody $xmlBody = null)
+    {
+        parent::__construct($api, $endpoint);
+        $this->xmlBody = $xmlBody ?: new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\XmlBody($api);
+    }
+    protected function payload(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $member, array $value, array &$opts)
+    {
+        $opts['headers']['Content-Type'] = 'application/xml';
+        $opts['body'] = (string) $this->xmlBody->build($member, $value);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Serializer/XmlBody.php

@@ -0,0 +1,148 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api\Serializer;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\MapShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\Api\Shape;
+use UglyRobot\Infinite_Uploads\Aws\Api\StructureShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\ListShape;
+use UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape;
+use XMLWriter;
+/**
+ * @internal Formats the XML body of a REST-XML services.
+ */
+class XmlBody
+{
+    /** @var \Aws\Api\Service */
+    private $api;
+    /**
+     * @param Service $api API being used to create the XML body.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api)
+    {
+        $this->api = $api;
+    }
+    /**
+     * Builds the XML body based on an array of arguments.
+     *
+     * @param Shape $shape Operation being constructed
+     * @param array $args  Associative array of arguments
+     *
+     * @return string
+     */
+    public function build(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, array $args)
+    {
+        $xml = new \XMLWriter();
+        $xml->openMemory();
+        $xml->startDocument('1.0', 'UTF-8');
+        $this->format($shape, $shape['locationName'] ?: $shape['name'], $args, $xml);
+        $xml->endDocument();
+        return $xml->outputMemory();
+    }
+    private function startElement(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, \XMLWriter $xml)
+    {
+        $xml->startElement($name);
+        if ($ns = $shape['xmlNamespace']) {
+            $xml->writeAttribute(isset($ns['prefix']) ? "xmlns:{$ns['prefix']}" : 'xmlns', $shape['xmlNamespace']['uri']);
+        }
+    }
+    private function format(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, $value, \XMLWriter $xml)
+    {
+        // Any method mentioned here has a custom serialization handler.
+        static $methods = ['add_structure' => true, 'add_list' => true, 'add_blob' => true, 'add_timestamp' => true, 'add_boolean' => true, 'add_map' => true, 'add_string' => true];
+        $type = 'add_' . $shape['type'];
+        if (isset($methods[$type])) {
+            $this->{$type}($shape, $name, $value, $xml);
+        } else {
+            $this->defaultShape($shape, $name, $value, $xml);
+        }
+    }
+    private function defaultShape(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, $value, \XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $xml->text($value);
+        $xml->endElement();
+    }
+    private function add_structure(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, $name, array $value, \XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        foreach ($this->getStructureMembers($shape, $value) as $k => $definition) {
+            $this->format($definition['member'], $definition['member']['locationName'] ?: $k, $definition['value'], $xml);
+        }
+        $xml->endElement();
+    }
+    private function getStructureMembers(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, array $value)
+    {
+        $members = [];
+        foreach ($value as $k => $v) {
+            if ($v !== null && $shape->hasMember($k)) {
+                $definition = ['member' => $shape->getMember($k), 'value' => $v];
+                if ($definition['member']['xmlAttribute']) {
+                    // array_unshift_associative
+                    $members = [$k => $definition] + $members;
+                } else {
+                    $members[$k] = $definition;
+                }
+            }
+        }
+        return $members;
+    }
+    private function add_list(\UglyRobot\Infinite_Uploads\Aws\Api\ListShape $shape, $name, array $value, \XMLWriter $xml)
+    {
+        $items = $shape->getMember();
+        if ($shape['flattened']) {
+            $elementName = $name;
+        } else {
+            $this->startElement($shape, $name, $xml);
+            $elementName = $items['locationName'] ?: 'member';
+        }
+        foreach ($value as $v) {
+            $this->format($items, $elementName, $v, $xml);
+        }
+        if (!$shape['flattened']) {
+            $xml->endElement();
+        }
+    }
+    private function add_map(\UglyRobot\Infinite_Uploads\Aws\Api\MapShape $shape, $name, array $value, \XMLWriter $xml)
+    {
+        $xmlEntry = $shape['flattened'] ? $shape['locationName'] : 'entry';
+        $xmlKey = $shape->getKey()['locationName'] ?: 'key';
+        $xmlValue = $shape->getValue()['locationName'] ?: 'value';
+        $this->startElement($shape, $name, $xml);
+        foreach ($value as $key => $v) {
+            $this->startElement($shape, $xmlEntry, $xml);
+            $this->format($shape->getKey(), $xmlKey, $key, $xml);
+            $this->format($shape->getValue(), $xmlValue, $v, $xml);
+            $xml->endElement();
+        }
+        $xml->endElement();
+    }
+    private function add_blob(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, $value, \XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $xml->writeRaw(base64_encode($value));
+        $xml->endElement();
+    }
+    private function add_timestamp(\UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape $shape, $name, $value, \XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $timestampFormat = !empty($shape['timestampFormat']) ? $shape['timestampFormat'] : 'iso8601';
+        $xml->writeRaw(\UglyRobot\Infinite_Uploads\Aws\Api\TimestampShape::format($value, $timestampFormat));
+        $xml->endElement();
+    }
+    private function add_boolean(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, $value, \XMLWriter $xml)
+    {
+        $this->startElement($shape, $name, $xml);
+        $xml->writeRaw($value ? 'true' : 'false');
+        $xml->endElement();
+    }
+    private function add_string(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $name, $value, \XMLWriter $xml)
+    {
+        if ($shape['xmlAttribute']) {
+            $xml->writeAttribute($shape['locationName'] ?: $name, $value);
+        } else {
+            $this->defaultShape($shape, $name, $value, $xml);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Service.php

@@ -0,0 +1,357 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Serializer\QuerySerializer;
+use UglyRobot\Infinite_Uploads\Aws\Api\Serializer\Ec2ParamBuilder;
+use UglyRobot\Infinite_Uploads\Aws\Api\Parser\QueryParser;
+/**
+ * Represents a web service API model.
+ */
+class Service extends \UglyRobot\Infinite_Uploads\Aws\Api\AbstractModel
+{
+    /** @var callable */
+    private $apiProvider;
+    /** @var string */
+    private $serviceName;
+    /** @var string */
+    private $apiVersion;
+    /** @var Operation[] */
+    private $operations = [];
+    /** @var array */
+    private $paginators = null;
+    /** @var array */
+    private $waiters = null;
+    /**
+     * @param array    $definition
+     * @param callable $provider
+     *
+     * @internal param array $definition Service description
+     */
+    public function __construct(array $definition, callable $provider)
+    {
+        static $defaults = ['operations' => [], 'shapes' => [], 'metadata' => []], $defaultMeta = ['apiVersion' => null, 'serviceFullName' => null, 'serviceId' => null, 'endpointPrefix' => null, 'signingName' => null, 'signatureVersion' => null, 'protocol' => null, 'uid' => null];
+        $definition += $defaults;
+        $definition['metadata'] += $defaultMeta;
+        $this->definition = $definition;
+        $this->apiProvider = $provider;
+        parent::__construct($definition, new \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap($definition['shapes']));
+        if (isset($definition['metadata']['serviceIdentifier'])) {
+            $this->serviceName = $this->getServiceName();
+        } else {
+            $this->serviceName = $this->getEndpointPrefix();
+        }
+        $this->apiVersion = $this->getApiVersion();
+    }
+    /**
+     * Creates a request serializer for the provided API object.
+     *
+     * @param Service $api      API that contains a protocol.
+     * @param string  $endpoint Endpoint to send requests to.
+     *
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createSerializer(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api, $endpoint)
+    {
+        static $mapping = ['json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Serializer\\JsonRpcSerializer', 'query' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Serializer\\QuerySerializer', 'rest-json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Serializer\\RestJsonSerializer', 'rest-xml' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Serializer\\RestXmlSerializer'];
+        $proto = $api->getProtocol();
+        if (isset($mapping[$proto])) {
+            return new $mapping[$proto]($api, $endpoint);
+        }
+        if ($proto == 'ec2') {
+            return new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\QuerySerializer($api, $endpoint, new \UglyRobot\Infinite_Uploads\Aws\Api\Serializer\Ec2ParamBuilder());
+        }
+        throw new \UnexpectedValueException('Unknown protocol: ' . $api->getProtocol());
+    }
+    /**
+     * Creates an error parser for the given protocol.
+     *
+     * Redundant method signature to preserve backwards compatibility.
+     *
+     * @param string $protocol Protocol to parse (e.g., query, json, etc.)
+     *
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createErrorParser($protocol, \UglyRobot\Infinite_Uploads\Aws\Api\Service $api = null)
+    {
+        static $mapping = ['json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ErrorParser\\JsonRpcErrorParser', 'query' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ErrorParser\\XmlErrorParser', 'rest-json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ErrorParser\\RestJsonErrorParser', 'rest-xml' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ErrorParser\\XmlErrorParser', 'ec2' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ErrorParser\\XmlErrorParser'];
+        if (isset($mapping[$protocol])) {
+            return new $mapping[$protocol]($api);
+        }
+        throw new \UnexpectedValueException("Unknown protocol: {$protocol}");
+    }
+    /**
+     * Applies the listeners needed to parse client models.
+     *
+     * @param Service $api API to create a parser for
+     * @return callable
+     * @throws \UnexpectedValueException
+     */
+    public static function createParser(\UglyRobot\Infinite_Uploads\Aws\Api\Service $api)
+    {
+        static $mapping = ['json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Parser\\JsonRpcParser', 'query' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Parser\\QueryParser', 'rest-json' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Parser\\RestJsonParser', 'rest-xml' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Parser\\RestXmlParser'];
+        $proto = $api->getProtocol();
+        if (isset($mapping[$proto])) {
+            return new $mapping[$proto]($api);
+        }
+        if ($proto == 'ec2') {
+            return new \UglyRobot\Infinite_Uploads\Aws\Api\Parser\QueryParser($api, null, false);
+        }
+        throw new \UnexpectedValueException('Unknown protocol: ' . $api->getProtocol());
+    }
+    /**
+     * Get the full name of the service
+     *
+     * @return string
+     */
+    public function getServiceFullName()
+    {
+        return $this->definition['metadata']['serviceFullName'];
+    }
+    /**
+     * Get the service id
+     *
+     * @return string
+     */
+    public function getServiceId()
+    {
+        return $this->definition['metadata']['serviceId'];
+    }
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getApiVersion()
+    {
+        return $this->definition['metadata']['apiVersion'];
+    }
+    /**
+     * Get the API version of the service
+     *
+     * @return string
+     */
+    public function getEndpointPrefix()
+    {
+        return $this->definition['metadata']['endpointPrefix'];
+    }
+    /**
+     * Get the signing name used by the service.
+     *
+     * @return string
+     */
+    public function getSigningName()
+    {
+        return $this->definition['metadata']['signingName'] ?: $this->definition['metadata']['endpointPrefix'];
+    }
+    /**
+     * Get the service name.
+     *
+     * @return string
+     */
+    public function getServiceName()
+    {
+        return $this->definition['metadata']['serviceIdentifier'];
+    }
+    /**
+     * Get the default signature version of the service.
+     *
+     * Note: this method assumes "v4" when not specified in the model.
+     *
+     * @return string
+     */
+    public function getSignatureVersion()
+    {
+        return $this->definition['metadata']['signatureVersion'] ?: 'v4';
+    }
+    /**
+     * Get the protocol used by the service.
+     *
+     * @return string
+     */
+    public function getProtocol()
+    {
+        return $this->definition['metadata']['protocol'];
+    }
+    /**
+     * Get the uid string used by the service
+     *
+     * @return string
+     */
+    public function getUid()
+    {
+        return $this->definition['metadata']['uid'];
+    }
+    /**
+     * Check if the description has a specific operation by name.
+     *
+     * @param string $name Operation to check by name
+     *
+     * @return bool
+     */
+    public function hasOperation($name)
+    {
+        return isset($this['operations'][$name]);
+    }
+    /**
+     * Get an operation by name.
+     *
+     * @param string $name Operation to retrieve by name
+     *
+     * @return Operation
+     * @throws \InvalidArgumentException If the operation is not found
+     */
+    public function getOperation($name)
+    {
+        if (!isset($this->operations[$name])) {
+            if (!isset($this->definition['operations'][$name])) {
+                throw new \InvalidArgumentException("Unknown operation: {$name}");
+            }
+            $this->operations[$name] = new \UglyRobot\Infinite_Uploads\Aws\Api\Operation($this->definition['operations'][$name], $this->shapeMap);
+        }
+        return $this->operations[$name];
+    }
+    /**
+     * Get all of the operations of the description.
+     *
+     * @return Operation[]
+     */
+    public function getOperations()
+    {
+        $result = [];
+        foreach ($this->definition['operations'] as $name => $definition) {
+            $result[$name] = $this->getOperation($name);
+        }
+        return $result;
+    }
+    /**
+     * Get all of the error shapes of the service
+     *
+     * @return array
+     */
+    public function getErrorShapes()
+    {
+        $result = [];
+        foreach ($this->definition['shapes'] as $name => $definition) {
+            if (!empty($definition['exception'])) {
+                $definition['name'] = $name;
+                $result[] = new \UglyRobot\Infinite_Uploads\Aws\Api\StructureShape($definition, $this->getShapeMap());
+            }
+        }
+        return $result;
+    }
+    /**
+     * Get all of the service metadata or a specific metadata key value.
+     *
+     * @param string|null $key Key to retrieve or null to retrieve all metadata
+     *
+     * @return mixed Returns the result or null if the key is not found
+     */
+    public function getMetadata($key = null)
+    {
+        if (!$key) {
+            return $this['metadata'];
+        }
+        if (isset($this->definition['metadata'][$key])) {
+            return $this->definition['metadata'][$key];
+        }
+        return null;
+    }
+    /**
+     * Gets an associative array of available paginator configurations where
+     * the key is the name of the paginator, and the value is the paginator
+     * configuration.
+     *
+     * @return array
+     * @unstable The configuration format of paginators may change in the future
+     */
+    public function getPaginators()
+    {
+        if (!isset($this->paginators)) {
+            $res = call_user_func($this->apiProvider, 'paginator', $this->serviceName, $this->apiVersion);
+            $this->paginators = isset($res['pagination']) ? $res['pagination'] : [];
+        }
+        return $this->paginators;
+    }
+    /**
+     * Determines if the service has a paginator by name.
+     *
+     * @param string $name Name of the paginator.
+     *
+     * @return bool
+     */
+    public function hasPaginator($name)
+    {
+        return isset($this->getPaginators()[$name]);
+    }
+    /**
+     * Retrieve a paginator by name.
+     *
+     * @param string $name Paginator to retrieve by name. This argument is
+     *                     typically the operation name.
+     * @return array
+     * @throws \UnexpectedValueException if the paginator does not exist.
+     * @unstable The configuration format of paginators may change in the future
+     */
+    public function getPaginatorConfig($name)
+    {
+        static $defaults = ['input_token' => null, 'output_token' => null, 'limit_key' => null, 'result_key' => null, 'more_results' => null];
+        if ($this->hasPaginator($name)) {
+            return $this->paginators[$name] + $defaults;
+        }
+        throw new \UnexpectedValueException("There is no {$name} " . "paginator defined for the {$this->serviceName} service.");
+    }
+    /**
+     * Gets an associative array of available waiter configurations where the
+     * key is the name of the waiter, and the value is the waiter
+     * configuration.
+     *
+     * @return array
+     */
+    public function getWaiters()
+    {
+        if (!isset($this->waiters)) {
+            $res = call_user_func($this->apiProvider, 'waiter', $this->serviceName, $this->apiVersion);
+            $this->waiters = isset($res['waiters']) ? $res['waiters'] : [];
+        }
+        return $this->waiters;
+    }
+    /**
+     * Determines if the service has a waiter by name.
+     *
+     * @param string $name Name of the waiter.
+     *
+     * @return bool
+     */
+    public function hasWaiter($name)
+    {
+        return isset($this->getWaiters()[$name]);
+    }
+    /**
+     * Get a waiter configuration by name.
+     *
+     * @param string $name Name of the waiter by name.
+     *
+     * @return array
+     * @throws \UnexpectedValueException if the waiter does not exist.
+     */
+    public function getWaiterConfig($name)
+    {
+        // Error if the waiter is not defined
+        if ($this->hasWaiter($name)) {
+            return $this->waiters[$name];
+        }
+        throw new \UnexpectedValueException("There is no {$name} waiter " . "defined for the {$this->serviceName} service.");
+    }
+    /**
+     * Get the shape map used by the API.
+     *
+     * @return ShapeMap
+     */
+    public function getShapeMap()
+    {
+        return $this->shapeMap;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Shape.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Base class representing a modeled shape.
+ */
+class Shape extends \UglyRobot\Infinite_Uploads\Aws\Api\AbstractModel
+{
+    /**
+     * Get a concrete shape for the given definition.
+     *
+     * @param array    $definition
+     * @param ShapeMap $shapeMap
+     *
+     * @return mixed
+     * @throws \RuntimeException if the type is invalid
+     */
+    public static function create(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        static $map = ['structure' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\StructureShape', 'map' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\MapShape', 'list' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\ListShape', 'timestamp' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\TimestampShape', 'integer' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'double' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'float' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'long' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'string' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'byte' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'character' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'blob' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape', 'boolean' => 'UglyRobot\\Infinite_Uploads\\Aws\\Api\\Shape'];
+        if (isset($definition['shape'])) {
+            return $shapeMap->resolve($definition);
+        }
+        if (!isset($map[$definition['type']])) {
+            throw new \RuntimeException('Invalid type: ' . print_r($definition, true));
+        }
+        $type = $map[$definition['type']];
+        return new $type($definition, $shapeMap);
+    }
+    /**
+     * Get the type of the shape
+     *
+     * @return string
+     */
+    public function getType()
+    {
+        return $this->definition['type'];
+    }
+    /**
+     * Get the name of the shape
+     *
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->definition['name'];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/ShapeMap.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Builds shape based on shape references.
+ */
+class ShapeMap
+{
+    /** @var array */
+    private $definitions;
+    /** @var Shape[] */
+    private $simple;
+    /**
+     * @param array $shapeModels Associative array of shape definitions.
+     */
+    public function __construct(array $shapeModels)
+    {
+        $this->definitions = $shapeModels;
+    }
+    /**
+     * Get an array of shape names.
+     *
+     * @return array
+     */
+    public function getShapeNames()
+    {
+        return array_keys($this->definitions);
+    }
+    /**
+     * Resolve a shape reference
+     *
+     * @param array $shapeRef Shape reference shape
+     *
+     * @return Shape
+     * @throws \InvalidArgumentException
+     */
+    public function resolve(array $shapeRef)
+    {
+        $shape = $shapeRef['shape'];
+        if (!isset($this->definitions[$shape])) {
+            throw new \InvalidArgumentException('Shape not found: ' . $shape);
+        }
+        $isSimple = count($shapeRef) == 1;
+        if ($isSimple && isset($this->simple[$shape])) {
+            return $this->simple[$shape];
+        }
+        $definition = $shapeRef + $this->definitions[$shape];
+        $definition['name'] = $definition['shape'];
+        if (isset($definition['shape'])) {
+            unset($definition['shape']);
+        }
+        $result = \UglyRobot\Infinite_Uploads\Aws\Api\Shape::create($definition, $this);
+        if ($isSimple) {
+            $this->simple[$shape] = $result;
+        }
+        return $result;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/StructureShape.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Represents a structure shape and resolve member shape references.
+ */
+class StructureShape extends \UglyRobot\Infinite_Uploads\Aws\Api\Shape
+{
+    /**
+     * @var Shape[]
+     */
+    private $members;
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'structure';
+        if (!isset($definition['members'])) {
+            $definition['members'] = [];
+        }
+        parent::__construct($definition, $shapeMap);
+    }
+    /**
+     * Gets a list of all members
+     *
+     * @return Shape[]
+     */
+    public function getMembers()
+    {
+        if (empty($this->members)) {
+            $this->generateMembersHash();
+        }
+        return $this->members;
+    }
+    /**
+     * Check if a specific member exists by name.
+     *
+     * @param string $name Name of the member to check
+     *
+     * @return bool
+     */
+    public function hasMember($name)
+    {
+        return isset($this->definition['members'][$name]);
+    }
+    /**
+     * Retrieve a member by name.
+     *
+     * @param string $name Name of the member to retrieve
+     *
+     * @return Shape
+     * @throws \InvalidArgumentException if the member is not found.
+     */
+    public function getMember($name)
+    {
+        $members = $this->getMembers();
+        if (!isset($members[$name])) {
+            throw new \InvalidArgumentException('Unknown member ' . $name);
+        }
+        return $members[$name];
+    }
+    private function generateMembersHash()
+    {
+        $this->members = [];
+        foreach ($this->definition['members'] as $name => $definition) {
+            $this->members[$name] = $this->shapeFor($definition);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/TimestampShape.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+/**
+ * Represents a timestamp shape.
+ */
+class TimestampShape extends \UglyRobot\Infinite_Uploads\Aws\Api\Shape
+{
+    public function __construct(array $definition, \UglyRobot\Infinite_Uploads\Aws\Api\ShapeMap $shapeMap)
+    {
+        $definition['type'] = 'timestamp';
+        parent::__construct($definition, $shapeMap);
+    }
+    /**
+     * Formats a timestamp value for a service.
+     *
+     * @param mixed  $value  Value to format
+     * @param string $format Format used to serialize the value
+     *
+     * @return int|string
+     * @throws \UnexpectedValueException if the format is unknown.
+     * @throws \InvalidArgumentException if the value is an unsupported type.
+     */
+    public static function format($value, $format)
+    {
+        if ($value instanceof \DateTime) {
+            $value = $value->getTimestamp();
+        } elseif (is_string($value)) {
+            $value = strtotime($value);
+        } elseif (!is_int($value)) {
+            throw new \InvalidArgumentException('Unable to handle the provided' . ' timestamp type: ' . gettype($value));
+        }
+        switch ($format) {
+            case 'iso8601':
+                return gmdate('Y-m-d\\TH:i:s\\Z', $value);
+            case 'rfc822':
+                return gmdate('D, d M Y H:i:s \\G\\M\\T', $value);
+            case 'unixTimestamp':
+                return $value;
+            default:
+                throw new \UnexpectedValueException('Unknown timestamp format: ' . $format);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Api/Validator.php

@@ -0,0 +1,193 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Api;
+
+use Aws;
+/**
+ * Validates a schema against a hash of input.
+ */
+class Validator
+{
+    private $path = [];
+    private $errors = [];
+    private $constraints = [];
+    private static $defaultConstraints = ['required' => true, 'min' => true, 'max' => false, 'pattern' => false];
+    /**
+     * @param array $constraints Associative array of constraints to enforce.
+     *                           Accepts the following keys: "required", "min",
+     *                           "max", and "pattern". If a key is not
+     *                           provided, the constraint will assume false.
+     */
+    public function __construct(array $constraints = null)
+    {
+        static $assumedFalseValues = ['required' => false, 'min' => false, 'max' => false, 'pattern' => false];
+        $this->constraints = empty($constraints) ? self::$defaultConstraints : $constraints + $assumedFalseValues;
+    }
+    /**
+     * Validates the given input against the schema.
+     *
+     * @param string $name  Operation name
+     * @param Shape  $shape Shape to validate
+     * @param array  $input Input to validate
+     *
+     * @throws \InvalidArgumentException if the input is invalid.
+     */
+    public function validate($name, \UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, array $input)
+    {
+        $this->dispatch($shape, $input);
+        if ($this->errors) {
+            $message = sprintf("Found %d error%s while validating the input provided for the " . "%s operation:\n%s", count($this->errors), count($this->errors) > 1 ? 's' : '', $name, implode("\n", $this->errors));
+            $this->errors = [];
+            throw new \InvalidArgumentException($message);
+        }
+    }
+    private function dispatch(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        static $methods = ['structure' => 'check_structure', 'list' => 'check_list', 'map' => 'check_map', 'blob' => 'check_blob', 'boolean' => 'check_boolean', 'integer' => 'check_numeric', 'float' => 'check_numeric', 'long' => 'check_numeric', 'string' => 'check_string', 'byte' => 'check_string', 'char' => 'check_string'];
+        $type = $shape->getType();
+        if (isset($methods[$type])) {
+            $this->{$methods[$type]}($shape, $value);
+        }
+    }
+    private function check_structure(\UglyRobot\Infinite_Uploads\Aws\Api\StructureShape $shape, $value)
+    {
+        if (!$this->checkAssociativeArray($value)) {
+            return;
+        }
+        if ($this->constraints['required'] && $shape['required']) {
+            foreach ($shape['required'] as $req) {
+                if (!isset($value[$req])) {
+                    $this->path[] = $req;
+                    $this->addError('is missing and is a required parameter');
+                    array_pop($this->path);
+                }
+            }
+        }
+        foreach ($value as $name => $v) {
+            if ($shape->hasMember($name)) {
+                $this->path[] = $name;
+                $this->dispatch($shape->getMember($name), isset($value[$name]) ? $value[$name] : null);
+                array_pop($this->path);
+            }
+        }
+    }
+    private function check_list(\UglyRobot\Infinite_Uploads\Aws\Api\ListShape $shape, $value)
+    {
+        if (!is_array($value)) {
+            $this->addError('must be an array. Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            return;
+        }
+        $this->validateRange($shape, count($value), "list element count");
+        $items = $shape->getMember();
+        foreach ($value as $index => $v) {
+            $this->path[] = $index;
+            $this->dispatch($items, $v);
+            array_pop($this->path);
+        }
+    }
+    private function check_map(\UglyRobot\Infinite_Uploads\Aws\Api\MapShape $shape, $value)
+    {
+        if (!$this->checkAssociativeArray($value)) {
+            return;
+        }
+        $values = $shape->getValue();
+        foreach ($value as $key => $v) {
+            $this->path[] = $key;
+            $this->dispatch($values, $v);
+            array_pop($this->path);
+        }
+    }
+    private function check_blob(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        static $valid = ['string' => true, 'integer' => true, 'double' => true, 'resource' => true];
+        $type = gettype($value);
+        if (!isset($valid[$type])) {
+            if ($type != 'object' || !method_exists($value, '__toString')) {
+                $this->addError('must be an fopen resource, a ' . 'UglyRobot\\Infinite_Uploads\\GuzzleHttp\\Stream\\StreamInterface object, or something ' . 'that can be cast to a string. Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            }
+        }
+    }
+    private function check_numeric(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        if (!is_numeric($value)) {
+            $this->addError('must be numeric. Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            return;
+        }
+        $this->validateRange($shape, $value, "numeric value");
+    }
+    private function check_boolean(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        if (!is_bool($value)) {
+            $this->addError('must be a boolean. Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+        }
+    }
+    private function check_string(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $value)
+    {
+        if ($shape['jsonvalue']) {
+            if (!self::canJsonEncode($value)) {
+                $this->addError('must be a value encodable with \'json_encode\'.' . ' Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            }
+            return;
+        }
+        if (!$this->checkCanString($value)) {
+            $this->addError('must be a string or an object that implements ' . '__toString(). Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            return;
+        }
+        $this->validateRange($shape, strlen($value), "string length");
+        if ($this->constraints['pattern']) {
+            $pattern = $shape['pattern'];
+            if ($pattern && !preg_match("/{$pattern}/", $value)) {
+                $this->addError("Pattern /{$pattern}/ failed to match '{$value}'");
+            }
+        }
+    }
+    private function validateRange(\UglyRobot\Infinite_Uploads\Aws\Api\Shape $shape, $length, $descriptor)
+    {
+        if ($this->constraints['min']) {
+            $min = $shape['min'];
+            if ($min && $length < $min) {
+                $this->addError("expected {$descriptor} to be >= {$min}, but " . "found {$descriptor} of {$length}");
+            }
+        }
+        if ($this->constraints['max']) {
+            $max = $shape['max'];
+            if ($max && $length > $max) {
+                $this->addError("expected {$descriptor} to be <= {$max}, but " . "found {$descriptor} of {$length}");
+            }
+        }
+    }
+    private function checkCanString($value)
+    {
+        static $valid = ['string' => true, 'integer' => true, 'double' => true, 'NULL' => true];
+        $type = gettype($value);
+        return isset($valid[$type]) || $type == 'object' && method_exists($value, '__toString');
+    }
+    private function checkAssociativeArray($value)
+    {
+        $isAssociative = false;
+        if (is_array($value)) {
+            $expectedIndex = 0;
+            $key = key($value);
+            do {
+                $isAssociative = $key !== $expectedIndex++;
+                next($value);
+                $key = key($value);
+            } while (!$isAssociative && null !== $key);
+        }
+        if (!$isAssociative) {
+            $this->addError('must be an associative array. Found ' . \UglyRobot\Infinite_Uploads\Aws\describe_type($value));
+            return false;
+        }
+        return true;
+    }
+    private function addError($message)
+    {
+        $this->errors[] = implode('', array_map(function ($s) {
+            return "[{$s}]";
+        }, $this->path)) . ' ' . $message;
+    }
+    private function canJsonEncode($data)
+    {
+        return !is_resource($data);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/AccessPointArn.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException;
+/**
+ * @internal
+ */
+class AccessPointArn extends \UglyRobot\Infinite_Uploads\Aws\Arn\Arn implements \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArnInterface
+{
+    use ResourceTypeAndIdTrait;
+    /**
+     * AccessPointArn constructor
+     *
+     * @param $data
+     */
+    public function __construct($data)
+    {
+        parent::__construct($data);
+        static::validate($this->data);
+    }
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        $data = self::parseResourceTypeAndId($data);
+        $data['accesspoint_name'] = $data['resource_id'];
+        return $data;
+    }
+    public function getAccesspointName()
+    {
+        return $this->data['accesspoint_name'];
+    }
+    /**
+     * Validation specific to AccessPointArn
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        self::validateRegion($data, 'access point ARN');
+        self::validateAccountId($data, 'access point ARN');
+        if ($data['resource_type'] !== 'accesspoint') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 6th component of an access point ARN" . " represents the resource type and must be 'accesspoint'.");
+        }
+        if (empty($data['resource_id'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 7th component of an access point ARN" . " represents the resource ID and must not be empty.");
+        }
+        if (strpos($data['resource_id'], ':') !== false) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The resource ID component of an access" . " point ARN must not contain additional components" . " (delimited by ':').");
+        }
+        if (!self::isValidHostLabel($data['resource_id'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The resource ID in an access point ARN" . " must be a valid host label value.");
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/AccessPointArnInterface.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+/**
+ * @internal
+ */
+interface AccessPointArnInterface extends ArnInterface
+{
+    public function getAccesspointName();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/Arn.php

@@ -0,0 +1,140 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException;
+/**
+ * Amazon Resource Names (ARNs) uniquely identify AWS resources. The Arn class
+ * parses and stores a generic ARN object representation that can apply to any
+ * service resource.
+ *
+ * @internal
+ */
+class Arn implements \UglyRobot\Infinite_Uploads\Aws\Arn\ArnInterface
+{
+    protected $data;
+    protected $string;
+    public static function parse($string)
+    {
+        $data = ['arn' => null, 'partition' => null, 'service' => null, 'region' => null, 'account_id' => null, 'resource' => null];
+        $length = strlen($string);
+        $lastDelim = 0;
+        $numComponents = 0;
+        for ($i = 0; $i < $length; $i++) {
+            if ($numComponents < 5 && $string[$i] === ':') {
+                // Split components between delimiters
+                $data[key($data)] = substr($string, $lastDelim, $i - $lastDelim);
+                // Do not include delimiter character itself
+                $lastDelim = $i + 1;
+                next($data);
+                $numComponents++;
+            }
+            if ($i === $length - 1) {
+                // Put the remainder in the last component.
+                if (in_array($numComponents, [5])) {
+                    $data['resource'] = substr($string, $lastDelim);
+                } else {
+                    // If there are < 5 components, put remainder in current
+                    // component.
+                    $data[key($data)] = substr($string, $lastDelim);
+                }
+            }
+        }
+        return $data;
+    }
+    public function __construct($data)
+    {
+        if (is_array($data)) {
+            $this->data = $data;
+        } elseif (is_string($data)) {
+            $this->data = static::parse($data);
+        } else {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException('Constructor accepts a string or an' . ' array as an argument.');
+        }
+        static::validate($this->data);
+    }
+    public function __toString()
+    {
+        if (!isset($this->string)) {
+            $components = [$this->getPrefix(), $this->getPartition(), $this->getService(), $this->getRegion(), $this->getAccountId(), $this->getResource()];
+            $this->string = implode(':', $components);
+        }
+        return $this->string;
+    }
+    public function getPrefix()
+    {
+        return $this->data['arn'];
+    }
+    public function getPartition()
+    {
+        return $this->data['partition'];
+    }
+    public function getService()
+    {
+        return $this->data['service'];
+    }
+    public function getRegion()
+    {
+        return $this->data['region'];
+    }
+    public function getAccountId()
+    {
+        return $this->data['account_id'];
+    }
+    public function getResource()
+    {
+        return $this->data['resource'];
+    }
+    public function toArray()
+    {
+        return $this->data;
+    }
+    /**
+     * Minimally restrictive generic ARN validation
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        if ($data['arn'] !== 'arn') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 1st component of an ARN must be" . " 'arn'.");
+        }
+        if (empty($data['partition'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 2nd component of an ARN" . " represents the partition and must not be empty.");
+        }
+        if (empty($data['service'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 3rd component of an ARN" . " represents the service and must not be empty.");
+        }
+        if (empty($data['resource'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 6th component of an ARN" . " represents the resource information and must not be empty." . " Individual service ARNs may include additional delimiters" . " to further qualify resources.");
+        }
+    }
+    protected static function validateAccountId($data, $arnName)
+    {
+        if (!self::isValidHostLabel($data['account_id'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 5th component of a {$arnName}" . " is required, represents the account ID, and" . " must be a valid host label.");
+        }
+    }
+    protected static function validateRegion($data, $arnName)
+    {
+        if (empty($data['region'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 4th component of a {$arnName}" . " represents the region and must not be empty.");
+        }
+    }
+    /**
+     * Validates whether a string component is a valid host label
+     *
+     * @param $string
+     * @return bool
+     */
+    protected static function isValidHostLabel($string)
+    {
+        if (empty($string) || strlen($string) > 63) {
+            return false;
+        }
+        if ($value = preg_match("/^[a-zA-Z0-9-]+\$/", $string)) {
+            return true;
+        }
+        return false;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/ArnInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+/**
+ * Amazon Resource Names (ARNs) uniquely identify AWS resources. Classes
+ * implementing ArnInterface parse and store an ARN object representation.
+ *
+ * Valid ARN formats include:
+ *
+ *   arn:partition:service:region:account-id:resource-id
+ *   arn:partition:service:region:account-id:resource-type/resource-id
+ *   arn:partition:service:region:account-id:resource-type:resource-id
+ *
+ * Some components may be omitted, depending on the service and resource type.
+ *
+ * @internal
+ */
+interface ArnInterface
+{
+    public static function parse($string);
+    public function __toString();
+    public function getPrefix();
+    public function getPartition();
+    public function getService();
+    public function getRegion();
+    public function getAccountId();
+    public function getResource();
+    public function toArray();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/ArnParser.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\S3\AccessPointArn as S3AccessPointArn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsBucketArn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\S3\RegionalBucketArn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsAccessPointArn;
+/**
+ * This class provides functionality to parse ARN strings and return a
+ * corresponding ARN object. ARN-parsing logic may be subject to change in the
+ * future, so this should not be relied upon for external customer usage.
+ *
+ * @internal
+ */
+class ArnParser
+{
+    /**
+     * @param $string
+     * @return bool
+     */
+    public static function isArn($string)
+    {
+        return strpos($string, 'arn:') === 0;
+    }
+    /**
+     * Parses a string and returns an instance of ArnInterface. Returns a
+     * specific type of Arn object if it has a specific class representation
+     * or a generic Arn object if not.
+     *
+     * @param $string
+     * @return ArnInterface
+     */
+    public static function parse($string)
+    {
+        $data = \UglyRobot\Infinite_Uploads\Aws\Arn\Arn::parse($string);
+        $resource = self::explodeResourceComponent($data['resource']);
+        if ($resource[0] === 'outpost') {
+            if (isset($resource[2]) && $resource[2] === 'bucket') {
+                return new \UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsBucketArn($string);
+            }
+            if (isset($resource[2]) && $resource[2] === 'accesspoint') {
+                return new \UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsAccessPointArn($string);
+            }
+        }
+        if ($resource[0] === 'accesspoint') {
+            if ($data['service'] === 's3') {
+                return new \UglyRobot\Infinite_Uploads\Aws\Arn\S3\AccessPointArn($string);
+            }
+            return new \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArn($string);
+        }
+        return new \UglyRobot\Infinite_Uploads\Aws\Arn\Arn($data);
+    }
+    private static function explodeResourceComponent($resource)
+    {
+        return preg_split("/[\\/:]/", $resource);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/Exception/InvalidArnException.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\Exception;
+
+/**
+ * Represents a failed attempt to construct an Arn
+ */
+class InvalidArnException extends \RuntimeException
+{
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/ResourceTypeAndIdTrait.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn;
+
+/**
+ * @internal
+ */
+trait ResourceTypeAndIdTrait
+{
+    public function getResourceType()
+    {
+        return $this->data['resource_type'];
+    }
+    public function getResourceId()
+    {
+        return $this->data['resource_id'];
+    }
+    private static function parseResourceTypeAndId(array $data)
+    {
+        $resourceData = preg_split("/[\\/:]/", $data['resource'], 2);
+        $data['resource_type'] = isset($resourceData[0]) ? $resourceData[0] : null;
+        $data['resource_id'] = isset($resourceData[1]) ? $resourceData[1] : null;
+        return $data;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/S3/AccessPointArn.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\S3;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArn as BaseAccessPointArn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArnInterface;
+use UglyRobot\Infinite_Uploads\Aws\Arn\ArnInterface;
+use UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException;
+/**
+ * @internal
+ */
+class AccessPointArn extends \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArn implements \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArnInterface
+{
+    /**
+     * Validation specific to AccessPointArn
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        parent::validate($data);
+        if ($data['service'] !== 's3') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 3rd component of an S3 access" . " point ARN represents the region and must be 's3'.");
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/S3/BucketArnInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\S3;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\ArnInterface;
+/**
+ * @internal
+ */
+interface BucketArnInterface extends ArnInterface
+{
+    public function getBucketName();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/S3/OutpostsAccessPointArn.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\S3;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArn as BaseAccessPointArn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArnInterface;
+use UglyRobot\Infinite_Uploads\Aws\Arn\Arn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException;
+/**
+ * This class represents an S3 Outposts access point ARN, which is in the
+ * following format:
+ *
+ * arn:{partition}:s3-outposts:{region}:{accountId}:outpost:{outpostId}:accesspoint:{accesspointName}
+ *
+ * ':' and '/' can be used interchangeably as delimiters for components after
+ * the account ID.
+ *
+ * @internal
+ */
+class OutpostsAccessPointArn extends \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArn implements \UglyRobot\Infinite_Uploads\Aws\Arn\AccessPointArnInterface, \UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsArnInterface
+{
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        return self::parseOutpostData($data);
+    }
+    public function getOutpostId()
+    {
+        return $this->data['outpost_id'];
+    }
+    public function getAccesspointName()
+    {
+        return $this->data['accesspoint_name'];
+    }
+    private static function parseOutpostData(array $data)
+    {
+        $resourceData = preg_split("/[\\/:]/", $data['resource_id']);
+        $data['outpost_id'] = isset($resourceData[0]) ? $resourceData[0] : null;
+        $data['accesspoint_type'] = isset($resourceData[1]) ? $resourceData[1] : null;
+        $data['accesspoint_name'] = isset($resourceData[2]) ? $resourceData[2] : null;
+        if (isset($resourceData[3])) {
+            $data['resource_extra'] = implode(':', array_slice($resourceData, 3));
+        }
+        return $data;
+    }
+    /**
+     * Validation specific to OutpostsAccessPointArn. Note this uses the base Arn
+     * class validation instead of the direct parent due to it having slightly
+     * differing requirements from its parent.
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        \UglyRobot\Infinite_Uploads\Aws\Arn\Arn::validate($data);
+        if ($data['service'] !== 's3-outposts') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 3rd component of an S3 Outposts" . " access point ARN represents the service and must be" . " 's3-outposts'.");
+        }
+        self::validateRegion($data, 'S3 Outposts access point ARN');
+        self::validateAccountId($data, 'S3 Outposts access point ARN');
+        if ($data['resource_type'] !== 'outpost') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 6th component of an S3 Outposts" . " access point ARN represents the resource type and must be" . " 'outpost'.");
+        }
+        if (!self::isValidHostLabel($data['outpost_id'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 7th component of an S3 Outposts" . " access point ARN is required, represents the outpost ID, and" . " must be a valid host label.");
+        }
+        if ($data['accesspoint_type'] !== 'accesspoint') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 8th component of an S3 Outposts" . " access point ARN must be 'accesspoint'");
+        }
+        if (!self::isValidHostLabel($data['accesspoint_name'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 9th component of an S3 Outposts" . " access point ARN is required, represents the accesspoint name," . " and must be a valid host label.");
+        }
+        if (!empty($data['resource_extra'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("An S3 Outposts access point ARN" . " should only have 9 components, delimited by the characters" . " ':' and '/'. '{$data['resource_extra']}' was found after the" . " 9th component.");
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/S3/OutpostsArnInterface.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\S3;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\ArnInterface;
+/**
+ * @internal
+ */
+interface OutpostsArnInterface extends ArnInterface
+{
+    public function getOutpostId();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Arn/S3/OutpostsBucketArn.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Arn\S3;
+
+use UglyRobot\Infinite_Uploads\Aws\Arn\Arn;
+use UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException;
+use UglyRobot\Infinite_Uploads\Aws\Arn\ResourceTypeAndIdTrait;
+/**
+ * This class represents an S3 Outposts bucket ARN, which is in the
+ * following format:
+ *
+ * @internal
+ */
+class OutpostsBucketArn extends \UglyRobot\Infinite_Uploads\Aws\Arn\Arn implements \UglyRobot\Infinite_Uploads\Aws\Arn\S3\BucketArnInterface, \UglyRobot\Infinite_Uploads\Aws\Arn\S3\OutpostsArnInterface
+{
+    use ResourceTypeAndIdTrait;
+    /**
+     * Parses a string into an associative array of components that represent
+     * a OutpostsBucketArn
+     *
+     * @param $string
+     * @return array
+     */
+    public static function parse($string)
+    {
+        $data = parent::parse($string);
+        $data = self::parseResourceTypeAndId($data);
+        return self::parseOutpostData($data);
+    }
+    public function getBucketName()
+    {
+        return $this->data['bucket_name'];
+    }
+    public function getOutpostId()
+    {
+        return $this->data['outpost_id'];
+    }
+    private static function parseOutpostData(array $data)
+    {
+        $resourceData = preg_split("/[\\/:]/", $data['resource_id'], 3);
+        $data['outpost_id'] = isset($resourceData[0]) ? $resourceData[0] : null;
+        $data['bucket_label'] = isset($resourceData[1]) ? $resourceData[1] : null;
+        $data['bucket_name'] = isset($resourceData[2]) ? $resourceData[2] : null;
+        return $data;
+    }
+    /**
+     *
+     * @param array $data
+     */
+    protected static function validate(array $data)
+    {
+        \UglyRobot\Infinite_Uploads\Aws\Arn\Arn::validate($data);
+        if ($data['service'] !== 's3-outposts') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 3rd component of an S3 Outposts" . " bucket ARN represents the service and must be 's3-outposts'.");
+        }
+        self::validateRegion($data, 'S3 Outposts bucket ARN');
+        self::validateAccountId($data, 'S3 Outposts bucket ARN');
+        if ($data['resource_type'] !== 'outpost') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 6th component of an S3 Outposts" . " bucket ARN represents the resource type and must be" . " 'outpost'.");
+        }
+        if (!self::isValidHostLabel($data['outpost_id'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 7th component of an S3 Outposts" . " bucket ARN is required, represents the outpost ID, and" . " must be a valid host label.");
+        }
+        if ($data['bucket_label'] !== 'bucket') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 8th component of an S3 Outposts" . " bucket ARN must be 'bucket'");
+        }
+        if (empty($data['bucket_name'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Arn\Exception\InvalidArnException("The 9th component of an S3 Outposts" . " bucket ARN represents the bucket name and must not be empty.");
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/AwsClient.php

@@ -0,0 +1,376 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\ApiProvider;
+use UglyRobot\Infinite_Uploads\Aws\Api\DocModel;
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+use UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ApiCallAttemptMonitoringMiddleware;
+use UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ApiCallMonitoringMiddleware;
+use UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider;
+use UglyRobot\Infinite_Uploads\Aws\EndpointDiscovery\EndpointDiscoveryMiddleware;
+use UglyRobot\Infinite_Uploads\Aws\Signature\SignatureProvider;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Uri;
+/**
+ * Default AWS client implementation
+ */
+class AwsClient implements \UglyRobot\Infinite_Uploads\Aws\AwsClientInterface
+{
+    use AwsClientTrait;
+    /** @var array */
+    private $aliases;
+    /** @var array */
+    private $config;
+    /** @var string */
+    private $region;
+    /** @var string */
+    private $endpoint;
+    /** @var Service */
+    private $api;
+    /** @var callable */
+    private $signatureProvider;
+    /** @var callable */
+    private $credentialProvider;
+    /** @var HandlerList */
+    private $handlerList;
+    /** @var array*/
+    private $defaultRequestOptions;
+    /**
+     * Get an array of client constructor arguments used by the client.
+     *
+     * @return array
+     */
+    public static function getArguments()
+    {
+        return \UglyRobot\Infinite_Uploads\Aws\ClientResolver::getDefaultArguments();
+    }
+    /**
+     * The client constructor accepts the following options:
+     *
+     * - api_provider: (callable) An optional PHP callable that accepts a
+     *   type, service, and version argument, and returns an array of
+     *   corresponding configuration data. The type value can be one of api,
+     *   waiter, or paginator.
+     * - credentials:
+     *   (Aws\Credentials\CredentialsInterface|array|bool|callable) Specifies
+     *   the credentials used to sign requests. Provide an
+     *   Aws\Credentials\CredentialsInterface object, an associative array of
+     *   "key", "secret", and an optional "token" key, `false` to use null
+     *   credentials, or a callable credentials provider used to create
+     *   credentials or return null. See Aws\Credentials\CredentialProvider for
+     *   a list of built-in credentials providers. If no credentials are
+     *   provided, the SDK will attempt to load them from the environment.
+     * - csm:
+     *   (Aws\ClientSideMonitoring\ConfigurationInterface|array|callable) Specifies
+     *   the credentials used to sign requests. Provide an
+     *   Aws\ClientSideMonitoring\ConfigurationInterface object, a callable
+     *   configuration provider used to create client-side monitoring configuration,
+     *   `false` to disable csm, or an associative array with the following keys:
+     *   enabled: (bool) Set to true to enable client-side monitoring, defaults
+     *   to false; host: (string) the host location to send monitoring events to,
+     *   defaults to 127.0.0.1; port: (int) The port used for the host connection,
+     *   defaults to 31000; client_id: (string) An identifier for this project
+     * - debug: (bool|array) Set to true to display debug information when
+     *   sending requests. Alternatively, you can provide an associative array
+     *   with the following keys: logfn: (callable) Function that is invoked
+     *   with log messages; stream_size: (int) When the size of a stream is
+     *   greater than this number, the stream data will not be logged (set to
+     *   "0" to not log any stream data); scrub_auth: (bool) Set to false to
+     *   disable the scrubbing of auth data from the logged messages; http:
+     *   (bool) Set to false to disable the "debug" feature of lower level HTTP
+     *   adapters (e.g., verbose curl output).
+     * - stats: (bool|array) Set to true to gather transfer statistics on
+     *   requests sent. Alternatively, you can provide an associative array with
+     *   the following keys: retries: (bool) Set to false to disable reporting
+     *   on retries attempted; http: (bool) Set to true to enable collecting
+     *   statistics from lower level HTTP adapters (e.g., values returned in
+     *   GuzzleHttp\TransferStats). HTTP handlers must support an
+     *   `http_stats_receiver` option for this to have an effect; timer: (bool)
+     *   Set to true to enable a command timer that reports the total wall clock
+     *   time spent on an operation in seconds.
+     * - disable_host_prefix_injection: (bool) Set to true to disable host prefix
+     *   injection logic for services that use it. This disables the entire
+     *   prefix injection, including the portions supplied by user-defined
+     *   parameters. Setting this flag will have no effect on services that do
+     *   not use host prefix injection.
+     * - endpoint: (string) The full URI of the webservice. This is only
+     *   required when connecting to a custom endpoint (e.g., a local version
+     *   of S3).
+     * - endpoint_discovery: (Aws\EndpointDiscovery\ConfigurationInterface,
+     *   Aws\CacheInterface, array, callable) Settings for endpoint discovery.
+     *   Provide an instance of Aws\EndpointDiscovery\ConfigurationInterface,
+     *   an instance Aws\CacheInterface, a callable that provides a promise for
+     *   a Configuration object, or an associative array with the following
+     *   keys: enabled: (bool) Set to true to enable endpoint discovery, false
+     *   to explicitly disable it, defaults to false; cache_limit: (int) The
+     *   maximum number of keys in the endpoints cache, defaults to 1000.
+     * - endpoint_provider: (callable) An optional PHP callable that
+     *   accepts a hash of options including a "service" and "region" key and
+     *   returns NULL or a hash of endpoint data, of which the "endpoint" key
+     *   is required. See Aws\Endpoint\EndpointProvider for a list of built-in
+     *   providers.
+     * - handler: (callable) A handler that accepts a command object,
+     *   request object and returns a promise that is fulfilled with an
+     *   Aws\ResultInterface object or rejected with an
+     *   Aws\Exception\AwsException. A handler does not accept a next handler
+     *   as it is terminal and expected to fulfill a command. If no handler is
+     *   provided, a default Guzzle handler will be utilized.
+     * - http: (array, default=array(0)) Set to an array of SDK request
+     *   options to apply to each request (e.g., proxy, verify, etc.).
+     * - http_handler: (callable) An HTTP handler is a function that
+     *   accepts a PSR-7 request object and returns a promise that is fulfilled
+     *   with a PSR-7 response object or rejected with an array of exception
+     *   data. NOTE: This option supersedes any provided "handler" option.
+     * - idempotency_auto_fill: (bool|callable) Set to false to disable SDK to
+     *   populate parameters that enabled 'idempotencyToken' trait with a random
+     *   UUID v4 value on your behalf. Using default value 'true' still allows
+     *   parameter value to be overwritten when provided. Note: auto-fill only
+     *   works when cryptographically secure random bytes generator functions
+     *   (random_bytes, openssl_random_pseudo_bytes or mcrypt_create_iv) can be
+     *   found. You may also provide a callable source of random bytes.
+     * - profile: (string) Allows you to specify which profile to use when
+     *   credentials are created from the AWS credentials file in your HOME
+     *   directory. This setting overrides the AWS_PROFILE environment
+     *   variable. Note: Specifying "profile" will cause the "credentials" key
+     *   to be ignored.
+     * - region: (string, required) Region to connect to. See
+     *   http://docs.aws.amazon.com/general/latest/gr/rande.html for a list of
+     *   available regions.
+     * - retries: (int, Aws\Retry\ConfigurationInterface, Aws\CacheInterface,
+     *   array, callable) Configures the retry mode and maximum number of
+     *   allowed retries for a client (pass 0 to disable retries). Provide an
+     *   integer for 'legacy' mode with the specified number of retries.
+     *   Otherwise provide an instance of Aws\Retry\ConfigurationInterface, an
+     *   instance of  Aws\CacheInterface, a callable function, or an array with
+     *   the following keys: mode: (string) Set to 'legacy', 'standard' (uses
+     *   retry quota management), or 'adapative' (an experimental mode that adds
+     *   client-side rate limiting to standard mode); max_attempts (int) The
+     *   maximum number of attempts for a given request.
+     * - scheme: (string, default=string(5) "https") URI scheme to use when
+     *   connecting connect. The SDK will utilize "https" endpoints (i.e.,
+     *   utilize SSL/TLS connections) by default. You can attempt to connect to
+     *   a service over an unencrypted "http" endpoint by setting ``scheme`` to
+     *   "http".
+     * - signature_provider: (callable) A callable that accepts a signature
+     *   version name (e.g., "v4"), a service name, and region, and
+     *   returns a SignatureInterface object or null. This provider is used to
+     *   create signers utilized by the client. See
+     *   Aws\Signature\SignatureProvider for a list of built-in providers
+     * - signature_version: (string) A string representing a custom
+     *   signature version to use with a service (e.g., v4). Note that
+     *   per/operation signature version MAY override this requested signature
+     *   version.
+     * - use_aws_shared_config_files: (bool, default=bool(true)) Set to false to
+     *   disable checking for shared config file in '~/.aws/config' and
+     *   '~/.aws/credentials'.  This will override the AWS_CONFIG_FILE
+     *   environment variable.
+     * - validate: (bool, default=bool(true)) Set to false to disable
+     *   client-side parameter validation.
+     * - version: (string, required) The version of the webservice to
+     *   utilize (e.g., 2006-03-01).
+     *
+     * @param array $args Client configuration arguments.
+     *
+     * @throws \InvalidArgumentException if any required options are missing or
+     *                                   the service is not supported.
+     */
+    public function __construct(array $args)
+    {
+        list($service, $exceptionClass) = $this->parseClass();
+        if (!isset($args['service'])) {
+            $args['service'] = manifest($service)['endpoint'];
+        }
+        if (!isset($args['exception_class'])) {
+            $args['exception_class'] = $exceptionClass;
+        }
+        $this->handlerList = new \UglyRobot\Infinite_Uploads\Aws\HandlerList();
+        $resolver = new \UglyRobot\Infinite_Uploads\Aws\ClientResolver(static::getArguments());
+        $config = $resolver->resolve($args, $this->handlerList);
+        $this->api = $config['api'];
+        $this->signatureProvider = $config['signature_provider'];
+        $this->endpoint = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Uri($config['endpoint']);
+        $this->credentialProvider = $config['credentials'];
+        $this->region = isset($config['region']) ? $config['region'] : null;
+        $this->config = $config['config'];
+        $this->defaultRequestOptions = $config['http'];
+        $this->addSignatureMiddleware();
+        $this->addInvocationId();
+        $this->addEndpointParameterMiddleware($args);
+        $this->addEndpointDiscoveryMiddleware($config, $args);
+        $this->loadAliases();
+        $this->addStreamRequestPayload();
+        if (isset($args['with_resolved'])) {
+            $args['with_resolved']($config);
+        }
+    }
+    public function getHandlerList()
+    {
+        return $this->handlerList;
+    }
+    public function getConfig($option = null)
+    {
+        return $option === null ? $this->config : (isset($this->config[$option]) ? $this->config[$option] : null);
+    }
+    public function getCredentials()
+    {
+        $fn = $this->credentialProvider;
+        return $fn();
+    }
+    public function getEndpoint()
+    {
+        return $this->endpoint;
+    }
+    public function getRegion()
+    {
+        return $this->region;
+    }
+    public function getApi()
+    {
+        return $this->api;
+    }
+    public function getCommand($name, array $args = [])
+    {
+        // Fail fast if the command cannot be found in the description.
+        if (!isset($this->getApi()['operations'][$name])) {
+            $name = ucfirst($name);
+            if (!isset($this->getApi()['operations'][$name])) {
+                throw new \InvalidArgumentException("Operation not found: {$name}");
+            }
+        }
+        if (!isset($args['@http'])) {
+            $args['@http'] = $this->defaultRequestOptions;
+        } else {
+            $args['@http'] += $this->defaultRequestOptions;
+        }
+        return new \UglyRobot\Infinite_Uploads\Aws\Command($name, $args, clone $this->getHandlerList());
+    }
+    public function __sleep()
+    {
+        throw new \RuntimeException('Instances of ' . static::class . ' cannot be serialized');
+    }
+    /**
+     * Get the signature_provider function of the client.
+     *
+     * @return callable
+     */
+    public final function getSignatureProvider()
+    {
+        return $this->signatureProvider;
+    }
+    /**
+     * Parse the class name and setup the custom exception class of the client
+     * and return the "service" name of the client and "exception_class".
+     *
+     * @return array
+     */
+    private function parseClass()
+    {
+        $klass = get_class($this);
+        if ($klass === __CLASS__) {
+            return ['', 'UglyRobot\\Infinite_Uploads\\Aws\\Exception\\AwsException'];
+        }
+        $service = substr($klass, strrpos($klass, '\\') + 1, -6);
+        return [strtolower($service), "UglyRobot\\Infinite_Uploads\\Aws\\{$service}\\Exception\\{$service}Exception"];
+    }
+    private function addEndpointParameterMiddleware($args)
+    {
+        if (empty($args['disable_host_prefix_injection'])) {
+            $list = $this->getHandlerList();
+            $list->appendBuild(\UglyRobot\Infinite_Uploads\Aws\EndpointParameterMiddleware::wrap($this->api), 'endpoint_parameter');
+        }
+    }
+    private function addEndpointDiscoveryMiddleware($config, $args)
+    {
+        $list = $this->getHandlerList();
+        if (!isset($args['endpoint'])) {
+            $list->appendBuild(\UglyRobot\Infinite_Uploads\Aws\EndpointDiscovery\EndpointDiscoveryMiddleware::wrap($this, $args, $config['endpoint_discovery']), 'EndpointDiscoveryMiddleware');
+        }
+    }
+    private function addSignatureMiddleware()
+    {
+        $api = $this->getApi();
+        $provider = $this->signatureProvider;
+        $version = $this->config['signature_version'];
+        $name = $this->config['signing_name'];
+        $region = $this->config['signing_region'];
+        $resolver = static function (\UglyRobot\Infinite_Uploads\Aws\CommandInterface $c) use($api, $provider, $name, $region, $version) {
+            if (!empty($c['@context']['signing_region'])) {
+                $region = $c['@context']['signing_region'];
+            }
+            if (!empty($c['@context']['signing_service'])) {
+                $name = $c['@context']['signing_service'];
+            }
+            $authType = $api->getOperation($c->getName())['authtype'];
+            switch ($authType) {
+                case 'none':
+                    $version = 'anonymous';
+                    break;
+                case 'v4-unsigned-body':
+                    $version = 'v4-unsigned-body';
+                    break;
+            }
+            return \UglyRobot\Infinite_Uploads\Aws\Signature\SignatureProvider::resolve($provider, $version, $name, $region);
+        };
+        $this->handlerList->appendSign(\UglyRobot\Infinite_Uploads\Aws\Middleware::signer($this->credentialProvider, $resolver), 'signer');
+    }
+    private function addInvocationId()
+    {
+        // Add invocation id to each request
+        $this->handlerList->prependSign(\UglyRobot\Infinite_Uploads\Aws\Middleware::invocationId(), 'invocation-id');
+    }
+    private function loadAliases($file = null)
+    {
+        if (!isset($this->aliases)) {
+            if (is_null($file)) {
+                $file = __DIR__ . '/data/aliases.json';
+            }
+            $aliases = \UglyRobot\Infinite_Uploads\Aws\load_compiled_json($file);
+            $serviceId = $this->api->getServiceId();
+            $version = $this->getApi()->getApiVersion();
+            if (!empty($aliases['operations'][$serviceId][$version])) {
+                $this->aliases = array_flip($aliases['operations'][$serviceId][$version]);
+            }
+        }
+    }
+    private function addStreamRequestPayload()
+    {
+        $streamRequestPayloadMiddleware = \UglyRobot\Infinite_Uploads\Aws\StreamRequestPayloadMiddleware::wrap($this->api);
+        $this->handlerList->prependSign($streamRequestPayloadMiddleware, 'StreamRequestPayloadMiddleware');
+    }
+    /**
+     * Returns a service model and doc model with any necessary changes
+     * applied.
+     *
+     * @param array $api  Array of service data being documented.
+     * @param array $docs Array of doc model data.
+     *
+     * @return array Tuple containing a [Service, DocModel]
+     *
+     * @internal This should only used to document the service API.
+     * @codeCoverageIgnore
+     */
+    public static function applyDocFilters(array $api, array $docs)
+    {
+        $aliases = \UglyRobot\Infinite_Uploads\Aws\load_compiled_json(__DIR__ . '/data/aliases.json');
+        $serviceId = $api['metadata']['serviceId'];
+        $version = $api['metadata']['apiVersion'];
+        // Replace names for any operations with SDK aliases
+        if (!empty($aliases['operations'][$serviceId][$version])) {
+            foreach ($aliases['operations'][$serviceId][$version] as $op => $alias) {
+                $api['operations'][$alias] = $api['operations'][$op];
+                $docs['operations'][$alias] = $docs['operations'][$op];
+                unset($api['operations'][$op], $docs['operations'][$op]);
+            }
+        }
+        ksort($api['operations']);
+        return [new \UglyRobot\Infinite_Uploads\Aws\Api\Service($api, \UglyRobot\Infinite_Uploads\Aws\Api\ApiProvider::defaultProvider()), new \UglyRobot\Infinite_Uploads\Aws\Api\DocModel($docs)];
+    }
+    /**
+     * @deprecated
+     * @return static
+     */
+    public static function factory(array $config = [])
+    {
+        return new static($config);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/AwsClientInterface.php

@@ -0,0 +1,156 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\UriInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
+/**
+ * Represents an AWS client.
+ */
+interface AwsClientInterface
+{
+    /**
+     * Creates and executes a command for an operation by name.
+     *
+     * Suffixing an operation name with "Async" will return a
+     * promise that can be used to execute commands asynchronously.
+     *
+     * @param string $name      Name of the command to execute.
+     * @param array  $arguments Arguments to pass to the getCommand method.
+     *
+     * @return ResultInterface
+     * @throws \Exception
+     */
+    public function __call($name, array $arguments);
+    /**
+     * Create a command for an operation name.
+     *
+     * Special keys may be set on the command to control how it behaves,
+     * including:
+     *
+     * - @http: Associative array of transfer specific options to apply to the
+     *   request that is serialized for this command. Available keys include
+     *   "proxy", "verify", "timeout", "connect_timeout", "debug", "delay", and
+     *   "headers".
+     *
+     * @param string $name Name of the operation to use in the command
+     * @param array  $args Arguments to pass to the command
+     *
+     * @return CommandInterface
+     * @throws \InvalidArgumentException if no command can be found by name
+     */
+    public function getCommand($name, array $args = []);
+    /**
+     * Execute a single command.
+     *
+     * @param CommandInterface $command Command to execute
+     *
+     * @return ResultInterface
+     * @throws \Exception
+     */
+    public function execute(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command);
+    /**
+     * Execute a command asynchronously.
+     *
+     * @param CommandInterface $command Command to execute
+     *
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    public function executeAsync(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command);
+    /**
+     * Returns a promise that is fulfilled with an
+     * {@see \Aws\Credentials\CredentialsInterface} object.
+     *
+     * If you need the credentials synchronously, then call the wait() method
+     * on the returned promise.
+     *
+     * @return PromiseInterface
+     */
+    public function getCredentials();
+    /**
+     * Get the region to which the client is configured to send requests.
+     *
+     * @return string
+     */
+    public function getRegion();
+    /**
+     * Gets the default endpoint, or base URL, used by the client.
+     *
+     * @return UriInterface
+     */
+    public function getEndpoint();
+    /**
+     * Get the service description associated with the client.
+     *
+     * @return \Aws\Api\Service
+     */
+    public function getApi();
+    /**
+     * Get a client configuration value.
+     *
+     * @param string|null $option The option to retrieve. Pass null to retrieve
+     *                            all options.
+     * @return mixed|null
+     */
+    public function getConfig($option = null);
+    /**
+     * Get the handler list used to transfer commands.
+     *
+     * This list can be modified to add middleware or to change the underlying
+     * handler used to send HTTP requests.
+     *
+     * @return HandlerList
+     */
+    public function getHandlerList();
+    /**
+     * Get a resource iterator for the specified operation.
+     *
+     * @param string $name Name of the iterator to retrieve.
+     * @param array  $args Command arguments to use with each command.
+     *
+     * @return \Iterator
+     * @throws \UnexpectedValueException if the iterator config is invalid.
+     */
+    public function getIterator($name, array $args = []);
+    /**
+     * Get a result paginator for the specified operation.
+     *
+     * @param string $name   Name of the operation used for iterator
+     * @param array  $args   Command args to be used with each command
+     *
+     * @return \Aws\ResultPaginator
+     * @throws \UnexpectedValueException if the iterator config is invalid.
+     */
+    public function getPaginator($name, array $args = []);
+    /**
+     * Wait until a resource is in a particular state.
+     *
+     * @param string|callable $name Name of the waiter that defines the wait
+     *                              configuration and conditions.
+     * @param array  $args          Args to be used with each command executed
+     *                              by the waiter. Waiter configuration options
+     *                              can be provided in an associative array in
+     *                              the @waiter key.
+     * @return void
+     * @throws \UnexpectedValueException if the waiter is invalid.
+     */
+    public function waitUntil($name, array $args = []);
+    /**
+     * Get a waiter that waits until a resource is in a particular state.
+     *
+     * Retrieving a waiter can be useful when you wish to wait asynchronously:
+     *
+     *     $waiter = $client->getWaiter('foo', ['bar' => 'baz']);
+     *     $waiter->promise()->then(function () { echo 'Done!'; });
+     *
+     * @param string|callable $name Name of the waiter that defines the wait
+     *                              configuration and conditions.
+     * @param array  $args          Args to be used with each command executed
+     *                              by the waiter. Waiter configuration options
+     *                              can be provided in an associative array in
+     *                              the @waiter key.
+     * @return \Aws\Waiter
+     * @throws \UnexpectedValueException if the waiter is invalid.
+     */
+    public function getWaiter($name, array $args = []);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/AwsClientTrait.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+use UglyRobot\Infinite_Uploads\Aws\Api\Service;
+/**
+ * A trait providing generic functionality for interacting with Amazon Web
+ * Services. This is meant to be used in classes implementing
+ * \Aws\AwsClientInterface
+ */
+trait AwsClientTrait
+{
+    public function getPaginator($name, array $args = [])
+    {
+        $config = $this->getApi()->getPaginatorConfig($name);
+        return new \UglyRobot\Infinite_Uploads\Aws\ResultPaginator($this, $name, $args, $config);
+    }
+    public function getIterator($name, array $args = [])
+    {
+        $config = $this->getApi()->getPaginatorConfig($name);
+        if (!$config['result_key']) {
+            throw new \UnexpectedValueException(sprintf('There are no resources to iterate for the %s operation of %s', $name, $this->getApi()['serviceFullName']));
+        }
+        $key = is_array($config['result_key']) ? $config['result_key'][0] : $config['result_key'];
+        if ($config['output_token'] && $config['input_token']) {
+            return $this->getPaginator($name, $args)->search($key);
+        }
+        $result = $this->execute($this->getCommand($name, $args))->search($key);
+        return new \ArrayIterator((array) $result);
+    }
+    public function waitUntil($name, array $args = [])
+    {
+        return $this->getWaiter($name, $args)->promise()->wait();
+    }
+    public function getWaiter($name, array $args = [])
+    {
+        $config = isset($args['@waiter']) ? $args['@waiter'] : [];
+        $config += $this->getApi()->getWaiterConfig($name);
+        return new \UglyRobot\Infinite_Uploads\Aws\Waiter($this, $name, $args, $config);
+    }
+    public function execute(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command)
+    {
+        return $this->executeAsync($command)->wait();
+    }
+    public function executeAsync(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $command)
+    {
+        $handler = $command->getHandlerList()->resolve();
+        return $handler($command);
+    }
+    public function __call($name, array $args)
+    {
+        if (substr($name, -5) === 'Async') {
+            $name = substr($name, 0, -5);
+            $isAsync = true;
+        }
+        if (!empty($this->aliases[ucfirst($name)])) {
+            $name = $this->aliases[ucfirst($name)];
+        }
+        $params = isset($args[0]) ? $args[0] : [];
+        if (!empty($isAsync)) {
+            return $this->executeAsync($this->getCommand($name, $params));
+        }
+        return $this->execute($this->getCommand($name, $params));
+    }
+    /**
+     * @param string $name
+     * @param array $args
+     *
+     * @return CommandInterface
+     */
+    public abstract function getCommand($name, array $args = []);
+    /**
+     * @return Service
+     */
+    public abstract function getApi();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/CacheInterface.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+/**
+ * Represents a simple cache interface.
+ */
+interface CacheInterface
+{
+    /**
+     * Get a cache item by key.
+     *
+     * @param string $key Key to retrieve.
+     *
+     * @return mixed|null Returns the value or null if not found.
+     */
+    public function get($key);
+    /**
+     * Set a cache key value.
+     *
+     * @param string $key   Key to set
+     * @param mixed  $value Value to set.
+     * @param int    $ttl   Number of seconds the item is allowed to live. Set
+     *                      to 0 to allow an unlimited lifetime.
+     */
+    public function set($key, $value, $ttl = 0);
+    /**
+     * Remove a cache key.
+     *
+     * @param string $key Key to remove.
+     */
+    public function remove($key);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/AbstractMonitoringMiddleware.php

@@ -0,0 +1,226 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * @internal
+ */
+abstract class AbstractMonitoringMiddleware implements \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\MonitoringMiddlewareInterface
+{
+    private static $socket;
+    private $nextHandler;
+    private $options;
+    protected $credentialProvider;
+    protected $region;
+    protected $service;
+    protected static function getAwsExceptionHeader(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e, $headerName)
+    {
+        $response = $e->getResponse();
+        if ($response !== null) {
+            $header = $response->getHeader($headerName);
+            if (!empty($header[0])) {
+                return $header[0];
+            }
+        }
+        return null;
+    }
+    protected static function getResultHeader(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result, $headerName)
+    {
+        if (isset($result['@metadata']['headers'][$headerName])) {
+            return $result['@metadata']['headers'][$headerName];
+        }
+        return null;
+    }
+    protected static function getExceptionHeader(\Exception $e, $headerName)
+    {
+        if ($e instanceof ResponseContainerInterface) {
+            $response = $e->getResponse();
+            if ($response instanceof ResponseInterface) {
+                $header = $response->getHeader($headerName);
+                if (!empty($header[0])) {
+                    return $header[0];
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Constructor stores the passed in handler and options.
+     *
+     * @param callable $handler
+     * @param callable $credentialProvider
+     * @param $options
+     * @param $region
+     * @param $service
+     */
+    public function __construct(callable $handler, callable $credentialProvider, $options, $region, $service)
+    {
+        $this->nextHandler = $handler;
+        $this->credentialProvider = $credentialProvider;
+        $this->options = $options;
+        $this->region = $region;
+        $this->service = $service;
+    }
+    /**
+     * Standard invoke pattern for middleware execution to be implemented by
+     * child classes.
+     *
+     * @param  CommandInterface $cmd
+     * @param  RequestInterface $request
+     * @return Promise\PromiseInterface
+     */
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
+    {
+        $handler = $this->nextHandler;
+        $eventData = null;
+        $enabled = $this->isEnabled();
+        if ($enabled) {
+            $cmd['@http']['collect_stats'] = true;
+            $eventData = $this->populateRequestEventData($cmd, $request, $this->getNewEvent($cmd, $request));
+        }
+        $g = function ($value) use($eventData, $enabled) {
+            if ($enabled) {
+                $eventData = $this->populateResultEventData($value, $eventData);
+                $this->sendEventData($eventData);
+                if ($value instanceof MonitoringEventsInterface) {
+                    $value->appendMonitoringEvent($eventData);
+                }
+            }
+            if ($value instanceof \Exception || $value instanceof \Throwable) {
+                return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\rejection_for($value);
+            }
+            return $value;
+        };
+        return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($handler($cmd, $request))->then($g, $g);
+    }
+    private function getClientId()
+    {
+        return $this->unwrappedOptions()->getClientId();
+    }
+    private function getNewEvent(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
+    {
+        $event = ['Api' => $cmd->getName(), 'ClientId' => $this->getClientId(), 'Region' => $this->getRegion(), 'Service' => $this->getService(), 'Timestamp' => (int) floor(microtime(true) * 1000), 'UserAgent' => substr($request->getHeaderLine('User-Agent') . ' ' . \UglyRobot\Infinite_Uploads\Aws\default_user_agent(), 0, 256), 'Version' => 1];
+        return $event;
+    }
+    private function getHost()
+    {
+        return $this->unwrappedOptions()->getHost();
+    }
+    private function getPort()
+    {
+        return $this->unwrappedOptions()->getPort();
+    }
+    private function getRegion()
+    {
+        return $this->region;
+    }
+    private function getService()
+    {
+        return $this->service;
+    }
+    /**
+     * Returns enabled flag from options, unwrapping options if necessary.
+     *
+     * @return bool
+     */
+    private function isEnabled()
+    {
+        return $this->unwrappedOptions()->isEnabled();
+    }
+    /**
+     * Returns $eventData array with information from the request and command.
+     *
+     * @param CommandInterface $cmd
+     * @param RequestInterface $request
+     * @param array $event
+     * @return array
+     */
+    protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
+    {
+        $dataFormat = static::getRequestData($request);
+        foreach ($dataFormat as $eventKey => $value) {
+            if ($value !== null) {
+                $event[$eventKey] = $value;
+            }
+        }
+        return $event;
+    }
+    /**
+     * Returns $eventData array with information from the response, including
+     * the calculation for attempt latency.
+     *
+     * @param ResultInterface|\Exception $result
+     * @param array $event
+     * @return array
+     */
+    protected function populateResultEventData($result, array $event)
+    {
+        $dataFormat = static::getResponseData($result);
+        foreach ($dataFormat as $eventKey => $value) {
+            if ($value !== null) {
+                $event[$eventKey] = $value;
+            }
+        }
+        return $event;
+    }
+    /**
+     * Creates a UDP socket resource and stores it with the class, or retrieves
+     * it if already instantiated and connected. Handles error-checking and
+     * re-connecting if necessary. If $forceNewConnection is set to true, a new
+     * socket will be created.
+     *
+     * @param bool $forceNewConnection
+     * @return Resource
+     */
+    private function prepareSocket($forceNewConnection = false)
+    {
+        if (!is_resource(self::$socket) || $forceNewConnection || socket_last_error(self::$socket)) {
+            self::$socket = socket_create(AF_INET, SOCK_DGRAM, SOL_UDP);
+            socket_clear_error(self::$socket);
+            socket_connect(self::$socket, $this->getHost(), $this->getPort());
+        }
+        return self::$socket;
+    }
+    /**
+     * Sends formatted monitoring event data via the UDP socket connection to
+     * the CSM agent endpoint.
+     *
+     * @param array $eventData
+     * @return int
+     */
+    private function sendEventData(array $eventData)
+    {
+        $socket = $this->prepareSocket();
+        $datagram = json_encode($eventData);
+        $result = socket_write($socket, $datagram, strlen($datagram));
+        if ($result === false) {
+            $this->prepareSocket(true);
+        }
+        return $result;
+    }
+    /**
+     * Unwraps options, if needed, and returns them.
+     *
+     * @return ConfigurationInterface
+     */
+    private function unwrappedOptions()
+    {
+        if (!$this->options instanceof ConfigurationInterface) {
+            try {
+                $this->options = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::unwrap($this->options);
+            } catch (\Exception $e) {
+                // Errors unwrapping CSM config defaults to disabling it
+                $this->options = new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration(false, \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::DEFAULT_HOST, \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationProvider::DEFAULT_PORT);
+            }
+        }
+        return $this->options;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ApiCallAttemptMonitoringMiddleware.php

@@ -0,0 +1,181 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Aws\ResponseContainerInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * @internal
+ */
+class ApiCallAttemptMonitoringMiddleware extends \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\AbstractMonitoringMiddleware
+{
+    /**
+     * Standard middleware wrapper function with CSM options passed in.
+     *
+     * @param callable $credentialProvider
+     * @param mixed  $options
+     * @param string $region
+     * @param string $service
+     * @return callable
+     */
+    public static function wrap(callable $credentialProvider, $options, $region, $service)
+    {
+        return function (callable $handler) use($credentialProvider, $options, $region, $service) {
+            return new static($handler, $credentialProvider, $options, $region, $service);
+        };
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
+    {
+        return ['Fqdn' => $request->getUri()->getHost()];
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public static function getResponseData($klass)
+    {
+        if ($klass instanceof ResultInterface) {
+            return ['AttemptLatency' => self::getResultAttemptLatency($klass), 'DestinationIp' => self::getResultDestinationIp($klass), 'DnsLatency' => self::getResultDnsLatency($klass), 'HttpStatusCode' => self::getResultHttpStatusCode($klass), 'XAmzId2' => self::getResultHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getResultHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getResultHeader($klass, 'x-amzn-RequestId')];
+        }
+        if ($klass instanceof AwsException) {
+            return ['AttemptLatency' => self::getAwsExceptionAttemptLatency($klass), 'AwsException' => substr(self::getAwsExceptionErrorCode($klass), 0, 128), 'AwsExceptionMessage' => substr(self::getAwsExceptionMessage($klass), 0, 512), 'DestinationIp' => self::getAwsExceptionDestinationIp($klass), 'DnsLatency' => self::getAwsExceptionDnsLatency($klass), 'HttpStatusCode' => self::getAwsExceptionHttpStatusCode($klass), 'XAmzId2' => self::getAwsExceptionHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getAwsExceptionHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getAwsExceptionHeader($klass, 'x-amzn-RequestId')];
+        }
+        if ($klass instanceof \Exception) {
+            return ['HttpStatusCode' => self::getExceptionHttpStatusCode($klass), 'SdkException' => substr(self::getExceptionCode($klass), 0, 128), 'SdkExceptionMessage' => substr(self::getExceptionMessage($klass), 0, 512), 'XAmzId2' => self::getExceptionHeader($klass, 'x-amz-id-2'), 'XAmzRequestId' => self::getExceptionHeader($klass, 'x-amz-request-id'), 'XAmznRequestId' => self::getExceptionHeader($klass, 'x-amzn-RequestId')];
+        }
+        throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface, AwsException or Exception.');
+    }
+    private static function getResultAttemptLatency(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['total_time'])) {
+                return (int) floor($attempt['total_time'] * 1000);
+            }
+        }
+        return null;
+    }
+    private static function getResultDestinationIp(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['primary_ip'])) {
+                return $attempt['primary_ip'];
+            }
+        }
+        return null;
+    }
+    private static function getResultDnsLatency(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            $attempt = end($result['@metadata']['transferStats']['http']);
+            if (isset($attempt['namelookup_time'])) {
+                return (int) floor($attempt['namelookup_time'] * 1000);
+            }
+        }
+        return null;
+    }
+    private static function getResultHttpStatusCode(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
+    {
+        return $result['@metadata']['statusCode'];
+    }
+    private static function getAwsExceptionAttemptLatency(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['total_time'])) {
+            return (int) floor($attempt['total_time'] * 1000);
+        }
+        return null;
+    }
+    private static function getAwsExceptionErrorCode(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        return $e->getAwsErrorCode();
+    }
+    private static function getAwsExceptionMessage(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        return $e->getAwsErrorMessage();
+    }
+    private static function getAwsExceptionDestinationIp(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['primary_ip'])) {
+            return $attempt['primary_ip'];
+        }
+        return null;
+    }
+    private static function getAwsExceptionDnsLatency(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        $attempt = $e->getTransferInfo();
+        if (isset($attempt['namelookup_time'])) {
+            return (int) floor($attempt['namelookup_time'] * 1000);
+        }
+        return null;
+    }
+    private static function getAwsExceptionHttpStatusCode(\UglyRobot\Infinite_Uploads\Aws\Exception\AwsException $e)
+    {
+        $response = $e->getResponse();
+        if ($response !== null) {
+            return $response->getStatusCode();
+        }
+        return null;
+    }
+    private static function getExceptionHttpStatusCode(\Exception $e)
+    {
+        if ($e instanceof ResponseContainerInterface) {
+            $response = $e->getResponse();
+            if ($response instanceof ResponseInterface) {
+                return $response->getStatusCode();
+            }
+        }
+        return null;
+    }
+    private static function getExceptionCode(\Exception $e)
+    {
+        if (!$e instanceof AwsException) {
+            return get_class($e);
+        }
+        return null;
+    }
+    private static function getExceptionMessage(\Exception $e)
+    {
+        if (!$e instanceof AwsException) {
+            return $e->getMessage();
+        }
+        return null;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
+    {
+        $event = parent::populateRequestEventData($cmd, $request, $event);
+        $event['Type'] = 'ApiCallAttempt';
+        return $event;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateResultEventData($result, array $event)
+    {
+        $event = parent::populateResultEventData($result, $event);
+        $provider = $this->credentialProvider;
+        /** @var CredentialsInterface $credentials */
+        $credentials = $provider()->wait();
+        $event['AccessKey'] = $credentials->getAccessKeyId();
+        $sessionToken = $credentials->getSecurityToken();
+        if ($sessionToken !== null) {
+            $event['SessionToken'] = $sessionToken;
+        }
+        if (empty($event['AttemptLatency'])) {
+            $event['AttemptLatency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
+        }
+        return $event;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ApiCallMonitoringMiddleware.php

@@ -0,0 +1,126 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
+use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+/**
+ * @internal
+ */
+class ApiCallMonitoringMiddleware extends \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\AbstractMonitoringMiddleware
+{
+    /**
+     * Api Call Attempt event keys for each Api Call event key
+     *
+     * @var array
+     */
+    private static $eventKeys = ['FinalAwsException' => 'AwsException', 'FinalAwsExceptionMessage' => 'AwsExceptionMessage', 'FinalSdkException' => 'SdkException', 'FinalSdkExceptionMessage' => 'SdkExceptionMessage', 'FinalHttpStatusCode' => 'HttpStatusCode'];
+    /**
+     * Standard middleware wrapper function with CSM options passed in.
+     *
+     * @param callable $credentialProvider
+     * @param mixed  $options
+     * @param string $region
+     * @param string $service
+     * @return callable
+     */
+    public static function wrap(callable $credentialProvider, $options, $region, $service)
+    {
+        return function (callable $handler) use($credentialProvider, $options, $region, $service) {
+            return new static($handler, $credentialProvider, $options, $region, $service);
+        };
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request)
+    {
+        return [];
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public static function getResponseData($klass)
+    {
+        if ($klass instanceof ResultInterface) {
+            $data = ['AttemptCount' => self::getResultAttemptCount($klass), 'MaxRetriesExceeded' => 0];
+        } elseif ($klass instanceof \Exception) {
+            $data = ['AttemptCount' => self::getExceptionAttemptCount($klass), 'MaxRetriesExceeded' => self::getMaxRetriesExceeded($klass)];
+        } else {
+            throw new \InvalidArgumentException('Parameter must be an instance of ResultInterface or Exception.');
+        }
+        return $data + self::getFinalAttemptData($klass);
+    }
+    private static function getResultAttemptCount(\UglyRobot\Infinite_Uploads\Aws\ResultInterface $result)
+    {
+        if (isset($result['@metadata']['transferStats']['http'])) {
+            return count($result['@metadata']['transferStats']['http']);
+        }
+        return 1;
+    }
+    private static function getExceptionAttemptCount(\Exception $e)
+    {
+        $attemptCount = 0;
+        if ($e instanceof MonitoringEventsInterface) {
+            foreach ($e->getMonitoringEvents() as $event) {
+                if (isset($event['Type']) && $event['Type'] === 'ApiCallAttempt') {
+                    $attemptCount++;
+                }
+            }
+        }
+        return $attemptCount;
+    }
+    private static function getFinalAttemptData($klass)
+    {
+        $data = [];
+        if ($klass instanceof MonitoringEventsInterface) {
+            $finalAttempt = self::getFinalAttempt($klass->getMonitoringEvents());
+            if (!empty($finalAttempt)) {
+                foreach (self::$eventKeys as $callKey => $attemptKey) {
+                    if (isset($finalAttempt[$attemptKey])) {
+                        $data[$callKey] = $finalAttempt[$attemptKey];
+                    }
+                }
+            }
+        }
+        return $data;
+    }
+    private static function getFinalAttempt(array $events)
+    {
+        for (end($events); key($events) !== null; prev($events)) {
+            $current = current($events);
+            if (isset($current['Type']) && $current['Type'] === 'ApiCallAttempt') {
+                return $current;
+            }
+        }
+        return null;
+    }
+    private static function getMaxRetriesExceeded($klass)
+    {
+        if ($klass instanceof AwsException && $klass->isMaxRetriesExceeded()) {
+            return 1;
+        }
+        return 0;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateRequestEventData(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request, array $event)
+    {
+        $event = parent::populateRequestEventData($cmd, $request, $event);
+        $event['Type'] = 'ApiCall';
+        return $event;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    protected function populateResultEventData($result, array $event)
+    {
+        $event = parent::populateResultEventData($result, $event);
+        $event['Latency'] = (int) (floor(microtime(true) * 1000) - $event['Timestamp']);
+        return $event;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/Configuration.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+class Configuration implements \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationInterface
+{
+    private $clientId;
+    private $enabled;
+    private $host;
+    private $port;
+    /**
+     * Constructs a new Configuration object with the specified CSM options set.
+     *
+     * @param mixed $enabled
+     * @param string $host
+     * @param string|int $port
+     * @param string $clientId
+     */
+    public function __construct($enabled, $host, $port, $clientId = '')
+    {
+        $this->host = $host;
+        $this->port = filter_var($port, FILTER_VALIDATE_INT);
+        if ($this->port === false) {
+            throw new \InvalidArgumentException("CSM 'port' value must be an integer!");
+        }
+        // Unparsable $enabled flag errors on the side of disabling CSM
+        $this->enabled = filter_var($enabled, FILTER_VALIDATE_BOOLEAN);
+        $this->clientId = trim($clientId);
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function isEnabled()
+    {
+        return $this->enabled;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getClientId()
+    {
+        return $this->clientId;
+    }
+    /**
+     * /{@inheritdoc}
+     */
+    public function getHost()
+    {
+        return $this->host;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function getPort()
+    {
+        return $this->port;
+    }
+    /**
+     * {@inheritdoc}
+     */
+    public function toArray()
+    {
+        return ['client_id' => $this->getClientId(), 'enabled' => $this->isEnabled(), 'host' => $this->getHost(), 'port' => $this->getPort()];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ConfigurationInterface.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+/**
+ * Provides access to client-side monitoring configuration options:
+ * 'client_id', 'enabled', 'host', 'port'
+ */
+interface ConfigurationInterface
+{
+    /**
+     * Checks whether or not client-side monitoring is enabled.
+     *
+     * @return bool
+     */
+    public function isEnabled();
+    /**
+     * Returns the Client ID, if available.
+     *
+     * @return string|null
+     */
+    public function getClientId();
+    /**
+     * Returns the configured host.
+     *
+     * @return string|null
+     */
+    public function getHost();
+    /**
+     * Returns the configured port.
+     *
+     * @return int|null
+     */
+    public function getPort();
+    /**
+     * Returns the configuration as an associative array.
+     *
+     * @return array
+     */
+    public function toArray();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/ConfigurationProvider.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+use UglyRobot\Infinite_Uploads\Aws\AbstractConfigurationProvider;
+use UglyRobot\Infinite_Uploads\Aws\CacheInterface;
+use UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception\ConfigurationException;
+use UglyRobot\Infinite_Uploads\Aws\ConfigurationProviderInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
+/**
+ * A configuration provider is a function that accepts no arguments and returns
+ * a promise that is fulfilled with a {@see \Aws\ClientSideMonitoring\ConfigurationInterface}
+ * or rejected with an {@see \Aws\ClientSideMonitoring\Exception\ConfigurationException}.
+ *
+ * <code>
+ * use Aws\ClientSideMonitoring\ConfigurationProvider;
+ * $provider = ConfigurationProvider::defaultProvider();
+ * // Returns a ConfigurationInterface or throws.
+ * $config = $provider()->wait();
+ * </code>
+ *
+ * Configuration providers can be composed to create configuration using
+ * conditional logic that can create different configurations in different
+ * environments. You can compose multiple providers into a single provider using
+ * {@see Aws\ClientSideMonitoring\ConfigurationProvider::chain}. This function
+ * accepts providers as variadic arguments and returns a new function that will
+ * invoke each provider until a successful configuration is returned.
+ *
+ * <code>
+ * // First try an INI file at this location.
+ * $a = ConfigurationProvider::ini(null, '/path/to/file.ini');
+ * // Then try an INI file at this location.
+ * $b = ConfigurationProvider::ini(null, '/path/to/other-file.ini');
+ * // Then try loading from environment variables.
+ * $c = ConfigurationProvider::env();
+ * // Combine the three providers together.
+ * $composed = ConfigurationProvider::chain($a, $b, $c);
+ * // Returns a promise that is fulfilled with a configuration or throws.
+ * $promise = $composed();
+ * // Wait on the configuration to resolve.
+ * $config = $promise->wait();
+ * </code>
+ */
+class ConfigurationProvider extends \UglyRobot\Infinite_Uploads\Aws\AbstractConfigurationProvider implements \UglyRobot\Infinite_Uploads\Aws\ConfigurationProviderInterface
+{
+    const DEFAULT_CLIENT_ID = '';
+    const DEFAULT_ENABLED = false;
+    const DEFAULT_HOST = '127.0.0.1';
+    const DEFAULT_PORT = 31000;
+    const ENV_CLIENT_ID = 'AWS_CSM_CLIENT_ID';
+    const ENV_ENABLED = 'AWS_CSM_ENABLED';
+    const ENV_HOST = 'AWS_CSM_HOST';
+    const ENV_PORT = 'AWS_CSM_PORT';
+    const ENV_PROFILE = 'AWS_PROFILE';
+    public static $cacheKey = 'aws_cached_csm_config';
+    protected static $interfaceClass = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\ConfigurationInterface::class;
+    protected static $exceptionClass = \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception\ConfigurationException::class;
+    /**
+     * Create a default config provider that first checks for environment
+     * variables, then checks for a specified profile in the environment-defined
+     * config file location (env variable is 'AWS_CONFIG_FILE', file location
+     * defaults to ~/.aws/config), then checks for the "default" profile in the
+     * environment-defined config file location, and failing those uses a default
+     * fallback set of configuration options.
+     *
+     * This provider is automatically wrapped in a memoize function that caches
+     * previously provided config options.
+     *
+     * @param array $config
+     *
+     * @return callable
+     */
+    public static function defaultProvider(array $config = [])
+    {
+        $configProviders = [self::env()];
+        if (!isset($config['use_aws_shared_config_files']) || $config['use_aws_shared_config_files'] != false) {
+            $configProviders[] = self::ini();
+        }
+        $configProviders[] = self::fallback();
+        $memo = self::memoize(call_user_func_array('self::chain', $configProviders));
+        if (isset($config['csm']) && $config['csm'] instanceof CacheInterface) {
+            return self::cache($memo, $config['csm'], self::$cacheKey);
+        }
+        return $memo;
+    }
+    /**
+     * Provider that creates CSM config from environment variables.
+     *
+     * @return callable
+     */
+    public static function env()
+    {
+        return function () {
+            // Use credentials from environment variables, if available
+            $enabled = getenv(self::ENV_ENABLED);
+            if ($enabled !== false) {
+                return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($enabled, getenv(self::ENV_HOST) ?: self::DEFAULT_HOST, getenv(self::ENV_PORT) ?: self::DEFAULT_PORT, getenv(self::ENV_CLIENT_ID) ?: self::DEFAULT_CLIENT_ID));
+            }
+            return self::reject('Could not find environment variable CSM config' . ' in ' . self::ENV_ENABLED . '/' . self::ENV_HOST . '/' . self::ENV_PORT . '/' . self::ENV_CLIENT_ID);
+        };
+    }
+    /**
+     * Fallback config options when other sources are not set.
+     *
+     * @return callable
+     */
+    public static function fallback()
+    {
+        return function () {
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration(self::DEFAULT_ENABLED, self::DEFAULT_HOST, self::DEFAULT_PORT, self::DEFAULT_CLIENT_ID));
+        };
+    }
+    /**
+     * Config provider that creates config using a config file whose location
+     * is specified by an environment variable 'AWS_CONFIG_FILE', defaulting to
+     * ~/.aws/config if not specified
+     *
+     * @param string|null $profile  Profile to use. If not specified will use
+     *                              the "default" profile.
+     * @param string|null $filename If provided, uses a custom filename rather
+     *                              than looking in the default directory.
+     *
+     * @return callable
+     */
+    public static function ini($profile = null, $filename = null)
+    {
+        $filename = $filename ?: self::getDefaultConfigFilename();
+        $profile = $profile ?: (getenv(self::ENV_PROFILE) ?: 'aws_csm');
+        return function () use($profile, $filename) {
+            if (!is_readable($filename)) {
+                return self::reject("Cannot read CSM config from {$filename}");
+            }
+            $data = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($filename, true);
+            if ($data === false) {
+                return self::reject("Invalid config file: {$filename}");
+            }
+            if (!isset($data[$profile])) {
+                return self::reject("'{$profile}' not found in config file");
+            }
+            if (!isset($data[$profile]['csm_enabled'])) {
+                return self::reject("Required CSM config values not present in \n                    INI profile '{$profile}' ({$filename})");
+            }
+            // host is optional
+            if (empty($data[$profile]['csm_host'])) {
+                $data[$profile]['csm_host'] = self::DEFAULT_HOST;
+            }
+            // port is optional
+            if (empty($data[$profile]['csm_port'])) {
+                $data[$profile]['csm_port'] = self::DEFAULT_PORT;
+            }
+            // client_id is optional
+            if (empty($data[$profile]['csm_client_id'])) {
+                $data[$profile]['csm_client_id'] = self::DEFAULT_CLIENT_ID;
+            }
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($data[$profile]['csm_enabled'], $data[$profile]['csm_host'], $data[$profile]['csm_port'], $data[$profile]['csm_client_id']));
+        };
+    }
+    /**
+     * Unwraps a configuration object in whatever valid form it is in,
+     * always returning a ConfigurationInterface object.
+     *
+     * @param  mixed $config
+     * @return ConfigurationInterface
+     * @throws \InvalidArgumentException
+     */
+    public static function unwrap($config)
+    {
+        if (is_callable($config)) {
+            $config = $config();
+        }
+        if ($config instanceof PromiseInterface) {
+            $config = $config->wait();
+        }
+        if ($config instanceof ConfigurationInterface) {
+            return $config;
+        } elseif (is_array($config) && isset($config['enabled'])) {
+            $client_id = isset($config['client_id']) ? $config['client_id'] : self::DEFAULT_CLIENT_ID;
+            $host = isset($config['host']) ? $config['host'] : self::DEFAULT_HOST;
+            $port = isset($config['port']) ? $config['port'] : self::DEFAULT_PORT;
+            return new \UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Configuration($config['enabled'], $host, $port, $client_id);
+        }
+        throw new \InvalidArgumentException('Not a valid CSM configuration ' . 'argument.');
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/Exception/ConfigurationException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring\Exception;
+
+use UglyRobot\Infinite_Uploads\Aws\HasMonitoringEventsTrait;
+use UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface;
+/**
+ * Represents an error interacting with configuration for client-side monitoring.
+ */
+class ConfigurationException extends \RuntimeException implements \UglyRobot\Infinite_Uploads\Aws\MonitoringEventsInterface
+{
+    use HasMonitoringEventsTrait;
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ClientSideMonitoring/MonitoringMiddlewareInterface.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\ClientSideMonitoring;
+
+use UglyRobot\Infinite_Uploads\Aws\CommandInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Aws\ResultInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface;
+/**
+ * @internal
+ */
+interface MonitoringMiddlewareInterface
+{
+    /**
+     * Data for event properties to be sent to the monitoring agent.
+     *
+     * @param RequestInterface $request
+     * @return array
+     */
+    public static function getRequestData(\UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request);
+    /**
+     * Data for event properties to be sent to the monitoring agent.
+     *
+     * @param ResultInterface|AwsException|\Exception $klass
+     * @return array
+     */
+    public static function getResponseData($klass);
+    public function __invoke(\UglyRobot\Infinite_Uploads\Aws\CommandInterface $cmd, \UglyRobot\Infinite_Uploads\Psr\Http\Message\RequestInterface $request);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Command.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+/**
+ * AWS command object.
+ */
+class Command implements \UglyRobot\Infinite_Uploads\Aws\CommandInterface
+{
+    use HasDataTrait;
+    /** @var string */
+    private $name;
+    /** @var HandlerList */
+    private $handlerList;
+    /**
+     * Accepts an associative array of command options, including:
+     *
+     * - @http: (array) Associative array of transfer options.
+     *
+     * @param string      $name           Name of the command
+     * @param array       $args           Arguments to pass to the command
+     * @param HandlerList $list           Handler list
+     */
+    public function __construct($name, array $args = [], \UglyRobot\Infinite_Uploads\Aws\HandlerList $list = null)
+    {
+        $this->name = $name;
+        $this->data = $args;
+        $this->handlerList = $list ?: new \UglyRobot\Infinite_Uploads\Aws\HandlerList();
+        if (!isset($this->data['@http'])) {
+            $this->data['@http'] = [];
+        }
+        if (!isset($this->data['@context'])) {
+            $this->data['@context'] = [];
+        }
+    }
+    public function __clone()
+    {
+        $this->handlerList = clone $this->handlerList;
+    }
+    public function getName()
+    {
+        return $this->name;
+    }
+    public function hasParam($name)
+    {
+        return array_key_exists($name, $this->data);
+    }
+    public function getHandlerList()
+    {
+        return $this->handlerList;
+    }
+    /** @deprecated */
+    public function get($name)
+    {
+        return $this[$name];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/CommandInterface.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+/**
+ * A command object encapsulates the input parameters used to control the
+ * creation of a HTTP request and processing of a HTTP response.
+ *
+ * Using the toArray() method will return the input parameters of the command
+ * as an associative array.
+ */
+interface CommandInterface extends \ArrayAccess, \Countable, \IteratorAggregate
+{
+    /**
+     * Converts the command parameters to an array
+     *
+     * @return array
+     */
+    public function toArray();
+    /**
+     * Get the name of the command
+     *
+     * @return string
+     */
+    public function getName();
+    /**
+     * Check if the command has a parameter by name.
+     *
+     * @param string $name Name of the parameter to check
+     *
+     * @return bool
+     */
+    public function hasParam($name);
+    /**
+     * Get the handler list used to transfer the command.
+     *
+     * @return HandlerList
+     */
+    public function getHandlerList();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/CommandPool.php

@@ -0,0 +1,130 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromisorInterface;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\EachPromise;
+/**
+ * Sends and iterator of commands concurrently using a capped pool size.
+ *
+ * The pool will read command objects from an iterator until it is cancelled or
+ * until the iterator is consumed.
+ */
+class CommandPool implements \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromisorInterface
+{
+    /** @var EachPromise */
+    private $each;
+    /**
+     * The CommandPool constructor accepts a hash of configuration options:
+     *
+     * - concurrency: (callable|int) Maximum number of commands to execute
+     *   concurrently. Provide a function to resize the pool dynamically. The
+     *   function will be provided the current number of pending requests and
+     *   is expected to return an integer representing the new pool size limit.
+     * - before: (callable) function to invoke before sending each command. The
+     *   before function accepts the command and the key of the iterator of the
+     *   command. You can mutate the command as needed in the before function
+     *   before sending the command.
+     * - fulfilled: (callable) Function to invoke when a promise is fulfilled.
+     *   The function is provided the result object, id of the iterator that the
+     *   result came from, and the aggregate promise that can be resolved/rejected
+     *   if you need to short-circuit the pool.
+     * - rejected: (callable) Function to invoke when a promise is rejected.
+     *   The function is provided an AwsException object, id of the iterator that
+     *   the exception came from, and the aggregate promise that can be
+     *   resolved/rejected if you need to short-circuit the pool.
+     * - preserve_iterator_keys: (bool) Retain the iterator key when generating
+     *   the commands.
+     *
+     * @param AwsClientInterface $client   Client used to execute commands.
+     * @param array|\Iterator    $commands Iterable that yields commands.
+     * @param array              $config   Associative array of options.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\AwsClientInterface $client, $commands, array $config = [])
+    {
+        if (!isset($config['concurrency'])) {
+            $config['concurrency'] = 25;
+        }
+        $before = $this->getBefore($config);
+        $mapFn = function ($commands) use($client, $before, $config) {
+            foreach ($commands as $key => $command) {
+                if (!$command instanceof CommandInterface) {
+                    throw new \InvalidArgumentException('Each value yielded by ' . 'the iterator must be an Aws\\CommandInterface.');
+                }
+                if ($before) {
+                    $before($command, $key);
+                }
+                if (!empty($config['preserve_iterator_keys'])) {
+                    (yield $key => $client->executeAsync($command));
+                } else {
+                    (yield $client->executeAsync($command));
+                }
+            }
+        };
+        $this->each = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\EachPromise($mapFn($commands), $config);
+    }
+    /**
+     * @return \GuzzleHttp\Promise\PromiseInterface
+     */
+    public function promise()
+    {
+        return $this->each->promise();
+    }
+    /**
+     * Executes a pool synchronously and aggregates the results of the pool
+     * into an indexed array in the same order as the passed in array.
+     *
+     * @param AwsClientInterface $client   Client used to execute commands.
+     * @param mixed              $commands Iterable that yields commands.
+     * @param array              $config   Configuration options.
+     *
+     * @return array
+     * @see \Aws\CommandPool::__construct for available configuration options.
+     */
+    public static function batch(\UglyRobot\Infinite_Uploads\Aws\AwsClientInterface $client, $commands, array $config = [])
+    {
+        $results = [];
+        self::cmpCallback($config, 'fulfilled', $results);
+        self::cmpCallback($config, 'rejected', $results);
+        return (new self($client, $commands, $config))->promise()->then(static function () use(&$results) {
+            ksort($results);
+            return $results;
+        })->wait();
+    }
+    /**
+     * @return callable
+     */
+    private function getBefore(array $config)
+    {
+        if (!isset($config['before'])) {
+            return null;
+        }
+        if (is_callable($config['before'])) {
+            return $config['before'];
+        }
+        throw new \InvalidArgumentException('before must be callable');
+    }
+    /**
+     * Adds an onFulfilled or onRejected callback that aggregates results into
+     * an array. If a callback is already present, it is replaced with the
+     * composed function.
+     *
+     * @param array $config
+     * @param       $name
+     * @param array $results
+     */
+    private static function cmpCallback(array &$config, $name, array &$results)
+    {
+        if (!isset($config[$name])) {
+            $config[$name] = function ($v, $k) use(&$results) {
+                $results[$k] = $v;
+            };
+        } else {
+            $currentFn = $config[$name];
+            $config[$name] = function ($v, $k) use(&$results, $currentFn) {
+                $currentFn($v, $k);
+                $results[$k] = $v;
+            };
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/ConfigurationProviderInterface.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws;
+
+interface ConfigurationProviderInterface
+{
+    /**
+     * Create a default config provider
+     *
+     * @param array $config
+     * @return callable
+     */
+    public static function defaultProvider(array $config = []);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/AssumeRoleCredentialProvider.php

@@ -0,0 +1,53 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException;
+use UglyRobot\Infinite_Uploads\Aws\Result;
+use UglyRobot\Infinite_Uploads\Aws\Sts\StsClient;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
+/**
+ * Credential provider that provides credentials via assuming a role
+ * More Information, see: http://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerole
+ */
+class AssumeRoleCredentialProvider
+{
+    const ERROR_MSG = "Missing required 'AssumeRoleCredentialProvider' configuration option: ";
+    /** @var StsClient */
+    private $client;
+    /** @var array */
+    private $assumeRoleParams;
+    /**
+     * The constructor requires following configure parameters:
+     *  - client: a StsClient
+     *  - assume_role_params: Parameters used to make assumeRole call
+     *
+     * @param array $config Configuration options
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config = [])
+    {
+        if (!isset($config['assume_role_params'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'assume_role_params'.");
+        }
+        if (!isset($config['client'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'client'.");
+        }
+        $this->client = $config['client'];
+        $this->assumeRoleParams = $config['assume_role_params'];
+    }
+    /**
+     * Loads assume role credentials.
+     *
+     * @return PromiseInterface
+     */
+    public function __invoke()
+    {
+        $client = $this->client;
+        return $client->assumeRoleAsync($this->assumeRoleParams)->then(function (\UglyRobot\Infinite_Uploads\Aws\Result $result) {
+            return $this->client->createCredentials($result);
+        })->otherwise(function (\RuntimeException $exception) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Error in retrieving assume role credentials.", 0, $exception);
+        });
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/AssumeRoleWithWebIdentityCredentialProvider.php

@@ -0,0 +1,120 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\AwsException;
+use UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException;
+use UglyRobot\Infinite_Uploads\Aws\Result;
+use UglyRobot\Infinite_Uploads\Aws\Sts\StsClient;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+/**
+ * Credential provider that provides credentials via assuming a role with a web identity
+ * More Information, see: https://docs.aws.amazon.com/aws-sdk-php/v3/api/api-sts-2011-06-15.html#assumerolewithwebidentity
+ */
+class AssumeRoleWithWebIdentityCredentialProvider
+{
+    const ERROR_MSG = "Missing required 'AssumeRoleWithWebIdentityCredentialProvider' configuration option: ";
+    const ENV_RETRIES = 'AWS_METADATA_SERVICE_NUM_ATTEMPTS';
+    /** @var string */
+    private $tokenFile;
+    /** @var string */
+    private $arn;
+    /** @var string */
+    private $session;
+    /** @var StsClient */
+    private $client;
+    /** @var integer */
+    private $retries;
+    /** @var integer */
+    private $authenticationAttempts;
+    /** @var integer */
+    private $tokenFileReadAttempts;
+    /**
+     * The constructor attempts to load config from environment variables.
+     * If not set, the following config options are used:
+     *  - WebIdentityTokenFile: full path of token filename
+     *  - RoleArn: arn of role to be assumed
+     *  - SessionName: (optional) set by SDK if not provided
+     *
+     * @param array $config Configuration options
+     * @throws \InvalidArgumentException
+     */
+    public function __construct(array $config = [])
+    {
+        if (!isset($config['RoleArn'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'RoleArn'.");
+        }
+        $this->arn = $config['RoleArn'];
+        if (!isset($config['WebIdentityTokenFile'])) {
+            throw new \InvalidArgumentException(self::ERROR_MSG . "'WebIdentityTokenFile'.");
+        }
+        $this->tokenFile = $config['WebIdentityTokenFile'];
+        if (!preg_match("/^\\w\\:|^\\/|^\\\\/", $this->tokenFile)) {
+            throw new \InvalidArgumentException("'WebIdentityTokenFile' must be an absolute path.");
+        }
+        $this->retries = (int) getenv(self::ENV_RETRIES) ?: (isset($config['retries']) ? $config['retries'] : 3);
+        $this->authenticationAttempts = 0;
+        $this->tokenFileReadAttempts = 0;
+        $this->session = isset($config['SessionName']) ? $config['SessionName'] : 'aws-sdk-php-' . round(microtime(true) * 1000);
+        $region = isset($config['region']) ? $config['region'] : 'us-east-1';
+        if (isset($config['client'])) {
+            $this->client = $config['client'];
+        } else {
+            $this->client = new \UglyRobot\Infinite_Uploads\Aws\Sts\StsClient(['credentials' => false, 'region' => $region, 'version' => 'latest']);
+        }
+    }
+    /**
+     * Loads assume role with web identity credentials.
+     *
+     * @return Promise\PromiseInterface
+     */
+    public function __invoke()
+    {
+        return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\coroutine(function () {
+            $client = $this->client;
+            $result = null;
+            while ($result == null) {
+                try {
+                    $token = is_readable($this->tokenFile) ? file_get_contents($this->tokenFile) : false;
+                    if (false === $token) {
+                        clearstatcache(true, dirname($this->tokenFile) . "/" . readlink($this->tokenFile));
+                        clearstatcache(true, dirname($this->tokenFile) . "/" . dirname(readlink($this->tokenFile)));
+                        clearstatcache(true, $this->tokenFile);
+                        if (!is_readable($this->tokenFile)) {
+                            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Unreadable tokenfile at location {$this->tokenFile}");
+                        }
+                        $token = file_get_contents($this->tokenFile);
+                    }
+                    if (empty($token)) {
+                        if ($this->tokenFileReadAttempts < $this->retries) {
+                            sleep(pow(1.2, $this->tokenFileReadAttempts));
+                            $this->tokenFileReadAttempts++;
+                            continue;
+                        }
+                        throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("InvalidIdentityToken from file: {$this->tokenFile}");
+                    }
+                } catch (\Exception $exception) {
+                    throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Error reading WebIdentityTokenFile from " . $this->tokenFile, 0, $exception);
+                }
+                $assumeParams = ['RoleArn' => $this->arn, 'RoleSessionName' => $this->session, 'WebIdentityToken' => $token];
+                try {
+                    $result = $client->assumeRoleWithWebIdentity($assumeParams);
+                } catch (AwsException $e) {
+                    if ($e->getAwsErrorCode() == 'InvalidIdentityToken') {
+                        if ($this->authenticationAttempts < $this->retries) {
+                            sleep(pow(1.2, $this->authenticationAttempts));
+                        } else {
+                            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("InvalidIdentityToken, retries exhausted");
+                        }
+                    } else {
+                        throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Error assuming role from web identity credentials", 0, $e);
+                    }
+                } catch (\Exception $e) {
+                    throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Error retrieving web identity credentials: " . $e->getMessage() . " (" . $e->getCode() . ")");
+                }
+                $this->authenticationAttempts++;
+            }
+            (yield $this->client->createCredentials($result));
+        });
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/CredentialProvider.php

@@ -0,0 +1,627 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+use Aws;
+use UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult;
+use UglyRobot\Infinite_Uploads\Aws\CacheInterface;
+use UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException;
+use UglyRobot\Infinite_Uploads\Aws\Sts\StsClient;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+/**
+ * Credential providers are functions that accept no arguments and return a
+ * promise that is fulfilled with an {@see \Aws\Credentials\CredentialsInterface}
+ * or rejected with an {@see \Aws\Exception\CredentialsException}.
+ *
+ * <code>
+ * use Aws\Credentials\CredentialProvider;
+ * $provider = CredentialProvider::defaultProvider();
+ * // Returns a CredentialsInterface or throws.
+ * $creds = $provider()->wait();
+ * </code>
+ *
+ * Credential providers can be composed to create credentials using conditional
+ * logic that can create different credentials in different environments. You
+ * can compose multiple providers into a single provider using
+ * {@see Aws\Credentials\CredentialProvider::chain}. This function accepts
+ * providers as variadic arguments and returns a new function that will invoke
+ * each provider until a successful set of credentials is returned.
+ *
+ * <code>
+ * // First try an INI file at this location.
+ * $a = CredentialProvider::ini(null, '/path/to/file.ini');
+ * // Then try an INI file at this location.
+ * $b = CredentialProvider::ini(null, '/path/to/other-file.ini');
+ * // Then try loading from environment variables.
+ * $c = CredentialProvider::env();
+ * // Combine the three providers together.
+ * $composed = CredentialProvider::chain($a, $b, $c);
+ * // Returns a promise that is fulfilled with credentials or throws.
+ * $promise = $composed();
+ * // Wait on the credentials to resolve.
+ * $creds = $promise->wait();
+ * </code>
+ */
+class CredentialProvider
+{
+    const ENV_ARN = 'AWS_ROLE_ARN';
+    const ENV_KEY = 'AWS_ACCESS_KEY_ID';
+    const ENV_PROFILE = 'AWS_PROFILE';
+    const ENV_ROLE_SESSION_NAME = 'AWS_ROLE_SESSION_NAME';
+    const ENV_SECRET = 'AWS_SECRET_ACCESS_KEY';
+    const ENV_SESSION = 'AWS_SESSION_TOKEN';
+    const ENV_TOKEN_FILE = 'AWS_WEB_IDENTITY_TOKEN_FILE';
+    const ENV_SHARED_CREDENTIALS_FILE = 'AWS_SHARED_CREDENTIALS_FILE';
+    /**
+     * Create a default credential provider that
+     * first checks for environment variables,
+     * then checks for assumed role via web identity,
+     * then checks for cached SSO credentials from the CLI,
+     * then check for credential_process in the "default" profile in ~/.aws/credentials,
+     * then checks for the "default" profile in ~/.aws/credentials,
+     * then for credential_process in the "default profile" profile in ~/.aws/config,
+     * then checks for "profile default" profile in ~/.aws/config (which is
+     * the default profile of AWS CLI),
+     * then tries to make a GET Request to fetch credentials if ECS environment variable is presented,
+     * finally checks for EC2 instance profile credentials.
+     *
+     * This provider is automatically wrapped in a memoize function that caches
+     * previously provided credentials.
+     *
+     * @param array $config Optional array of ecs/instance profile credentials
+     *                      provider options.
+     *
+     * @return callable
+     */
+    public static function defaultProvider(array $config = [])
+    {
+        $cacheable = ['web_identity', 'sso', 'process_credentials', 'process_config', 'ecs', 'instance'];
+        $defaultChain = ['env' => self::env(), 'web_identity' => self::assumeRoleWithWebIdentityCredentialProvider($config)];
+        if (!isset($config['use_aws_shared_config_files']) || $config['use_aws_shared_config_files'] !== false) {
+            $defaultChain['sso'] = self::sso('profile default', self::getHomeDir() . '/.aws/config', $config);
+            $defaultChain['process_credentials'] = self::process();
+            $defaultChain['ini'] = self::ini();
+            $defaultChain['process_config'] = self::process('profile default', self::getHomeDir() . '/.aws/config');
+            $defaultChain['ini_config'] = self::ini('profile default', self::getHomeDir() . '/.aws/config');
+        }
+        $shouldUseEcsCredentialsProvider = getenv(\UglyRobot\Infinite_Uploads\Aws\Credentials\EcsCredentialProvider::ENV_URI);
+        // getenv() is not thread safe - fall back to $_SERVER
+        if ($shouldUseEcsCredentialsProvider === false) {
+            $shouldUseEcsCredentialsProvider = isset($_SERVER[\UglyRobot\Infinite_Uploads\Aws\Credentials\EcsCredentialProvider::ENV_URI]) ? $_SERVER[\UglyRobot\Infinite_Uploads\Aws\Credentials\EcsCredentialProvider::ENV_URI] : false;
+        }
+        if (!empty($shouldUseEcsCredentialsProvider)) {
+            $defaultChain['ecs'] = self::ecsCredentials($config);
+        } else {
+            $defaultChain['instance'] = self::instanceProfile($config);
+        }
+        if (isset($config['credentials']) && $config['credentials'] instanceof CacheInterface) {
+            foreach ($cacheable as $provider) {
+                if (isset($defaultChain[$provider])) {
+                    $defaultChain[$provider] = self::cache($defaultChain[$provider], $config['credentials'], 'aws_cached_' . $provider . '_credentials');
+                }
+            }
+        }
+        return self::memoize(call_user_func_array('self::chain', array_values($defaultChain)));
+    }
+    /**
+     * Create a credential provider function from a set of static credentials.
+     *
+     * @param CredentialsInterface $creds
+     *
+     * @return callable
+     */
+    public static function fromCredentials(\UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface $creds)
+    {
+        $promise = \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($creds);
+        return function () use($promise) {
+            return $promise;
+        };
+    }
+    /**
+     * Creates an aggregate credentials provider that invokes the provided
+     * variadic providers one after the other until a provider returns
+     * credentials.
+     *
+     * @return callable
+     */
+    public static function chain()
+    {
+        $links = func_get_args();
+        if (empty($links)) {
+            throw new \InvalidArgumentException('No providers in chain');
+        }
+        return function () use($links) {
+            /** @var callable $parent */
+            $parent = array_shift($links);
+            $promise = $parent();
+            while ($next = array_shift($links)) {
+                $promise = $promise->otherwise($next);
+            }
+            return $promise;
+        };
+    }
+    /**
+     * Wraps a credential provider and caches previously provided credentials.
+     *
+     * Ensures that cached credentials are refreshed when they expire.
+     *
+     * @param callable $provider Credentials provider function to wrap.
+     *
+     * @return callable
+     */
+    public static function memoize(callable $provider)
+    {
+        return function () use($provider) {
+            static $result;
+            static $isConstant;
+            // Constant credentials will be returned constantly.
+            if ($isConstant) {
+                return $result;
+            }
+            // Create the initial promise that will be used as the cached value
+            // until it expires.
+            if (null === $result) {
+                $result = $provider();
+            }
+            // Return credentials that could expire and refresh when needed.
+            return $result->then(function (\UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface $creds) use($provider, &$isConstant, &$result) {
+                // Determine if these are constant credentials.
+                if (!$creds->getExpiration()) {
+                    $isConstant = true;
+                    return $creds;
+                }
+                // Refresh expired credentials.
+                if (!$creds->isExpired()) {
+                    return $creds;
+                }
+                // Refresh the result and forward the promise.
+                return $result = $provider();
+            })->otherwise(function ($reason) use(&$result) {
+                // Cleanup rejected promise.
+                $result = null;
+                return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\RejectedPromise($reason);
+            });
+        };
+    }
+    /**
+     * Wraps a credential provider and saves provided credentials in an
+     * instance of Aws\CacheInterface. Forwards calls when no credentials found
+     * in cache and updates cache with the results.
+     *
+     * @param callable $provider Credentials provider function to wrap
+     * @param CacheInterface $cache Cache to store credentials
+     * @param string|null $cacheKey (optional) Cache key to use
+     *
+     * @return callable
+     */
+    public static function cache(callable $provider, \UglyRobot\Infinite_Uploads\Aws\CacheInterface $cache, $cacheKey = null)
+    {
+        $cacheKey = $cacheKey ?: 'aws_cached_credentials';
+        return function () use($provider, $cache, $cacheKey) {
+            $found = $cache->get($cacheKey);
+            if ($found instanceof CredentialsInterface && !$found->isExpired()) {
+                return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($found);
+            }
+            return $provider()->then(function (\UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface $creds) use($cache, $cacheKey) {
+                $cache->set($cacheKey, $creds, null === $creds->getExpiration() ? 0 : $creds->getExpiration() - time());
+                return $creds;
+            });
+        };
+    }
+    /**
+     * Provider that creates credentials from environment variables
+     * AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and AWS_SESSION_TOKEN.
+     *
+     * @return callable
+     */
+    public static function env()
+    {
+        return function () {
+            // Use credentials from environment variables, if available
+            $key = getenv(self::ENV_KEY);
+            $secret = getenv(self::ENV_SECRET);
+            if ($key && $secret) {
+                return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($key, $secret, getenv(self::ENV_SESSION) ?: NULL));
+            }
+            return self::reject('Could not find environment variable ' . 'credentials in ' . self::ENV_KEY . '/' . self::ENV_SECRET);
+        };
+    }
+    /**
+     * Credential provider that creates credentials using instance profile
+     * credentials.
+     *
+     * @param array $config Array of configuration data.
+     *
+     * @return InstanceProfileProvider
+     * @see Aws\Credentials\InstanceProfileProvider for $config details.
+     */
+    public static function instanceProfile(array $config = [])
+    {
+        return new \UglyRobot\Infinite_Uploads\Aws\Credentials\InstanceProfileProvider($config);
+    }
+    /**
+     * Credential provider that retrieves cached SSO credentials from the CLI
+     *
+     * @return callable
+     */
+    public static function sso($ssoProfileName, $filename = null, $config = [])
+    {
+        $filename = $filename ?: self::getHomeDir() . '/.aws/config';
+        return function () use($ssoProfileName, $filename, $config) {
+            if (!is_readable($filename)) {
+                return self::reject("Cannot read credentials from {$filename}");
+            }
+            $data = self::loadProfiles($filename);
+            if (empty($data[$ssoProfileName])) {
+                return self::reject("Profile {$ssoProfileName} does not exist in {$filename}.");
+            }
+            $ssoProfile = $data[$ssoProfileName];
+            if (empty($ssoProfile['sso_start_url']) || empty($ssoProfile['sso_region']) || empty($ssoProfile['sso_account_id']) || empty($ssoProfile['sso_role_name'])) {
+                return self::reject("Profile {$ssoProfileName} in {$filename} must contain the following keys: " . "sso_start_url, sso_region, sso_account_id, and sso_role_name.");
+            }
+            $tokenLocation = self::getHomeDir() . '/.aws/sso/cache/' . utf8_encode(sha1($ssoProfile['sso_start_url'])) . ".json";
+            if (!is_readable($tokenLocation)) {
+                return self::reject("Unable to read token file at {$tokenLocation}");
+            }
+            $tokenData = json_decode(file_get_contents($tokenLocation), true);
+            if (empty($tokenData['accessToken']) || empty($tokenData['expiresAt'])) {
+                return self::reject("Token file at {$tokenLocation} must contain an access token and an expiration");
+            }
+            try {
+                $expiration = (new \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult($tokenData['expiresAt']))->getTimestamp();
+            } catch (\Exception $e) {
+                return self::reject("Cached SSO credentials returned an invalid expiration");
+            }
+            $now = time();
+            if ($expiration < $now) {
+                return self::reject("Cached SSO credentials returned expired credentials");
+            }
+            $ssoClient = null;
+            if (empty($config['ssoClient'])) {
+                $ssoClient = new \UglyRobot\Infinite_Uploads\Aws\SSO\SSOClient(['region' => $ssoProfile['sso_region'], 'version' => '2019-06-10', 'credentials' => false]);
+            } else {
+                $ssoClient = $config['ssoClient'];
+            }
+            $ssoResponse = $ssoClient->getRoleCredentials(['accessToken' => $tokenData['accessToken'], 'accountId' => $ssoProfile['sso_account_id'], 'roleName' => $ssoProfile['sso_role_name']]);
+            $ssoCredentials = $ssoResponse['roleCredentials'];
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($ssoCredentials['accessKeyId'], $ssoCredentials['secretAccessKey'], $ssoCredentials['sessionToken'], $expiration));
+        };
+    }
+    /**
+     * Credential provider that creates credentials using
+     * ecs credentials by a GET request, whose uri is specified
+     * by environment variable
+     *
+     * @param array $config Array of configuration data.
+     *
+     * @return EcsCredentialProvider
+     * @see Aws\Credentials\EcsCredentialProvider for $config details.
+     */
+    public static function ecsCredentials(array $config = [])
+    {
+        return new \UglyRobot\Infinite_Uploads\Aws\Credentials\EcsCredentialProvider($config);
+    }
+    /**
+     * Credential provider that creates credentials using assume role
+     *
+     * @param array $config Array of configuration data
+     * @return callable
+     * @see Aws\Credentials\AssumeRoleCredentialProvider for $config details.
+     */
+    public static function assumeRole(array $config = [])
+    {
+        return new \UglyRobot\Infinite_Uploads\Aws\Credentials\AssumeRoleCredentialProvider($config);
+    }
+    /**
+     * Credential provider that creates credentials by assuming role from a
+     * Web Identity Token
+     *
+     * @param array $config Array of configuration data
+     * @return callable
+     * @see Aws\Credentials\AssumeRoleWithWebIdentityCredentialProvider for
+     * $config details.
+     */
+    public static function assumeRoleWithWebIdentityCredentialProvider(array $config = [])
+    {
+        return function () use($config) {
+            $arnFromEnv = getenv(self::ENV_ARN);
+            $tokenFromEnv = getenv(self::ENV_TOKEN_FILE);
+            $stsClient = isset($config['stsClient']) ? $config['stsClient'] : null;
+            $region = isset($config['region']) ? $config['region'] : null;
+            if ($tokenFromEnv && $arnFromEnv) {
+                $sessionName = getenv(self::ENV_ROLE_SESSION_NAME) ? getenv(self::ENV_ROLE_SESSION_NAME) : null;
+                $provider = new \UglyRobot\Infinite_Uploads\Aws\Credentials\AssumeRoleWithWebIdentityCredentialProvider(['RoleArn' => $arnFromEnv, 'WebIdentityTokenFile' => $tokenFromEnv, 'SessionName' => $sessionName, 'client' => $stsClient, 'region' => $region]);
+                return $provider();
+            }
+            $profileName = getenv(self::ENV_PROFILE) ?: 'default';
+            if (isset($config['filename'])) {
+                $profiles = self::loadProfiles($config['filename']);
+            } else {
+                $profiles = self::loadDefaultProfiles();
+            }
+            if (isset($profiles[$profileName])) {
+                $profile = $profiles[$profileName];
+                if (isset($profile['region'])) {
+                    $region = $profile['region'];
+                }
+                if (isset($profile['web_identity_token_file']) && isset($profile['role_arn'])) {
+                    $sessionName = isset($profile['role_session_name']) ? $profile['role_session_name'] : null;
+                    $provider = new \UglyRobot\Infinite_Uploads\Aws\Credentials\AssumeRoleWithWebIdentityCredentialProvider(['RoleArn' => $profile['role_arn'], 'WebIdentityTokenFile' => $profile['web_identity_token_file'], 'SessionName' => $sessionName, 'client' => $stsClient, 'region' => $region]);
+                    return $provider();
+                }
+            } else {
+                return self::reject("Unknown profile: {$profileName}");
+            }
+            return self::reject("No RoleArn or WebIdentityTokenFile specified");
+        };
+    }
+    /**
+     * Credentials provider that creates credentials using an ini file stored
+     * in the current user's home directory.  A source can be provided
+     * in this file for assuming a role using the credential_source config option.
+     *
+     * @param string|null $profile  Profile to use. If not specified will use
+     *                              the "default" profile in "~/.aws/credentials".
+     * @param string|null $filename If provided, uses a custom filename rather
+     *                              than looking in the home directory.
+     * @param array|null $config If provided, may contain the following:
+     *                           preferStaticCredentials: If true, prefer static
+     *                           credentials to role_arn if both are present
+     *                           disableAssumeRole: If true, disable support for
+     *                           roles that assume an IAM role. If true and role profile
+     *                           is selected, an error is raised.
+     *                           stsClient: StsClient used to assume role specified in profile
+     *
+     * @return callable
+     */
+    public static function ini($profile = null, $filename = null, array $config = [])
+    {
+        $filename = self::getFileName($filename);
+        $profile = $profile ?: (getenv(self::ENV_PROFILE) ?: 'default');
+        return function () use($profile, $filename, $config) {
+            $preferStaticCredentials = isset($config['preferStaticCredentials']) ? $config['preferStaticCredentials'] : false;
+            $disableAssumeRole = isset($config['disableAssumeRole']) ? $config['disableAssumeRole'] : false;
+            $stsClient = isset($config['stsClient']) ? $config['stsClient'] : null;
+            if (!is_readable($filename)) {
+                return self::reject("Cannot read credentials from {$filename}");
+            }
+            $data = self::loadProfiles($filename);
+            if ($data === false) {
+                return self::reject("Invalid credentials file: {$filename}");
+            }
+            if (!isset($data[$profile])) {
+                return self::reject("'{$profile}' not found in credentials file");
+            }
+            /*
+            In the CLI, the presence of both a role_arn and static credentials have
+            different meanings depending on how many profiles have been visited. For
+            the first profile processed, role_arn takes precedence over any static
+            credentials, but for all subsequent profiles, static credentials are
+            used if present, and only in their absence will the profile's
+            source_profile and role_arn keys be used to load another set of
+            credentials. This bool is intended to yield compatible behaviour in this
+            sdk.
+            */
+            $preferStaticCredentialsToRoleArn = $preferStaticCredentials && isset($data[$profile]['aws_access_key_id']) && isset($data[$profile]['aws_secret_access_key']);
+            if (isset($data[$profile]['role_arn']) && !$preferStaticCredentialsToRoleArn) {
+                if ($disableAssumeRole) {
+                    return self::reject("Role assumption profiles are disabled. " . "Failed to load profile " . $profile);
+                }
+                return self::loadRoleProfile($data, $profile, $filename, $stsClient, $config);
+            }
+            if (!isset($data[$profile]['aws_access_key_id']) || !isset($data[$profile]['aws_secret_access_key'])) {
+                return self::reject("No credentials present in INI profile " . "'{$profile}' ({$filename})");
+            }
+            if (empty($data[$profile]['aws_session_token'])) {
+                $data[$profile]['aws_session_token'] = isset($data[$profile]['aws_security_token']) ? $data[$profile]['aws_security_token'] : null;
+            }
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($data[$profile]['aws_access_key_id'], $data[$profile]['aws_secret_access_key'], $data[$profile]['aws_session_token']));
+        };
+    }
+    /**
+     * Credentials provider that creates credentials using a process configured in
+     * ini file stored in the current user's home directory.
+     *
+     * @param string|null $profile  Profile to use. If not specified will use
+     *                              the "default" profile in "~/.aws/credentials".
+     * @param string|null $filename If provided, uses a custom filename rather
+     *                              than looking in the home directory.
+     *
+     * @return callable
+     */
+    public static function process($profile = null, $filename = null)
+    {
+        $filename = self::getFileName($filename);
+        $profile = $profile ?: (getenv(self::ENV_PROFILE) ?: 'default');
+        return function () use($profile, $filename) {
+            if (!is_readable($filename)) {
+                return self::reject("Cannot read process credentials from {$filename}");
+            }
+            $data = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($filename, true, INI_SCANNER_RAW);
+            if ($data === false) {
+                return self::reject("Invalid credentials file: {$filename}");
+            }
+            if (!isset($data[$profile])) {
+                return self::reject("'{$profile}' not found in credentials file");
+            }
+            if (!isset($data[$profile]['credential_process'])) {
+                return self::reject("No credential_process present in INI profile " . "'{$profile}' ({$filename})");
+            }
+            $credentialProcess = $data[$profile]['credential_process'];
+            $json = shell_exec($credentialProcess);
+            $processData = json_decode($json, true);
+            // Only support version 1
+            if (isset($processData['Version'])) {
+                if ($processData['Version'] !== 1) {
+                    return self::reject("credential_process does not return Version == 1");
+                }
+            }
+            if (!isset($processData['AccessKeyId']) || !isset($processData['SecretAccessKey'])) {
+                return self::reject("credential_process does not return valid credentials");
+            }
+            if (isset($processData['Expiration'])) {
+                try {
+                    $expiration = new \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult($processData['Expiration']);
+                } catch (\Exception $e) {
+                    return self::reject("credential_process returned invalid expiration");
+                }
+                $now = new \UglyRobot\Infinite_Uploads\Aws\Api\DateTimeResult();
+                if ($expiration < $now) {
+                    return self::reject("credential_process returned expired credentials");
+                }
+                $expires = $expiration->getTimestamp();
+            } else {
+                $expires = null;
+            }
+            if (empty($processData['SessionToken'])) {
+                $processData['SessionToken'] = null;
+            }
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for(new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($processData['AccessKeyId'], $processData['SecretAccessKey'], $processData['SessionToken'], $expires));
+        };
+    }
+    /**
+     * Assumes role for profile that includes role_arn
+     *
+     * @return callable
+     */
+    private static function loadRoleProfile($profiles, $profileName, $filename, $stsClient, $config = [])
+    {
+        $roleProfile = $profiles[$profileName];
+        $roleArn = isset($roleProfile['role_arn']) ? $roleProfile['role_arn'] : '';
+        $roleSessionName = isset($roleProfile['role_session_name']) ? $roleProfile['role_session_name'] : 'aws-sdk-php-' . round(microtime(true) * 1000);
+        if (empty($roleProfile['source_profile']) == empty($roleProfile['credential_source'])) {
+            return self::reject("Either source_profile or credential_source must be set " . "using profile " . $profileName . ", but not both.");
+        }
+        $sourceProfileName = "";
+        if (!empty($roleProfile['source_profile'])) {
+            $sourceProfileName = $roleProfile['source_profile'];
+            if (!isset($profiles[$sourceProfileName])) {
+                return self::reject("source_profile " . $sourceProfileName . " using profile " . $profileName . " does not exist");
+            }
+            if (isset($config['visited_profiles']) && in_array($roleProfile['source_profile'], $config['visited_profiles'])) {
+                return self::reject("Circular source_profile reference found.");
+            }
+            $config['visited_profiles'][] = $roleProfile['source_profile'];
+        } else {
+            if (empty($roleArn)) {
+                return self::reject("A role_arn must be provided with credential_source in " . "file {$filename} under profile {$profileName} ");
+            }
+        }
+        if (empty($stsClient)) {
+            $sourceRegion = isset($profiles[$sourceProfileName]['region']) ? $profiles[$sourceProfileName]['region'] : 'us-east-1';
+            $config['preferStaticCredentials'] = true;
+            $sourceCredentials = null;
+            if (!empty($roleProfile['source_profile'])) {
+                $sourceCredentials = call_user_func(\UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialProvider::ini($sourceProfileName, $filename, $config))->wait();
+            } else {
+                $sourceCredentials = self::getCredentialsFromSource($profileName, $filename);
+            }
+            $stsClient = new \UglyRobot\Infinite_Uploads\Aws\Sts\StsClient(['credentials' => $sourceCredentials, 'region' => $sourceRegion, 'version' => '2011-06-15']);
+        }
+        $result = $stsClient->assumeRole(['RoleArn' => $roleArn, 'RoleSessionName' => $roleSessionName]);
+        $credentials = $stsClient->createCredentials($result);
+        return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($credentials);
+    }
+    /**
+     * Gets the environment's HOME directory if available.
+     *
+     * @return null|string
+     */
+    private static function getHomeDir()
+    {
+        // On Linux/Unix-like systems, use the HOME environment variable
+        if ($homeDir = getenv('HOME')) {
+            return $homeDir;
+        }
+        // Get the HOMEDRIVE and HOMEPATH values for Windows hosts
+        $homeDrive = getenv('HOMEDRIVE');
+        $homePath = getenv('HOMEPATH');
+        return $homeDrive && $homePath ? $homeDrive . $homePath : null;
+    }
+    /**
+     * Gets profiles from specified $filename, or default ini files.
+     */
+    private static function loadProfiles($filename)
+    {
+        $profileData = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($filename, true, INI_SCANNER_RAW);
+        // If loading .aws/credentials, also load .aws/config when AWS_SDK_LOAD_NONDEFAULT_CONFIG is set
+        if ($filename === self::getHomeDir() . '/.aws/credentials' && getenv('AWS_SDK_LOAD_NONDEFAULT_CONFIG')) {
+            $configFilename = self::getHomeDir() . '/.aws/config';
+            $configProfileData = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($configFilename, true, INI_SCANNER_RAW);
+            foreach ($configProfileData as $name => $profile) {
+                // standardize config profile names
+                $name = str_replace('profile ', '', $name);
+                if (!isset($profileData[$name])) {
+                    $profileData[$name] = $profile;
+                }
+            }
+        }
+        return $profileData;
+    }
+    /**
+     * Gets profiles from ~/.aws/credentials and ~/.aws/config ini files
+     */
+    private static function loadDefaultProfiles()
+    {
+        $profiles = [];
+        $credFile = self::getHomeDir() . '/.aws/credentials';
+        $configFile = self::getHomeDir() . '/.aws/config';
+        if (file_exists($credFile)) {
+            $profiles = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($credFile, true, INI_SCANNER_RAW);
+        }
+        if (file_exists($configFile)) {
+            $configProfileData = \UglyRobot\Infinite_Uploads\Aws\parse_ini_file($configFile, true, INI_SCANNER_RAW);
+            foreach ($configProfileData as $name => $profile) {
+                // standardize config profile names
+                $name = str_replace('profile ', '', $name);
+                if (!isset($profiles[$name])) {
+                    $profiles[$name] = $profile;
+                }
+            }
+        }
+        return $profiles;
+    }
+    public static function getCredentialsFromSource($profileName = '', $filename = '', $config = [])
+    {
+        $data = self::loadProfiles($filename);
+        $credentialSource = !empty($data[$profileName]['credential_source']) ? $data[$profileName]['credential_source'] : null;
+        $credentialsPromise = null;
+        switch ($credentialSource) {
+            case 'Environment':
+                $credentialsPromise = self::env();
+                break;
+            case 'Ec2InstanceMetadata':
+                $credentialsPromise = self::instanceProfile($config);
+                break;
+            case 'EcsContainer':
+                $credentialsPromise = self::ecsCredentials($config);
+                break;
+            default:
+                throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Invalid credential_source found in config file: {$credentialSource}. Valid inputs " . "include Environment, Ec2InstanceMetadata, and EcsContainer.");
+        }
+        $credentialsResult = null;
+        try {
+            $credentialsResult = $credentialsPromise()->wait();
+        } catch (\Exception $reason) {
+            return self::reject("Unable to successfully retrieve credentials from the source specified in the" . " credentials file: {$credentialSource}; failure message was: " . $reason->getMessage());
+        }
+        return function () use($credentialsResult) {
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\promise_for($credentialsResult);
+        };
+    }
+    private static function reject($msg)
+    {
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\RejectedPromise(new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException($msg));
+    }
+    /**
+     * @param $filename
+     * @return string
+     */
+    private static function getFileName($filename)
+    {
+        if (!isset($filename)) {
+            $filename = getenv(self::ENV_SHARED_CREDENTIALS_FILE) ?: self::getHomeDir() . '/.aws/credentials';
+        }
+        return $filename;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/Credentials.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+/**
+ * Basic implementation of the AWS Credentials interface that allows callers to
+ * pass in the AWS Access Key and AWS Secret Access Key in the constructor.
+ */
+class Credentials implements \UglyRobot\Infinite_Uploads\Aws\Credentials\CredentialsInterface, \Serializable
+{
+    private $key;
+    private $secret;
+    private $token;
+    private $expires;
+    /**
+     * Constructs a new BasicAWSCredentials object, with the specified AWS
+     * access key and AWS secret key
+     *
+     * @param string $key     AWS access key ID
+     * @param string $secret  AWS secret access key
+     * @param string $token   Security token to use
+     * @param int    $expires UNIX timestamp for when credentials expire
+     */
+    public function __construct($key, $secret, $token = null, $expires = null)
+    {
+        $this->key = trim($key);
+        $this->secret = trim($secret);
+        $this->token = $token;
+        $this->expires = $expires;
+    }
+    public static function __set_state(array $state)
+    {
+        return new self($state['key'], $state['secret'], $state['token'], $state['expires']);
+    }
+    public function getAccessKeyId()
+    {
+        return $this->key;
+    }
+    public function getSecretKey()
+    {
+        return $this->secret;
+    }
+    public function getSecurityToken()
+    {
+        return $this->token;
+    }
+    public function getExpiration()
+    {
+        return $this->expires;
+    }
+    public function isExpired()
+    {
+        return $this->expires !== null && time() >= $this->expires;
+    }
+    public function toArray()
+    {
+        return ['key' => $this->key, 'secret' => $this->secret, 'token' => $this->token, 'expires' => $this->expires];
+    }
+    public function serialize()
+    {
+        return json_encode($this->toArray());
+    }
+    public function unserialize($serialized)
+    {
+        $data = json_decode($serialized, true);
+        $this->key = $data['key'];
+        $this->secret = $data['secret'];
+        $this->token = $data['token'];
+        $this->expires = $data['expires'];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/CredentialsInterface.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+/**
+ * Provides access to the AWS credentials used for accessing AWS services: AWS
+ * access key ID, secret access key, and security token. These credentials are
+ * used to securely sign requests to AWS services.
+ */
+interface CredentialsInterface
+{
+    /**
+     * Returns the AWS access key ID for this credentials object.
+     *
+     * @return string
+     */
+    public function getAccessKeyId();
+    /**
+     * Returns the AWS secret access key for this credentials object.
+     *
+     * @return string
+     */
+    public function getSecretKey();
+    /**
+     * Get the associated security token if available
+     *
+     * @return string|null
+     */
+    public function getSecurityToken();
+    /**
+     * Get the UNIX timestamp in which the credentials will expire
+     *
+     * @return int|null
+     */
+    public function getExpiration();
+    /**
+     * Check if the credentials are expired
+     *
+     * @return bool
+     */
+    public function isExpired();
+    /**
+     * Converts the credentials to an associative array.
+     *
+     * @return array
+     */
+    public function toArray();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/EcsCredentialProvider.php

@@ -0,0 +1,77 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Credential provider that fetches credentials with GET request.
+ * ECS environment variable is used in constructing request URI.
+ */
+class EcsCredentialProvider
+{
+    const SERVER_URI = 'http://169.254.170.2';
+    const ENV_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
+    const ENV_TIMEOUT = 'AWS_METADATA_SERVICE_TIMEOUT';
+    /** @var callable */
+    private $client;
+    /** @var float|mixed */
+    private $timeout;
+    /**
+     *  The constructor accepts following options:
+     *  - timeout: (optional) Connection timeout, in seconds, default 1.0
+     *  - client: An EcsClient to make request from
+     *
+     * @param array $config Configuration options
+     */
+    public function __construct(array $config = [])
+    {
+        $timeout = getenv(self::ENV_TIMEOUT);
+        if (!$timeout) {
+            $timeout = isset($_SERVER[self::ENV_TIMEOUT]) ? $_SERVER[self::ENV_TIMEOUT] : (isset($config['timeout']) ? $config['timeout'] : 1.0);
+        }
+        $this->timeout = (double) $timeout;
+        $this->client = isset($config['client']) ? $config['client'] : \UglyRobot\Infinite_Uploads\Aws\default_http_handler();
+    }
+    /**
+     * Load ECS credentials
+     *
+     * @return PromiseInterface
+     */
+    public function __invoke()
+    {
+        $client = $this->client;
+        $request = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request('GET', self::getEcsUri());
+        return $client($request, ['timeout' => $this->timeout, 'proxy' => ''])->then(function (\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response) {
+            $result = $this->decodeResult((string) $response->getBody());
+            return new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($result['AccessKeyId'], $result['SecretAccessKey'], $result['Token'], strtotime($result['Expiration']));
+        })->otherwise(function ($reason) {
+            $reason = is_array($reason) ? $reason['exception'] : $reason;
+            $msg = $reason->getMessage();
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException("Error retrieving credential from ECS ({$msg})");
+        });
+    }
+    /**
+     * Fetch credential URI from ECS environment variable
+     *
+     * @return string Returns ECS URI
+     */
+    private function getEcsUri()
+    {
+        $credsUri = getenv(self::ENV_URI);
+        if ($credsUri === false) {
+            $credsUri = isset($_SERVER[self::ENV_URI]) ? $_SERVER[self::ENV_URI] : '';
+        }
+        return self::SERVER_URI . $credsUri;
+    }
+    private function decodeResult($response)
+    {
+        $result = json_decode($response, true);
+        if (!isset($result['AccessKeyId'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException('Unexpected ECS credential value');
+        }
+        return $result;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Credentials/InstanceProfileProvider.php

@@ -0,0 +1,185 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Credentials;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException;
+use UglyRobot\Infinite_Uploads\Aws\Exception\InvalidJsonException;
+use UglyRobot\Infinite_Uploads\Aws\Sdk;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Exception\TransferException;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Exception\RequestException;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\PromiseInterface;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface;
+/**
+ * Credential provider that provides credentials from the EC2 metadata service.
+ */
+class InstanceProfileProvider
+{
+    const SERVER_URI = 'http://169.254.169.254/latest/';
+    const CRED_PATH = 'meta-data/iam/security-credentials/';
+    const TOKEN_PATH = 'api/token';
+    const ENV_DISABLE = 'AWS_EC2_METADATA_DISABLED';
+    const ENV_TIMEOUT = 'AWS_METADATA_SERVICE_TIMEOUT';
+    const ENV_RETRIES = 'AWS_METADATA_SERVICE_NUM_ATTEMPTS';
+    /** @var string */
+    private $profile;
+    /** @var callable */
+    private $client;
+    /** @var int */
+    private $retries;
+    /** @var int */
+    private $attempts;
+    /** @var float|mixed */
+    private $timeout;
+    /** @var bool */
+    private $secureMode = true;
+    /**
+     * The constructor accepts the following options:
+     *
+     * - timeout: Connection timeout, in seconds.
+     * - profile: Optional EC2 profile name, if known.
+     * - retries: Optional number of retries to be attempted.
+     *
+     * @param array $config Configuration options.
+     */
+    public function __construct(array $config = [])
+    {
+        $this->timeout = (double) getenv(self::ENV_TIMEOUT) ?: (isset($config['timeout']) ? $config['timeout'] : 1.0);
+        $this->profile = isset($config['profile']) ? $config['profile'] : null;
+        $this->retries = (int) getenv(self::ENV_RETRIES) ?: (isset($config['retries']) ? $config['retries'] : 3);
+        $this->attempts = 0;
+        $this->client = isset($config['client']) ? $config['client'] : \UglyRobot\Infinite_Uploads\Aws\default_http_handler();
+    }
+    /**
+     * Loads instance profile credentials.
+     *
+     * @return PromiseInterface
+     */
+    public function __invoke()
+    {
+        return \UglyRobot\Infinite_Uploads\GuzzleHttp\Promise\coroutine(function () {
+            // Retrieve token or switch out of secure mode
+            $token = null;
+            while ($this->secureMode && is_null($token)) {
+                try {
+                    $token = (yield $this->request(self::TOKEN_PATH, 'PUT', ['x-aws-ec2-metadata-token-ttl-seconds' => 21600]));
+                } catch (TransferException $e) {
+                    if (!method_exists($e, 'getResponse') || empty($e->getResponse()) || !in_array($e->getResponse()->getStatusCode(), [400, 500, 502, 503, 504])) {
+                        $this->secureMode = false;
+                    } else {
+                        $this->handleRetryableException($e, [], $this->createErrorMessage('Error retrieving metadata token'));
+                    }
+                }
+                $this->attempts++;
+            }
+            // Set token header only for secure mode
+            $headers = [];
+            if ($this->secureMode) {
+                $headers = ['x-aws-ec2-metadata-token' => $token];
+            }
+            // Retrieve profile
+            while (!$this->profile) {
+                try {
+                    $this->profile = (yield $this->request(self::CRED_PATH, 'GET', $headers));
+                } catch (TransferException $e) {
+                    // 401 indicates insecure flow not supported, switch to
+                    // attempting secure mode for subsequent calls
+                    if (!empty($this->getExceptionStatusCode($e)) && $this->getExceptionStatusCode($e) === 401) {
+                        $this->secureMode = true;
+                    }
+                    $this->handleRetryableException($e, ['blacklist' => [401, 403]], $this->createErrorMessage($e->getMessage()));
+                }
+                $this->attempts++;
+            }
+            // Retrieve credentials
+            $result = null;
+            while ($result == null) {
+                try {
+                    $json = (yield $this->request(self::CRED_PATH . $this->profile, 'GET', $headers));
+                    $result = $this->decodeResult($json);
+                } catch (InvalidJsonException $e) {
+                    $this->handleRetryableException($e, ['blacklist' => [401, 403]], $this->createErrorMessage('Invalid JSON response, retries exhausted'));
+                } catch (TransferException $e) {
+                    // 401 indicates insecure flow not supported, switch to
+                    // attempting secure mode for subsequent calls
+                    if (!empty($this->getExceptionStatusCode($e)) && $this->getExceptionStatusCode($e) === 401) {
+                        $this->secureMode = true;
+                    }
+                    $this->handleRetryableException($e, ['blacklist' => [401, 403]], $this->createErrorMessage($e->getMessage()));
+                }
+                $this->attempts++;
+            }
+            (yield new \UglyRobot\Infinite_Uploads\Aws\Credentials\Credentials($result['AccessKeyId'], $result['SecretAccessKey'], $result['Token'], strtotime($result['Expiration'])));
+        });
+    }
+    /**
+     * @param string $url
+     * @param string $method
+     * @param array $headers
+     * @return PromiseInterface Returns a promise that is fulfilled with the
+     *                          body of the response as a string.
+     */
+    private function request($url, $method = 'GET', $headers = [])
+    {
+        $disabled = getenv(self::ENV_DISABLE) ?: false;
+        if (strcasecmp($disabled, 'true') === 0) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException($this->createErrorMessage('EC2 metadata service access disabled'));
+        }
+        $fn = $this->client;
+        $request = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Request($method, self::SERVER_URI . $url);
+        $userAgent = 'aws-sdk-php/' . \UglyRobot\Infinite_Uploads\Aws\Sdk::VERSION;
+        if (defined('HHVM_VERSION')) {
+            $userAgent .= ' HHVM/' . HHVM_VERSION;
+        }
+        $userAgent .= ' ' . \UglyRobot\Infinite_Uploads\Aws\default_user_agent();
+        $request = $request->withHeader('User-Agent', $userAgent);
+        foreach ($headers as $key => $value) {
+            $request = $request->withHeader($key, $value);
+        }
+        return $fn($request, ['timeout' => $this->timeout])->then(function (\UglyRobot\Infinite_Uploads\Psr\Http\Message\ResponseInterface $response) {
+            return (string) $response->getBody();
+        })->otherwise(function (array $reason) {
+            $reason = $reason['exception'];
+            if ($reason instanceof TransferException) {
+                throw $reason;
+            }
+            $msg = $reason->getMessage();
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException($this->createErrorMessage($msg));
+        });
+    }
+    private function handleRetryableException(\Exception $e, $retryOptions, $message)
+    {
+        $isRetryable = true;
+        if (!empty($status = $this->getExceptionStatusCode($e)) && isset($retryOptions['blacklist']) && in_array($status, $retryOptions['blacklist'])) {
+            $isRetryable = false;
+        }
+        if ($isRetryable && $this->attempts < $this->retries) {
+            sleep(pow(1.2, $this->attempts));
+        } else {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException($message);
+        }
+    }
+    private function getExceptionStatusCode(\Exception $e)
+    {
+        if (method_exists($e, 'getResponse') && !empty($e->getResponse())) {
+            return $e->getResponse()->getStatusCode();
+        }
+        return null;
+    }
+    private function createErrorMessage($previous)
+    {
+        return "Error retrieving credentials from the instance profile " . "metadata service. ({$previous})";
+    }
+    private function decodeResult($response)
+    {
+        $result = json_decode($response, true);
+        if (json_last_error() > 0) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\InvalidJsonException();
+        }
+        if ($result['Code'] !== 'Success') {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CredentialsException('Unexpected instance profile ' . 'response code: ' . $result['Code']);
+        }
+        return $result;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AbstractCryptoClient.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\Cbc;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream;
+/**
+ * Legacy abstract encryption client. New workflows should use
+ * AbstractCryptoClientV2.
+ *
+ * @deprecated
+ * @internal
+ */
+abstract class AbstractCryptoClient
+{
+    public static $supportedCiphers = ['cbc', 'gcm'];
+    public static $supportedKeyWraps = [\UglyRobot\Infinite_Uploads\Aws\Crypto\KmsMaterialsProvider::WRAP_ALGORITHM_NAME];
+    /**
+     * Returns if the passed cipher name is supported for encryption by the SDK.
+     *
+     * @param string $cipherName The name of a cipher to verify is registered.
+     *
+     * @return bool If the cipher passed is in our supported list.
+     */
+    public static function isSupportedCipher($cipherName)
+    {
+        return in_array($cipherName, self::$supportedCiphers);
+    }
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-cbc` or `aes-128-ctr`.
+     *
+     * @param string $cipherName Name of the cipher being used for encrypting
+     *                           or decrypting.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return string
+     */
+    protected abstract function getCipherOpenSslName($cipherName, $keySize);
+    /**
+     * Constructs a CipherMethod for the given name, initialized with the other
+     * data passed for use in encrypting or decrypting.
+     *
+     * @param string $cipherName Name of the cipher to generate for encrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Performs a reverse lookup to get the openssl_* cipher name from the
+     * AESName passed in from the MetadataEnvelope.
+     *
+     * @param $aesName
+     *
+     * @return string
+     *
+     * @internal
+     */
+    protected abstract function getCipherFromAesName($aesName);
+    /**
+     * Dependency to provide an interface for building an encryption stream for
+     * data given cipher details, metadata, and materials to do so.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     * @param MaterialsProvider $provider A provider to supply and encrypt
+     *                                    materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be added to.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    public abstract function encrypt(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, array $cipherOptions, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProvider $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope);
+    /**
+     * Dependency to provide an interface for building a decryption stream for
+     * cipher text given metadata and materials to do so.
+     *
+     * @param string $cipherText Plain-text data to be decrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param MaterialsProviderInterface $provider A provider to supply and encrypt
+     *                                             materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     * @param array $cipherOptions Additional verification options.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    public abstract function decrypt($cipherText, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterface $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope, array $cipherOptions = []);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AbstractCryptoClientV2.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream;
+/**
+ * @internal
+ */
+abstract class AbstractCryptoClientV2
+{
+    public static $supportedCiphers = ['gcm'];
+    public static $supportedKeyWraps = [\UglyRobot\Infinite_Uploads\Aws\Crypto\KmsMaterialsProviderV2::WRAP_ALGORITHM_NAME];
+    public static $supportedSecurityProfiles = ['V2', 'V2_AND_LEGACY'];
+    public static $legacySecurityProfiles = ['V2_AND_LEGACY'];
+    /**
+     * Returns if the passed cipher name is supported for encryption by the SDK.
+     *
+     * @param string $cipherName The name of a cipher to verify is registered.
+     *
+     * @return bool If the cipher passed is in our supported list.
+     */
+    public static function isSupportedCipher($cipherName)
+    {
+        return in_array($cipherName, self::$supportedCiphers, true);
+    }
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-gcm`
+     *
+     * @param string $cipherName Name of the cipher being used for encrypting
+     *                           or decrypting.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return string
+     */
+    protected abstract function getCipherOpenSslName($cipherName, $keySize);
+    /**
+     * Constructs a CipherMethod for the given name, initialized with the other
+     * data passed for use in encrypting or decrypting.
+     *
+     * @param string $cipherName Name of the cipher to generate for encrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Performs a reverse lookup to get the openssl_* cipher name from the
+     * AESName passed in from the MetadataEnvelope.
+     *
+     * @param $aesName
+     *
+     * @return string
+     *
+     * @internal
+     */
+    protected abstract function getCipherFromAesName($aesName);
+    /**
+     * Dependency to provide an interface for building an encryption stream for
+     * data given cipher details, metadata, and materials to do so.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param array $options Options for use in encryption.
+     * @param MaterialsProviderV2 $provider A provider to supply and encrypt
+     *                                      materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be added to.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    public abstract function encrypt(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, array $options, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderV2 $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope);
+    /**
+     * Dependency to provide an interface for building a decryption stream for
+     * cipher text given metadata and materials to do so.
+     *
+     * @param string $cipherText Plain-text data to be decrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param MaterialsProviderInterface $provider A provider to supply and encrypt
+     *                                             materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     * @param array $options Options used for decryption.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    public abstract function decrypt($cipherText, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterfaceV2 $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope, array $options = []);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesDecryptingStream.php

@@ -0,0 +1,108 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\StreamDecoratorTrait;
+use LogicException;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod;
+/**
+ * @internal Represents a stream of data to be decrypted with passed cipher.
+ */
+class AesDecryptingStream implements \UglyRobot\Infinite_Uploads\Aws\Crypto\AesStreamInterface
+{
+    const BLOCK_SIZE = 16;
+    // 128 bits
+    use StreamDecoratorTrait;
+    /**
+     * @var string
+     */
+    private $buffer = '';
+    /**
+     * @var CipherMethod
+     */
+    private $cipherMethod;
+    /**
+     * @var string
+     */
+    private $key;
+    /**
+     * @var StreamInterface
+     */
+    private $stream;
+    /**
+     * @param StreamInterface $cipherText
+     * @param string $key
+     * @param CipherMethod $cipherMethod
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $key, \UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod $cipherMethod)
+    {
+        $this->stream = $cipherText;
+        $this->key = $key;
+        $this->cipherMethod = clone $cipherMethod;
+    }
+    public function getOpenSslName()
+    {
+        return $this->cipherMethod->getOpenSslName();
+    }
+    public function getAesName()
+    {
+        return $this->cipherMethod->getAesName();
+    }
+    public function getCurrentIv()
+    {
+        return $this->cipherMethod->getCurrentIv();
+    }
+    public function getSize()
+    {
+        $plainTextSize = $this->stream->getSize();
+        if ($this->cipherMethod->requiresPadding()) {
+            // PKCS7 padding requires that between 1 and self::BLOCK_SIZE be
+            // added to the plaintext to make it an even number of blocks. The
+            // plaintext is between strlen($cipherText) - self::BLOCK_SIZE and
+            // strlen($cipherText) - 1
+            return null;
+        }
+        return $plainTextSize;
+    }
+    public function isWritable()
+    {
+        return false;
+    }
+    public function read($length)
+    {
+        if ($length > strlen($this->buffer)) {
+            $this->buffer .= $this->decryptBlock(self::BLOCK_SIZE * ceil(($length - strlen($this->buffer)) / self::BLOCK_SIZE));
+        }
+        $data = substr($this->buffer, 0, $length);
+        $this->buffer = substr($this->buffer, $length);
+        return $data ? $data : '';
+    }
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        if ($offset === 0 && $whence === SEEK_SET) {
+            $this->buffer = '';
+            $this->cipherMethod->seek(0, SEEK_SET);
+            $this->stream->seek(0, SEEK_SET);
+        } else {
+            throw new \LogicException('AES encryption streams only support being' . ' rewound, not arbitrary seeking.');
+        }
+    }
+    private function decryptBlock($length)
+    {
+        if ($this->stream->eof()) {
+            return '';
+        }
+        $cipherText = '';
+        do {
+            $cipherText .= $this->stream->read($length - strlen($cipherText));
+        } while (strlen($cipherText) < $length && !$this->stream->eof());
+        $options = OPENSSL_RAW_DATA;
+        if (!$this->stream->eof() && $this->stream->getSize() !== $this->stream->tell()) {
+            $options |= OPENSSL_ZERO_PADDING;
+        }
+        $plaintext = openssl_decrypt($cipherText, $this->cipherMethod->getOpenSslName(), $this->key, $options, $this->cipherMethod->getCurrentIv());
+        $this->cipherMethod->update($cipherText);
+        return $plaintext;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesEncryptingStream.php

@@ -0,0 +1,113 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\StreamDecoratorTrait;
+use LogicException;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod;
+/**
+ * @internal Represents a stream of data to be encrypted with a passed cipher.
+ */
+class AesEncryptingStream implements \UglyRobot\Infinite_Uploads\Aws\Crypto\AesStreamInterface
+{
+    const BLOCK_SIZE = 16;
+    // 128 bits
+    use StreamDecoratorTrait;
+    /**
+     * @var string
+     */
+    private $buffer = '';
+    /**
+     * @var CipherMethod
+     */
+    private $cipherMethod;
+    /**
+     * @var string
+     */
+    private $key;
+    /**
+     * @var StreamInterface
+     */
+    private $stream;
+    /**
+     * @param StreamInterface $plainText
+     * @param string $key
+     * @param CipherMethod $cipherMethod
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $plainText, $key, \UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod $cipherMethod)
+    {
+        $this->stream = $plainText;
+        $this->key = $key;
+        $this->cipherMethod = clone $cipherMethod;
+    }
+    public function getOpenSslName()
+    {
+        return $this->cipherMethod->getOpenSslName();
+    }
+    public function getAesName()
+    {
+        return $this->cipherMethod->getAesName();
+    }
+    public function getCurrentIv()
+    {
+        return $this->cipherMethod->getCurrentIv();
+    }
+    public function getSize()
+    {
+        $plainTextSize = $this->stream->getSize();
+        if ($this->cipherMethod->requiresPadding() && $plainTextSize !== null) {
+            // PKCS7 padding requires that between 1 and self::BLOCK_SIZE be
+            // added to the plaintext to make it an even number of blocks.
+            $padding = self::BLOCK_SIZE - $plainTextSize % self::BLOCK_SIZE;
+            return $plainTextSize + $padding;
+        }
+        return $plainTextSize;
+    }
+    public function isWritable()
+    {
+        return false;
+    }
+    public function read($length)
+    {
+        if ($length > strlen($this->buffer)) {
+            $this->buffer .= $this->encryptBlock(self::BLOCK_SIZE * ceil(($length - strlen($this->buffer)) / self::BLOCK_SIZE));
+        }
+        $data = substr($this->buffer, 0, $length);
+        $this->buffer = substr($this->buffer, $length);
+        return $data ? $data : '';
+    }
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        if ($whence === SEEK_CUR) {
+            $offset = $this->tell() + $offset;
+            $whence = SEEK_SET;
+        }
+        if ($whence === SEEK_SET) {
+            $this->buffer = '';
+            $wholeBlockOffset = (int) ($offset / self::BLOCK_SIZE) * self::BLOCK_SIZE;
+            $this->stream->seek($wholeBlockOffset);
+            $this->cipherMethod->seek($wholeBlockOffset);
+            $this->read($offset - $wholeBlockOffset);
+        } else {
+            throw new \LogicException('Unrecognized whence.');
+        }
+    }
+    private function encryptBlock($length)
+    {
+        if ($this->stream->eof()) {
+            return '';
+        }
+        $plainText = '';
+        do {
+            $plainText .= $this->stream->read($length - strlen($plainText));
+        } while (strlen($plainText) < $length && !$this->stream->eof());
+        $options = OPENSSL_RAW_DATA;
+        if (!$this->stream->eof() || $this->stream->getSize() !== $this->stream->tell()) {
+            $options |= OPENSSL_ZERO_PADDING;
+        }
+        $cipherText = openssl_encrypt($plainText, $this->cipherMethod->getOpenSslName(), $this->key, $options, $this->cipherMethod->getCurrentIv());
+        $this->cipherMethod->update($cipherText);
+        return $cipherText;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesGcmDecryptingStream.php

@@ -0,0 +1,71 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\StreamDecoratorTrait;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\AesGcm;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\Key;
+/**
+ * @internal Represents a stream of data to be gcm decrypted.
+ */
+class AesGcmDecryptingStream implements \UglyRobot\Infinite_Uploads\Aws\Crypto\AesStreamInterface
+{
+    use StreamDecoratorTrait;
+    private $aad;
+    private $initializationVector;
+    private $key;
+    private $keySize;
+    private $cipherText;
+    private $tag;
+    private $tagLength;
+    /**
+     * @param StreamInterface $cipherText
+     * @param string $key
+     * @param string $initializationVector
+     * @param string $tag
+     * @param string $aad
+     * @param int $tagLength
+     * @param int $keySize
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $key, $initializationVector, $tag, $aad = '', $tagLength = 128, $keySize = 256)
+    {
+        $this->cipherText = $cipherText;
+        $this->key = $key;
+        $this->initializationVector = $initializationVector;
+        $this->tag = $tag;
+        $this->aad = $aad;
+        $this->tagLength = $tagLength;
+        $this->keySize = $keySize;
+    }
+    public function getOpenSslName()
+    {
+        return "aes-{$this->keySize}-gcm";
+    }
+    public function getAesName()
+    {
+        return 'AES/GCM/NoPadding';
+    }
+    public function getCurrentIv()
+    {
+        return $this->initializationVector;
+    }
+    public function createStream()
+    {
+        if (version_compare(PHP_VERSION, '7.1', '<')) {
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for(\UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\AesGcm::decrypt((string) $this->cipherText, $this->initializationVector, new \UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\Key($this->key), $this->aad, $this->tag, $this->keySize));
+        } else {
+            $result = \openssl_decrypt((string) $this->cipherText, $this->getOpenSslName(), $this->key, OPENSSL_RAW_DATA, $this->initializationVector, $this->tag, $this->aad);
+            if ($result === false) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException('The requested object could not be' . ' decrypted due to an invalid authentication tag.');
+            }
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($result);
+        }
+    }
+    public function isWritable()
+    {
+        return false;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesGcmEncryptingStream.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\AesGcm;
+use UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\Key;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\StreamDecoratorTrait;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+use RuntimeException;
+/**
+ * @internal Represents a stream of data to be gcm encrypted.
+ */
+class AesGcmEncryptingStream implements \UglyRobot\Infinite_Uploads\Aws\Crypto\AesStreamInterface, \UglyRobot\Infinite_Uploads\Aws\Crypto\AesStreamInterfaceV2
+{
+    use StreamDecoratorTrait;
+    private $aad;
+    private $initializationVector;
+    private $key;
+    private $keySize;
+    private $plaintext;
+    private $tag = '';
+    private $tagLength;
+    /**
+     * Same as non-static 'getAesName' method, allowing calls in a static
+     * context.
+     *
+     * @return string
+     */
+    public static function getStaticAesName()
+    {
+        return 'AES/GCM/NoPadding';
+    }
+    /**
+     * @param StreamInterface $plaintext
+     * @param string $key
+     * @param string $initializationVector
+     * @param string $aad
+     * @param int $tagLength
+     * @param int $keySize
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $plaintext, $key, $initializationVector, $aad = '', $tagLength = 16, $keySize = 256)
+    {
+        $this->plaintext = $plaintext;
+        $this->key = $key;
+        $this->initializationVector = $initializationVector;
+        $this->aad = $aad;
+        $this->tagLength = $tagLength;
+        $this->keySize = $keySize;
+    }
+    public function getOpenSslName()
+    {
+        return "aes-{$this->keySize}-gcm";
+    }
+    /**
+     * Same as static method and retained for backwards compatibility
+     *
+     * @return string
+     */
+    public function getAesName()
+    {
+        return self::getStaticAesName();
+    }
+    public function getCurrentIv()
+    {
+        return $this->initializationVector;
+    }
+    public function createStream()
+    {
+        if (version_compare(PHP_VERSION, '7.1', '<')) {
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for(\UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\AesGcm::encrypt((string) $this->plaintext, $this->initializationVector, new \UglyRobot\Infinite_Uploads\Aws\Crypto\Polyfill\Key($this->key), $this->aad, $this->tag, $this->keySize));
+        } else {
+            return \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for(\openssl_encrypt((string) $this->plaintext, $this->getOpenSslName(), $this->key, OPENSSL_RAW_DATA, $this->initializationVector, $this->tag, $this->aad, $this->tagLength));
+        }
+    }
+    /**
+     * @return string
+     */
+    public function getTag()
+    {
+        return $this->tag;
+    }
+    public function isWritable()
+    {
+        return false;
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesStreamInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+interface AesStreamInterface extends StreamInterface
+{
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-cbc` or `aes-128-ctr`.
+     *
+     * @return string
+     */
+    public function getOpenSslName();
+    /**
+     * Returns an AES recognizable name, such as 'AES/GCM/NoPadding'.
+     *
+     * @return string
+     */
+    public function getAesName();
+    /**
+     * Returns the IV that should be used to initialize the next block in
+     * encrypt or decrypt.
+     *
+     * @return string
+     */
+    public function getCurrentIv();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/AesStreamInterfaceV2.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+interface AesStreamInterfaceV2 extends StreamInterface
+{
+    /**
+     * Returns an AES recognizable name, such as 'AES/GCM/NoPadding'. V2
+     * interface is accessible from a static context.
+     *
+     * @return string
+     */
+    public static function getStaticAesName();
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-cbc` or `aes-128-ctr`.
+     *
+     * @return string
+     */
+    public function getOpenSslName();
+    /**
+     * Returns the IV that should be used to initialize the next block in
+     * encrypt or decrypt.
+     *
+     * @return string
+     */
+    public function getCurrentIv();
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/Cipher/Cbc.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher;
+
+use InvalidArgumentException;
+use LogicException;
+/**
+ * An implementation of the CBC cipher for use with an AesEncryptingStream or
+ * AesDecrypting stream.
+ *
+ * This cipher method is deprecated and in maintenance mode - no new updates will be
+ * released. Please see https://docs.aws.amazon.com/general/latest/gr/aws_sdk_cryptography.html
+ * for more information.
+ *
+ * @deprecated
+ */
+class Cbc implements \UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\CipherMethod
+{
+    const BLOCK_SIZE = 16;
+    /**
+     * @var string
+     */
+    private $baseIv;
+    /**
+     * @var string
+     */
+    private $iv;
+    /**
+     * @var int
+     */
+    private $keySize;
+    /**
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @throws InvalidArgumentException Thrown if the passed iv does not match
+     *                                  the iv length required by the cipher.
+     */
+    public function __construct($iv, $keySize = 256)
+    {
+        $this->baseIv = $this->iv = $iv;
+        $this->keySize = $keySize;
+        if (strlen($iv) !== openssl_cipher_iv_length($this->getOpenSslName())) {
+            throw new \InvalidArgumentException('Invalid initialization vector');
+        }
+    }
+    public function getOpenSslName()
+    {
+        return "aes-{$this->keySize}-cbc";
+    }
+    public function getAesName()
+    {
+        return 'AES/CBC/PKCS5Padding';
+    }
+    public function getCurrentIv()
+    {
+        return $this->iv;
+    }
+    public function requiresPadding()
+    {
+        return true;
+    }
+    public function seek($offset, $whence = SEEK_SET)
+    {
+        if ($offset === 0 && $whence === SEEK_SET) {
+            $this->iv = $this->baseIv;
+        } else {
+            throw new \LogicException('CBC initialization only support being' . ' rewound, not arbitrary seeking.');
+        }
+    }
+    public function update($cipherTextBlock)
+    {
+        $this->iv = substr($cipherTextBlock, self::BLOCK_SIZE * -1);
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/Cipher/CipherBuilderTrait.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException;
+trait CipherBuilderTrait
+{
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-cbc` or `aes-128-ctr`.
+     *
+     * @param string $cipherName Name of the cipher being used for encrypting
+     *                           or decrypting.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return string
+     */
+    protected function getCipherOpenSslName($cipherName, $keySize)
+    {
+        return "aes-{$keySize}-{$cipherName}";
+    }
+    /**
+     * Constructs a CipherMethod for the given name, initialized with the other
+     * data passed for use in encrypting or decrypting.
+     *
+     * @param string $cipherName Name of the cipher to generate for encrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return CipherMethod
+     *
+     * @internal
+     */
+    protected function buildCipherMethod($cipherName, $iv, $keySize)
+    {
+        switch ($cipherName) {
+            case 'cbc':
+                return new \UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher\Cbc($iv, $keySize);
+            default:
+                return null;
+        }
+    }
+    /**
+     * Performs a reverse lookup to get the openssl_* cipher name from the
+     * AESName passed in from the MetadataEnvelope.
+     *
+     * @param $aesName
+     *
+     * @return string
+     *
+     * @internal
+     */
+    protected function getCipherFromAesName($aesName)
+    {
+        switch ($aesName) {
+            case 'AES/GCM/NoPadding':
+                return 'gcm';
+            case 'AES/CBC/PKCS5Padding':
+                return 'cbc';
+            default:
+                throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException('Unrecognized or unsupported' . ' AESName for reverse lookup.');
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/Cipher/CipherMethod.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto\Cipher;
+
+interface CipherMethod
+{
+    /**
+     * Returns an identifier recognizable by `openssl_*` functions, such as
+     * `aes-256-cbc` or `aes-128-ctr`.
+     *
+     * @return string
+     */
+    public function getOpenSslName();
+    /**
+     * Returns an AES recognizable name, such as 'AES/GCM/NoPadding'.
+     *
+     * @return string
+     */
+    public function getAesName();
+    /**
+     * Returns the IV that should be used to initialize the next block in
+     * encrypt or decrypt.
+     *
+     * @return string
+     */
+    public function getCurrentIv();
+    /**
+     * Indicates whether the cipher method used with this IV requires padding
+     * the final block to make sure the plaintext is evenly divisible by the
+     * block size.
+     *
+     * @return boolean
+     */
+    public function requiresPadding();
+    /**
+     * Adjust the return of this::getCurrentIv to reflect a seek performed on
+     * the encryption stream using this IV object.
+     *
+     * @param int $offset
+     * @param int $whence
+     *
+     * @throws LogicException   Thrown if the requested seek is not supported by
+     *                          this IV implementation. For example, a CBC IV
+     *                          only supports a full rewind ($offset === 0 &&
+     *                          $whence === SEEK_SET)
+     */
+    public function seek($offset, $whence = SEEK_SET);
+    /**
+     * Take account of the last cipher text block to adjust the return of
+     * this::getCurrentIv
+     *
+     * @param string $cipherTextBlock
+     */
+    public function update($cipherTextBlock);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/DecryptionTrait.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+trait DecryptionTrait
+{
+    /**
+     * Dependency to reverse lookup the openssl_* cipher name from the AESName
+     * in the MetadataEnvelope.
+     *
+     * @param $aesName
+     *
+     * @return string
+     *
+     * @internal
+     */
+    protected abstract function getCipherFromAesName($aesName);
+    /**
+     * Dependency to generate a CipherMethod from a set of inputs for loading
+     * in to an AesDecryptingStream.
+     *
+     * @param string $cipherName Name of the cipher to generate for decrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return Cipher\CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Builds an AesStreamInterface using cipher options loaded from the
+     * MetadataEnvelope and MaterialsProvider. Can decrypt data from both the
+     * legacy and V2 encryption client workflows.
+     *
+     * @param string $cipherText Plain-text data to be encrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param MaterialsProviderInterface $provider A provider to supply and encrypt
+     *                                             materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     * @param array $cipherOptions Additional verification options.
+     *
+     * @return AesStreamInterface
+     *
+     * @throws \InvalidArgumentException Thrown when a value in $cipherOptions
+     *                                   is not valid.
+     *
+     * @internal
+     */
+    public function decrypt($cipherText, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterface $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope, array $cipherOptions = [])
+    {
+        $cipherOptions['Iv'] = base64_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::IV_HEADER]);
+        $cipherOptions['TagLength'] = $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CRYPTO_TAG_LENGTH_HEADER] / 8;
+        $cek = $provider->decryptCek(base64_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_KEY_V2_HEADER]), json_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER], true));
+        $cipherOptions['KeySize'] = strlen($cek) * 8;
+        $cipherOptions['Cipher'] = $this->getCipherFromAesName($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER]);
+        $decryptionStream = $this->getDecryptingStream($cipherText, $cek, $cipherOptions);
+        unset($cek);
+        return $decryptionStream;
+    }
+    private function getTagFromCiphertextStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $tagLength)
+    {
+        $cipherTextSize = $cipherText->getSize();
+        if ($cipherTextSize == null || $cipherTextSize <= 0) {
+            throw new \RuntimeException('Cannot decrypt a stream of unknown' . ' size.');
+        }
+        return (string) new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream($cipherText, $tagLength, $cipherTextSize - $tagLength);
+    }
+    private function getStrippedCiphertextStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $tagLength)
+    {
+        $cipherTextSize = $cipherText->getSize();
+        if ($cipherTextSize == null || $cipherTextSize <= 0) {
+            throw new \RuntimeException('Cannot decrypt a stream of unknown' . ' size.');
+        }
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream($cipherText, $cipherTextSize - $tagLength, 0);
+    }
+    /**
+     * Generates a stream that wraps the cipher text with the proper cipher and
+     * uses the content encryption key (CEK) to decrypt the data when read.
+     *
+     * @param string $cipherText Plain-text data to be encrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param string $cek A content encryption key for use by the stream for
+     *                    encrypting the plaintext data.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    protected function getDecryptingStream($cipherText, $cek, $cipherOptions)
+    {
+        $cipherTextStream = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($cipherText);
+        switch ($cipherOptions['Cipher']) {
+            case 'gcm':
+                $cipherOptions['Tag'] = $this->getTagFromCiphertextStream($cipherTextStream, $cipherOptions['TagLength']);
+                return new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesGcmDecryptingStream($this->getStrippedCiphertextStream($cipherTextStream, $cipherOptions['TagLength']), $cek, $cipherOptions['Iv'], $cipherOptions['Tag'], $cipherOptions['Aad'] = isset($cipherOptions['Aad']) ? $cipherOptions['Aad'] : null, $cipherOptions['TagLength'] ?: null, $cipherOptions['KeySize']);
+            default:
+                $cipherMethod = $this->buildCipherMethod($cipherOptions['Cipher'], $cipherOptions['Iv'], $cipherOptions['KeySize']);
+                return new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesDecryptingStream($cipherTextStream, $cek, $cipherMethod);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/DecryptionTraitV2.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+trait DecryptionTraitV2
+{
+    /**
+     * Dependency to reverse lookup the openssl_* cipher name from the AESName
+     * in the MetadataEnvelope.
+     *
+     * @param $aesName
+     *
+     * @return string
+     *
+     * @internal
+     */
+    protected abstract function getCipherFromAesName($aesName);
+    /**
+     * Dependency to generate a CipherMethod from a set of inputs for loading
+     * in to an AesDecryptingStream.
+     *
+     * @param string $cipherName Name of the cipher to generate for decrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return Cipher\CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Builds an AesStreamInterface using cipher options loaded from the
+     * MetadataEnvelope and MaterialsProvider. Can decrypt data from both the
+     * legacy and V2 encryption client workflows.
+     *
+     * @param string $cipherText Plain-text data to be encrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param MaterialsProviderInterfaceV2 $provider A provider to supply and encrypt
+     *                                             materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     * @param array $options Options used for decryption.
+     *
+     * @return AesStreamInterface
+     *
+     * @throws \InvalidArgumentException Thrown when a value in $cipherOptions
+     *                                   is not valid.
+     *
+     * @internal
+     */
+    public function decrypt($cipherText, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterfaceV2 $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope, array $options = [])
+    {
+        $options['@CipherOptions'] = !empty($options['@CipherOptions']) ? $options['@CipherOptions'] : [];
+        $options['@CipherOptions']['Iv'] = base64_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::IV_HEADER]);
+        $options['@CipherOptions']['TagLength'] = $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CRYPTO_TAG_LENGTH_HEADER] / 8;
+        $cek = $provider->decryptCek(base64_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_KEY_V2_HEADER]), json_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER], true), $options);
+        $options['@CipherOptions']['KeySize'] = strlen($cek) * 8;
+        $options['@CipherOptions']['Cipher'] = $this->getCipherFromAesName($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER]);
+        $this->validateOptionsAndEnvelope($options, $envelope);
+        $decryptionStream = $this->getDecryptingStream($cipherText, $cek, $options['@CipherOptions']);
+        unset($cek);
+        return $decryptionStream;
+    }
+    private function getTagFromCiphertextStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $tagLength)
+    {
+        $cipherTextSize = $cipherText->getSize();
+        if ($cipherTextSize == null || $cipherTextSize <= 0) {
+            throw new \RuntimeException('Cannot decrypt a stream of unknown' . ' size.');
+        }
+        return (string) new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream($cipherText, $tagLength, $cipherTextSize - $tagLength);
+    }
+    private function getStrippedCiphertextStream(\UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface $cipherText, $tagLength)
+    {
+        $cipherTextSize = $cipherText->getSize();
+        if ($cipherTextSize == null || $cipherTextSize <= 0) {
+            throw new \RuntimeException('Cannot decrypt a stream of unknown' . ' size.');
+        }
+        return new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\LimitStream($cipherText, $cipherTextSize - $tagLength, 0);
+    }
+    private function validateOptionsAndEnvelope($options, $envelope)
+    {
+        $allowedCiphers = AbstractCryptoClientV2::$supportedCiphers;
+        $allowedKeywraps = AbstractCryptoClientV2::$supportedKeyWraps;
+        if ($options['@SecurityProfile'] == 'V2_AND_LEGACY') {
+            $allowedCiphers = array_unique(array_merge($allowedCiphers, AbstractCryptoClient::$supportedCiphers));
+            $allowedKeywraps = array_unique(array_merge($allowedKeywraps, AbstractCryptoClient::$supportedKeyWraps));
+        }
+        $v1SchemaException = new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("The requested object is encrypted" . " with V1 encryption schemas that have been disabled by" . " client configuration @SecurityProfile=V2. Retry with" . " V2_AND_LEGACY enabled or reencrypt the object.");
+        if (!in_array($options['@CipherOptions']['Cipher'], $allowedCiphers)) {
+            if (in_array($options['@CipherOptions']['Cipher'], AbstractCryptoClient::$supportedCiphers)) {
+                throw $v1SchemaException;
+            }
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("The requested object is encrypted with" . " the cipher '{$options['@CipherOptions']['Cipher']}', which is not" . " supported for decryption with the selected security profile." . " This profile allows decryption with: " . implode(", ", $allowedCiphers));
+        }
+        if (!in_array($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::KEY_WRAP_ALGORITHM_HEADER], $allowedKeywraps)) {
+            if (in_array($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::KEY_WRAP_ALGORITHM_HEADER], AbstractCryptoClient::$supportedKeyWraps)) {
+                throw $v1SchemaException;
+            }
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("The requested object is encrypted with" . " the keywrap schema '{$envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::KEY_WRAP_ALGORITHM_HEADER]}'," . " which is not supported for decryption with the current security" . " profile.");
+        }
+        $matdesc = json_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER], true);
+        if (isset($matdesc['aws:x-amz-cek-alg']) && $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER] !== $matdesc['aws:x-amz-cek-alg']) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("There is a mismatch in specified content" . " encryption algrithm between the materials description value" . " and the metadata envelope value: {$matdesc['aws:x-amz-cek-alg']}" . " vs. {$envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER]}.");
+        }
+    }
+    /**
+     * Generates a stream that wraps the cipher text with the proper cipher and
+     * uses the content encryption key (CEK) to decrypt the data when read.
+     *
+     * @param string $cipherText Plain-text data to be encrypted using the
+     *                           materials, algorithm, and data provided.
+     * @param string $cek A content encryption key for use by the stream for
+     *                    encrypting the plaintext data.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     *
+     * @return AesStreamInterface
+     *
+     * @internal
+     */
+    protected function getDecryptingStream($cipherText, $cek, $cipherOptions)
+    {
+        $cipherTextStream = \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($cipherText);
+        switch ($cipherOptions['Cipher']) {
+            case 'gcm':
+                $cipherOptions['Tag'] = $this->getTagFromCiphertextStream($cipherTextStream, $cipherOptions['TagLength']);
+                return new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesGcmDecryptingStream($this->getStrippedCiphertextStream($cipherTextStream, $cipherOptions['TagLength']), $cek, $cipherOptions['Iv'], $cipherOptions['Tag'], $cipherOptions['Aad'] = isset($cipherOptions['Aad']) ? $cipherOptions['Aad'] : null, $cipherOptions['TagLength'] ?: null, $cipherOptions['KeySize']);
+            default:
+                $cipherMethod = $this->buildCipherMethod($cipherOptions['Cipher'], $cipherOptions['Iv'], $cipherOptions['KeySize']);
+                return new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesDecryptingStream($cipherTextStream, $cek, $cipherMethod);
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/EncryptionTrait.php

@@ -0,0 +1,114 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\AppendStream;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream;
+trait EncryptionTrait
+{
+    private static $allowedOptions = ['Cipher' => true, 'KeySize' => true, 'Aad' => true];
+    /**
+     * Dependency to generate a CipherMethod from a set of inputs for loading
+     * in to an AesEncryptingStream.
+     *
+     * @param string $cipherName Name of the cipher to generate for encrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return Cipher\CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Builds an AesStreamInterface and populates encryption metadata into the
+     * supplied envelope.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     * @param MaterialsProvider $provider A provider to supply and encrypt
+     *                                    materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be added to.
+     *
+     * @return AesStreamInterface
+     *
+     * @throws \InvalidArgumentException Thrown when a value in $cipherOptions
+     *                                   is not valid.
+     *
+     * @internal
+     */
+    public function encrypt(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, array $cipherOptions, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProvider $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope)
+    {
+        $materialsDescription = $provider->getMaterialsDescription();
+        $cipherOptions = array_intersect_key($cipherOptions, self::$allowedOptions);
+        if (empty($cipherOptions['Cipher'])) {
+            throw new \InvalidArgumentException('An encryption cipher must be' . ' specified in the "cipher_options".');
+        }
+        if (!self::isSupportedCipher($cipherOptions['Cipher'])) {
+            throw new \InvalidArgumentException('The cipher requested is not' . ' supported by the SDK.');
+        }
+        if (empty($cipherOptions['KeySize'])) {
+            $cipherOptions['KeySize'] = 256;
+        }
+        if (!is_int($cipherOptions['KeySize'])) {
+            throw new \InvalidArgumentException('The cipher "KeySize" must be' . ' an integer.');
+        }
+        if (!\UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProvider::isSupportedKeySize($cipherOptions['KeySize'])) {
+            throw new \InvalidArgumentException('The cipher "KeySize" requested' . ' is not supported by AES (128, 192, or 256).');
+        }
+        $cipherOptions['Iv'] = $provider->generateIv($this->getCipherOpenSslName($cipherOptions['Cipher'], $cipherOptions['KeySize']));
+        $cek = $provider->generateCek($cipherOptions['KeySize']);
+        list($encryptingStream, $aesName) = $this->getEncryptingStream($plaintext, $cek, $cipherOptions);
+        // Populate envelope data
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_KEY_V2_HEADER] = $provider->encryptCek($cek, $materialsDescription);
+        unset($cek);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::IV_HEADER] = base64_encode($cipherOptions['Iv']);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::KEY_WRAP_ALGORITHM_HEADER] = $provider->getWrapAlgorithmName();
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER] = $aesName;
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::UNENCRYPTED_CONTENT_LENGTH_HEADER] = strlen($plaintext);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER] = json_encode($materialsDescription);
+        if (!empty($cipherOptions['Tag'])) {
+            $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CRYPTO_TAG_LENGTH_HEADER] = strlen($cipherOptions['Tag']) * 8;
+        }
+        return $encryptingStream;
+    }
+    /**
+     * Generates a stream that wraps the plaintext with the proper cipher and
+     * uses the content encryption key (CEK) to encrypt the data when read.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param string $cek A content encryption key for use by the stream for
+     *                    encrypting the plaintext data.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     *
+     * @return [AesStreamInterface, string]
+     *
+     * @internal
+     */
+    protected function getEncryptingStream(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, $cek, &$cipherOptions)
+    {
+        switch ($cipherOptions['Cipher']) {
+            case 'gcm':
+                $cipherOptions['TagLength'] = 16;
+                $cipherTextStream = new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesGcmEncryptingStream($plaintext, $cek, $cipherOptions['Iv'], $cipherOptions['Aad'] = isset($cipherOptions['Aad']) ? $cipherOptions['Aad'] : null, $cipherOptions['TagLength'], $cipherOptions['KeySize']);
+                if (!empty($cipherOptions['Aad'])) {
+                    trigger_error("'Aad' has been supplied for content encryption" . " with " . $cipherTextStream->getAesName() . ". The" . " PHP SDK encryption client can decrypt an object" . " encrypted in this way, but other AWS SDKs may not be" . " able to.", E_USER_WARNING);
+                }
+                $appendStream = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\AppendStream([$cipherTextStream->createStream()]);
+                $cipherOptions['Tag'] = $cipherTextStream->getTag();
+                $appendStream->addStream(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($cipherOptions['Tag']));
+                return [$appendStream, $cipherTextStream->getAesName()];
+            default:
+                $cipherMethod = $this->buildCipherMethod($cipherOptions['Cipher'], $cipherOptions['Iv'], $cipherOptions['KeySize']);
+                $cipherTextStream = new \UglyRobot\Infinite_Uploads\Aws\Crypto\AesEncryptingStream($plaintext, $cek, $cipherMethod);
+                return [$cipherTextStream, $cipherTextStream->getAesName()];
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/EncryptionTraitV2.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\AppendStream;
+use UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream;
+use UglyRobot\Infinite_Uploads\Psr\Http\Message\StreamInterface;
+trait EncryptionTraitV2
+{
+    private static $allowedOptions = ['Cipher' => true, 'KeySize' => true, 'Aad' => true];
+    private static $encryptClasses = ['gcm' => \UglyRobot\Infinite_Uploads\Aws\Crypto\AesGcmEncryptingStream::class];
+    /**
+     * Dependency to generate a CipherMethod from a set of inputs for loading
+     * in to an AesEncryptingStream.
+     *
+     * @param string $cipherName Name of the cipher to generate for encrypting.
+     * @param string $iv Base Initialization Vector for the cipher.
+     * @param int $keySize Size of the encryption key, in bits, that will be
+     *                     used.
+     *
+     * @return Cipher\CipherMethod
+     *
+     * @internal
+     */
+    protected abstract function buildCipherMethod($cipherName, $iv, $keySize);
+    /**
+     * Builds an AesStreamInterface and populates encryption metadata into the
+     * supplied envelope.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param array $options    Options for use in encryption, including cipher
+     *                          options, and encryption context.
+     * @param MaterialsProviderV2 $provider A provider to supply and encrypt
+     *                                      materials used in encryption.
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be added to.
+     *
+     * @return StreamInterface
+     *
+     * @throws \InvalidArgumentException Thrown when a value in $options['@CipherOptions']
+     *                                   is not valid.
+     *s
+     * @internal
+     */
+    public function encrypt(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, array $options, \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderV2 $provider, \UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope)
+    {
+        $options = array_change_key_case($options);
+        $cipherOptions = array_intersect_key($options['@cipheroptions'], self::$allowedOptions);
+        if (empty($cipherOptions['Cipher'])) {
+            throw new \InvalidArgumentException('An encryption cipher must be' . ' specified in @CipherOptions["Cipher"].');
+        }
+        $cipherOptions['Cipher'] = strtolower($cipherOptions['Cipher']);
+        if (!self::isSupportedCipher($cipherOptions['Cipher'])) {
+            throw new \InvalidArgumentException('The cipher requested is not' . ' supported by the SDK.');
+        }
+        if (empty($cipherOptions['KeySize'])) {
+            $cipherOptions['KeySize'] = 256;
+        }
+        if (!is_int($cipherOptions['KeySize'])) {
+            throw new \InvalidArgumentException('The cipher "KeySize" must be' . ' an integer.');
+        }
+        if (!\UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderV2::isSupportedKeySize($cipherOptions['KeySize'])) {
+            throw new \InvalidArgumentException('The cipher "KeySize" requested' . ' is not supported by AES (128 or 256).');
+        }
+        $cipherOptions['Iv'] = $provider->generateIv($this->getCipherOpenSslName($cipherOptions['Cipher'], $cipherOptions['KeySize']));
+        $encryptClass = self::$encryptClasses[$cipherOptions['Cipher']];
+        $aesName = $encryptClass::getStaticAesName();
+        $materialsDescription = ['aws:x-amz-cek-alg' => $aesName];
+        $keys = $provider->generateCek($cipherOptions['KeySize'], $materialsDescription, $options);
+        // Some providers modify materials description based on options
+        if (isset($keys['UpdatedContext'])) {
+            $materialsDescription = $keys['UpdatedContext'];
+        }
+        $encryptingStream = $this->getEncryptingStream($plaintext, $keys['Plaintext'], $cipherOptions);
+        // Populate envelope data
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_KEY_V2_HEADER] = $keys['Ciphertext'];
+        unset($keys);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::IV_HEADER] = base64_encode($cipherOptions['Iv']);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::KEY_WRAP_ALGORITHM_HEADER] = $provider->getWrapAlgorithmName();
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CONTENT_CRYPTO_SCHEME_HEADER] = $aesName;
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::UNENCRYPTED_CONTENT_LENGTH_HEADER] = strlen($plaintext);
+        $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER] = json_encode($materialsDescription);
+        if (!empty($cipherOptions['Tag'])) {
+            $envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::CRYPTO_TAG_LENGTH_HEADER] = strlen($cipherOptions['Tag']) * 8;
+        }
+        return $encryptingStream;
+    }
+    /**
+     * Generates a stream that wraps the plaintext with the proper cipher and
+     * uses the content encryption key (CEK) to encrypt the data when read.
+     *
+     * @param Stream $plaintext Plain-text data to be encrypted using the
+     *                          materials, algorithm, and data provided.
+     * @param string $cek A content encryption key for use by the stream for
+     *                    encrypting the plaintext data.
+     * @param array $cipherOptions Options for use in determining the cipher to
+     *                             be used for encrypting data.
+     *
+     * @return [AesStreamInterface, string]
+     *
+     * @internal
+     */
+    protected function getEncryptingStream(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\Stream $plaintext, $cek, &$cipherOptions)
+    {
+        switch ($cipherOptions['Cipher']) {
+            // Only 'gcm' is supported for encryption currently
+            case 'gcm':
+                $cipherOptions['TagLength'] = 16;
+                $encryptClass = self::$encryptClasses['gcm'];
+                $cipherTextStream = new $encryptClass($plaintext, $cek, $cipherOptions['Iv'], $cipherOptions['Aad'] = isset($cipherOptions['Aad']) ? $cipherOptions['Aad'] : '', $cipherOptions['TagLength'], $cipherOptions['KeySize']);
+                if (!empty($cipherOptions['Aad'])) {
+                    trigger_error("'Aad' has been supplied for content encryption" . " with " . $cipherTextStream->getAesName() . ". The" . " PHP SDK encryption client can decrypt an object" . " encrypted in this way, but other AWS SDKs may not be" . " able to.", E_USER_WARNING);
+                }
+                $appendStream = new \UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\AppendStream([$cipherTextStream->createStream()]);
+                $cipherOptions['Tag'] = $cipherTextStream->getTag();
+                $appendStream->addStream(\UglyRobot\Infinite_Uploads\GuzzleHttp\Psr7\stream_for($cipherOptions['Tag']));
+                return $appendStream;
+        }
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/KmsMaterialsProvider.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Kms\KmsClient;
+/**
+ * Uses KMS to supply materials for encrypting and decrypting data.
+ *
+ * Legacy implementation that supports legacy S3EncryptionClient and
+ * S3EncryptionMultipartUploader, which use an older encryption workflow. Use
+ * KmsMaterialsProviderV2 with S3EncryptionClientV2 or
+ * S3EncryptionMultipartUploaderV2 if possible.
+ *
+ * @deprecated
+ */
+class KmsMaterialsProvider extends \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProvider implements \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterface
+{
+    const WRAP_ALGORITHM_NAME = 'kms';
+    private $kmsClient;
+    private $kmsKeyId;
+    /**
+     * @param KmsClient $kmsClient A KMS Client for use encrypting and
+     *                             decrypting keys.
+     * @param string $kmsKeyId The private KMS key id to be used for encrypting
+     *                         and decrypting keys.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Kms\KmsClient $kmsClient, $kmsKeyId = null)
+    {
+        $this->kmsClient = $kmsClient;
+        $this->kmsKeyId = $kmsKeyId;
+    }
+    public function fromDecryptionEnvelope(\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope)
+    {
+        if (empty($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER])) {
+            throw new \RuntimeException('Not able to detect the materials description.');
+        }
+        $materialsDescription = json_decode($envelope[\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope::MATERIALS_DESCRIPTION_HEADER], true);
+        if (empty($materialsDescription['kms_cmk_id']) && empty($materialsDescription['aws:x-amz-cek-alg'])) {
+            throw new \RuntimeException('Not able to detect kms_cmk_id (legacy' . ' implementation) or aws:x-amz-cek-alg (current implementation)' . ' from kms materials description.');
+        }
+        return new self($this->kmsClient, isset($materialsDescription['kms_cmk_id']) ? $materialsDescription['kms_cmk_id'] : null);
+    }
+    /**
+     * The KMS key id for use in matching this Provider to its keys,
+     * consistently with other SDKs as 'kms_cmk_id'.
+     *
+     * @return array
+     */
+    public function getMaterialsDescription()
+    {
+        return ['kms_cmk_id' => $this->kmsKeyId];
+    }
+    public function getWrapAlgorithmName()
+    {
+        return self::WRAP_ALGORITHM_NAME;
+    }
+    /**
+     * Takes a content encryption key (CEK) and description to return an encrypted
+     * key by using KMS' Encrypt API.
+     *
+     * @param string $unencryptedCek Key for use in encrypting other data
+     *                               that itself needs to be encrypted by the
+     *                               Provider.
+     * @param string $materialDescription Material Description for use in
+     *                                    encrypting the $cek.
+     *
+     * @return string
+     */
+    public function encryptCek($unencryptedCek, $materialDescription)
+    {
+        $encryptedDataKey = $this->kmsClient->encrypt(['Plaintext' => $unencryptedCek, 'KeyId' => $this->kmsKeyId, 'EncryptionContext' => $materialDescription]);
+        return base64_encode($encryptedDataKey['CiphertextBlob']);
+    }
+    /**
+     * Takes an encrypted content encryption key (CEK) and material description
+     * for use decrypting the key by using KMS' Decrypt API.
+     *
+     * @param string $encryptedCek Encrypted key to be decrypted by the Provider
+     *                             for use decrypting other data.
+     * @param string $materialDescription Material Description for use in
+     *                                    encrypting the $cek.
+     *
+     * @return string
+     */
+    public function decryptCek($encryptedCek, $materialDescription)
+    {
+        $result = $this->kmsClient->decrypt(['CiphertextBlob' => $encryptedCek, 'EncryptionContext' => $materialDescription]);
+        return $result['Plaintext'];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/KmsMaterialsProviderV2.php

@@ -0,0 +1,69 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException;
+use UglyRobot\Infinite_Uploads\Aws\Kms\KmsClient;
+/**
+ * Uses KMS to supply materials for encrypting and decrypting data. This
+ * V2 implementation should be used with the V2 encryption clients (i.e.
+ * S3EncryptionClientV2).
+ */
+class KmsMaterialsProviderV2 extends \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderV2 implements \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterfaceV2
+{
+    const WRAP_ALGORITHM_NAME = 'kms+context';
+    private $kmsClient;
+    private $kmsKeyId;
+    /**
+     * @param KmsClient $kmsClient A KMS Client for use encrypting and
+     *                             decrypting keys.
+     * @param string $kmsKeyId The private KMS key id to be used for encrypting
+     *                         and decrypting keys.
+     */
+    public function __construct(\UglyRobot\Infinite_Uploads\Aws\Kms\KmsClient $kmsClient, $kmsKeyId = null)
+    {
+        $this->kmsClient = $kmsClient;
+        $this->kmsKeyId = $kmsKeyId;
+    }
+    /**
+     * @inheritDoc
+     */
+    public function getWrapAlgorithmName()
+    {
+        return self::WRAP_ALGORITHM_NAME;
+    }
+    /**
+     * @inheritDoc
+     */
+    public function decryptCek($encryptedCek, $materialDescription, $options)
+    {
+        $params = ['CiphertextBlob' => $encryptedCek, 'EncryptionContext' => $materialDescription];
+        if (empty($options['@KmsAllowDecryptWithAnyCmk'])) {
+            if (empty($this->kmsKeyId)) {
+                throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException('KMS CMK ID was not specified and the' . ' operation is not opted-in to attempting to use any valid' . ' CMK it discovers. Please specify a CMK ID, or explicitly' . ' enable attempts to use any valid KMS CMK with the' . ' @KmsAllowDecryptWithAnyCmk option.');
+            }
+            $params['KeyId'] = $this->kmsKeyId;
+        }
+        $result = $this->kmsClient->decrypt($params);
+        return $result['Plaintext'];
+    }
+    /**
+     * @inheritDoc
+     */
+    public function generateCek($keySize, $context, $options)
+    {
+        if (empty($this->kmsKeyId)) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException('A KMS key id is required for encryption' . ' with KMS keywrap. Use a KmsMaterialsProviderV2 that has been' . ' instantiated with a KMS key id.');
+        }
+        $options = array_change_key_case($options);
+        if (!isset($options['@kmsencryptioncontext']) || !is_array($options['@kmsencryptioncontext'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("'@KmsEncryptionContext' is a" . " required argument when using KmsMaterialsProviderV2, and" . " must be an associative array (or empty array).");
+        }
+        if (isset($options['@kmsencryptioncontext']['aws:x-amz-cek-alg'])) {
+            throw new \UglyRobot\Infinite_Uploads\Aws\Exception\CryptoException("Conflict in reserved @KmsEncryptionContext" . " key aws:x-amz-cek-alg. This value is reserved for the S3" . " Encryption Client and cannot be set by the user.");
+        }
+        $context = array_merge($options['@kmsencryptioncontext'], $context);
+        $result = $this->kmsClient->generateDataKey(['KeyId' => $this->kmsKeyId, 'KeySpec' => "AES_{$keySize}", 'EncryptionContext' => $context]);
+        return ['Plaintext' => $result['Plaintext'], 'Ciphertext' => base64_encode($result['CiphertextBlob']), 'UpdatedContext' => $context];
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/MaterialsProvider.php

@@ -0,0 +1,92 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+abstract class MaterialsProvider implements \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterface
+{
+    private static $supportedKeySizes = [128 => true, 192 => true, 256 => true];
+    /**
+     * Returns if the requested size is supported by AES.
+     *
+     * @param int $keySize Size of the requested key in bits.
+     *
+     * @return bool
+     */
+    public static function isSupportedKeySize($keySize)
+    {
+        return isset(self::$supportedKeySizes[$keySize]);
+    }
+    /**
+     * Performs further initialization of the MaterialsProvider based on the
+     * data inside the MetadataEnvelope.
+     *
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     *
+     * @return MaterialsProvider
+     *
+     * @throws \RuntimeException Thrown when there is an empty or improperly
+     *                           formed materials description in the envelope.
+     *
+     * @internal
+     */
+    public abstract function fromDecryptionEnvelope(\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope);
+    /**
+     * Returns the material description for this Provider so it can be verified
+     * by encryption mechanisms.
+     *
+     * @return string
+     */
+    public abstract function getMaterialsDescription();
+    /**
+     * Returns the wrap algorithm name for this Provider.
+     *
+     * @return string
+     */
+    public abstract function getWrapAlgorithmName();
+    /**
+     * Takes a content encryption key (CEK) and description to return an
+     * encrypted key according to the Provider's specifications.
+     *
+     * @param string $unencryptedCek Key for use in encrypting other data
+     *                               that itself needs to be encrypted by the
+     *                               Provider.
+     * @param string $materialDescription Material Description for use in
+     *                                    encrypting the $cek.
+     *
+     * @return string
+     */
+    public abstract function encryptCek($unencryptedCek, $materialDescription);
+    /**
+     * Takes an encrypted content encryption key (CEK) and material description
+     * for use decrypting the key according to the Provider's specifications.
+     *
+     * @param string $encryptedCek Encrypted key to be decrypted by the Provider
+     *                             for use decrypting other data.
+     * @param string $materialDescription Material Description for use in
+     *                                    encrypting the $cek.
+     *
+     * @return string
+     */
+    public abstract function decryptCek($encryptedCek, $materialDescription);
+    /**
+     * @param string $keySize Length of a cipher key in bits for generating a
+     *                        random content encryption key (CEK).
+     *
+     * @return string
+     */
+    public function generateCek($keySize)
+    {
+        return openssl_random_pseudo_bytes($keySize / 8);
+    }
+    /**
+     * @param string $openSslName Cipher OpenSSL name to use for generating
+     *                            an initialization vector.
+     *
+     * @return string
+     */
+    public function generateIv($openSslName)
+    {
+        return openssl_random_pseudo_bytes(openssl_cipher_iv_length($openSslName));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/MaterialsProviderInterface.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+interface MaterialsProviderInterface
+{
+    /**
+     * Returns if the requested size is supported by AES.
+     *
+     * @param int $keySize Size of the requested key in bits.
+     *
+     * @return bool
+     */
+    public static function isSupportedKeySize($keySize);
+    /**
+     * Performs further initialization of the MaterialsProvider based on the
+     * data inside the MetadataEnvelope.
+     *
+     * @param MetadataEnvelope $envelope A storage envelope for encryption
+     *                                   metadata to be read from.
+     *
+     * @internal
+     */
+    public function fromDecryptionEnvelope(\UglyRobot\Infinite_Uploads\Aws\Crypto\MetadataEnvelope $envelope);
+    /**
+     * Returns the wrap algorithm name for this Provider.
+     *
+     * @return string
+     */
+    public function getWrapAlgorithmName();
+    /**
+     * Takes an encrypted content encryption key (CEK) and material description
+     * for use decrypting the key according to the Provider's specifications.
+     *
+     * @param string $encryptedCek Encrypted key to be decrypted by the Provider
+     *                             for use decrypting other data.
+     * @param string $materialDescription Material Description for use in
+     *                                    encrypting the $cek.
+     *
+     * @return string
+     */
+    public function decryptCek($encryptedCek, $materialDescription);
+    /**
+     * @param string $keySize Length of a cipher key in bits for generating a
+     *                        random content encryption key (CEK).
+     *
+     * @return string
+     */
+    public function generateCek($keySize);
+    /**
+     * @param string $openSslName Cipher OpenSSL name to use for generating
+     *                            an initialization vector.
+     *
+     * @return string
+     */
+    public function generateIv($openSslName);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/MaterialsProviderInterfaceV2.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+interface MaterialsProviderInterfaceV2
+{
+    /**
+     * Returns if the requested size is supported by AES.
+     *
+     * @param int $keySize Size of the requested key in bits.
+     *
+     * @return bool
+     */
+    public static function isSupportedKeySize($keySize);
+    /**
+     * Returns the wrap algorithm name for this Provider.
+     *
+     * @return string
+     */
+    public function getWrapAlgorithmName();
+    /**
+     * Takes an encrypted content encryption key (CEK) and material description
+     * for use decrypting the key according to the Provider's specifications.
+     *
+     * @param string $encryptedCek Encrypted key to be decrypted by the Provider
+     *                             for use decrypting other data.
+     * @param string $materialDescription Material Description for use in
+     *                                    decrypting the CEK.
+     * @param array $options Options for use in decrypting the CEK.
+     *
+     * @return string
+     */
+    public function decryptCek($encryptedCek, $materialDescription, $options);
+    /**
+     * @param string $keySize Length of a cipher key in bits for generating a
+     *                        random content encryption key (CEK).
+     * @param array $context Context map needed for key encryption
+     * @param array $options Additional options to be used in CEK generation
+     *
+     * @return array
+     */
+    public function generateCek($keySize, $context, $options);
+    /**
+     * @param string $openSslName Cipher OpenSSL name to use for generating
+     *                            an initialization vector.
+     *
+     * @return string
+     */
+    public function generateIv($openSslName);
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/MaterialsProviderV2.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+abstract class MaterialsProviderV2 implements \UglyRobot\Infinite_Uploads\Aws\Crypto\MaterialsProviderInterfaceV2
+{
+    private static $supportedKeySizes = [128 => true, 256 => true];
+    /**
+     * Returns if the requested size is supported by AES.
+     *
+     * @param int $keySize Size of the requested key in bits.
+     *
+     * @return bool
+     */
+    public static function isSupportedKeySize($keySize)
+    {
+        return isset(self::$supportedKeySizes[$keySize]);
+    }
+    /**
+     * Returns the wrap algorithm name for this Provider.
+     *
+     * @return string
+     */
+    public abstract function getWrapAlgorithmName();
+    /**
+     * Takes an encrypted content encryption key (CEK) and material description
+     * for use decrypting the key according to the Provider's specifications.
+     *
+     * @param string $encryptedCek Encrypted key to be decrypted by the Provider
+     *                             for use decrypting other data.
+     * @param string $materialDescription Material Description for use in
+     *                                    decrypting the CEK.
+     * @param string $options Options for use in decrypting the CEK.
+     *
+     * @return string
+     */
+    public abstract function decryptCek($encryptedCek, $materialDescription, $options);
+    /**
+     * @param string $keySize Length of a cipher key in bits for generating a
+     *                        random content encryption key (CEK).
+     * @param array $context Context map needed for key encryption
+     * @param array $options Additional options to be used in CEK generation
+     *
+     * @return array
+     */
+    public abstract function generateCek($keySize, $context, $options);
+    /**
+     * @param string $openSslName Cipher OpenSSL name to use for generating
+     *                            an initialization vector.
+     *
+     * @return string
+     */
+    public function generateIv($openSslName)
+    {
+        return openssl_random_pseudo_bytes(openssl_cipher_iv_length($openSslName));
+    }
+}

wp-content/plugins/infinite-uploads/vendor/Aws3/Aws/Crypto/MetadataEnvelope.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace UglyRobot\Infinite_Uploads\Aws\Crypto;
+
+use UglyRobot\Infinite_Uploads\Aws\HasDataTrait;
+use ArrayAccess;
+use IteratorAggregate;
+use InvalidArgumentException;
+use JsonSerializable;
+/**
+ * Stores encryption metadata for reading and writing.
+ *
+ * @internal
+ */
+class MetadataEnvelope implements \ArrayAccess, \IteratorAggregate, \JsonSerializable
+{
+    use HasDataTrait;
+    const CONTENT_KEY_V2_HEADER = 'x-amz-key-v2';
+    const IV_HEADER = 'x-amz-iv';
+    const MATERIALS_DESCRIPTION_HEADER = 'x-amz-matdesc';
+    const KEY_WRAP_ALGORITHM_HEADER = 'x-amz-wrap-alg';
+    const CONTENT_CRYPTO_SCHEME_HEADER = 'x-amz-cek-alg';
+    const CRYPTO_TAG_LENGTH_HEADER = 'x-amz-tag-len';
+    const UNENCRYPTED_CONTENT_LENGTH_HEADER = 'x-amz-unencrypted-content-length';
+    private static $constants = [];
+    public static function getConstantValues()
+    {
+        if (empty(self::$constants)) {
+            $reflection = new \ReflectionClass(static::class);
+            foreach (array_values($reflection->getConstants()) as $constant) {
+                self::$constants[$constant] = true;
+            }
+        }
+        return array_keys(self::$constants);
+    }
+    public function offsetSet($name, $value)
+    {
+        $constants = self::getConstantValues();
+        if (is_null($name) || !in_array($name, $constants)) {
+            throw new \InvalidArgumentException('MetadataEnvelope fields must' . ' must match a predefined offset; use the header constants.');
+        }
+        $this->data[$name] = $value;
+    }
+    public function jsonSerialize()
+    {
+        return $this->data;
+    }
+}