Initial Commit

dependencies/stripe/stripe-php/lib/Util/ApiVersion.php

@@ -0,0 +1,9 @@
+<?php
+
+// File generated from our OpenAPI spec
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+class ApiVersion
+{
+    const CURRENT = '2022-11-15';
+}

dependencies/stripe/stripe-php/lib/Util/CaseInsensitiveArray.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+/**
+ * CaseInsensitiveArray is an array-like class that ignores case for keys.
+ *
+ * It is used to store HTTP headers. Per RFC 2616, section 4.2:
+ * Each header field consists of a name followed by a colon (":") and the field value. Field names
+ * are case-insensitive.
+ *
+ * In the context of stripe-php, this is useful because the API will return headers with different
+ * case depending on whether HTTP/2 is used or not (with HTTP/2, headers are always in lowercase).
+ */
+class CaseInsensitiveArray implements \ArrayAccess, \Countable, \IteratorAggregate
+{
+    private $container = [];
+    public function __construct($initial_array = [])
+    {
+        $this->container = \array_change_key_case($initial_array, \CASE_LOWER);
+    }
+    /**
+     * @return int
+     */
+    #[\ReturnTypeWillChange]
+    public function count()
+    {
+        return \count($this->container);
+    }
+    /**
+     * @return \ArrayIterator
+     */
+    #[\ReturnTypeWillChange]
+    public function getIterator()
+    {
+        return new \ArrayIterator($this->container);
+    }
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetSet($offset, $value)
+    {
+        $offset = self::maybeLowercase($offset);
+        if (null === $offset) {
+            $this->container[] = $value;
+        } else {
+            $this->container[$offset] = $value;
+        }
+    }
+    /**
+     * @return bool
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetExists($offset)
+    {
+        $offset = self::maybeLowercase($offset);
+        return isset($this->container[$offset]);
+    }
+    /**
+     * @return void
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetUnset($offset)
+    {
+        $offset = self::maybeLowercase($offset);
+        unset($this->container[$offset]);
+    }
+    /**
+     * @return mixed
+     */
+    #[\ReturnTypeWillChange]
+    public function offsetGet($offset)
+    {
+        $offset = self::maybeLowercase($offset);
+        return isset($this->container[$offset]) ? $this->container[$offset] : null;
+    }
+    private static function maybeLowercase($v)
+    {
+        if (\is_string($v)) {
+            return \strtolower($v);
+        }
+        return $v;
+    }
+}

dependencies/stripe/stripe-php/lib/Util/DefaultLogger.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+/**
+ * A very basic implementation of LoggerInterface that has just enough
+ * functionality that it can be the default for this library.
+ */
+class DefaultLogger implements LoggerInterface
+{
+    /** @var int */
+    public $messageType = 0;
+    /** @var null|string */
+    public $destination;
+    public function error($message, array $context = [])
+    {
+        if (\count($context) > 0) {
+            throw new \WP_Ultimo\Dependencies\Stripe\Exception\BadMethodCallException('DefaultLogger does not currently implement context. Please implement if you need it.');
+        }
+        if (null === $this->destination) {
+            \error_log($message, $this->messageType);
+        } else {
+            \error_log($message, $this->messageType, $this->destination);
+        }
+    }
+}

dependencies/stripe/stripe-php/lib/Util/LoggerInterface.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+/**
+ * Describes a logger instance.
+ *
+ * This is a subset of the interface of the same name in the PSR-3 logger
+ * interface. We guarantee to keep it compatible, but we'd redefined it here so
+ * that we don't have to pull in the extra dependencies for users who don't want
+ * it.
+ *
+ * See https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md
+ * for the full interface specification.
+ *
+ * The message MUST be a string or object implementing __toString().
+ *
+ * The message MAY contain placeholders in the form: {foo} where foo
+ * will be replaced by the context data in key "foo".
+ *
+ * The context array can contain arbitrary data, the only assumption that
+ * can be made by implementors is that if an Exception instance is given
+ * to produce a stack trace, it MUST be in a key named "exception".
+ */
+interface LoggerInterface
+{
+    /**
+     * Runtime errors that do not require immediate action but should typically
+     * be logged and monitored.
+     *
+     * @param string $message
+     */
+    public function error($message, array $context = []);
+}

dependencies/stripe/stripe-php/lib/Util/RandomGenerator.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+/**
+ * A basic random generator. This is in a separate class so we the generator
+ * can be injected as a dependency and replaced with a mock in tests.
+ */
+class RandomGenerator
+{
+    /**
+     * Returns a random value between 0 and $max.
+     *
+     * @param float $max (optional)
+     *
+     * @return float
+     */
+    public function randFloat($max = 1.0)
+    {
+        return \mt_rand() / \mt_getrandmax() * $max;
+    }
+    /**
+     * Returns a v4 UUID.
+     *
+     * @return string
+     */
+    public function uuid()
+    {
+        $arr = \array_values(\unpack('N1a/n4b/N1c', \openssl_random_pseudo_bytes(16)));
+        $arr[2] = $arr[2] & 0xfff | 0x4000;
+        $arr[3] = $arr[3] & 0x3fff | 0x8000;
+        return \vsprintf('%08x-%04x-%04x-%04x-%04x%08x', $arr);
+    }
+}

dependencies/stripe/stripe-php/lib/Util/RequestOptions.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+class RequestOptions
+{
+    /**
+     * @var array<string> a list of headers that should be persisted across requests
+     */
+    public static $HEADERS_TO_PERSIST = ['Stripe-Account', 'Stripe-Version'];
+    /** @var array<string, string> */
+    public $headers;
+    /** @var null|string */
+    public $apiKey;
+    /** @var null|string */
+    public $apiBase;
+    /**
+     * @param null|string $key
+     * @param array<string, string> $headers
+     * @param null|string $base
+     */
+    public function __construct($key = null, $headers = [], $base = null)
+    {
+        $this->apiKey = $key;
+        $this->headers = $headers;
+        $this->apiBase = $base;
+    }
+    /**
+     * @return array<string, string>
+     */
+    public function __debugInfo()
+    {
+        return ['apiKey' => $this->redactedApiKey(), 'headers' => $this->headers, 'apiBase' => $this->apiBase];
+    }
+    /**
+     * Unpacks an options array and merges it into the existing RequestOptions
+     * object.
+     *
+     * @param null|array|RequestOptions|string $options a key => value array
+     * @param bool $strict when true, forbid string form and arbitrary keys in array form
+     *
+     * @return RequestOptions
+     */
+    public function merge($options, $strict = \false)
+    {
+        $other_options = self::parse($options, $strict);
+        if (null === $other_options->apiKey) {
+            $other_options->apiKey = $this->apiKey;
+        }
+        if (null === $other_options->apiBase) {
+            $other_options->apiBase = $this->apiBase;
+        }
+        $other_options->headers = \array_merge($this->headers, $other_options->headers);
+        return $other_options;
+    }
+    /**
+     * Discards all headers that we don't want to persist across requests.
+     */
+    public function discardNonPersistentHeaders()
+    {
+        foreach ($this->headers as $k => $v) {
+            if (!\in_array($k, self::$HEADERS_TO_PERSIST, \true)) {
+                unset($this->headers[$k]);
+            }
+        }
+    }
+    /**
+     * Unpacks an options array into an RequestOptions object.
+     *
+     * @param null|array|RequestOptions|string $options a key => value array
+     * @param bool $strict when true, forbid string form and arbitrary keys in array form
+     *
+     * @throws \Stripe\Exception\InvalidArgumentException
+     *
+     * @return RequestOptions
+     */
+    public static function parse($options, $strict = \false)
+    {
+        if ($options instanceof self) {
+            return clone $options;
+        }
+        if (null === $options) {
+            return new RequestOptions(null, [], null);
+        }
+        if (\is_string($options)) {
+            if ($strict) {
+                $message = 'Do not pass a string for request options. If you want to set the ' . 'API key, pass an array like ["api_key" => <apiKey>] instead.';
+                throw new \WP_Ultimo\Dependencies\Stripe\Exception\InvalidArgumentException($message);
+            }
+            return new RequestOptions($options, [], null);
+        }
+        if (\is_array($options)) {
+            $headers = [];
+            $key = null;
+            $base = null;
+            if (\array_key_exists('api_key', $options)) {
+                $key = $options['api_key'];
+                unset($options['api_key']);
+            }
+            if (\array_key_exists('idempotency_key', $options)) {
+                $headers['Idempotency-Key'] = $options['idempotency_key'];
+                unset($options['idempotency_key']);
+            }
+            if (\array_key_exists('stripe_account', $options)) {
+                $headers['Stripe-Account'] = $options['stripe_account'];
+                unset($options['stripe_account']);
+            }
+            if (\array_key_exists('stripe_version', $options)) {
+                $headers['Stripe-Version'] = $options['stripe_version'];
+                unset($options['stripe_version']);
+            }
+            if (\array_key_exists('api_base', $options)) {
+                $base = $options['api_base'];
+                unset($options['api_base']);
+            }
+            if ($strict && !empty($options)) {
+                $message = 'Got unexpected keys in options array: ' . \implode(', ', \array_keys($options));
+                throw new \WP_Ultimo\Dependencies\Stripe\Exception\InvalidArgumentException($message);
+            }
+            return new RequestOptions($key, $headers, $base);
+        }
+        $message = 'The second argument to Stripe API method calls is an ' . 'optional per-request apiKey, which must be a string, or ' . 'per-request options, which must be an array. (HINT: you can set ' . 'a global apiKey by "Stripe::setApiKey(<apiKey>)")';
+        throw new \WP_Ultimo\Dependencies\Stripe\Exception\InvalidArgumentException($message);
+    }
+    /** @return string */
+    private function redactedApiKey()
+    {
+        if (null === $this->apiKey) {
+            return '';
+        }
+        $pieces = \explode('_', $this->apiKey, 3);
+        $last = \array_pop($pieces);
+        $redactedLast = \strlen($last) > 4 ? \str_repeat('*', \strlen($last) - 4) . \substr($last, -4) : $last;
+        $pieces[] = $redactedLast;
+        return \implode('_', $pieces);
+    }
+}

dependencies/stripe/stripe-php/lib/Util/Set.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+use ArrayIterator;
+use IteratorAggregate;
+class Set implements IteratorAggregate
+{
+    private $_elts;
+    public function __construct($members = [])
+    {
+        $this->_elts = [];
+        foreach ($members as $item) {
+            $this->_elts[$item] = \true;
+        }
+    }
+    public function includes($elt)
+    {
+        return isset($this->_elts[$elt]);
+    }
+    public function add($elt)
+    {
+        $this->_elts[$elt] = \true;
+    }
+    public function discard($elt)
+    {
+        unset($this->_elts[$elt]);
+    }
+    public function toArray()
+    {
+        return \array_keys($this->_elts);
+    }
+    /**
+     * @return ArrayIterator
+     */
+    #[\ReturnTypeWillChange]
+    public function getIterator()
+    {
+        return new ArrayIterator($this->toArray());
+    }
+}

dependencies/stripe/stripe-php/lib/Util/Util.php

@@ -0,0 +1,228 @@
+<?php
+
+namespace WP_Ultimo\Dependencies\Stripe\Util;
+
+use WP_Ultimo\Dependencies\Stripe\StripeObject;
+abstract class Util
+{
+    private static $isMbstringAvailable = null;
+    private static $isHashEqualsAvailable = null;
+    /**
+     * Whether the provided array (or other) is a list rather than a dictionary.
+     * A list is defined as an array for which all the keys are consecutive
+     * integers starting at 0. Empty arrays are considered to be lists.
+     *
+     * @param array|mixed $array
+     *
+     * @return bool true if the given object is a list
+     */
+    public static function isList($array)
+    {
+        if (!\is_array($array)) {
+            return \false;
+        }
+        if ([] === $array) {
+            return \true;
+        }
+        if (\array_keys($array) !== \range(0, \count($array) - 1)) {
+            return \false;
+        }
+        return \true;
+    }
+    /**
+     * Converts a response from the Stripe API to the corresponding PHP object.
+     *
+     * @param array $resp the response from the Stripe API
+     * @param array $opts
+     *
+     * @return array|StripeObject
+     */
+    public static function convertToStripeObject($resp, $opts)
+    {
+        $types = \WP_Ultimo\Dependencies\Stripe\Util\ObjectTypes::mapping;
+        if (self::isList($resp)) {
+            $mapped = [];
+            foreach ($resp as $i) {
+                $mapped[] = self::convertToStripeObject($i, $opts);
+            }
+            return $mapped;
+        }
+        if (\is_array($resp)) {
+            if (isset($resp['object']) && \is_string($resp['object']) && isset($types[$resp['object']])) {
+                $class = $types[$resp['object']];
+            } else {
+                $class = \WP_Ultimo\Dependencies\Stripe\StripeObject::class;
+            }
+            return $class::constructFrom($resp, $opts);
+        }
+        return $resp;
+    }
+    /**
+     * @param mixed|string $value a string to UTF8-encode
+     *
+     * @return mixed|string the UTF8-encoded string, or the object passed in if
+     *    it wasn't a string
+     */
+    public static function utf8($value)
+    {
+        if (null === self::$isMbstringAvailable) {
+            self::$isMbstringAvailable = \function_exists('mb_detect_encoding') && \function_exists('mb_convert_encoding');
+            if (!self::$isMbstringAvailable) {
+                \trigger_error('It looks like the mbstring extension is not enabled. ' . 'UTF-8 strings will not properly be encoded. Ask your system ' . 'administrator to enable the mbstring extension, or write to ' . 'support@stripe.com if you have any questions.', \E_USER_WARNING);
+            }
+        }
+        if (\is_string($value) && self::$isMbstringAvailable && 'UTF-8' !== \mb_detect_encoding($value, 'UTF-8', \true)) {
+            return \mb_convert_encoding($value, 'UTF-8', 'ISO-8859-1');
+        }
+        return $value;
+    }
+    /**
+     * Compares two strings for equality. The time taken is independent of the
+     * number of characters that match.
+     *
+     * @param string $a one of the strings to compare
+     * @param string $b the other string to compare
+     *
+     * @return bool true if the strings are equal, false otherwise
+     */
+    public static function secureCompare($a, $b)
+    {
+        if (null === self::$isHashEqualsAvailable) {
+            self::$isHashEqualsAvailable = \function_exists('hash_equals');
+        }
+        if (self::$isHashEqualsAvailable) {
+            return \hash_equals($a, $b);
+        }
+        if (\strlen($a) !== \strlen($b)) {
+            return \false;
+        }
+        $result = 0;
+        for ($i = 0; $i < \strlen($a); ++$i) {
+            $result |= \ord($a[$i]) ^ \ord($b[$i]);
+        }
+        return 0 === $result;
+    }
+    /**
+     * Recursively goes through an array of parameters. If a parameter is an instance of
+     * ApiResource, then it is replaced by the resource's ID.
+     * Also clears out null values.
+     *
+     * @param mixed $h
+     *
+     * @return mixed
+     */
+    public static function objectsToIds($h)
+    {
+        if ($h instanceof \WP_Ultimo\Dependencies\Stripe\ApiResource) {
+            return $h->id;
+        }
+        if (static::isList($h)) {
+            $results = [];
+            foreach ($h as $v) {
+                $results[] = static::objectsToIds($v);
+            }
+            return $results;
+        }
+        if (\is_array($h)) {
+            $results = [];
+            foreach ($h as $k => $v) {
+                if (null === $v) {
+                    continue;
+                }
+                $results[$k] = static::objectsToIds($v);
+            }
+            return $results;
+        }
+        return $h;
+    }
+    /**
+     * @param array $params
+     *
+     * @return string
+     */
+    public static function encodeParameters($params)
+    {
+        $flattenedParams = self::flattenParams($params);
+        $pieces = [];
+        foreach ($flattenedParams as $param) {
+            list($k, $v) = $param;
+            $pieces[] = self::urlEncode($k) . '=' . self::urlEncode($v);
+        }
+        return \implode('&', $pieces);
+    }
+    /**
+     * @param array $params
+     * @param null|string $parentKey
+     *
+     * @return array
+     */
+    public static function flattenParams($params, $parentKey = null)
+    {
+        $result = [];
+        foreach ($params as $key => $value) {
+            $calculatedKey = $parentKey ? "{$parentKey}[{$key}]" : $key;
+            if (self::isList($value)) {
+                $result = \array_merge($result, self::flattenParamsList($value, $calculatedKey));
+            } elseif (\is_array($value)) {
+                $result = \array_merge($result, self::flattenParams($value, $calculatedKey));
+            } else {
+                \array_push($result, [$calculatedKey, $value]);
+            }
+        }
+        return $result;
+    }
+    /**
+     * @param array $value
+     * @param string $calculatedKey
+     *
+     * @return array
+     */
+    public static function flattenParamsList($value, $calculatedKey)
+    {
+        $result = [];
+        foreach ($value as $i => $elem) {
+            if (self::isList($elem)) {
+                $result = \array_merge($result, self::flattenParamsList($elem, $calculatedKey));
+            } elseif (\is_array($elem)) {
+                $result = \array_merge($result, self::flattenParams($elem, "{$calculatedKey}[{$i}]"));
+            } else {
+                \array_push($result, ["{$calculatedKey}[{$i}]", $elem]);
+            }
+        }
+        return $result;
+    }
+    /**
+     * @param string $key a string to URL-encode
+     *
+     * @return string the URL-encoded string
+     */
+    public static function urlEncode($key)
+    {
+        $s = \urlencode((string) $key);
+        // Don't use strict form encoding by changing the square bracket control
+        // characters back to their literals. This is fine by the server, and
+        // makes these parameter strings easier to read.
+        $s = \str_replace('%5B', '[', $s);
+        return \str_replace('%5D', ']', $s);
+    }
+    public static function normalizeId($id)
+    {
+        if (\is_array($id)) {
+            $params = $id;
+            $id = $params['id'];
+            unset($params['id']);
+        } else {
+            $params = [];
+        }
+        return [$id, $params];
+    }
+    /**
+     * Returns UNIX timestamp in milliseconds.
+     *
+     * @return int current time in millis
+     */
+    public static function currentTimeMillis()
+    {
+        return (int) \round(\microtime(\true) * 1000);
+    }
+}