';
+
foreach ($templates as $templateName => $template) {
if ($this->designedForMyMonitoredObjectType($template)
&& $template->getCheckCommand() === $this->checkCommand) {
$charts = $template->getCharts(static::getMetricsDataSource(), $filter);
if (! empty($charts)) {
- $result[] = '
';
+ $result[] = $div;
if (! $this->compact) {
$result[] = '
';
@@ -287,4 +298,28 @@ abstract class Graphs extends AbstractWidget
return $this;
}
+
+ /**
+ * Get additional CSS classes for the
s around the images
+ *
+ * @return string[]
+ */
+ public function getClasses()
+ {
+ return $this->classes;
+ }
+
+ /**
+ * Set additional CSS classes for the s around the images
+ *
+ * @param string[] $classes
+ *
+ * @return $this
+ */
+ public function setClasses($classes)
+ {
+ $this->classes = $classes;
+
+ return $this;
+ }
}
diff --git a/library/vendor/Psr/Http/Message/MessageInterface.php b/library/vendor/Psr/Http/Message/MessageInterface.php
new file mode 100644
index 0000000..8f67a05
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/MessageInterface.php
@@ -0,0 +1,187 @@
+getHeaders() as $name => $values) {
+ * echo $name . ": " . implode(", ", $values);
+ * }
+ *
+ * // Emit headers iteratively:
+ * foreach ($message->getHeaders() as $name => $values) {
+ * foreach ($values as $value) {
+ * header(sprintf('%s: %s', $name, $value), false);
+ * }
+ * }
+ *
+ * While header names are not case-sensitive, getHeaders() will preserve the
+ * exact case in which headers were originally specified.
+ *
+ * @return array Returns an associative array of the message's headers. Each
+ * key MUST be a header name, and each value MUST be an array of strings
+ * for that header.
+ */
+ public function getHeaders();
+
+ /**
+ * Checks if a header exists by the given case-insensitive name.
+ *
+ * @param string $name Case-insensitive header field name.
+ * @return bool Returns true if any header names match the given header
+ * name using a case-insensitive string comparison. Returns false if
+ * no matching header name is found in the message.
+ */
+ public function hasHeader($name);
+
+ /**
+ * Retrieves a message header value by the given case-insensitive name.
+ *
+ * This method returns an array of all the header values of the given
+ * case-insensitive header name.
+ *
+ * If the header does not appear in the message, this method MUST return an
+ * empty array.
+ *
+ * @param string $name Case-insensitive header field name.
+ * @return string[] An array of string values as provided for the given
+ * header. If the header does not appear in the message, this method MUST
+ * return an empty array.
+ */
+ public function getHeader($name);
+
+ /**
+ * Retrieves a comma-separated string of the values for a single header.
+ *
+ * This method returns all of the header values of the given
+ * case-insensitive header name as a string concatenated together using
+ * a comma.
+ *
+ * NOTE: Not all header values may be appropriately represented using
+ * comma concatenation. For such headers, use getHeader() instead
+ * and supply your own delimiter when concatenating.
+ *
+ * If the header does not appear in the message, this method MUST return
+ * an empty string.
+ *
+ * @param string $name Case-insensitive header field name.
+ * @return string A string of values as provided for the given header
+ * concatenated together using a comma. If the header does not appear in
+ * the message, this method MUST return an empty string.
+ */
+ public function getHeaderLine($name);
+
+ /**
+ * Return an instance with the provided value replacing the specified header.
+ *
+ * While header names are case-insensitive, the casing of the header will
+ * be preserved by this function, and returned from getHeaders().
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * new and/or updated header and value.
+ *
+ * @param string $name Case-insensitive header field name.
+ * @param string|string[] $value Header value(s).
+ * @return self
+ * @throws \InvalidArgumentException for invalid header names or values.
+ */
+ public function withHeader($name, $value);
+
+ /**
+ * Return an instance with the specified header appended with the given value.
+ *
+ * Existing values for the specified header will be maintained. The new
+ * value(s) will be appended to the existing list. If the header did not
+ * exist previously, it will be added.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * new header and/or value.
+ *
+ * @param string $name Case-insensitive header field name to add.
+ * @param string|string[] $value Header value(s).
+ * @return self
+ * @throws \InvalidArgumentException for invalid header names or values.
+ */
+ public function withAddedHeader($name, $value);
+
+ /**
+ * Return an instance without the specified header.
+ *
+ * Header resolution MUST be done without case-sensitivity.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that removes
+ * the named header.
+ *
+ * @param string $name Case-insensitive header field name to remove.
+ * @return self
+ */
+ public function withoutHeader($name);
+
+ /**
+ * Gets the body of the message.
+ *
+ * @return StreamInterface Returns the body as a stream.
+ */
+ public function getBody();
+
+ /**
+ * Return an instance with the specified message body.
+ *
+ * The body MUST be a StreamInterface object.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return a new instance that has the
+ * new body stream.
+ *
+ * @param StreamInterface $body Body.
+ * @return self
+ * @throws \InvalidArgumentException When the body is not valid.
+ */
+ public function withBody(StreamInterface $body);
+}
diff --git a/library/vendor/Psr/Http/Message/RequestInterface.php b/library/vendor/Psr/Http/Message/RequestInterface.php
new file mode 100644
index 0000000..75c802e
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/RequestInterface.php
@@ -0,0 +1,129 @@
+getQuery()`
+ * or from the `QUERY_STRING` server param.
+ *
+ * @return array
+ */
+ public function getQueryParams();
+
+ /**
+ * Return an instance with the specified query string arguments.
+ *
+ * These values SHOULD remain immutable over the course of the incoming
+ * request. They MAY be injected during instantiation, such as from PHP's
+ * $_GET superglobal, or MAY be derived from some other value such as the
+ * URI. In cases where the arguments are parsed from the URI, the data
+ * MUST be compatible with what PHP's parse_str() would return for
+ * purposes of how duplicate query parameters are handled, and how nested
+ * sets are handled.
+ *
+ * Setting query string arguments MUST NOT change the URI stored by the
+ * request, nor the values in the server params.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * updated query string arguments.
+ *
+ * @param array $query Array of query string arguments, typically from
+ * $_GET.
+ * @return self
+ */
+ public function withQueryParams(array $query);
+
+ /**
+ * Retrieve normalized file upload data.
+ *
+ * This method returns upload metadata in a normalized tree, with each leaf
+ * an instance of Psr\Http\Message\UploadedFileInterface.
+ *
+ * These values MAY be prepared from $_FILES or the message body during
+ * instantiation, or MAY be injected via withUploadedFiles().
+ *
+ * @return array An array tree of UploadedFileInterface instances; an empty
+ * array MUST be returned if no data is present.
+ */
+ public function getUploadedFiles();
+
+ /**
+ * Create a new instance with the specified uploaded files.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * updated body parameters.
+ *
+ * @param array An array tree of UploadedFileInterface instances.
+ * @return self
+ * @throws \InvalidArgumentException if an invalid structure is provided.
+ */
+ public function withUploadedFiles(array $uploadedFiles);
+
+ /**
+ * Retrieve any parameters provided in the request body.
+ *
+ * If the request Content-Type is either application/x-www-form-urlencoded
+ * or multipart/form-data, and the request method is POST, this method MUST
+ * return the contents of $_POST.
+ *
+ * Otherwise, this method may return any results of deserializing
+ * the request body content; as parsing returns structured content, the
+ * potential types MUST be arrays or objects only. A null value indicates
+ * the absence of body content.
+ *
+ * @return null|array|object The deserialized body parameters, if any.
+ * These will typically be an array or object.
+ */
+ public function getParsedBody();
+
+ /**
+ * Return an instance with the specified body parameters.
+ *
+ * These MAY be injected during instantiation.
+ *
+ * If the request Content-Type is either application/x-www-form-urlencoded
+ * or multipart/form-data, and the request method is POST, use this method
+ * ONLY to inject the contents of $_POST.
+ *
+ * The data IS NOT REQUIRED to come from $_POST, but MUST be the results of
+ * deserializing the request body content. Deserialization/parsing returns
+ * structured data, and, as such, this method ONLY accepts arrays or objects,
+ * or a null value if nothing was available to parse.
+ *
+ * As an example, if content negotiation determines that the request data
+ * is a JSON payload, this method could be used to create a request
+ * instance with the deserialized parameters.
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * updated body parameters.
+ *
+ * @param null|array|object $data The deserialized body data. This will
+ * typically be in an array or object.
+ * @return self
+ * @throws \InvalidArgumentException if an unsupported argument type is
+ * provided.
+ */
+ public function withParsedBody($data);
+
+ /**
+ * Retrieve attributes derived from the request.
+ *
+ * The request "attributes" may be used to allow injection of any
+ * parameters derived from the request: e.g., the results of path
+ * match operations; the results of decrypting cookies; the results of
+ * deserializing non-form-encoded message bodies; etc. Attributes
+ * will be application and request specific, and CAN be mutable.
+ *
+ * @return array Attributes derived from the request.
+ */
+ public function getAttributes();
+
+ /**
+ * Retrieve a single derived request attribute.
+ *
+ * Retrieves a single derived request attribute as described in
+ * getAttributes(). If the attribute has not been previously set, returns
+ * the default value as provided.
+ *
+ * This method obviates the need for a hasAttribute() method, as it allows
+ * specifying a default value to return if the attribute is not found.
+ *
+ * @see getAttributes()
+ * @param string $name The attribute name.
+ * @param mixed $default Default value to return if the attribute does not exist.
+ * @return mixed
+ */
+ public function getAttribute($name, $default = null);
+
+ /**
+ * Return an instance with the specified derived request attribute.
+ *
+ * This method allows setting a single derived request attribute as
+ * described in getAttributes().
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that has the
+ * updated attribute.
+ *
+ * @see getAttributes()
+ * @param string $name The attribute name.
+ * @param mixed $value The value of the attribute.
+ * @return self
+ */
+ public function withAttribute($name, $value);
+
+ /**
+ * Return an instance that removes the specified derived request attribute.
+ *
+ * This method allows removing a single derived request attribute as
+ * described in getAttributes().
+ *
+ * This method MUST be implemented in such a way as to retain the
+ * immutability of the message, and MUST return an instance that removes
+ * the attribute.
+ *
+ * @see getAttributes()
+ * @param string $name The attribute name.
+ * @return self
+ */
+ public function withoutAttribute($name);
+}
diff --git a/library/vendor/Psr/Http/Message/StreamInterface.php b/library/vendor/Psr/Http/Message/StreamInterface.php
new file mode 100644
index 0000000..f68f391
--- /dev/null
+++ b/library/vendor/Psr/Http/Message/StreamInterface.php
@@ -0,0 +1,158 @@
+
+ * [user-info@]host[:port]
+ *
+ *
+ * If the port component is not set or is the standard port for the current
+ * scheme, it SHOULD NOT be included.
+ *
+ * @see https://tools.ietf.org/html/rfc3986#section-3.2
+ * @return string The URI authority, in "[user-info@]host[:port]" format.
+ */
+ public function getAuthority();
+
+ /**
+ * Retrieve the user information component of the URI.
+ *
+ * If no user information is present, this method MUST return an empty
+ * string.
+ *
+ * If a user is present in the URI, this will return that value;
+ * additionally, if the password is also present, it will be appended to the
+ * user value, with a colon (":") separating the values.
+ *
+ * The trailing "@" character is not part of the user information and MUST
+ * NOT be added.
+ *
+ * @return string The URI user information, in "username[:password]" format.
+ */
+ public function getUserInfo();
+
+ /**
+ * Retrieve the host component of the URI.
+ *
+ * If no host is present, this method MUST return an empty string.
+ *
+ * The value returned MUST be normalized to lowercase, per RFC 3986
+ * Section 3.2.2.
+ *
+ * @see http://tools.ietf.org/html/rfc3986#section-3.2.2
+ * @return string The URI host.
+ */
+ public function getHost();
+
+ /**
+ * Retrieve the port component of the URI.
+ *
+ * If a port is present, and it is non-standard for the current scheme,
+ * this method MUST return it as an integer. If the port is the standard port
+ * used with the current scheme, this method SHOULD return null.
+ *
+ * If no port is present, and no scheme is present, this method MUST return
+ * a null value.
+ *
+ * If no port is present, but a scheme is present, this method MAY return
+ * the standard port for that scheme, but SHOULD return null.
+ *
+ * @return null|int The URI port.
+ */
+ public function getPort();
+
+ /**
+ * Retrieve the path component of the URI.
+ *
+ * The path can either be empty or absolute (starting with a slash) or
+ * rootless (not starting with a slash). Implementations MUST support all
+ * three syntaxes.
+ *
+ * Normally, the empty path "" and absolute path "/" are considered equal as
+ * defined in RFC 7230 Section 2.7.3. But this method MUST NOT automatically
+ * do this normalization because in contexts with a trimmed base path, e.g.
+ * the front controller, this difference becomes significant. It's the task
+ * of the user to handle both "" and "/".
+ *
+ * The value returned MUST be percent-encoded, but MUST NOT double-encode
+ * any characters. To determine what characters to encode, please refer to
+ * RFC 3986, Sections 2 and 3.3.
+ *
+ * As an example, if the value should include a slash ("/") not intended as
+ * delimiter between path segments, that value MUST be passed in encoded
+ * form (e.g., "%2F") to the instance.
+ *
+ * @see https://tools.ietf.org/html/rfc3986#section-2
+ * @see https://tools.ietf.org/html/rfc3986#section-3.3
+ * @return string The URI path.
+ */
+ public function getPath();
+
+ /**
+ * Retrieve the query string of the URI.
+ *
+ * If no query string is present, this method MUST return an empty string.
+ *
+ * The leading "?" character is not part of the query and MUST NOT be
+ * added.
+ *
+ * The value returned MUST be percent-encoded, but MUST NOT double-encode
+ * any characters. To determine what characters to encode, please refer to
+ * RFC 3986, Sections 2 and 3.4.
+ *
+ * As an example, if a value in a key/value pair of the query string should
+ * include an ampersand ("&") not intended as a delimiter between values,
+ * that value MUST be passed in encoded form (e.g., "%26") to the instance.
+ *
+ * @see https://tools.ietf.org/html/rfc3986#section-2
+ * @see https://tools.ietf.org/html/rfc3986#section-3.4
+ * @return string The URI query string.
+ */
+ public function getQuery();
+
+ /**
+ * Retrieve the fragment component of the URI.
+ *
+ * If no fragment is present, this method MUST return an empty string.
+ *
+ * The leading "#" character is not part of the fragment and MUST NOT be
+ * added.
+ *
+ * The value returned MUST be percent-encoded, but MUST NOT double-encode
+ * any characters. To determine what characters to encode, please refer to
+ * RFC 3986, Sections 2 and 3.5.
+ *
+ * @see https://tools.ietf.org/html/rfc3986#section-2
+ * @see https://tools.ietf.org/html/rfc3986#section-3.5
+ * @return string The URI fragment.
+ */
+ public function getFragment();
+
+ /**
+ * Return an instance with the specified scheme.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified scheme.
+ *
+ * Implementations MUST support the schemes "http" and "https" case
+ * insensitively, and MAY accommodate other schemes if required.
+ *
+ * An empty scheme is equivalent to removing the scheme.
+ *
+ * @param string $scheme The scheme to use with the new instance.
+ * @return self A new instance with the specified scheme.
+ * @throws \InvalidArgumentException for invalid or unsupported schemes.
+ */
+ public function withScheme($scheme);
+
+ /**
+ * Return an instance with the specified user information.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified user information.
+ *
+ * Password is optional, but the user information MUST include the
+ * user; an empty string for the user is equivalent to removing user
+ * information.
+ *
+ * @param string $user The user name to use for authority.
+ * @param null|string $password The password associated with $user.
+ * @return self A new instance with the specified user information.
+ */
+ public function withUserInfo($user, $password = null);
+
+ /**
+ * Return an instance with the specified host.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified host.
+ *
+ * An empty host value is equivalent to removing the host.
+ *
+ * @param string $host The hostname to use with the new instance.
+ * @return self A new instance with the specified host.
+ * @throws \InvalidArgumentException for invalid hostnames.
+ */
+ public function withHost($host);
+
+ /**
+ * Return an instance with the specified port.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified port.
+ *
+ * Implementations MUST raise an exception for ports outside the
+ * established TCP and UDP port ranges.
+ *
+ * A null value provided for the port is equivalent to removing the port
+ * information.
+ *
+ * @param null|int $port The port to use with the new instance; a null value
+ * removes the port information.
+ * @return self A new instance with the specified port.
+ * @throws \InvalidArgumentException for invalid ports.
+ */
+ public function withPort($port);
+
+ /**
+ * Return an instance with the specified path.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified path.
+ *
+ * The path can either be empty or absolute (starting with a slash) or
+ * rootless (not starting with a slash). Implementations MUST support all
+ * three syntaxes.
+ *
+ * If the path is intended to be domain-relative rather than path relative then
+ * it must begin with a slash ("/"). Paths not starting with a slash ("/")
+ * are assumed to be relative to some base path known to the application or
+ * consumer.
+ *
+ * Users can provide both encoded and decoded path characters.
+ * Implementations ensure the correct encoding as outlined in getPath().
+ *
+ * @param string $path The path to use with the new instance.
+ * @return self A new instance with the specified path.
+ * @throws \InvalidArgumentException for invalid paths.
+ */
+ public function withPath($path);
+
+ /**
+ * Return an instance with the specified query string.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified query string.
+ *
+ * Users can provide both encoded and decoded query characters.
+ * Implementations ensure the correct encoding as outlined in getQuery().
+ *
+ * An empty query string value is equivalent to removing the query string.
+ *
+ * @param string $query The query string to use with the new instance.
+ * @return self A new instance with the specified query string.
+ * @throws \InvalidArgumentException for invalid query strings.
+ */
+ public function withQuery($query);
+
+ /**
+ * Return an instance with the specified URI fragment.
+ *
+ * This method MUST retain the state of the current instance, and return
+ * an instance that contains the specified URI fragment.
+ *
+ * Users can provide both encoded and decoded fragment characters.
+ * Implementations ensure the correct encoding as outlined in getFragment().
+ *
+ * An empty fragment value is equivalent to removing the fragment.
+ *
+ * @param string $fragment The fragment to use with the new instance.
+ * @return self A new instance with the specified fragment.
+ */
+ public function withFragment($fragment);
+
+ /**
+ * Return the string representation as a URI reference.
+ *
+ * Depending on which components of the URI are present, the resulting
+ * string is either a full URI or relative reference according to RFC 3986,
+ * Section 4.1. The method concatenates the various components of the URI,
+ * using the appropriate delimiters:
+ *
+ * - If a scheme is present, it MUST be suffixed by ":".
+ * - If an authority is present, it MUST be prefixed by "//".
+ * - The path can be concatenated without delimiters. But there are two
+ * cases where the path has to be adjusted to make the URI reference
+ * valid as PHP does not allow to throw an exception in __toString():
+ * - If the path is rootless and an authority is present, the path MUST
+ * be prefixed by "/".
+ * - If the path is starting with more than one "/" and no authority is
+ * present, the starting slashes MUST be reduced to one.
+ * - If a query is present, it MUST be prefixed by "?".
+ * - If a fragment is present, it MUST be prefixed by "#".
+ *
+ * @see http://tools.ietf.org/html/rfc3986#section-4.1
+ * @return string
+ */
+ public function __toString();
+}
diff --git a/library/vendor/Psr/LICENSE b/library/vendor/Psr/LICENSE
new file mode 100644
index 0000000..c2d8e45
--- /dev/null
+++ b/library/vendor/Psr/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2014 PHP Framework Interoperability Group
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/library/vendor/Psr/Loader.php b/library/vendor/Psr/Loader.php
new file mode 100644
index 0000000..45c78af
--- /dev/null
+++ b/library/vendor/Psr/Loader.php
@@ -0,0 +1,21 @@
+getUri()->withFragment(''));
+
+ // Bypass Expect: 100-continue timeouts
+ $headers = [];
+ foreach ($request->getHeaders() as $name => $values) {
+ if (strtolower($name) === 'expect') {
+ continue;
+ }
+ $headers[] = $name . ': ' . implode(', ', $values);
+ }
+
+ $options = [
+ CURLOPT_CUSTOMREQUEST => $request->getMethod(),
+ CURLOPT_FOLLOWLOCATION => 1,
+ CURLOPT_HTTPHEADER => $headers,
+ CURLOPT_RETURNTRANSFER => 1,
+ CURLOPT_USERAGENT => $this->getAgent()
+ ];
+
+ if ($request->getProtocolVersion()) {
+ $protocolVersion = null;
+ switch ($request->getProtocolVersion()) {
+ case '2.0':
+ if (version_compare(phpversion(), '7.0.7', '<')) {
+ throw new RuntimeException('You need at least PHP 7.0.7 to use HTTP 2.0');
+ }
+ $protocolVersion = CURL_HTTP_VERSION_2;
+ break;
+ case '1.1':
+ $protocolVersion = CURL_HTTP_VERSION_1_1;
+ break;
+ default:
+ $protocolVersion = CURL_HTTP_VERSION_1_0;
+ }
+
+ $options[CURLOPT_HTTP_VERSION] = $protocolVersion;
+ }
+
+ if ($request->getBody()) {
+ $options[CURLOPT_POSTFIELDS] = (string) $request->getBody();
+ }
+
+ $handle = new Handle();
+
+ $options[CURLOPT_HEADERFUNCTION] = function($ch, $header) use ($handle) {
+ $size = strlen($header);
+
+ if (! trim($header) || strpos($header, 'HTTP/') === 0) {
+ return $size;
+ }
+
+ list($key, $value) = explode(': ', $header, 2);
+ $handle->responseHeaders[$key] = rtrim($value, "\r\n");
+
+ return $size;
+ };
+
+ curl_setopt_array($ch, $options);
+
+ $handle->handle = $ch;
+
+ return $handle;
+ }
+
+ /**
+ * Execute a cURL handle and return the response as response object
+ *
+ * @param Handle $handle
+ *
+ * @return ResponseInterface
+ *
+ * @throws RuntimeException
+ */
+ public function executeHandle(Handle $handle)
+ {
+ $ch = $handle->handle;
+
+ $body = curl_exec($ch);
+
+ if ($body === false) {
+ throw new RuntimeException(curl_error($ch));
+ }
+
+ $response = new Response(curl_getinfo($ch, CURLINFO_HTTP_CODE), $handle->responseHeaders, $body);
+
+ curl_close($ch);
+
+ return $response;
+ }
+
+ public function send(RequestInterface $request)
+ {
+ $handle = $this->createHandle($request);
+
+ $response = $this->executeHandle($handle);
+
+ return $response;
+ }
+}
diff --git a/library/vendor/iplx/Http/ClientInterface.php b/library/vendor/iplx/Http/ClientInterface.php
new file mode 100644
index 0000000..d5b1b09
--- /dev/null
+++ b/library/vendor/iplx/Http/ClientInterface.php
@@ -0,0 +1,28 @@
+protocolVersion;
+ }
+
+ public function withProtocolVersion($version)
+ {
+ $message = clone $this;
+ $message->protocolVersion = $version;
+
+ return $message;
+ }
+
+ public function getHeaders()
+ {
+ return array_combine($this->headerNames, $this->headerValues);
+ }
+
+ public function hasHeader($header)
+ {
+ return isset($this->headerValues[strtolower($header)]);
+ }
+
+ public function getHeader($header)
+ {
+ $header = strtolower($header);
+
+ if (! isset($this->headerValues[$header])) {
+ return [];
+ }
+
+ return $this->headerValues[$header];
+ }
+
+ public function getHeaderLine($name)
+ {
+ $name = strtolower($name);
+
+ if (! isset($this->headerValues[$name])) {
+ return '';
+ }
+
+ return implode(', ', $this->headerValues[$name]);
+ }
+
+ public function withHeader($name, $value)
+ {
+ $name = rtrim($name);
+
+ $value = $this->normalizeHeaderValues($value);
+
+ $normalized = strtolower($name);
+
+ $message = clone $this;
+ $message->headerNames[$normalized] = $name;
+ $message->headerValues[$normalized] = $value;
+
+ return $message;
+ }
+
+ public function withAddedHeader($name, $value)
+ {
+ $name = rtrim($name);
+
+ $value = $this->normalizeHeaderValues($value);
+
+ $normalized = strtolower($name);
+
+ $message = clone $this;
+ if (isset($message->headerNames[$normalized])) {
+ $message->headerValues[$normalized] = array_merge($message->headerValues[$normalized], $value);
+ } else {
+ $message->headerNames[$normalized] = $name;
+ $message->headerValues[$normalized] = $value;
+ }
+
+ return $message;
+ }
+
+ public function withoutHeader($name)
+ {
+ $normalized = strtolower(rtrim($name));
+
+ $message = clone $this;
+ unset($message->headerNames[$normalized]);
+ unset($message->headerValues[$normalized]);
+
+ return $message;
+ }
+
+ public function getBody()
+ {
+ return $this->body;
+ }
+
+ public function withBody(StreamInterface $body)
+ {
+ $message = clone $this;
+ $message->body = $body;
+
+ return $message;
+ }
+
+ protected function setHeaders(array $headers)
+ {
+ // Prepare header field names and header field values according to
+ // https://tools.ietf.org/html/rfc7230#section-3.2.4
+ $names = array_map('rtrim', array_keys($headers));
+ $values = $this->normalizeHeaderValues($headers);
+
+ $normalized = array_map('strtolower', $names);
+
+ $this->headerNames = array_combine(
+ $normalized,
+ $names
+ );
+
+ $this->headerValues = array_combine(
+ $normalized,
+ $values
+ );
+ }
+
+ protected function normalizeHeaderValues(array $values)
+ {
+ // Prepare header field names and header field values according to
+ // https://tools.ietf.org/html/rfc7230#section-3.2.4
+ return array_map(function ($value) {
+ if (! is_array($value)) {
+ $value = [$value];
+ }
+
+ return array_map(function ($value) {
+ return trim($value, " \t");
+ }, $value);
+ }, $values);
+ }
+}
diff --git a/library/vendor/iplx/Http/Request.php b/library/vendor/iplx/Http/Request.php
new file mode 100644
index 0000000..917cbf8
--- /dev/null
+++ b/library/vendor/iplx/Http/Request.php
@@ -0,0 +1,79 @@
+method = $method;
+ $this->uri = new Uri($uri);
+ $this->setHeaders($headers);
+ $this->body = Stream::create($body);
+ $this->protocolVersion = $protocolVersion;
+ }
+
+ public function getRequestTarget()
+ {
+ // TODO: Implement getRequestTarget() method.
+ }
+
+ public function withRequestTarget($requestTarget)
+ {
+ // TODO: Implement withRequestTarget() method.
+ }
+
+ public function getMethod()
+ {
+ return $this->method;
+ }
+
+ public function withMethod($method)
+ {
+ $request = clone $this;
+ $request->method = $method;
+
+ return $this;
+ }
+
+ public function getUri()
+ {
+ return $this->uri;
+ }
+
+ public function withUri(UriInterface $uri, $preserveHost = false)
+ {
+ // TODO: Implement withUri() method.
+ }
+}
diff --git a/library/vendor/iplx/Http/Response.php b/library/vendor/iplx/Http/Response.php
new file mode 100644
index 0000000..25448b1
--- /dev/null
+++ b/library/vendor/iplx/Http/Response.php
@@ -0,0 +1,64 @@
+statusCode = $statusCode;
+ $this->setHeaders($headers);
+ $this->body = Stream::create($body);
+ $this->protocolVersion = $protocolVersion;
+ $this->reasonPhrase = $reasonPhrase;
+ }
+
+ public function getStatusCode()
+ {
+ return $this->statusCode;
+ }
+
+ public function withStatus($code, $reasonPhrase = '')
+ {
+ $response = clone $this;
+ $response->statusCode = $code;
+ $response->reasonPhrase = $reasonPhrase;
+
+ return $response;
+ }
+
+ public function getReasonPhrase()
+ {
+ return $this->reasonPhrase;
+ }
+}
diff --git a/library/vendor/iplx/Http/Stream.php b/library/vendor/iplx/Http/Stream.php
new file mode 100644
index 0000000..d43faf6
--- /dev/null
+++ b/library/vendor/iplx/Http/Stream.php
@@ -0,0 +1,250 @@
+stream = $stream;
+
+ $meta = stream_get_meta_data($this->stream);
+ $this->seekable = $meta['seekable'];
+ $this->readable = preg_match('/[r+]/', $meta['mode']) === 1;
+ $this->writable = preg_match('/[waxc+]/', $meta['mode']) === 1;
+ }
+
+ public function __destruct()
+ {
+ $this->close();
+ }
+
+ public function __toString()
+ {
+ try {
+ $this->seek(0);
+ $contents = stream_get_contents($this->stream);
+ } catch (Exception $e) {
+ $contents = '';
+ }
+
+ return $contents;
+ }
+
+ public function close()
+ {
+ if (isset($this->stream)) {
+ if (is_resource($this->stream)) {
+ fclose($this->stream);
+ }
+ $this->detach();
+ }
+ }
+
+ public function detach()
+ {
+ if (! isset($this->stream)) {
+ return null;
+ }
+
+ $stream = $this->stream;
+
+ $this->stream = null;
+ $this->size = null;
+ $this->seekable = false;
+ $this->readable = false;
+ $this->writable = false;
+
+ return $stream;
+ }
+
+ public function getSize()
+ {
+ if ($this->size !== null) {
+ return $this->size;
+ }
+
+ if (! isset($this->stream)) {
+ return null;
+ }
+
+ $stats = fstat($this->stream);
+ $this->size = $stats['size'];
+
+ return $this->size;
+ }
+
+ public function tell()
+ {
+ $this->assertAttached();
+
+ $position = ftell($this->stream);
+
+ if ($position === false) {
+ throw new RuntimeException();
+ }
+
+ return $position;
+ }
+
+ public function eof()
+ {
+ $this->assertAttached();
+
+ return feof($this->stream);
+ }
+
+ public function isSeekable()
+ {
+ return $this->seekable;
+ }
+
+ public function seek($offset, $whence = SEEK_SET)
+ {
+ $this->assertSeekable();
+
+ if (fseek($this->stream, $offset, $whence) === -1) {
+ throw new RuntimeException();
+ }
+ }
+
+ public function rewind()
+ {
+ $this->seek(0);
+ }
+
+ public function isWritable()
+ {
+ return $this->writable;
+ }
+
+ public function write($string)
+ {
+ $this->assertWritable();
+
+ $written = fwrite($this->stream, $string);
+
+ if ($written === false) {
+ throw new RuntimeException();
+ }
+
+ return $written;
+ }
+
+ public function isReadable()
+ {
+ return $this->readable;
+ }
+
+ public function read($length)
+ {
+ $this->assertReadable();
+
+ $data = fread($this->stream, $length);
+
+ if ($data === false) {
+ throw new RuntimeException();
+ }
+
+ return $data;
+ }
+
+ public function getContents()
+ {
+ $this->assertReadable();
+
+ $contents = stream_get_contents($this->stream);
+
+ if ($contents === false) {
+ throw new RuntimeException();
+ }
+
+ return $contents;
+ }
+
+ public function getMetadata($key = null)
+ {
+ // TODO: Implement getMetadata() method.
+ }
+
+ public function assertAttached()
+ {
+ if (! isset($this->stream)) {
+ throw new RuntimeException();
+ }
+ }
+
+ public function assertSeekable()
+ {
+ $this->assertAttached();
+
+ if (! $this->isSeekable()) {
+ throw new RuntimeException();
+ }
+ }
+
+ public function assertReadable()
+ {
+ $this->assertAttached();
+
+ if (! $this->isReadable()) {
+ throw new RuntimeException();
+ }
+ }
+
+ public function assertWritable()
+ {
+ $this->assertAttached();
+
+ if (! $this->isWritable()) {
+ throw new RuntimeException();
+ }
+ }
+
+ public static function open($filename = 'php://temp', $mode = 'r+')
+ {
+ $stream = fopen($filename, $mode);
+
+ return new static($stream);
+ }
+
+ public static function create($resource = null)
+ {
+ if (is_scalar($resource)) {
+ $stream = fopen('php://temp', 'r+');
+
+ if ($resource !== '') {
+ fwrite($stream, $resource);
+ fseek($stream, 0);
+ }
+
+ return new static($stream);
+ }
+
+ if (is_resource($resource)) {
+ return new static($resource);
+ }
+
+ return static::open();
+ }
+
+}
diff --git a/library/vendor/iplx/Http/Uri.php b/library/vendor/iplx/Http/Uri.php
new file mode 100644
index 0000000..45c1106
--- /dev/null
+++ b/library/vendor/iplx/Http/Uri.php
@@ -0,0 +1,239 @@
+ $value) {
+ $this->applyComponent($component, $value);
+ }
+ }
+
+ public function getScheme()
+ {
+ return $this->scheme;
+ }
+
+ public function getAuthority()
+ {
+ // Weak type check to also check null
+ if ($this->host == '') {
+ return '';
+ }
+
+ $authority = $this->host;
+
+ $userInfo = $this->getUserInfo();
+ $port = $this->getPort();
+
+ if ($userInfo) {
+ $authority = "$userInfo@$authority";
+ }
+
+ if ($port !== null) {
+ $authority .= ":$port";
+ }
+
+ return $authority;
+ }
+
+ public function getUserInfo()
+ {
+ $userInfo = $this->user;
+
+ if ($this->password !== null) {
+ $userInfo .= ":{$this->password}";
+ }
+
+ return $userInfo;
+ }
+
+ public function getHost()
+ {
+ return $this->host;
+ }
+
+ public function getPort()
+ {
+ return $this->port;
+ }
+
+ public function getPath()
+ {
+ return $this->path;
+ }
+
+ public function getQuery()
+ {
+ return $this->query;
+ }
+
+ public function getFragment()
+ {
+ return $this->fragment;
+ }
+
+ public function withScheme($scheme)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('scheme', $scheme);
+
+ return $uri;
+ }
+
+ public function withUserInfo($user, $password = null)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('user', $user);
+ $uri->applyComponent('password', $password);
+
+ return $uri;
+ }
+
+ public function withHost($host)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('host', $host);
+
+ return $uri;
+ }
+
+ public function withPort($port)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('port', $port);
+
+ return $uri;
+ }
+
+ public function withPath($path)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('path', $path);
+
+ return $uri;
+ }
+
+ public function withQuery($query)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('query', $query);
+
+ return $uri;
+ }
+
+ public function withFragment($fragment)
+ {
+ $uri = clone $this;
+ $uri->applyComponent('fragment', $fragment);
+
+ return $uri;
+ }
+
+ public function __toString()
+ {
+ $scheme = $this->getScheme();
+ $authority = $this->getAuthority();
+ $path = $this->getPath();
+ $query = $this->getQuery();
+ $fragment = $this->getFragment();
+
+ $uri = '';
+
+ // Weak type checks to also check null
+
+ if ($scheme != '') {
+ $uri = "$scheme:";
+ }
+
+ if ($authority != '') {
+ $uri .= "//$authority";
+ }
+
+ if ($path != '') {
+ if ($path[0] === '/') {
+ if ($authority == '') {
+ $path = ltrim($path, '/');
+ }
+ } else {
+ $path = "/$path";
+ }
+
+ $uri .= $path;
+ }
+
+ if ($query != '') {
+ $uri .= "?$query";
+ }
+
+ if ($fragment != '') {
+ $uri .= "#$fragment";
+ }
+
+ return $uri;
+ }
+
+ protected function applyComponent($name, $value)
+ {
+ switch ($name) {
+ case 'scheme':
+ $this->scheme = $value;
+ break;
+
+ case 'host':
+ $this->host = $value;
+ break;
+
+ case 'port':
+ $this->port = $value;
+ break;
+
+ case 'user':
+ $this->user = $value;
+ break;
+
+ case 'pass':
+ $this->password = $value;
+ break;
+
+ case 'path':
+ $this->path = $value;
+ break;
+
+ case 'query':
+ $this->query = $value;
+ break;
+
+ case 'fragment':
+ $this->fragment = $value;
+ break;
+ }
+ }
+}
diff --git a/library/vendor/iplx/LICENSE b/library/vendor/iplx/LICENSE
new file mode 100644
index 0000000..ecbc059
--- /dev/null
+++ b/library/vendor/iplx/LICENSE
@@ -0,0 +1,339 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+
+ Copyright (C)
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ , 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
\ No newline at end of file
diff --git a/library/vendor/iplx/Loader.php b/library/vendor/iplx/Loader.php
new file mode 100644
index 0000000..5a6c9c0
--- /dev/null
+++ b/library/vendor/iplx/Loader.php
@@ -0,0 +1,20 @@
+getLibDir() . '/vendor/Psr/Loader.php';
+require_once $this->getLibDir() . '/vendor/iplx/Loader.php';
+
$this->provideHook('monitoring/DetailviewExtension');