Skip to content
GitLab
Projects
Groups
Snippets
/
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
Maarch
MaarchCourrier
Commits
56b18639
Commit
56b18639
authored
Mar 26, 2021
by
Guillaume Heurtier
Browse files
FEAT #13988 TIME 0:05 fix vendor
parent
4bbc6b27
Changes
1000
Hide whitespace changes
Inline
Side-by-side
Too many changes to show.
To preserve performance only
20 of 1000+
files are displayed.
Plain diff
Email patch
vendor/bin/php-parse
0 → 120000
View file @
56b18639
../nikic/php-parser/bin/php-parse
\ No newline at end of file
vendor/clue/stream-filter/.github/FUNDING.yml
0 → 100644
View file @
56b18639
github
:
clue
custom
:
https://clue.engineering/support
vendor/clue/stream-filter/src/functions_include.php
0 → 100644
View file @
56b18639
<?php
// @codeCoverageIgnoreStart
if
(
!
\
function_exists
(
'Clue\\StreamFilter\\append'
))
{
require
__DIR__
.
'/functions.php'
;
}
vendor/endroid/qr-code/.vscode/temp.sql
0 → 100644
View file @
56b18639
vendor/firebase/php-jwt/src/JWK.php
0 → 100644
View file @
56b18639
<?php
namespace
Firebase\JWT
;
use
DomainException
;
use
InvalidArgumentException
;
use
UnexpectedValueException
;
/**
* JSON Web Key implementation, based on this spec:
* https://tools.ietf.org/html/draft-ietf-jose-json-web-key-41
*
* PHP version 5
*
* @category Authentication
* @package Authentication_JWT
* @author Bui Sy Nguyen <nguyenbs@gmail.com>
* @license http://opensource.org/licenses/BSD-3-Clause 3-clause BSD
* @link https://github.com/firebase/php-jwt
*/
class
JWK
{
/**
* Parse a set of JWK keys
*
* @param array $jwks The JSON Web Key Set as an associative array
*
* @return array An associative array that represents the set of keys
*
* @throws InvalidArgumentException Provided JWK Set is empty
* @throws UnexpectedValueException Provided JWK Set was invalid
* @throws DomainException OpenSSL failure
*
* @uses parseKey
*/
public
static
function
parseKeySet
(
array
$jwks
)
{
$keys
=
array
();
if
(
!
isset
(
$jwks
[
'keys'
]))
{
throw
new
UnexpectedValueException
(
'"keys" member must exist in the JWK Set'
);
}
if
(
empty
(
$jwks
[
'keys'
]))
{
throw
new
InvalidArgumentException
(
'JWK Set did not contain any keys'
);
}
foreach
(
$jwks
[
'keys'
]
as
$k
=>
$v
)
{
$kid
=
isset
(
$v
[
'kid'
])
?
$v
[
'kid'
]
:
$k
;
if
(
$key
=
self
::
parseKey
(
$v
))
{
$keys
[
$kid
]
=
$key
;
}
}
if
(
0
===
\
count
(
$keys
))
{
throw
new
UnexpectedValueException
(
'No supported algorithms found in JWK Set'
);
}
return
$keys
;
}
/**
* Parse a JWK key
*
* @param array $jwk An individual JWK
*
* @return resource|array An associative array that represents the key
*
* @throws InvalidArgumentException Provided JWK is empty
* @throws UnexpectedValueException Provided JWK was invalid
* @throws DomainException OpenSSL failure
*
* @uses createPemFromModulusAndExponent
*/
private
static
function
parseKey
(
array
$jwk
)
{
if
(
empty
(
$jwk
))
{
throw
new
InvalidArgumentException
(
'JWK must not be empty'
);
}
if
(
!
isset
(
$jwk
[
'kty'
]))
{
throw
new
UnexpectedValueException
(
'JWK must contain a "kty" parameter'
);
}
switch
(
$jwk
[
'kty'
])
{
case
'RSA'
:
if
(
\
array_key_exists
(
'd'
,
$jwk
))
{
throw
new
UnexpectedValueException
(
'RSA private keys are not supported'
);
}
if
(
!
isset
(
$jwk
[
'n'
])
||
!
isset
(
$jwk
[
'e'
]))
{
throw
new
UnexpectedValueException
(
'RSA keys must contain values for both "n" and "e"'
);
}
$pem
=
self
::
createPemFromModulusAndExponent
(
$jwk
[
'n'
],
$jwk
[
'e'
]);
$publicKey
=
\
openssl_pkey_get_public
(
$pem
);
if
(
false
===
$publicKey
)
{
throw
new
DomainException
(
'OpenSSL error: '
.
\
openssl_error_string
()
);
}
return
$publicKey
;
default
:
// Currently only RSA is supported
break
;
}
}
/**
* Create a public key represented in PEM format from RSA modulus and exponent information
*
* @param string $n The RSA modulus encoded in Base64
* @param string $e The RSA exponent encoded in Base64
*
* @return string The RSA public key represented in PEM format
*
* @uses encodeLength
*/
private
static
function
createPemFromModulusAndExponent
(
$n
,
$e
)
{
$modulus
=
JWT
::
urlsafeB64Decode
(
$n
);
$publicExponent
=
JWT
::
urlsafeB64Decode
(
$e
);
$components
=
array
(
'modulus'
=>
\
pack
(
'Ca*a*'
,
2
,
self
::
encodeLength
(
\
strlen
(
$modulus
)),
$modulus
),
'publicExponent'
=>
\
pack
(
'Ca*a*'
,
2
,
self
::
encodeLength
(
\
strlen
(
$publicExponent
)),
$publicExponent
)
);
$rsaPublicKey
=
\
pack
(
'Ca*a*a*'
,
48
,
self
::
encodeLength
(
\
strlen
(
$components
[
'modulus'
])
+
\
strlen
(
$components
[
'publicExponent'
])),
$components
[
'modulus'
],
$components
[
'publicExponent'
]
);
// sequence(oid(1.2.840.113549.1.1.1), null)) = rsaEncryption.
$rsaOID
=
\
pack
(
'H*'
,
'300d06092a864886f70d0101010500'
);
// hex version of MA0GCSqGSIb3DQEBAQUA
$rsaPublicKey
=
\
chr
(
0
)
.
$rsaPublicKey
;
$rsaPublicKey
=
\
chr
(
3
)
.
self
::
encodeLength
(
\
strlen
(
$rsaPublicKey
))
.
$rsaPublicKey
;
$rsaPublicKey
=
\
pack
(
'Ca*a*'
,
48
,
self
::
encodeLength
(
\
strlen
(
$rsaOID
.
$rsaPublicKey
)),
$rsaOID
.
$rsaPublicKey
);
$rsaPublicKey
=
"-----BEGIN PUBLIC KEY-----
\r\n
"
.
\
chunk_split
(
\
base64_encode
(
$rsaPublicKey
),
64
)
.
'-----END PUBLIC KEY-----'
;
return
$rsaPublicKey
;
}
/**
* DER-encode the length
*
* DER supports lengths up to (2**8)**127, however, we'll only support lengths up to (2**8)**4. See
* {@link http://itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf#p=13 X.690 paragraph 8.1.3} for more information.
*
* @param int $length
* @return string
*/
private
static
function
encodeLength
(
$length
)
{
if
(
$length
<=
0x7F
)
{
return
\
chr
(
$length
);
}
$temp
=
\
ltrim
(
\
pack
(
'N'
,
$length
),
\
chr
(
0
));
return
\
pack
(
'Ca*'
,
0x80
|
\
strlen
(
$temp
),
$temp
);
}
}
vendor/guzzlehttp/guzzle/.php_cs
0 → 100644
View file @
56b18639
<?php
$config
=
PhpCsFixer\Config
::
create
()
->
setRiskyAllowed
(
true
)
->
setRules
([
'@PSR2'
=>
true
,
'array_syntax'
=>
[
'syntax'
=>
'short'
],
'declare_strict_types'
=>
false
,
'concat_space'
=>
[
'spacing'
=>
'one'
],
'php_unit_test_case_static_method_calls'
=>
[
'call_type'
=>
'self'
],
'ordered_imports'
=>
true
,
// 'phpdoc_align' => ['align'=>'vertical'],
// 'native_function_invocation' => true,
])
->
setFinder
(
PhpCsFixer\Finder
::
create
()
->
in
(
__DIR__
.
'/src'
)
->
in
(
__DIR__
.
'/tests'
)
->
name
(
'*.php'
)
)
;
return
$config
;
vendor/guzzlehttp/guzzle/Dockerfile
0 → 100644
View file @
56b18639
FROM
composer:latest
as
setup
RUN
mkdir
/guzzle
WORKDIR
/guzzle
RUN
set
-xe
\
&&
composer init
--name
=
guzzlehttp/test
--description
=
"Simple project for testing Guzzle scripts"
--author
=
"Márk Sági-Kazár <mark.sagikazar@gmail.com>"
--no-interaction
\
&&
composer require guzzlehttp/guzzle
FROM
php:7.3
RUN
mkdir
/guzzle
WORKDIR
/guzzle
COPY
--from=setup /guzzle /guzzle
vendor/guzzlehttp/guzzle/src/Exception/InvalidArgumentException.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp\Exception
;
final
class
InvalidArgumentException
extends
\
InvalidArgumentException
implements
GuzzleException
{
}
vendor/guzzlehttp/guzzle/src/Utils.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp
;
use
GuzzleHttp\Exception\InvalidArgumentException
;
use
Psr\Http\Message\UriInterface
;
use
Symfony\Polyfill\Intl\Idn\Idn
;
final
class
Utils
{
/**
* Wrapper for the hrtime() or microtime() functions
* (depending on the PHP version, one of the two is used)
*
* @return float|mixed UNIX timestamp
*
* @internal
*/
public
static
function
currentTime
()
{
return
function_exists
(
'hrtime'
)
?
hrtime
(
true
)
/
1
e9
:
microtime
(
true
);
}
/**
* @param int $options
*
* @return UriInterface
* @throws InvalidArgumentException
*
* @internal
*/
public
static
function
idnUriConvert
(
UriInterface
$uri
,
$options
=
0
)
{
if
(
$uri
->
getHost
())
{
$asciiHost
=
self
::
idnToAsci
(
$uri
->
getHost
(),
$options
,
$info
);
if
(
$asciiHost
===
false
)
{
$errorBitSet
=
isset
(
$info
[
'errors'
])
?
$info
[
'errors'
]
:
0
;
$errorConstants
=
array_filter
(
array_keys
(
get_defined_constants
()),
function
(
$name
)
{
return
substr
(
$name
,
0
,
11
)
===
'IDNA_ERROR_'
;
});
$errors
=
[];
foreach
(
$errorConstants
as
$errorConstant
)
{
if
(
$errorBitSet
&
constant
(
$errorConstant
))
{
$errors
[]
=
$errorConstant
;
}
}
$errorMessage
=
'IDN conversion failed'
;
if
(
$errors
)
{
$errorMessage
.
=
' (errors: '
.
implode
(
', '
,
$errors
)
.
')'
;
}
throw
new
InvalidArgumentException
(
$errorMessage
);
}
else
{
if
(
$uri
->
getHost
()
!==
$asciiHost
)
{
// Replace URI only if the ASCII version is different
$uri
=
$uri
->
withHost
(
$asciiHost
);
}
}
}
return
$uri
;
}
/**
* @param string $domain
* @param int $options
* @param array $info
*
* @return string|false
*/
private
static
function
idnToAsci
(
$domain
,
$options
,
&
$info
=
[])
{
if
(
\
preg_match
(
'%^[ -~]+$%'
,
$domain
)
===
1
)
{
return
$domain
;
}
if
(
\
extension_loaded
(
'intl'
)
&&
defined
(
'INTL_IDNA_VARIANT_UTS46'
))
{
return
\
idn_to_ascii
(
$domain
,
$options
,
INTL_IDNA_VARIANT_UTS46
,
$info
);
}
/*
* The Idn class is marked as @internal. Verify that class and method exists.
*/
if
(
method_exists
(
Idn
::
class
,
'idn_to_ascii'
))
{
return
Idn
::
idn_to_ascii
(
$domain
,
$options
,
Idn
::
INTL_IDNA_VARIANT_UTS46
,
$info
);
}
throw
new
\
RuntimeException
(
'ext-intl or symfony/polyfill-intl-idn not loaded or too old'
);
}
}
vendor/guzzlehttp/promises/src/Create.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp\Promise
;
final
class
Create
{
/**
* Creates a promise for a value if the value is not a promise.
*
* @param mixed $value Promise or value.
*
* @return PromiseInterface
*/
public
static
function
promiseFor
(
$value
)
{
if
(
$value
instanceof
PromiseInterface
)
{
return
$value
;
}
// Return a Guzzle promise that shadows the given promise.
if
(
is_object
(
$value
)
&&
method_exists
(
$value
,
'then'
))
{
$wfn
=
method_exists
(
$value
,
'wait'
)
?
[
$value
,
'wait'
]
:
null
;
$cfn
=
method_exists
(
$value
,
'cancel'
)
?
[
$value
,
'cancel'
]
:
null
;
$promise
=
new
Promise
(
$wfn
,
$cfn
);
$value
->
then
([
$promise
,
'resolve'
],
[
$promise
,
'reject'
]);
return
$promise
;
}
return
new
FulfilledPromise
(
$value
);
}
/**
* Creates a rejected promise for a reason if the reason is not a promise.
* If the provided reason is a promise, then it is returned as-is.
*
* @param mixed $reason Promise or reason.
*
* @return PromiseInterface
*/
public
static
function
rejectionFor
(
$reason
)
{
if
(
$reason
instanceof
PromiseInterface
)
{
return
$reason
;
}
return
new
RejectedPromise
(
$reason
);
}
/**
* Create an exception for a rejected promise value.
*
* @param mixed $reason
*
* @return \Exception|\Throwable
*/
public
static
function
exceptionFor
(
$reason
)
{
if
(
$reason
instanceof
\
Exception
||
$reason
instanceof
\
Throwable
)
{
return
$reason
;
}
return
new
RejectionException
(
$reason
);
}
/**
* Returns an iterator for the given value.
*
* @param mixed $value
*
* @return \Iterator
*/
public
static
function
iterFor
(
$value
)
{
if
(
$value
instanceof
\
Iterator
)
{
return
$value
;
}
if
(
is_array
(
$value
))
{
return
new
\
ArrayIterator
(
$value
);
}
return
new
\
ArrayIterator
([
$value
]);
}
}
vendor/guzzlehttp/promises/src/Each.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp\Promise
;
final
class
Each
{
/**
* Given an iterator that yields promises or values, returns a promise that
* is fulfilled with a null value when the iterator has been consumed or
* the aggregate promise has been fulfilled or rejected.
*
* $onFulfilled is a function that accepts the fulfilled value, iterator
* index, and the aggregate promise. The callback can invoke any necessary
* side effects and choose to resolve or reject the aggregate if needed.
*
* $onRejected is a function that accepts the rejection reason, iterator
* index, and the aggregate promise. The callback can invoke any necessary
* side effects and choose to resolve or reject the aggregate if needed.
*
* @param mixed $iterable Iterator or array to iterate over.
* @param callable $onFulfilled
* @param callable $onRejected
*
* @return PromiseInterface
*/
public
static
function
of
(
$iterable
,
callable
$onFulfilled
=
null
,
callable
$onRejected
=
null
)
{
return
(
new
EachPromise
(
$iterable
,
[
'fulfilled'
=>
$onFulfilled
,
'rejected'
=>
$onRejected
]))
->
promise
();
}
/**
* Like of, but only allows a certain number of outstanding promises at any
* given time.
*
* $concurrency may be an integer or a function that accepts the number of
* pending promises and returns a numeric concurrency limit value to allow
* for dynamic a concurrency size.
*
* @param mixed $iterable
* @param int|callable $concurrency
* @param callable $onFulfilled
* @param callable $onRejected
*
* @return PromiseInterface
*/
public
static
function
ofLimit
(
$iterable
,
$concurrency
,
callable
$onFulfilled
=
null
,
callable
$onRejected
=
null
)
{
return
(
new
EachPromise
(
$iterable
,
[
'fulfilled'
=>
$onFulfilled
,
'rejected'
=>
$onRejected
,
'concurrency'
=>
$concurrency
]))
->
promise
();
}
/**
* Like limit, but ensures that no promise in the given $iterable argument
* is rejected. If any promise is rejected, then the aggregate promise is
* rejected with the encountered rejection.
*
* @param mixed $iterable
* @param int|callable $concurrency
* @param callable $onFulfilled
*
* @return PromiseInterface
*/
public
static
function
ofLimitAll
(
$iterable
,
$concurrency
,
callable
$onFulfilled
=
null
)
{
return
each_limit
(
$iterable
,
$concurrency
,
$onFulfilled
,
function
(
$reason
,
$idx
,
PromiseInterface
$aggregate
)
{
$aggregate
->
reject
(
$reason
);
}
);
}
}
vendor/guzzlehttp/promises/src/Is.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp\Promise
;
final
class
Is
{
/**
* Returns true if a promise is pending.
*
* @return bool
*/
public
static
function
pending
(
PromiseInterface
$promise
)
{
return
$promise
->
getState
()
===
PromiseInterface
::
PENDING
;
}
/**
* Returns true if a promise is fulfilled or rejected.
*
* @return bool
*/
public
static
function
settled
(
PromiseInterface
$promise
)
{
return
$promise
->
getState
()
!==
PromiseInterface
::
PENDING
;
}
/**
* Returns true if a promise is fulfilled.
*
* @return bool
*/
public
static
function
fulfilled
(
PromiseInterface
$promise
)
{
return
$promise
->
getState
()
===
PromiseInterface
::
FULFILLED
;
}
/**
* Returns true if a promise is rejected.
*
* @return bool
*/
public
static
function
rejected
(
PromiseInterface
$promise
)
{
return
$promise
->
getState
()
===
PromiseInterface
::
REJECTED
;
}
}
vendor/guzzlehttp/promises/src/Utils.php
0 → 100644
View file @
56b18639
<?php
namespace
GuzzleHttp\Promise
;
final
class
Utils
{
/**
* Get the global task queue used for promise resolution.
*
* This task queue MUST be run in an event loop in order for promises to be
* settled asynchronously. It will be automatically run when synchronously
* waiting on a promise.
*
* <code>
* while ($eventLoop->isRunning()) {
* GuzzleHttp\Promise\Utils::queue()->run();
* }
* </code>
*
* @param TaskQueueInterface $assign Optionally specify a new queue instance.
*
* @return TaskQueueInterface
*/
public
static
function
queue
(
TaskQueueInterface
$assign
=
null
)
{
static
$queue
;
if
(
$assign
)
{
$queue
=
$assign
;
}
elseif
(
!
$queue
)
{
$queue
=
new
TaskQueue
();
}
return
$queue
;
}
/**
* Adds a function to run in the task queue when it is next `run()` and
* returns a promise that is fulfilled or rejected with the result.
*
* @param callable $task Task function to run.
*
* @return PromiseInterface
*/
public
static
function
task
(
callable
$task
)
{
$queue
=
self
::
queue
();
$promise
=
new
Promise
([
$queue
,
'run'
]);
$queue
->
add
(
function
()
use
(
$task
,
$promise
)
{
try
{
$promise
->
resolve
(
$task
());
}
catch
(
\
Throwable
$e
)
{
$promise
->
reject
(
$e
);
}
catch
(
\
Exception
$e
)
{
$promise
->
reject
(
$e
);
}
});