Index: vendor/google/apiclient/src/Http/Batch.php
===================================================================
--- vendor/google/apiclient/src/Http/Batch.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
+++ vendor/google/apiclient/src/Http/Batch.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
@@ -0,0 +1,261 @@
+<?php
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Http;
+
+use Google\Client;
+use Google\Service\Exception as GoogleServiceException;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Class to handle batched requests to the Google API service.
+ *
+ * Note that calls to `Google\Http\Batch::execute()` do not clear the queued
+ * requests. To start a new batch, be sure to create a new instance of this
+ * class.
+ */
+class Batch
+{
+    const BATCH_PATH = 'batch';
+
+    private static $CONNECTION_ESTABLISHED_HEADERS = [
+        "HTTP/1.0 200 Connection established\r\n\r\n",
+        "HTTP/1.1 200 Connection established\r\n\r\n",
+    ];
+
+    /** @var string Multipart Boundary. */
+    private $boundary;
+
+    /** @var array service requests to be executed. */
+    private $requests = [];
+
+    /** @var Client */
+    private $client;
+
+    private $rootUrl;
+
+    private $batchPath;
+
+    public function __construct(
+        Client $client,
+        $boundary = false,
+        $rootUrl = null,
+        $batchPath = null
+    ) {
+        $this->client = $client;
+        $this->boundary = $boundary ?: mt_rand();
+        $rootUrl = rtrim($rootUrl ?: $this->client->getConfig('base_path'), '/');
+        $this->rootUrl = str_replace(
+            'UNIVERSE_DOMAIN',
+            $this->client->getUniverseDomain(),
+            $rootUrl
+        );
+        $this->batchPath = $batchPath ?: self::BATCH_PATH;
+    }
+
+    public function add(RequestInterface $request, $key = false)
+    {
+        if (false == $key) {
+            $key = mt_rand();
+        }
+
+        $this->requests[$key] = $request;
+    }
+
+    public function execute()
+    {
+        $body = '';
+        $classes = [];
+        $batchHttpTemplate = <<<EOF
+--%s
+Content-Type: application/http
+Content-Transfer-Encoding: binary
+MIME-Version: 1.0
+Content-ID: %s
+
+%s
+%s%s
+
+
+EOF;
+
+        /** @var RequestInterface $request */
+        foreach ($this->requests as $key => $request) {
+            $firstLine = sprintf(
+                '%s %s HTTP/%s',
+                $request->getMethod(),
+                $request->getRequestTarget(),
+                $request->getProtocolVersion()
+            );
+
+            $content = (string) $request->getBody();
+
+            $headers = '';
+            foreach ($request->getHeaders() as $name => $values) {
+                $headers .= sprintf("%s:%s\r\n", $name, implode(', ', $values));
+            }
+
+            $body .= sprintf(
+                $batchHttpTemplate,
+                $this->boundary,
+                $key,
+                $firstLine,
+                $headers,
+                $content ? "\n" . $content : ''
+            );
+
+            $classes['response-' . $key] = $request->getHeaderLine('X-Php-Expected-Class');
+        }
+
+        $body .= "--{$this->boundary}--";
+        $body = trim($body);
+        $url = $this->rootUrl . '/' . $this->batchPath;
+        $headers = [
+            'Content-Type' => sprintf('multipart/mixed; boundary=%s', $this->boundary),
+            'Content-Length' => (string) strlen($body),
+        ];
+
+        $request = new Request(
+            'POST',
+            $url,
+            $headers,
+            $body
+        );
+
+        $response = $this->client->execute($request);
+
+        return $this->parseResponse($response, $classes);
+    }
+
+    public function parseResponse(ResponseInterface $response, $classes = [])
+    {
+        $contentType = $response->getHeaderLine('content-type');
+        $contentType = explode(';', $contentType);
+        $boundary = false;
+        foreach ($contentType as $part) {
+            $part = explode('=', $part, 2);
+            if (isset($part[0]) && 'boundary' == trim($part[0])) {
+                $boundary = $part[1];
+            }
+        }
+
+        $body = (string) $response->getBody();
+        if (!empty($body)) {
+            $body = str_replace("--$boundary--", "--$boundary", $body);
+            $parts = explode("--$boundary", $body);
+            $responses = [];
+            $requests = array_values($this->requests);
+
+            foreach ($parts as $i => $part) {
+                $part = trim($part);
+                if (!empty($part)) {
+                    list($rawHeaders, $part) = explode("\r\n\r\n", $part, 2);
+                    $headers = $this->parseRawHeaders($rawHeaders);
+
+                    $status = substr($part, 0, strpos($part, "\n"));
+                    $status = explode(" ", $status);
+                    $status = $status[1];
+
+                    list($partHeaders, $partBody) = $this->parseHttpResponse($part, 0);
+                    $response = new Response(
+                        (int) $status,
+                        $partHeaders,
+                        Psr7\Utils::streamFor($partBody)
+                    );
+
+                    // Need content id.
+                    $key = $headers['content-id'];
+
+                    try {
+                        $response = REST::decodeHttpResponse($response, $requests[$i-1]);
+                    } catch (GoogleServiceException $e) {
+                        // Store the exception as the response, so successful responses
+                        // can be processed.
+                        $response = $e;
+                    }
+
+                    $responses[$key] = $response;
+                }
+            }
+
+            return $responses;
+        }
+
+        return null;
+    }
+
+    private function parseRawHeaders($rawHeaders)
+    {
+        $headers = [];
+        $responseHeaderLines = explode("\r\n", $rawHeaders);
+        foreach ($responseHeaderLines as $headerLine) {
+            if ($headerLine && strpos($headerLine, ':') !== false) {
+                list($header, $value) = explode(': ', $headerLine, 2);
+                $header = strtolower($header);
+                if (isset($headers[$header])) {
+                    $headers[$header] = array_merge((array)$headers[$header], (array)$value);
+                } else {
+                    $headers[$header] = $value;
+                }
+            }
+        }
+        return $headers;
+    }
+
+    /**
+     * Used by the IO lib and also the batch processing.
+     *
+     * @param string $respData
+     * @param int $headerSize
+     * @return array
+     */
+    private function parseHttpResponse($respData, $headerSize)
+    {
+        // check proxy header
+        foreach (self::$CONNECTION_ESTABLISHED_HEADERS as $established_header) {
+            if (stripos($respData, $established_header) !== false) {
+                // existed, remove it
+                $respData = str_ireplace($established_header, '', $respData);
+                // Subtract the proxy header size unless the cURL bug prior to 7.30.0
+                // is present which prevented the proxy header size from being taken into
+                // account.
+                // @TODO look into this
+                // if (!$this->needsQuirk()) {
+                //   $headerSize -= strlen($established_header);
+                // }
+                break;
+            }
+        }
+
+        if ($headerSize) {
+            $responseBody = substr($respData, $headerSize);
+            $responseHeaders = substr($respData, 0, $headerSize);
+        } else {
+            $responseSegments = explode("\r\n\r\n", $respData, 2);
+            $responseHeaders = $responseSegments[0];
+            $responseBody = isset($responseSegments[1]) ? $responseSegments[1] : null;
+        }
+
+        $responseHeaders = $this->parseRawHeaders($responseHeaders);
+
+        return [$responseHeaders, $responseBody];
+    }
+}
Index: vendor/google/apiclient/src/Http/MediaFileUpload.php
===================================================================
--- vendor/google/apiclient/src/Http/MediaFileUpload.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
+++ vendor/google/apiclient/src/Http/MediaFileUpload.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
@@ -0,0 +1,353 @@
+<?php
+/**
+ * Copyright 2012 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Http;
+
+use Google\Client;
+use Google\Exception as GoogleException;
+use GuzzleHttp\Psr7;
+use GuzzleHttp\Psr7\Request;
+use GuzzleHttp\Psr7\Uri;
+use Psr\Http\Message\RequestInterface;
+
+/**
+ * Manage large file uploads, which may be media but can be any type
+ * of sizable data.
+ */
+class MediaFileUpload
+{
+    const UPLOAD_MEDIA_TYPE = 'media';
+    const UPLOAD_MULTIPART_TYPE = 'multipart';
+    const UPLOAD_RESUMABLE_TYPE = 'resumable';
+
+    /** @var string $mimeType */
+    private $mimeType;
+
+    /** @var string $data */
+    private $data;
+
+    /** @var bool $resumable */
+    private $resumable;
+
+    /** @var int $chunkSize */
+    private $chunkSize;
+
+    /** @var int $size */
+    private $size;
+
+    /** @var string $resumeUri */
+    private $resumeUri;
+
+    /** @var int $progress */
+    private $progress;
+
+    /** @var Client */
+    private $client;
+
+    /** @var RequestInterface */
+    private $request;
+
+    /** @var string */
+    private $boundary; // @phpstan-ignore-line
+
+    /**
+   * Result code from last HTTP call
+   * @var int
+   */
+    private $httpResultCode;
+
+    /**
+     * @param Client $client
+     * @param RequestInterface $request
+     * @param string $mimeType
+     * @param string $data The bytes you want to upload.
+     * @param bool $resumable
+     * @param int $chunkSize File will be uploaded in chunks of this many bytes.
+     * only used if resumable=True
+     */
+    public function __construct(
+        Client $client,
+        RequestInterface $request,
+        $mimeType,
+        $data,
+        $resumable = false,
+        $chunkSize = 0
+    ) {
+        $this->client = $client;
+        $this->request = $request;
+        $this->mimeType = $mimeType;
+        $this->data = $data;
+        $this->resumable = $resumable;
+        $this->chunkSize = $chunkSize;
+        $this->progress = 0;
+
+        $this->process();
+    }
+
+    /**
+     * Set the size of the file that is being uploaded.
+     * @param int $size - int file size in bytes
+     */
+    public function setFileSize($size)
+    {
+        $this->size = $size;
+    }
+
+    /**
+     * Return the progress on the upload
+     * @return int progress in bytes uploaded.
+     */
+    public function getProgress()
+    {
+        return $this->progress;
+    }
+
+    /**
+     * Send the next part of the file to upload.
+     * @param string|bool $chunk Optional. The next set of bytes to send. If false will
+     * use $data passed at construct time.
+     */
+    public function nextChunk($chunk = false)
+    {
+        $resumeUri = $this->getResumeUri();
+
+        if (false == $chunk) {
+            $chunk = substr($this->data, $this->progress, $this->chunkSize);
+        }
+
+        $lastBytePos = $this->progress + strlen($chunk) - 1;
+        $headers = [
+            'content-range' => "bytes $this->progress-$lastBytePos/$this->size",
+            'content-length' => (string) strlen($chunk),
+            'expect' => '',
+        ];
+
+        $request = new Request(
+            'PUT',
+            $resumeUri,
+            $headers,
+            Psr7\Utils::streamFor($chunk)
+        );
+
+        return $this->makePutRequest($request);
+    }
+
+    /**
+     * Return the HTTP result code from the last call made.
+     * @return int code
+     */
+    public function getHttpResultCode()
+    {
+        return $this->httpResultCode;
+    }
+
+    /**
+     * Sends a PUT-Request to google drive and parses the response,
+     * setting the appropiate variables from the response()
+     *
+     * @param RequestInterface $request the Request which will be send
+     *
+     * @return false|mixed false when the upload is unfinished or the decoded http response
+     *
+     */
+    private function makePutRequest(RequestInterface $request)
+    {
+        $response = $this->client->execute($request);
+        $this->httpResultCode = $response->getStatusCode();
+
+        if (308 == $this->httpResultCode) {
+            // Track the amount uploaded.
+            $range = $response->getHeaderLine('range');
+            if ($range) {
+                $range_array = explode('-', $range);
+                $this->progress = ((int) $range_array[1]) + 1;
+            }
+
+            // Allow for changing upload URLs.
+            $location = $response->getHeaderLine('location');
+            if ($location) {
+                $this->resumeUri = $location;
+            }
+
+            // No problems, but upload not complete.
+            return false;
+        }
+
+        return REST::decodeHttpResponse($response, $this->request);
+    }
+
+    /**
+     * Resume a previously unfinished upload
+     * @param string $resumeUri the resume-URI of the unfinished, resumable upload.
+     */
+    public function resume($resumeUri)
+    {
+        $this->resumeUri = $resumeUri;
+        $headers = [
+            'content-range' => "bytes */$this->size",
+            'content-length' => '0',
+        ];
+        $httpRequest = new Request(
+            'PUT',
+            $this->resumeUri,
+            $headers
+        );
+        return $this->makePutRequest($httpRequest);
+    }
+
+    /**
+     * @return RequestInterface
+     * @visible for testing
+     */
+    private function process()
+    {
+        $this->transformToUploadUrl();
+        $request = $this->request;
+
+        $postBody = '';
+        $contentType = false;
+
+        $meta = json_decode((string) $request->getBody(), true);
+
+        $uploadType = $this->getUploadType($meta);
+        $request = $request->withUri(
+            Uri::withQueryValue($request->getUri(), 'uploadType', $uploadType)
+        );
+
+        $mimeType = $this->mimeType ?: $request->getHeaderLine('content-type');
+
+        if (self::UPLOAD_RESUMABLE_TYPE == $uploadType) {
+            $contentType = $mimeType;
+            $postBody = is_string($meta) ? $meta : json_encode($meta);
+        } elseif (self::UPLOAD_MEDIA_TYPE == $uploadType) {
+            $contentType = $mimeType;
+            $postBody = $this->data;
+        } elseif (self::UPLOAD_MULTIPART_TYPE == $uploadType) {
+            // This is a multipart/related upload.
+            $boundary = $this->boundary ?: mt_rand();
+            $boundary = str_replace('"', '', $boundary);
+            $contentType = 'multipart/related; boundary=' . $boundary;
+            $related = "--$boundary\r\n";
+            $related .= "Content-Type: application/json; charset=UTF-8\r\n";
+            $related .= "\r\n" . json_encode($meta) . "\r\n";
+            $related .= "--$boundary\r\n";
+            $related .= "Content-Type: $mimeType\r\n";
+            $related .= "Content-Transfer-Encoding: base64\r\n";
+            $related .= "\r\n" . base64_encode($this->data) . "\r\n";
+            $related .= "--$boundary--";
+            $postBody = $related;
+        }
+
+        $request = $request->withBody(Psr7\Utils::streamFor($postBody));
+
+        if ($contentType) {
+            $request = $request->withHeader('content-type', $contentType);
+        }
+
+        return $this->request = $request;
+    }
+
+    /**
+     * Valid upload types:
+     * - resumable (UPLOAD_RESUMABLE_TYPE)
+     * - media (UPLOAD_MEDIA_TYPE)
+     * - multipart (UPLOAD_MULTIPART_TYPE)
+     * @param string|false $meta
+     * @return string
+     * @visible for testing
+     */
+    public function getUploadType($meta)
+    {
+        if ($this->resumable) {
+            return self::UPLOAD_RESUMABLE_TYPE;
+        }
+
+        if (false == $meta && $this->data) {
+            return self::UPLOAD_MEDIA_TYPE;
+        }
+
+        return self::UPLOAD_MULTIPART_TYPE;
+    }
+
+    public function getResumeUri()
+    {
+        if (null === $this->resumeUri) {
+            $this->resumeUri = $this->fetchResumeUri();
+        }
+
+        return $this->resumeUri;
+    }
+
+    private function fetchResumeUri()
+    {
+        $body = $this->request->getBody();
+        $headers = [
+            'content-type' => 'application/json; charset=UTF-8',
+            'content-length' => $body->getSize(),
+            'x-upload-content-type' => $this->mimeType,
+            'x-upload-content-length' => $this->size,
+            'expect' => '',
+        ];
+        foreach ($headers as $key => $value) {
+            $this->request = $this->request->withHeader($key, $value);
+        }
+
+        $response = $this->client->execute($this->request, false);
+        $location = $response->getHeaderLine('location');
+        $code = $response->getStatusCode();
+
+        if (200 == $code && true == $location) {
+            return $location;
+        }
+
+        $message = $code;
+        $body = json_decode((string) $this->request->getBody(), true);
+        if (isset($body['error']['errors'])) {
+            $message .= ': ';
+            foreach ($body['error']['errors'] as $error) {
+                $message .= "{$error['domain']}, {$error['message']};";
+            }
+            $message = rtrim($message, ';');
+        }
+
+        $error = "Failed to start the resumable upload (HTTP {$message})";
+        $this->client->getLogger()->error($error);
+
+        throw new GoogleException($error);
+    }
+
+    private function transformToUploadUrl()
+    {
+        $parts = parse_url((string) $this->request->getUri());
+        if (!isset($parts['path'])) {
+            $parts['path'] = '';
+        }
+        $parts['path'] = '/upload' . $parts['path'];
+        $uri = Uri::fromParts($parts);
+        $this->request = $this->request->withUri($uri);
+    }
+
+    public function setChunkSize($chunkSize)
+    {
+        $this->chunkSize = $chunkSize;
+    }
+
+    public function getRequest()
+    {
+        return $this->request;
+    }
+}
Index: vendor/google/apiclient/src/Http/REST.php
===================================================================
--- vendor/google/apiclient/src/Http/REST.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
+++ vendor/google/apiclient/src/Http/REST.php	(revision e3d4e0a8bc0f13135f27c0b055b5c00f64a28f01)
@@ -0,0 +1,198 @@
+<?php
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Google\Http;
+
+use Google\Auth\HttpHandler\HttpHandlerFactory;
+use Google\Service\Exception as GoogleServiceException;
+use Google\Task\Runner;
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\Exception\RequestException;
+use GuzzleHttp\Psr7\Response;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * This class implements the RESTful transport of apiServiceRequest()'s
+ */
+class REST
+{
+    /**
+     * Executes a Psr\Http\Message\RequestInterface and (if applicable) automatically retries
+     * when errors occur.
+     *
+     * @template T
+     * @param ClientInterface $client
+     * @param RequestInterface $request
+     * @param class-string<T>|false|null $expectedClass
+     * @param array $config
+     * @param array $retryMap
+     * @return mixed|T|null
+     * @throws \Google\Service\Exception on server side error (ie: not authenticated,
+     *  invalid or malformed post body, invalid url)
+     */
+    public static function execute(
+        ClientInterface $client,
+        RequestInterface $request,
+        $expectedClass = null,
+        $config = [],
+        $retryMap = null
+    ) {
+        $runner = new Runner(
+            $config,
+            sprintf('%s %s', $request->getMethod(), (string)$request->getUri()),
+            [self::class, 'doExecute'],
+            [$client, $request, $expectedClass]
+        );
+
+        if (null !== $retryMap) {
+            $runner->setRetryMap($retryMap);
+        }
+
+        return $runner->run();
+    }
+
+    /**
+     * Executes a Psr\Http\Message\RequestInterface
+     *
+     * @template T
+     * @param ClientInterface $client
+     * @param RequestInterface $request
+     * @param class-string<T>|false|null $expectedClass
+     * @return mixed|T|null
+     * @throws \Google\Service\Exception on server side error (ie: not authenticated,
+     *  invalid or malformed post body, invalid url)
+     */
+    public static function doExecute(ClientInterface $client, RequestInterface $request, $expectedClass = null)
+    {
+        try {
+            $httpHandler = HttpHandlerFactory::build($client);
+            $response = $httpHandler($request);
+        } catch (RequestException $e) {
+            // if Guzzle throws an exception, catch it and handle the response
+            if (!$e->hasResponse()) {
+                throw $e;
+            }
+
+            $response = $e->getResponse();
+            // specific checking for Guzzle 5: convert to PSR7 response
+            if (
+                interface_exists('\GuzzleHttp\Message\ResponseInterface')
+                && $response instanceof \GuzzleHttp\Message\ResponseInterface
+            ) {
+                $response = new Response(
+                    $response->getStatusCode(),
+                    $response->getHeaders() ?: [],
+                    $response->getBody(),
+                    $response->getProtocolVersion(),
+                    $response->getReasonPhrase()
+                );
+            }
+        }
+
+        return self::decodeHttpResponse($response, $request, $expectedClass);
+    }
+
+    /**
+     * Decode an HTTP Response.
+     * @static
+     *
+     * @template T
+     * @param RequestInterface $response The http response to be decoded.
+     * @param ResponseInterface $response
+     * @param class-string<T>|false|null $expectedClass
+     * @return mixed|T|null
+     * @throws \Google\Service\Exception
+     */
+    public static function decodeHttpResponse(
+        ResponseInterface $response,
+        ?RequestInterface $request = null,
+        $expectedClass = null
+    ) {
+        $code = $response->getStatusCode();
+
+        // retry strategy
+        if (intVal($code) >= 400) {
+            // if we errored out, it should be safe to grab the response body
+            $body = (string)$response->getBody();
+
+            // Check if we received errors, and add those to the Exception for convenience
+            throw new GoogleServiceException($body, $code, null, self::getResponseErrors($body));
+        }
+
+        // Ensure we only pull the entire body into memory if the request is not
+        // of media type
+        $body = self::decodeBody($response, $request);
+
+        if ($expectedClass = self::determineExpectedClass($expectedClass, $request)) {
+            $json = json_decode($body, true);
+
+            return new $expectedClass($json);
+        }
+
+        return $response;
+    }
+
+    private static function decodeBody(ResponseInterface $response, ?RequestInterface $request = null)
+    {
+        if (self::isAltMedia($request)) {
+            // don't decode the body, it's probably a really long string
+            return '';
+        }
+
+        return (string)$response->getBody();
+    }
+
+    private static function determineExpectedClass($expectedClass, ?RequestInterface $request = null)
+    {
+        // "false" is used to explicitly prevent an expected class from being returned
+        if (false === $expectedClass) {
+            return null;
+        }
+
+        // if we don't have a request, we just use what's passed in
+        if (null === $request) {
+            return $expectedClass;
+        }
+
+        // return what we have in the request header if one was not supplied
+        return $expectedClass ?: $request->getHeaderLine('X-Php-Expected-Class');
+    }
+
+    private static function getResponseErrors($body)
+    {
+        $json = json_decode($body, true);
+
+        if (isset($json['error']['errors'])) {
+            return $json['error']['errors'];
+        }
+
+        return null;
+    }
+
+    private static function isAltMedia(?RequestInterface $request = null)
+    {
+        if ($request && $qs = $request->getUri()->getQuery()) {
+            parse_str($qs, $query);
+            if (isset($query['alt']) && $query['alt'] == 'media') {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
