One Hat Cyber Team
Your IP:
216.73.216.176
Server IP:
198.54.114.155
Server:
Linux server71.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64
Server Software:
LiteSpeed
PHP Version:
5.6.40
Create File
|
Create Folder
Execute
Dir :
~
/
proc
/
self
/
cwd
/
View File Name :
README.md.tar
home/fluxyjvi/public_html/project/vendor/ramsey/collection/README.md 0000644 00000007041 15105633426 0021542 0 ustar 00 <h1 align="center">ramsey/collection</h1> <p align="center"> <strong>A PHP library for representing and manipulating collections.</strong> </p> <p align="center"> <a href="https://github.com/ramsey/collection"><img src="http://img.shields.io/badge/source-ramsey/collection-blue.svg?style=flat-square" alt="Source Code"></a> <a href="https://packagist.org/packages/ramsey/collection"><img src="https://img.shields.io/packagist/v/ramsey/collection.svg?style=flat-square&label=release" alt="Download Package"></a> <a href="https://php.net"><img src="https://img.shields.io/packagist/php-v/ramsey/collection.svg?style=flat-square&colorB=%238892BF" alt="PHP Programming Language"></a> <a href="https://github.com/ramsey/collection/blob/master/LICENSE"><img src="https://img.shields.io/packagist/l/ramsey/collection.svg?style=flat-square&colorB=darkcyan" alt="Read License"></a> <a href="https://github.com/ramsey/collection/actions/workflows/continuous-integration.yml"><img src="https://img.shields.io/github/actions/workflow/status/ramsey/collection/continuous-integration.yml?branch=main&logo=github&style=flat-square" alt="Build Status"></a> <a href="https://codecov.io/gh/ramsey/collection"><img src="https://img.shields.io/codecov/c/gh/ramsey/collection?label=codecov&logo=codecov&style=flat-square" alt="Codecov Code Coverage"></a> <a href="https://shepherd.dev/github/ramsey/collection"><img src="https://img.shields.io/endpoint?style=flat-square&url=https%3A%2F%2Fshepherd.dev%2Fgithub%2Framsey%2Fcollection%2Fcoverage" alt="Psalm Type Coverage"></a> </p> ## About ramsey/collection is a PHP library for representing and manipulating collections. Much inspiration for this library came from the [Java Collections Framework][java]. This project adheres to a [code of conduct](CODE_OF_CONDUCT.md). By participating in this project and its community, you are expected to uphold this code. ## Installation Install this package as a dependency using [Composer](https://getcomposer.org). ``` bash composer require ramsey/collection ``` ## Usage Examples of how to use this library may be found in the [Wiki pages](https://github.com/ramsey/collection/wiki/Examples). ## Contributing Contributions are welcome! To contribute, please familiarize yourself with [CONTRIBUTING.md](CONTRIBUTING.md). ## Coordinated Disclosure Keeping user information safe and secure is a top priority, and we welcome the contribution of external security researchers. If you believe you've found a security issue in software that is maintained in this repository, please read [SECURITY.md][] for instructions on submitting a vulnerability report. ## ramsey/collection for Enterprise Available as part of the Tidelift Subscription. The maintainers of ramsey/collection and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-ramsey-collection?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) ## Copyright and License The ramsey/collection library is copyright Β© [Ben Ramsey](https://benramsey.com) and licensed for use under the terms of the MIT License (MIT). Please see [LICENSE](LICENSE) for more information. [java]: http://docs.oracle.com/javase/8/docs/technotes/guides/collections/index.html [security.md]: https://github.com/ramsey/collection/blob/main/SECURITY.md home/fluxyjvi/public_html/project/vendor/nicmart/tree/README.md 0000644 00000014241 15105650070 0020475 0 ustar 00 # Tree [](https://github.com/nicmart/Tree/actions) [](https://github.com/nicmart/Tree/actions) [](https://packagist.org/packages/nicmart/tree) [](https://packagist.org/packages/nicmart/tree) [](https://packagist.org/packages/nicmart/tree) In Tree you can find a basic but flexible tree data structure for php together with and an handful Builder class, that enables you to build tree in a fluent way. ## The tree data structure The `Tree\Node\NodeInterface` interface abstracts the concept of a tree node. In `Tree` a Node has essentially two things: a set of children (that implements the same `NodeInterface` interface) and a value. On the other hand, the `Tree\Node\Node` gives a straight implementation for that interface. ### Creating a node ```php use Tree\Node\Node; $node = new Node('foo'); ``` ### Getting and setting the value of a node Each node has a value property, that can be any php value. ```php $node->setValue('my value'); echo $node->getValue(); //Prints 'my value' ``` ### Adding one or more children ```php $child1 = new Node('child1'); $child2 = new Node('child2'); $node ->addChild($child1) ->addChild($child2); ``` ### Removing a child ```php $node->removeChild($child1); ``` ### Getting the array of all children ```php $children = $node->getChildren(); ``` ### Overwriting the children set ```php $node->setChildren([new Node('foo'), new Node('bar')]); ``` ### Removing all children ```php $node->removeAllChildren(); ``` ### Getting if the node is a leaf or not A leaf is a node with no children. ```php $node->isLeaf(); ``` ### Getting if the node is a child or not A child is a node that has a parent. ```php $node->isChild(); ``` ### Getting the parent of a node Reference to the parent node is automatically managed by child-modifiers methods ```php $root->addChild($node = new Node('child')); $node->getParent(); // Returns $root ``` ### Getting the ancestors of a node ```php $root = (new Node('root')) ->addChild($child = new Node('child')) ->addChild($grandChild = new Node('grandchild')) ; $grandchild->getAncestors(); // Returns [$root, $child] ``` #### Related Methods - `getAncestorsAndSelf` retrieves ancestors of a node with the current node included. ### Getting the root of a node ```php $root = $node->root(); ``` ### Getting the neighbors of a node ```php $root = (new Node('root')) ->addChild($child1 = new Node('child1')) ->addChild($child2 = new Node('child2')) ->addChild($child3 = new Node('child3')) ; $child2->getNeighbors(); // Returns [$child1, $child3] ``` #### Related Methods - `getNeighborsAndSelf` retrieves neighbors of current node and the node itself. ### Getting the number of nodes in the tree ```php $node->getSize(); ``` ### Getting the depth of a node ```php $node->getDepth(); ``` ### Getting the height of a node ```php $node->getHeight(); ``` ## The Builder The builder provides a convenient way to build trees. It is provided by the ```Builder``` class, but you can implement your own builder making an implementation of the ```BuilderInterface```class. ### Example Let's see how to build the following tree, where the nodes label are represents nodes values: ``` A / \ B C /|\ D E F /| G H ``` And here is the code: ```php $builder = new Tree\Builder\NodeBuilder; $builder ->value('A') ->leaf('B') ->tree('C') ->tree('D') ->leaf('G') ->leaf('H') ->end() ->leaf('E') ->leaf('F') ->end() ; $nodeA = $builder->getNode(); ``` The example should be self-explanatory, but here you are a brief description of the methods used above. ### Builder::value($value) Set the value of the current node to ```$value``` ### Builder::leaf($value) Add to the current node a new child whose value is ```$value```. ### Builder::tree($value) Add to the current node a new child whose value is ```$value```, and set the new node as the builder current node. ### Builder::end() Returns to the context the builder was before the call to ```tree```method, i.e. make the builder go one level up. ### Builder::getNode() Returns the current node. ## Traversing a tree ### Yield You can obtain the yield of a tree (i.e. the list of leaves in a pre-order traversal) using the YieldVisitor. For example, if `$node` is the tree built above, then ```php use Tree\Visitor\YieldVisitor; $visitor = new YieldVisitor; $yield = $node->accept($visitor); // $yield will contain nodes B, G, H, E, F ``` ### Pre-order Traversal You can walk a tree in pre-order: ```php use Tree\Visitor\PreOrderVisitor; $visitor = new PreOrderVisitor; $yield = $node->accept($visitor); // $yield will contain nodes A, B, C, D, G, H, E, F ``` ### Post-order Traversal You can walk a tree in post-order: ```php use Tree\Visitor\PostOrderVisitor; $visitor = new PostOrderVisitor; $yield = $node->accept($visitor); // $yield will contain nodes B, G, H, D, E, F, C, A ``` ## Install The best way to install Tree is [through composer](http://getcomposer.org). Just create a composer.json file for your project: ```JSON { "require": { "nicmart/tree": "~0.2" } } ``` Then you can run these two commands to install it: $ curl -s http://getcomposer.org/installer | php $ php composer.phar install or simply run `composer install` if you have have already [installed the composer globally](http://getcomposer.org/doc/00-intro.md#globally). Then you can include the autoloader, and you will have access to the library classes: ```php <?php require 'vendor/autoload.php'; ``` # Tests ``` phpunit ``` ## Changelog Please have a look at [`CHANGELOG.md`](CHANGELOG.md). ## Contributing Please have a look at [`CONTRIBUTING.md`](.github/CONTRIBUTING.md). ## License This package is licensed using the MIT License. Please have a look at [`LICENSE.md`](LICENSE.md). home/fluxyjvi/public_html/project/vendor/doctrine/inflector/README.md 0000644 00000001015 15105703736 0021700 0 ustar 00 # Doctrine Inflector Doctrine Inflector is a small library that can perform string manipulations with regard to uppercase/lowercase and singular/plural forms of words. [](https://github.com/doctrine/inflector/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A4.0.x) [](https://codecov.io/gh/doctrine/inflector/branch/2.0.x) home/fluxyjvi/public_html/project/vendor/laravel/tinker/README.md 0000644 00000002756 15107327044 0021037 0 ustar 00 <p align="center"><img src="/art/logo.svg" alt="Logo Laravel Tinker"></p> <p align="center"> <a href="https://github.com/laravel/tinker/actions"><img src="https://github.com/laravel/tinker/workflows/tests/badge.svg" alt="Build Status"></a> <a href="https://packagist.org/packages/laravel/tinker"><img src="https://img.shields.io/packagist/dt/laravel/tinker" alt="Total Downloads"></a> <a href="https://packagist.org/packages/laravel/tinker"><img src="https://img.shields.io/packagist/v/laravel/tinker" alt="Latest Stable Version"></a> <a href="https://packagist.org/packages/laravel/tinker"><img src="https://img.shields.io/packagist/l/laravel/tinker" alt="License"></a> </p> ## Introduction Laravel Tinker is a powerful REPL for the Laravel framework. ## Official Documentation Documentation for Tinker can be found on the [Laravel website](https://laravel.com/docs/artisan#tinker). ## Contributing Thank you for considering contributing to Tinker! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities Please review [our security policy](https://github.com/laravel/tinker/security/policy) on how to report security vulnerabilities. ## License Laravel Tinker is open-sourced software licensed under the [MIT license](LICENSE.md). home/fluxyjvi/public_html/project/vendor/sebastian/code-unit/README.md 0000644 00000002025 15107340676 0021750 0 ustar 00 [](https://packagist.org/packages/sebastian/code-unit) [](https://github.com/sebastianbergmann/code-unit/actions) [](https://shepherd.dev/github/sebastianbergmann/code-unit) [](https://codecov.io/gh/sebastianbergmann/code-unit) # sebastian/code-unit Collection of value objects that represent the PHP code units. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/code-unit ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/code-unit ``` home/fluxyjvi/public_html/project/vendor/mercadopago/dx-php/README.md 0000644 00000006061 15107350220 0021557 0 ustar 00 # Mercado Pago SDK for PHP [](https://packagist.org/packages/mercadopago/dx-php) [](https://packagist.org/packages/mercadopago/dx-php) [](https://packagist.org/packages/mercadopago/dx-php) This library provides developers with a simple set of bindings to help you integrate Mercado Pago API to a website and start receiving payments. ## π‘ Requirements PHP 5.6, 7.1 or higher ## π» Installation First time using Mercado Pago? Create your [Mercado Pago account](https://www.mercadopago.com), if you donβt have one already. 1. Download [Composer](https://getcomposer.org/doc/00-intro.md) if not already installed 2. On your project directory run on the command line `composer require "mercadopago/dx-php:2.6.1"` for PHP7 or `composer require "mercadopago/dx-php:1.12.5"` for PHP5.6. 3. Copy the access_token in the [credentials](https://www.mercadopago.com/mlb/account/credentials) section of the page and replace YOUR_ACCESS_TOKEN with it. That's it! Mercado Pago SDK has been successfully installed. ## π Getting Started Simple usage looks like: ```php <?php require_once 'vendor/autoload.php'; // You have to require the library from your Composer vendor folder MercadoPago\SDK::setAccessToken("YOUR_ACCESS_TOKEN"); // Either Production or SandBox AccessToken $payment = new MercadoPago\Payment(); $payment->transaction_amount = 141; $payment->token = "YOUR_CARD_TOKEN"; $payment->description = "Ergonomic Silk Shirt"; $payment->installments = 1; $payment->payment_method_id = "visa"; $payment->payer = array( "email" => "larue.nienow@email.com" ); $payment->save(); echo $payment->status; ?> ``` ## π Documentation Visit our Dev Site for further information regarding: - Payments APIs: [Spanish](https://www.mercadopago.com.ar/developers/es/guides/payments/api/introduction/) / [Portuguese](https://www.mercadopago.com.br/developers/pt/guides/payments/api/introduction/) - Mercado Pago checkout: [Spanish](https://www.mercadopago.com.ar/developers/es/guides/payments/web-payment-checkout/introduction/) / [Portuguese](https://www.mercadopago.com.br/developers/pt/guides/payments/web-payment-checkout/introduction/) - Web Tokenize checkout: [Spanish](https://www.mercadopago.com.ar/developers/es/guides/payments/web-tokenize-checkout/introduction/) / [Portuguese](https://www.mercadopago.com.br/developers/pt/guides/payments/web-tokenize-checkout/introduction/) Check [our official code reference](https://www.mercadopago.com.br/developers/pt/docs/sdks-library/server-side) to explore all available functionalities. ## β€οΈ Support If you require technical support, please contact our support team at [developers.mercadopago.com](https://developers.mercadopago.com) ## π» License ``` MIT license. Copyright (c) 2018 - Mercado Pago / Mercado Libre For more information, see the LICENSE file. ``` home/fluxyjvi/public_html/project/vendor/doctrine/annotations/README.md 0000644 00000002773 15107350344 0022257 0 ustar 00 β οΈ PHP 8 introduced [attributes](https://www.php.net/manual/en/language.attributes.overview.php), which are a native replacement for annotations. As such, this library is considered feature complete, and should receive exclusively bugfixes and security fixes. # Doctrine Annotations [](https://github.com/doctrine/persistence/actions) [](https://www.versioneye.com/package/php--doctrine--annotations) [](https://www.versioneye.com/php/doctrine:annotations/references) [](https://packagist.org/packages/doctrine/annotations) [](https://packagist.org/packages/doctrine/annotations) Docblock Annotations Parser library (extracted from [Doctrine Common](https://github.com/doctrine/common)). ## Documentation See the [doctrine-project website](https://www.doctrine-project.org/projects/doctrine-annotations/en/latest/index.html). ## Contributing When making a pull request, make sure your changes follow the [Coding Standard Guidelines](https://www.doctrine-project.org/projects/doctrine-coding-standard/en/current/reference/index.html#introduction). home/fluxyjvi/public_html/project/vendor/doctrine/lexer/README.md 0000644 00000000557 15107350360 0021035 0 ustar 00 # Doctrine Lexer [](https://github.com/doctrine/lexer/actions) Base library for a lexer that can be used in Top-Down, Recursive Descent Parsers. This lexer is used in Doctrine Annotations and in Doctrine ORM (DQL). https://www.doctrine-project.org/projects/lexer.html home/fluxyjvi/public_html/project/vendor/psr/cache/README.md 0000644 00000001042 15107350741 0017747 0 ustar 00 Caching Interface ============== This repository holds all interfaces related to [PSR-6 (Caching Interface)][psr-url]. Note that this is not a Caching implementation of its own. It is merely interfaces that describe the components of a Caching mechanism. The installable [package][package-url] and [implementations][implementation-url] are listed on Packagist. [psr-url]: https://www.php-fig.org/psr/psr-6/ [package-url]: https://packagist.org/packages/psr/cache [implementation-url]: https://packagist.org/providers/psr/cache-implementation home/fluxyjvi/public_html/project/vendor/ramsey/uuid/README.md 0000644 00000010003 15107356715 0020352 0 ustar 00 <h1 align="center">ramsey/uuid</h1> <p align="center"> <strong>A PHP library for generating and working with UUIDs.</strong> </p> <p align="center"> <a href="https://github.com/ramsey/uuid"><img src="http://img.shields.io/badge/source-ramsey/uuid-blue.svg?style=flat-square" alt="Source Code"></a> <a href="https://packagist.org/packages/ramsey/uuid"><img src="https://img.shields.io/packagist/v/ramsey/uuid.svg?style=flat-square&label=release" alt="Download Package"></a> <a href="https://php.net"><img src="https://img.shields.io/packagist/php-v/ramsey/uuid.svg?style=flat-square&colorB=%238892BF" alt="PHP Programming Language"></a> <a href="https://github.com/ramsey/uuid/blob/4.x/LICENSE"><img src="https://img.shields.io/packagist/l/ramsey/uuid.svg?style=flat-square&colorB=darkcyan" alt="Read License"></a> <a href="https://github.com/ramsey/uuid/actions/workflows/continuous-integration.yml"><img src="https://img.shields.io/github/actions/workflow/status/ramsey/uuid/continuous-integration.yml?branch=4.x&logo=github&style=flat-square" alt="Build Status"></a> <a href="https://app.codecov.io/gh/ramsey/uuid/branch/4.x"><img src="https://img.shields.io/codecov/c/github/ramsey/uuid/4.x?label=codecov&logo=codecov&style=flat-square" alt="Codecov Code Coverage"></a> <a href="https://shepherd.dev/github/ramsey/uuid"><img src="https://img.shields.io/endpoint?style=flat-square&url=https%3A%2F%2Fshepherd.dev%2Fgithub%2Framsey%2Fuuid%2Fcoverage" alt="Psalm Type Coverage"></a> </p> ramsey/uuid is a PHP library for generating and working with universally unique identifiers (UUIDs). This project adheres to a [code of conduct](CODE_OF_CONDUCT.md). By participating in this project and its community, you are expected to uphold this code. Much inspiration for this library came from the [Java][javauuid] and [Python][pyuuid] UUID libraries. ## Installation The preferred method of installation is via [Composer][]. Run the following command to install the package and add it as a requirement to your project's `composer.json`: ```bash composer require ramsey/uuid ``` ## Upgrading to Version 4 See the documentation for a thorough upgrade guide: * [Upgrading ramsey/uuid Version 3 to 4](https://uuid.ramsey.dev/en/stable/upgrading/3-to-4.html) ## Documentation Please see <https://uuid.ramsey.dev> for documentation, tips, examples, and frequently asked questions. ## Contributing Contributions are welcome! To contribute, please familiarize yourself with [CONTRIBUTING.md](CONTRIBUTING.md). ## Coordinated Disclosure Keeping user information safe and secure is a top priority, and we welcome the contribution of external security researchers. If you believe you've found a security issue in software that is maintained in this repository, please read [SECURITY.md][] for instructions on submitting a vulnerability report. ## ramsey/uuid for Enterprise Available as part of the Tidelift Subscription. The maintainers of ramsey/uuid and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source packages you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-ramsey-uuid?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) ## Copyright and License The ramsey/uuid library is copyright Β© [Ben Ramsey](https://benramsey.com/) and licensed for use under the MIT License (MIT). Please see [LICENSE][] for more information. [rfc4122]: http://tools.ietf.org/html/rfc4122 [conduct]: https://github.com/ramsey/uuid/blob/4.x/CODE_OF_CONDUCT.md [javauuid]: http://docs.oracle.com/javase/6/docs/api/java/util/UUID.html [pyuuid]: http://docs.python.org/3/library/uuid.html [composer]: http://getcomposer.org/ [contributing.md]: https://github.com/ramsey/uuid/blob/4.x/CONTRIBUTING.md [security.md]: https://github.com/ramsey/uuid/blob/4.x/SECURITY.md [license]: https://github.com/ramsey/uuid/blob/4.x/LICENSE home/fluxyjvi/public_html/project/vendor/guzzlehttp/psr7/README.md 0000644 00000071104 15107364462 0021226 0 ustar 00 # PSR-7 Message Implementation This repository contains a full [PSR-7](https://www.php-fig.org/psr/psr-7/) message implementation, several stream decorators, and some helpful functionality like query string parsing.   ## Features This package comes with a number of stream implementations and stream decorators. ## Installation ```shell composer require guzzlehttp/psr7 ``` ## Version Guidance | Version | Status | PHP Version | |---------|---------------------|--------------| | 1.x | Security fixes only | >=5.4,<8.1 | | 2.x | Latest | >=7.2.5,<8.4 | ## AppendStream `GuzzleHttp\Psr7\AppendStream` Reads from multiple streams, one after the other. ```php use GuzzleHttp\Psr7; $a = Psr7\Utils::streamFor('abc, '); $b = Psr7\Utils::streamFor('123.'); $composed = new Psr7\AppendStream([$a, $b]); $composed->addStream(Psr7\Utils::streamFor(' Above all listen to me')); echo $composed; // abc, 123. Above all listen to me. ``` ## BufferStream `GuzzleHttp\Psr7\BufferStream` Provides a buffer stream that can be written to fill a buffer, and read from to remove bytes from the buffer. This stream returns a "hwm" metadata value that tells upstream consumers what the configured high water mark of the stream is, or the maximum preferred size of the buffer. ```php use GuzzleHttp\Psr7; // When more than 1024 bytes are in the buffer, it will begin returning // false to writes. This is an indication that writers should slow down. $buffer = new Psr7\BufferStream(1024); ``` ## CachingStream The CachingStream is used to allow seeking over previously read bytes on non-seekable streams. This can be useful when transferring a non-seekable entity body fails due to needing to rewind the stream (for example, resulting from a redirect). Data that is read from the remote stream will be buffered in a PHP temp stream so that previously read bytes are cached first in memory, then on disk. ```php use GuzzleHttp\Psr7; $original = Psr7\Utils::streamFor(fopen('http://www.google.com', 'r')); $stream = new Psr7\CachingStream($original); $stream->read(1024); echo $stream->tell(); // 1024 $stream->seek(0); echo $stream->tell(); // 0 ``` ## DroppingStream `GuzzleHttp\Psr7\DroppingStream` Stream decorator that begins dropping data once the size of the underlying stream becomes too full. ```php use GuzzleHttp\Psr7; // Create an empty stream $stream = Psr7\Utils::streamFor(); // Start dropping data when the stream has more than 10 bytes $dropping = new Psr7\DroppingStream($stream, 10); $dropping->write('01234567890123456789'); echo $stream; // 0123456789 ``` ## FnStream `GuzzleHttp\Psr7\FnStream` Compose stream implementations based on a hash of functions. Allows for easy testing and extension of a provided stream without needing to create a concrete class for a simple extension point. ```php use GuzzleHttp\Psr7; $stream = Psr7\Utils::streamFor('hi'); $fnStream = Psr7\FnStream::decorate($stream, [ 'rewind' => function () use ($stream) { echo 'About to rewind - '; $stream->rewind(); echo 'rewound!'; } ]); $fnStream->rewind(); // Outputs: About to rewind - rewound! ``` ## InflateStream `GuzzleHttp\Psr7\InflateStream` Uses PHP's zlib.inflate filter to inflate zlib (HTTP deflate, RFC1950) or gzipped (RFC1952) content. This stream decorator converts the provided stream to a PHP stream resource, then appends the zlib.inflate filter. The stream is then converted back to a Guzzle stream resource to be used as a Guzzle stream. ## LazyOpenStream `GuzzleHttp\Psr7\LazyOpenStream` Lazily reads or writes to a file that is opened only after an IO operation take place on the stream. ```php use GuzzleHttp\Psr7; $stream = new Psr7\LazyOpenStream('/path/to/file', 'r'); // The file has not yet been opened... echo $stream->read(10); // The file is opened and read from only when needed. ``` ## LimitStream `GuzzleHttp\Psr7\LimitStream` LimitStream can be used to read a subset or slice of an existing stream object. This can be useful for breaking a large file into smaller pieces to be sent in chunks (e.g. Amazon S3's multipart upload API). ```php use GuzzleHttp\Psr7; $original = Psr7\Utils::streamFor(fopen('/tmp/test.txt', 'r+')); echo $original->getSize(); // >>> 1048576 // Limit the size of the body to 1024 bytes and start reading from byte 2048 $stream = new Psr7\LimitStream($original, 1024, 2048); echo $stream->getSize(); // >>> 1024 echo $stream->tell(); // >>> 0 ``` ## MultipartStream `GuzzleHttp\Psr7\MultipartStream` Stream that when read returns bytes for a streaming multipart or multipart/form-data stream. ## NoSeekStream `GuzzleHttp\Psr7\NoSeekStream` NoSeekStream wraps a stream and does not allow seeking. ```php use GuzzleHttp\Psr7; $original = Psr7\Utils::streamFor('foo'); $noSeek = new Psr7\NoSeekStream($original); echo $noSeek->read(3); // foo var_export($noSeek->isSeekable()); // false $noSeek->seek(0); var_export($noSeek->read(3)); // NULL ``` ## PumpStream `GuzzleHttp\Psr7\PumpStream` Provides a read only stream that pumps data from a PHP callable. When invoking the provided callable, the PumpStream will pass the amount of data requested to read to the callable. The callable can choose to ignore this value and return fewer or more bytes than requested. Any extra data returned by the provided callable is buffered internally until drained using the read() function of the PumpStream. The provided callable MUST return false when there is no more data to read. ## Implementing stream decorators Creating a stream decorator is very easy thanks to the `GuzzleHttp\Psr7\StreamDecoratorTrait`. This trait provides methods that implement `Psr\Http\Message\StreamInterface` by proxying to an underlying stream. Just `use` the `StreamDecoratorTrait` and implement your custom methods. For example, let's say we wanted to call a specific function each time the last byte is read from a stream. This could be implemented by overriding the `read()` method. ```php use Psr\Http\Message\StreamInterface; use GuzzleHttp\Psr7\StreamDecoratorTrait; class EofCallbackStream implements StreamInterface { use StreamDecoratorTrait; private $callback; private $stream; public function __construct(StreamInterface $stream, callable $cb) { $this->stream = $stream; $this->callback = $cb; } public function read($length) { $result = $this->stream->read($length); // Invoke the callback when EOF is hit. if ($this->eof()) { call_user_func($this->callback); } return $result; } } ``` This decorator could be added to any existing stream and used like so: ```php use GuzzleHttp\Psr7; $original = Psr7\Utils::streamFor('foo'); $eofStream = new EofCallbackStream($original, function () { echo 'EOF!'; }); $eofStream->read(2); $eofStream->read(1); // echoes "EOF!" $eofStream->seek(0); $eofStream->read(3); // echoes "EOF!" ``` ## PHP StreamWrapper You can use the `GuzzleHttp\Psr7\StreamWrapper` class if you need to use a PSR-7 stream as a PHP stream resource. Use the `GuzzleHttp\Psr7\StreamWrapper::getResource()` method to create a PHP stream from a PSR-7 stream. ```php use GuzzleHttp\Psr7\StreamWrapper; $stream = GuzzleHttp\Psr7\Utils::streamFor('hello!'); $resource = StreamWrapper::getResource($stream); echo fread($resource, 6); // outputs hello! ``` # Static API There are various static methods available under the `GuzzleHttp\Psr7` namespace. ## `GuzzleHttp\Psr7\Message::toString` `public static function toString(MessageInterface $message): string` Returns the string representation of an HTTP message. ```php $request = new GuzzleHttp\Psr7\Request('GET', 'http://example.com'); echo GuzzleHttp\Psr7\Message::toString($request); ``` ## `GuzzleHttp\Psr7\Message::bodySummary` `public static function bodySummary(MessageInterface $message, int $truncateAt = 120): string|null` Get a short summary of the message body. Will return `null` if the response is not printable. ## `GuzzleHttp\Psr7\Message::rewindBody` `public static function rewindBody(MessageInterface $message): void` Attempts to rewind a message body and throws an exception on failure. The body of the message will only be rewound if a call to `tell()` returns a value other than `0`. ## `GuzzleHttp\Psr7\Message::parseMessage` `public static function parseMessage(string $message): array` Parses an HTTP message into an associative array. The array contains the "start-line" key containing the start line of the message, "headers" key containing an associative array of header array values, and a "body" key containing the body of the message. ## `GuzzleHttp\Psr7\Message::parseRequestUri` `public static function parseRequestUri(string $path, array $headers): string` Constructs a URI for an HTTP request message. ## `GuzzleHttp\Psr7\Message::parseRequest` `public static function parseRequest(string $message): Request` Parses a request message string into a request object. ## `GuzzleHttp\Psr7\Message::parseResponse` `public static function parseResponse(string $message): Response` Parses a response message string into a response object. ## `GuzzleHttp\Psr7\Header::parse` `public static function parse(string|array $header): array` Parse an array of header values containing ";" separated data into an array of associative arrays representing the header key value pair data of the header. When a parameter does not contain a value, but just contains a key, this function will inject a key with a '' string value. ## `GuzzleHttp\Psr7\Header::splitList` `public static function splitList(string|string[] $header): string[]` Splits a HTTP header defined to contain a comma-separated list into each individual value: ``` $knownEtags = Header::splitList($request->getHeader('if-none-match')); ``` Example headers include `accept`, `cache-control` and `if-none-match`. ## `GuzzleHttp\Psr7\Header::normalize` (deprecated) `public static function normalize(string|array $header): array` `Header::normalize()` is deprecated in favor of [`Header::splitList()`](README.md#guzzlehttppsr7headersplitlist) which performs the same operation with a cleaned up API and improved documentation. Converts an array of header values that may contain comma separated headers into an array of headers with no comma separated values. ## `GuzzleHttp\Psr7\Query::parse` `public static function parse(string $str, int|bool $urlEncoding = true): array` Parse a query string into an associative array. If multiple values are found for the same key, the value of that key value pair will become an array. This function does not parse nested PHP style arrays into an associative array (e.g., `foo[a]=1&foo[b]=2` will be parsed into `['foo[a]' => '1', 'foo[b]' => '2'])`. ## `GuzzleHttp\Psr7\Query::build` `public static function build(array $params, int|false $encoding = PHP_QUERY_RFC3986): string` Build a query string from an array of key value pairs. This function can use the return value of `parse()` to build a query string. This function does not modify the provided keys when an array is encountered (like `http_build_query()` would). ## `GuzzleHttp\Psr7\Utils::caselessRemove` `public static function caselessRemove(iterable<string> $keys, $keys, array $data): array` Remove the items given by the keys, case insensitively from the data. ## `GuzzleHttp\Psr7\Utils::copyToStream` `public static function copyToStream(StreamInterface $source, StreamInterface $dest, int $maxLen = -1): void` Copy the contents of a stream into another stream until the given number of bytes have been read. ## `GuzzleHttp\Psr7\Utils::copyToString` `public static function copyToString(StreamInterface $stream, int $maxLen = -1): string` Copy the contents of a stream into a string until the given number of bytes have been read. ## `GuzzleHttp\Psr7\Utils::hash` `public static function hash(StreamInterface $stream, string $algo, bool $rawOutput = false): string` Calculate a hash of a stream. This method reads the entire stream to calculate a rolling hash, based on PHP's `hash_init` functions. ## `GuzzleHttp\Psr7\Utils::modifyRequest` `public static function modifyRequest(RequestInterface $request, array $changes): RequestInterface` Clone and modify a request with the given changes. This method is useful for reducing the number of clones needed to mutate a message. - method: (string) Changes the HTTP method. - set_headers: (array) Sets the given headers. - remove_headers: (array) Remove the given headers. - body: (mixed) Sets the given body. - uri: (UriInterface) Set the URI. - query: (string) Set the query string value of the URI. - version: (string) Set the protocol version. ## `GuzzleHttp\Psr7\Utils::readLine` `public static function readLine(StreamInterface $stream, int $maxLength = null): string` Read a line from the stream up to the maximum allowed buffer length. ## `GuzzleHttp\Psr7\Utils::streamFor` `public static function streamFor(resource|string|null|int|float|bool|StreamInterface|callable|\Iterator $resource = '', array $options = []): StreamInterface` Create a new stream based on the input type. Options is an associative array that can contain the following keys: - metadata: Array of custom metadata. - size: Size of the stream. This method accepts the following `$resource` types: - `Psr\Http\Message\StreamInterface`: Returns the value as-is. - `string`: Creates a stream object that uses the given string as the contents. - `resource`: Creates a stream object that wraps the given PHP stream resource. - `Iterator`: If the provided value implements `Iterator`, then a read-only stream object will be created that wraps the given iterable. Each time the stream is read from, data from the iterator will fill a buffer and will be continuously called until the buffer is equal to the requested read size. Subsequent read calls will first read from the buffer and then call `next` on the underlying iterator until it is exhausted. - `object` with `__toString()`: If the object has the `__toString()` method, the object will be cast to a string and then a stream will be returned that uses the string value. - `NULL`: When `null` is passed, an empty stream object is returned. - `callable` When a callable is passed, a read-only stream object will be created that invokes the given callable. The callable is invoked with the number of suggested bytes to read. The callable can return any number of bytes, but MUST return `false` when there is no more data to return. The stream object that wraps the callable will invoke the callable until the number of requested bytes are available. Any additional bytes will be buffered and used in subsequent reads. ```php $stream = GuzzleHttp\Psr7\Utils::streamFor('foo'); $stream = GuzzleHttp\Psr7\Utils::streamFor(fopen('/path/to/file', 'r')); $generator = function ($bytes) { for ($i = 0; $i < $bytes; $i++) { yield ' '; } } $stream = GuzzleHttp\Psr7\Utils::streamFor($generator(100)); ``` ## `GuzzleHttp\Psr7\Utils::tryFopen` `public static function tryFopen(string $filename, string $mode): resource` Safely opens a PHP stream resource using a filename. When fopen fails, PHP normally raises a warning. This function adds an error handler that checks for errors and throws an exception instead. ## `GuzzleHttp\Psr7\Utils::tryGetContents` `public static function tryGetContents(resource $stream): string` Safely gets the contents of a given stream. When stream_get_contents fails, PHP normally raises a warning. This function adds an error handler that checks for errors and throws an exception instead. ## `GuzzleHttp\Psr7\Utils::uriFor` `public static function uriFor(string|UriInterface $uri): UriInterface` Returns a UriInterface for the given value. This function accepts a string or UriInterface and returns a UriInterface for the given value. If the value is already a UriInterface, it is returned as-is. ## `GuzzleHttp\Psr7\MimeType::fromFilename` `public static function fromFilename(string $filename): string|null` Determines the mimetype of a file by looking at its extension. ## `GuzzleHttp\Psr7\MimeType::fromExtension` `public static function fromExtension(string $extension): string|null` Maps a file extensions to a mimetype. ## Upgrading from Function API The static API was first introduced in 1.7.0, in order to mitigate problems with functions conflicting between global and local copies of the package. The function API was removed in 2.0.0. A migration table has been provided here for your convenience: | Original Function | Replacement Method | |----------------|----------------| | `str` | `Message::toString` | | `uri_for` | `Utils::uriFor` | | `stream_for` | `Utils::streamFor` | | `parse_header` | `Header::parse` | | `normalize_header` | `Header::normalize` | | `modify_request` | `Utils::modifyRequest` | | `rewind_body` | `Message::rewindBody` | | `try_fopen` | `Utils::tryFopen` | | `copy_to_string` | `Utils::copyToString` | | `copy_to_stream` | `Utils::copyToStream` | | `hash` | `Utils::hash` | | `readline` | `Utils::readLine` | | `parse_request` | `Message::parseRequest` | | `parse_response` | `Message::parseResponse` | | `parse_query` | `Query::parse` | | `build_query` | `Query::build` | | `mimetype_from_filename` | `MimeType::fromFilename` | | `mimetype_from_extension` | `MimeType::fromExtension` | | `_parse_message` | `Message::parseMessage` | | `_parse_request_uri` | `Message::parseRequestUri` | | `get_message_body_summary` | `Message::bodySummary` | | `_caseless_remove` | `Utils::caselessRemove` | # Additional URI Methods Aside from the standard `Psr\Http\Message\UriInterface` implementation in form of the `GuzzleHttp\Psr7\Uri` class, this library also provides additional functionality when working with URIs as static methods. ## URI Types An instance of `Psr\Http\Message\UriInterface` can either be an absolute URI or a relative reference. An absolute URI has a scheme. A relative reference is used to express a URI relative to another URI, the base URI. Relative references can be divided into several forms according to [RFC 3986 Section 4.2](https://tools.ietf.org/html/rfc3986#section-4.2): - network-path references, e.g. `//example.com/path` - absolute-path references, e.g. `/path` - relative-path references, e.g. `subpath` The following methods can be used to identify the type of the URI. ### `GuzzleHttp\Psr7\Uri::isAbsolute` `public static function isAbsolute(UriInterface $uri): bool` Whether the URI is absolute, i.e. it has a scheme. ### `GuzzleHttp\Psr7\Uri::isNetworkPathReference` `public static function isNetworkPathReference(UriInterface $uri): bool` Whether the URI is a network-path reference. A relative reference that begins with two slash characters is termed an network-path reference. ### `GuzzleHttp\Psr7\Uri::isAbsolutePathReference` `public static function isAbsolutePathReference(UriInterface $uri): bool` Whether the URI is a absolute-path reference. A relative reference that begins with a single slash character is termed an absolute-path reference. ### `GuzzleHttp\Psr7\Uri::isRelativePathReference` `public static function isRelativePathReference(UriInterface $uri): bool` Whether the URI is a relative-path reference. A relative reference that does not begin with a slash character is termed a relative-path reference. ### `GuzzleHttp\Psr7\Uri::isSameDocumentReference` `public static function isSameDocumentReference(UriInterface $uri, UriInterface $base = null): bool` Whether the URI is a same-document reference. A same-document reference refers to a URI that is, aside from its fragment component, identical to the base URI. When no base URI is given, only an empty URI reference (apart from its fragment) is considered a same-document reference. ## URI Components Additional methods to work with URI components. ### `GuzzleHttp\Psr7\Uri::isDefaultPort` `public static function isDefaultPort(UriInterface $uri): bool` Whether the URI has the default port of the current scheme. `Psr\Http\Message\UriInterface::getPort` may return null or the standard port. This method can be used independently of the implementation. ### `GuzzleHttp\Psr7\Uri::composeComponents` `public static function composeComponents($scheme, $authority, $path, $query, $fragment): string` Composes a URI reference string from its various components according to [RFC 3986 Section 5.3](https://tools.ietf.org/html/rfc3986#section-5.3). Usually this method does not need to be called manually but instead is used indirectly via `Psr\Http\Message\UriInterface::__toString`. ### `GuzzleHttp\Psr7\Uri::fromParts` `public static function fromParts(array $parts): UriInterface` Creates a URI from a hash of [`parse_url`](https://www.php.net/manual/en/function.parse-url.php) components. ### `GuzzleHttp\Psr7\Uri::withQueryValue` `public static function withQueryValue(UriInterface $uri, $key, $value): UriInterface` Creates a new URI with a specific query string value. Any existing query string values that exactly match the provided key are removed and replaced with the given key value pair. A value of null will set the query string key without a value, e.g. "key" instead of "key=value". ### `GuzzleHttp\Psr7\Uri::withQueryValues` `public static function withQueryValues(UriInterface $uri, array $keyValueArray): UriInterface` Creates a new URI with multiple query string values. It has the same behavior as `withQueryValue()` but for an associative array of key => value. ### `GuzzleHttp\Psr7\Uri::withoutQueryValue` `public static function withoutQueryValue(UriInterface $uri, $key): UriInterface` Creates a new URI with a specific query string value removed. Any existing query string values that exactly match the provided key are removed. ## Cross-Origin Detection `GuzzleHttp\Psr7\UriComparator` provides methods to determine if a modified URL should be considered cross-origin. ### `GuzzleHttp\Psr7\UriComparator::isCrossOrigin` `public static function isCrossOrigin(UriInterface $original, UriInterface $modified): bool` Determines if a modified URL should be considered cross-origin with respect to an original URL. ## Reference Resolution `GuzzleHttp\Psr7\UriResolver` provides methods to resolve a URI reference in the context of a base URI according to [RFC 3986 Section 5](https://tools.ietf.org/html/rfc3986#section-5). This is for example also what web browsers do when resolving a link in a website based on the current request URI. ### `GuzzleHttp\Psr7\UriResolver::resolve` `public static function resolve(UriInterface $base, UriInterface $rel): UriInterface` Converts the relative URI into a new URI that is resolved against the base URI. ### `GuzzleHttp\Psr7\UriResolver::removeDotSegments` `public static function removeDotSegments(string $path): string` Removes dot segments from a path and returns the new path according to [RFC 3986 Section 5.2.4](https://tools.ietf.org/html/rfc3986#section-5.2.4). ### `GuzzleHttp\Psr7\UriResolver::relativize` `public static function relativize(UriInterface $base, UriInterface $target): UriInterface` Returns the target URI as a relative reference from the base URI. This method is the counterpart to resolve(): ```php (string) $target === (string) UriResolver::resolve($base, UriResolver::relativize($base, $target)) ``` One use-case is to use the current request URI as base URI and then generate relative links in your documents to reduce the document size or offer self-contained downloadable document archives. ```php $base = new Uri('http://example.com/a/b/'); echo UriResolver::relativize($base, new Uri('http://example.com/a/b/c')); // prints 'c'. echo UriResolver::relativize($base, new Uri('http://example.com/a/x/y')); // prints '../x/y'. echo UriResolver::relativize($base, new Uri('http://example.com/a/b/?q')); // prints '?q'. echo UriResolver::relativize($base, new Uri('http://example.org/a/b/')); // prints '//example.org/a/b/'. ``` ## Normalization and Comparison `GuzzleHttp\Psr7\UriNormalizer` provides methods to normalize and compare URIs according to [RFC 3986 Section 6](https://tools.ietf.org/html/rfc3986#section-6). ### `GuzzleHttp\Psr7\UriNormalizer::normalize` `public static function normalize(UriInterface $uri, $flags = self::PRESERVING_NORMALIZATIONS): UriInterface` Returns a normalized URI. The scheme and host component are already normalized to lowercase per PSR-7 UriInterface. This methods adds additional normalizations that can be configured with the `$flags` parameter which is a bitmask of normalizations to apply. The following normalizations are available: - `UriNormalizer::PRESERVING_NORMALIZATIONS` Default normalizations which only include the ones that preserve semantics. - `UriNormalizer::CAPITALIZE_PERCENT_ENCODING` All letters within a percent-encoding triplet (e.g., "%3A") are case-insensitive, and should be capitalized. Example: `http://example.org/a%c2%b1b` β `http://example.org/a%C2%B1b` - `UriNormalizer::DECODE_UNRESERVED_CHARACTERS` Decodes percent-encoded octets of unreserved characters. For consistency, percent-encoded octets in the ranges of ALPHA (%41β%5A and %61β%7A), DIGIT (%30β%39), hyphen (%2D), period (%2E), underscore (%5F), or tilde (%7E) should not be created by URI producers and, when found in a URI, should be decoded to their corresponding unreserved characters by URI normalizers. Example: `http://example.org/%7Eusern%61me/` β `http://example.org/~username/` - `UriNormalizer::CONVERT_EMPTY_PATH` Converts the empty path to "/" for http and https URIs. Example: `http://example.org` β `http://example.org/` - `UriNormalizer::REMOVE_DEFAULT_HOST` Removes the default host of the given URI scheme from the URI. Only the "file" scheme defines the default host "localhost". All of `file:/myfile`, `file:///myfile`, and `file://localhost/myfile` are equivalent according to RFC 3986. Example: `file://localhost/myfile` β `file:///myfile` - `UriNormalizer::REMOVE_DEFAULT_PORT` Removes the default port of the given URI scheme from the URI. Example: `http://example.org:80/` β `http://example.org/` - `UriNormalizer::REMOVE_DOT_SEGMENTS` Removes unnecessary dot-segments. Dot-segments in relative-path references are not removed as it would change the semantics of the URI reference. Example: `http://example.org/../a/b/../c/./d.html` β `http://example.org/a/c/d.html` - `UriNormalizer::REMOVE_DUPLICATE_SLASHES` Paths which include two or more adjacent slashes are converted to one. Webservers usually ignore duplicate slashes and treat those URIs equivalent. But in theory those URIs do not need to be equivalent. So this normalization may change the semantics. Encoded slashes (%2F) are not removed. Example: `http://example.org//foo///bar.html` β `http://example.org/foo/bar.html` - `UriNormalizer::SORT_QUERY_PARAMETERS` Sort query parameters with their values in alphabetical order. However, the order of parameters in a URI may be significant (this is not defined by the standard). So this normalization is not safe and may change the semantics of the URI. Example: `?lang=en&article=fred` β `?article=fred&lang=en` ### `GuzzleHttp\Psr7\UriNormalizer::isEquivalent` `public static function isEquivalent(UriInterface $uri1, UriInterface $uri2, $normalizations = self::PRESERVING_NORMALIZATIONS): bool` Whether two URIs can be considered equivalent. Both URIs are normalized automatically before comparison with the given `$normalizations` bitmask. The method also accepts relative URI references and returns true when they are equivalent. This of course assumes they will be resolved against the same base URI. If this is not the case, determination of equivalence or difference of relative references does not mean anything. ## Security If you discover a security vulnerability within this package, please send an email to security@tidelift.com. All security vulnerabilities will be promptly addressed. Please do not disclose security-related issues publicly until a fix has been announced. Please see [Security Policy](https://github.com/guzzle/psr7/security/policy) for more information. ## License Guzzle is made available under the MIT License (MIT). Please see [License File](LICENSE) for more information. ## For Enterprise Available as part of the Tidelift Subscription The maintainers of Guzzle and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-guzzlehttp-psr7?utm_source=packagist-guzzlehttp-psr7&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) home/fluxyjvi/public_html/project/vendor/psr/clock/README.md 0000644 00000002744 15107366716 0020022 0 ustar 00 # PSR Clock This repository holds the interface for [PSR-20][psr-url]. Note that this is not a clock of its own. It is merely an interface that describes a clock. See the specification for more details. ## Installation ```bash composer require psr/clock ``` ## Usage If you need a clock, you can use the interface like this: ```php <?php use Psr\Clock\ClockInterface; class Foo { private ClockInterface $clock; public function __construct(ClockInterface $clock) { $this->clock = $clock; } public function doSomething() { /** @var DateTimeImmutable $currentDateAndTime */ $currentDateAndTime = $this->clock->now(); // do something useful with that information } } ``` You can then pick one of the [implementations][implementation-url] of the interface to get a clock. If you want to implement the interface, you can require this package and implement `Psr\Clock\ClockInterface` in your code. Don't forget to add `psr/clock-implementation` to your `composer.json`s `provides`-section like this: ```json { "provides": { "psr/clock-implementation": "1.0" } } ``` And please read the [specification text][specification-url] for details on the interface. [psr-url]: https://www.php-fig.org/psr/psr-20 [package-url]: https://packagist.org/packages/psr/clock [implementation-url]: https://packagist.org/providers/psr/clock-implementation [specification-url]: https://github.com/php-fig/fig-standards/blob/master/proposed/clock.md home/fluxyjvi/public_html/project/vendor/mockery/mockery/docs/README.md 0000644 00000000124 15107373323 0022153 0 ustar 00 mockery-docs ============ Document for the PHP Mockery framework on readthedocs.org home/fluxyjvi/public_html/project/vendor/league/commonmark/README.md 0000644 00000027654 15107402435 0021524 0 ustar 00 # league/commonmark [](https://packagist.org/packages/league/commonmark) [](https://packagist.org/packages/league/commonmark) [](LICENSE) [](https://github.com/thephpleague/commonmark/actions?query=workflow%3ATests+branch%3Amain) [](https://scrutinizer-ci.com/g/thephpleague/commonmark/code-structure) [](https://scrutinizer-ci.com/g/thephpleague/commonmark) [](https://shepherd.dev/github/thephpleague/commonmark) [](https://bestpractices.coreinfrastructure.org/projects/126) [](https://www.colinodell.com/sponsor)  **league/commonmark** is a highly-extensible PHP Markdown parser created by [Colin O'Dell][@colinodell] which supports the full [CommonMark] spec and [GitHub-Flavored Markdown]. It is based on the [CommonMark JS reference implementation][commonmark.js] by [John MacFarlane] \([@jgm]\). ## π¦ Installation & Basic Usage This project requires PHP 7.4 or higher with the `mbstring` extension. To install it via [Composer] simply run: ``` bash $ composer require league/commonmark ``` The `CommonMarkConverter` class provides a simple wrapper for converting CommonMark to HTML: ```php use League\CommonMark\CommonMarkConverter; $converter = new CommonMarkConverter([ 'html_input' => 'strip', 'allow_unsafe_links' => false, ]); echo $converter->convert('# Hello World!'); // <h1>Hello World!</h1> ``` Or if you want GitHub-Flavored Markdown, use the `GithubFlavoredMarkdownConverter` class instead: ```php use League\CommonMark\GithubFlavoredMarkdownConverter; $converter = new GithubFlavoredMarkdownConverter([ 'html_input' => 'strip', 'allow_unsafe_links' => false, ]); echo $converter->convert('# Hello World!'); // <h1>Hello World!</h1> ``` Please note that only UTF-8 and ASCII encodings are supported. If your Markdown uses a different encoding please convert it to UTF-8 before running it through this library. π If you will be parsing untrusted input from users, please consider setting the `html_input` and `allow_unsafe_links` options per the example above. See <https://commonmark.thephpleague.com/security/> for more details. If you also do choose to allow raw HTML input from untrusted users, consider using a library (like [HTML Purifier](https://github.com/ezyang/htmlpurifier)) to provide additional HTML filtering. ## π Documentation Full documentation on advanced usage, configuration, and customization can be found at [commonmark.thephpleague.com][docs]. ## β« Upgrading Information on how to upgrade to newer versions of this library can be found at <https://commonmark.thephpleague.com/releases>. ## π» GitHub-Flavored Markdown The `GithubFlavoredMarkdownConverter` shown earlier is a drop-in replacement for the `CommonMarkConverter` which adds additional features found in the GFM spec: - Autolinks - Disallowed raw HTML - Strikethrough - Tables - Task Lists See the [Extensions documentation](https://commonmark.thephpleague.com/customization/extensions/) for more details on how to include only certain GFM features if you don't want them all. ## ποΈ Related Packages ### Integrations - [CakePHP 3](https://github.com/gourmet/common-mark) - [Drupal](https://www.drupal.org/project/markdown) - [Laravel 4+](https://github.com/GrahamCampbell/Laravel-Markdown) - [Sculpin](https://github.com/bcremer/sculpin-commonmark-bundle) - [Symfony 2 & 3](https://github.com/webuni/commonmark-bundle) - [Symfony 4](https://github.com/avensome/commonmark-bundle) - [Twig Markdown extension](https://github.com/twigphp/markdown-extension) - [Twig filter and tag](https://github.com/aptoma/twig-markdown) - [Laravel CommonMark Blog](https://github.com/spekulatius/laravel-commonmark-blog) ### Included Extensions See [our extension documentation](https://commonmark.thephpleague.com/extensions/overview) for a full list of extensions bundled with this library. ### Community Extensions Custom parsers/renderers can be bundled into extensions which extend CommonMark. Here are some that you may find interesting: - [Alt Three Emoji](https://github.com/AltThree/Emoji) An emoji parser for CommonMark. - [Sup Sub extensions](https://github.com/OWS/commonmark-sup-sub-extensions) - Adds support of superscript and subscript (`<sup>` and `<sub>` HTML tags) - [YouTube iframe extension](https://github.com/zoonru/commonmark-ext-youtube-iframe) - Replaces youtube link with iframe. - [Lazy Image extension](https://github.com/simonvomeyser/commonmark-ext-lazy-image) - Adds various options for lazy loading of images. - [Marker Extension](https://github.com/noah1400/commonmark-marker-extension) - Adds support of highlighted text (`<mark>` HTML tag) Others can be found on [Packagist under the `commonmark-extension` package type](https://packagist.org/packages/league/commonmark?type=commonmark-extension). If you build your own, feel free to submit a PR to add it to this list! ### Others Check out the other cool things people are doing with `league/commonmark`: <https://packagist.org/packages/league/commonmark/dependents> ## π·οΈ Versioning [SemVer](http://semver.org/) is followed closely. Minor and patch releases should not introduce breaking changes to the codebase; however, they might change the resulting AST or HTML output of parsed Markdown (due to bug fixes, spec changes, etc.) As a result, you might get slightly different HTML, but any custom code built onto this library should still function correctly. Any classes or methods marked `@internal` are not intended for use outside of this library and are subject to breaking changes at any time, so please avoid using them. ## π οΈ Maintenance & Support When a new **minor** version (e.g. `2.0` -> `2.1`) is released, the previous one (`2.0`) will continue to receive security and critical bug fixes for *at least* 3 months. When a new **major** version is released (e.g. `1.6` -> `2.0`), the previous one (`1.6`) will receive critical bug fixes for *at least* 3 months and security updates for 6 months after that new release comes out. (This policy may change in the future and exceptions may be made on a case-by-case basis.) **Professional support, including notification of new releases and security updates, is available through a [Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme).** ## π·ββοΈ Contributing To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure with us. If you encounter a bug in the spec, please report it to the [CommonMark] project. Any resulting fix will eventually be implemented in this project as well. Contributions to this library are **welcome**, especially ones that: * Improve usability or flexibility without compromising our ability to adhere to the [CommonMark spec] * Mirror fixes made to the [reference implementation][commonmark.js] * Optimize performance * Fix issues with adhering to the [CommonMark spec] Major refactoring to core parsing logic should be avoided if possible so that we can easily follow updates made to [the reference implementation][commonmark.js]. That being said, we will absolutely consider changes which don't deviate too far from the reference spec or which are favored by other popular CommonMark implementations. Please see [CONTRIBUTING](https://github.com/thephpleague/commonmark/blob/main/.github/CONTRIBUTING.md) for additional details. ## π§ͺ Testing ``` bash $ composer test ``` This will also test league/commonmark against the latest supported spec. ## π Performance Benchmarks You can compare the performance of **league/commonmark** to other popular parsers by running the included benchmark tool: ``` bash $ ./tests/benchmark/benchmark.php ``` ## π₯ Credits & Acknowledgements - [Colin O'Dell][@colinodell] - [John MacFarlane][@jgm] - [All Contributors] This code is partially based on the [CommonMark JS reference implementation][commonmark.js] which is written, maintained and copyrighted by [John MacFarlane]. This project simply wouldn't exist without his work. ### Sponsors We'd also like to extend our sincere thanks the following sponsors who support ongoing development of this project: - [Tidelift](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme) for offering support to both the maintainers and end-users through their [professional support](https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme) program - [Blackfire](https://www.blackfire.io/) for providing an Open-Source Profiler subscription - [JetBrains](https://www.jetbrains.com/) for supporting this project with complimentary [PhpStorm](https://www.jetbrains.com/phpstorm/) licenses - [Taylor Otwell](https://twitter.com/taylorotwell) for sponsoring this project through GitHub sponsors Are you interested in sponsoring development of this project? See <https://www.colinodell.com/sponsor> for a list of ways to contribute. ## π License **league/commonmark** is licensed under the BSD-3 license. See the [`LICENSE`](LICENSE) file for more details. ## ποΈ Governance This project is primarily maintained by [Colin O'Dell][@colinodell]. Members of the [PHP League] Leadership Team may occasionally assist with some of these duties. ## πΊοΈ Who Uses It? This project is used by [Drupal](https://www.drupal.org/project/markdown), [Laravel Framework](https://laravel.com/), [Cachet](https://cachethq.io/), [Firefly III](https://firefly-iii.org/), [Neos](https://www.neos.io/), [Daux.io](https://daux.io/), and [more](https://packagist.org/packages/league/commonmark/dependents)! --- <div align="center"> <b> <a href="https://tidelift.com/subscription/pkg/packagist-league-commonmark?utm_source=packagist-league-commonmark&utm_medium=referral&utm_campaign=readme">Get professional support for league/commonmark with a Tidelift subscription</a> </b> <br> <sub> Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies. </sub> </div> [CommonMark]: http://commonmark.org/ [CommonMark spec]: http://spec.commonmark.org/ [commonmark.js]: https://github.com/jgm/commonmark.js [GitHub-Flavored Markdown]: https://github.github.com/gfm/ [John MacFarlane]: http://johnmacfarlane.net [docs]: https://commonmark.thephpleague.com/ [docs-examples]: https://commonmark.thephpleague.com/customization/overview/#examples [docs-example-twitter]: https://commonmark.thephpleague.com/customization/inline-parsing#example-1---twitter-handles [docs-example-smilies]: https://commonmark.thephpleague.com/customization/inline-parsing#example-2---emoticons [All Contributors]: https://github.com/thephpleague/commonmark/contributors [@colinodell]: https://www.twitter.com/colinodell [@jgm]: https://github.com/jgm [jgm/stmd]: https://github.com/jgm/stmd [Composer]: https://getcomposer.org/ [PHP League]: https://thephpleague.com home/fluxyjvi/public_html/project/vendor/moneyphp/money/README.md 0000644 00000007171 15107413626 0021101 0 ustar 00 # Money [](https://github.com/moneyphp/money/releases)  [](https://packagist.org/packages/moneyphp/money) [](mailto:team@moneyphp.org)  PHP library to make working with money safer, easier, and fun! > "If I had a dime for every time I've seen someone use FLOAT to store currency, I'd have $999.997634" -- [Bill Karwin](https://twitter.com/billkarwin/status/347561901460447232) In short: You shouldn't represent monetary values by a float. Wherever you need to represent money, use this Money value object. Since version 3.0 this library uses [strings internally](https://github.com/moneyphp/money/pull/136) in order to support unlimited integers. ```php <?php use Money\Money; $fiveEur = Money::EUR(500); $tenEur = $fiveEur->add($fiveEur); list($part1, $part2, $part3) = $tenEur->allocate([1, 1, 1]); assert($part1->equals(Money::EUR(334))); assert($part2->equals(Money::EUR(333))); assert($part3->equals(Money::EUR(333))); ``` The documentation is available at http://moneyphp.org ## Requirements This library requires the [BCMath PHP extension](https://www.php.net/manual/en/book.bc.php). There might be additional dependencies for specific feature, e.g. the Swap exchange implementation, check the documentation for more information. Version 4 requires PHP 8.0. For older version of PHP, use version 3 of this library. ## Install Via Composer ```bash $ composer require moneyphp/money ``` ## Features - JSON Serialization - Big integer support utilizing different, transparent calculation logic upon availability (bcmath, gmp, plain php) - Money formatting (including intl formatter) - Currency repositories (ISO currencies included) - Money exchange (including [Swap](http://swap.voutzinos.org) implementation) ## Documentation Please see the [official documentation](http://moneyphp.org). ## Testing We try to follow BDD and TDD, as such we use both [phpspec](http://www.phpspec.net) and [phpunit](https://phpunit.de) to test this library. ```bash $ composer test ``` ### Running the tests in Docker Money requires a set of dependencies, so you might want to run it in Docker. First, build the image locally: ```bash $ docker build -t moneyphp . ``` Then run the tests: ```bash $ docker run --rm -it -v $PWD:/app -w /app moneyphp vendor/bin/phpunit --exclude-group segmentation ``` ## Contributing We would love to see you helping us to make this library better and better. Please keep in mind we do not use suffixes and prefixes in class names, so not `CurrenciesInterface`, but `Currencies`. Other than that, Style CI will help you using the same code style as we are using. Please provide tests when creating a PR and clear descriptions of bugs when filing issues. ## Security If you discover any security related issues, please contact us at [team@moneyphp.org](mailto:team@moneyphp.org). ## License The MIT License (MIT). Please see [License File](LICENSE) for more information. ## Acknowledgements This library is heavily inspired by [Martin Fowler's Money pattern](http://martinfowler.com/eaaCatalog/money.html). A special remark goes to [Mathias Verraes](https://github.com/mathiasverraes), without his contributions, in code and via his [blog](http://verraes.net/#blog), this library would not be where it stands now. home/fluxyjvi/public_html/project/vendor/sebastian/cli-parser/README.md 0000644 00000002053 15107413737 0022122 0 ustar 00 [](https://packagist.org/packages/sebastian/cli-parser) [](https://github.com/sebastianbergmann/cli-parser/actions) [](https://shepherd.dev/github/sebastianbergmann/cli-parser) [](https://codecov.io/gh/sebastianbergmann/cli-parser) # sebastian/cli-parser Library for parsing `$_SERVER['argv']`, extracted from `phpunit/phpunit`. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/cli-parser ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/cli-parser ``` home/fluxyjvi/public_html/project/vendor/sebastian/comparator/README.md 0000644 00000003073 15107416520 0022224 0 ustar 00 [](https://packagist.org/packages/sebastian/comparator) [](https://github.com/sebastianbergmann/comparator/actions) [](https://shepherd.dev/github/sebastianbergmann/comparator) [](https://codecov.io/gh/sebastianbergmann/comparator) # sebastian/comparator This component provides the functionality to compare PHP values for equality. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/comparator ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/comparator ``` ## Usage ```php <?php use SebastianBergmann\Comparator\Factory; use SebastianBergmann\Comparator\ComparisonFailure; $date1 = new DateTime('2013-03-29 04:13:35', new DateTimeZone('America/New_York')); $date2 = new DateTime('2013-03-29 03:13:35', new DateTimeZone('America/Chicago')); $factory = new Factory; $comparator = $factory->getComparatorFor($date1, $date2); try { $comparator->assertEquals($date1, $date2); print "Dates match"; } catch (ComparisonFailure $failure) { print "Dates don't match"; } ``` home/fluxyjvi/public_html/project/vendor/league/glide/README.md 0000644 00000007066 15107421534 0020441 0 ustar 00 # Glide [](https://github.com/thephpleague/glide/releases) [](https://github.com/thephpleague/glide/blob/master/LICENSE) [](https://github.com/thephpleague/glide/actions/workflows/test.yaml?query=branch%3Amaster++) [](https://app.codecov.io/gh/thephpleague/glide/) [](https://packagist.org/packages/league/glide) [](https://github.com/thephpleague/glide) [](https://twitter.com/reinink) [](https://twitter.com/titouangalopin) Glide is a wonderfully easy on-demand image manipulation library written in PHP. Its straightforward API is exposed via HTTP, similar to cloud image processing services like [Imgix](http://www.imgix.com/) and [Cloudinary](http://cloudinary.com/). Glide leverages powerful libraries like [Intervention Image](http://image.intervention.io/) (for image handling and manipulation) and [Flysystem](http://flysystem.thephpleague.com/) (for file system abstraction). [](https://glide.herokuapp.com/1.0/kayaks.jpg?w=1000) > Β© Photo Joel Reynolds ## Highlights - Adjust, resize and add effects to images using a simple HTTP based API. - Manipulated images are automatically cached and served with far-future expires headers. - Create your own image processing server or integrate Glide directly into your app. - Supports both the [GD](http://php.net/manual/en/book.image.php) library and the [Imagick](http://php.net/manual/en/book.imagick.php) PHP extension. - Supports many response methods, including PSR-7, HttpFoundation and more. - Ability to secure image URLs using HTTP signatures. - Works with many different file systems, thanks to the [Flysystem](http://flysystem.thephpleague.com/) library. - Powered by the battle tested [Intervention Image](http://image.intervention.io/) image handling and manipulation library. - Framework-agnostic, will work with any project. - Composer ready and PSR-2 compliant. ## Documentation Full documentation can be found at [glide.thephpleague.com](http://glide.thephpleague.com). ## Installation Glide is available via Composer: ```bash $ composer require league/glide ``` ## Testing Glide has a [PHPUnit](https://phpunit.de/) test suite. To run the tests, run the following command from the project folder: ```bash $ phpunit ``` ## Contributing Contributions are welcome and will be fully credited. Please see [CONTRIBUTING](https://github.com/thephpleague/glide/blob/master/CONTRIBUTING.md) for details. ## Security If you discover any security related issues, please email jonathan@reinink.ca instead of using the issue tracker. ## Credits - [Jonathan Reinink](https://github.com/reinink) - [All Contributors](https://github.com/thephpleague/glide/contributors) ## License The MIT License (MIT). Please see [LICENSE](https://github.com/thephpleague/glide/blob/master/LICENSE) for more information. home/fluxyjvi/public_html/project/vendor/monolog/monolog/README.md 0000644 00000014117 15107441662 0021236 0 ustar 00  # Monolog - Logging for PHP [](https://github.com/Seldaek/monolog/actions) [](https://packagist.org/packages/monolog/monolog) [](https://packagist.org/packages/monolog/monolog) >**Note** This is the **documentation for Monolog 3.x**, if you are using older releases >see the documentation for [Monolog 2.x](https://github.com/Seldaek/monolog/blob/2.x/README.md) or [Monolog 1.x](https://github.com/Seldaek/monolog/blob/1.x/README.md) Monolog sends your logs to files, sockets, inboxes, databases and various web services. See the complete list of handlers below. Special handlers allow you to build advanced logging strategies. This library implements the [PSR-3](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md) interface that you can type-hint against in your own libraries to keep a maximum of interoperability. You can also use it in your applications to make sure you can always use another compatible logger at a later time. As of 1.11.0 Monolog public APIs will also accept PSR-3 log levels. Internally Monolog still uses its own level scheme since it predates PSR-3. ## Installation Install the latest version with ```bash $ composer require monolog/monolog ``` ## Basic Usage ```php <?php use Monolog\Level; use Monolog\Logger; use Monolog\Handler\StreamHandler; // create a log channel $log = new Logger('name'); $log->pushHandler(new StreamHandler('path/to/your.log', Level::Warning)); // add records to the log $log->warning('Foo'); $log->error('Bar'); ``` ## Documentation - [Usage Instructions](doc/01-usage.md) - [Handlers, Formatters and Processors](doc/02-handlers-formatters-processors.md) - [Utility Classes](doc/03-utilities.md) - [Extending Monolog](doc/04-extending.md) - [Log Record Structure](doc/message-structure.md) ## Support Monolog Financially Get supported Monolog and help fund the project with the [Tidelift Subscription](https://tidelift.com/subscription/pkg/packagist-monolog-monolog?utm_source=packagist-monolog-monolog&utm_medium=referral&utm_campaign=enterprise) or via [GitHub sponsorship](https://github.com/sponsors/Seldaek). Tidelift delivers commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. ## Third Party Packages Third party handlers, formatters and processors are [listed in the wiki](https://github.com/Seldaek/monolog/wiki/Third-Party-Packages). You can also add your own there if you publish one. ## About ### Requirements - Monolog `^3.0` works with PHP 8.1 or above. - Monolog `^2.5` works with PHP 7.2 or above. - Monolog `^1.25` works with PHP 5.3 up to 8.1, but is not very maintained anymore and will not receive PHP support fixes anymore. ### Support Monolog 1.x support is somewhat limited at this point and only important fixes will be done. You should migrate to Monolog 2 or 3 where possible to benefit from all the latest features and fixes. ### Submitting bugs and feature requests Bugs and feature request are tracked on [GitHub](https://github.com/Seldaek/monolog/issues) ### Framework Integrations - Frameworks and libraries using [PSR-3](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md) can be used very easily with Monolog since it implements the interface. - [Symfony](http://symfony.com) comes out of the box with Monolog. - [Laravel](http://laravel.com/) comes out of the box with Monolog. - [Lumen](http://lumen.laravel.com/) comes out of the box with Monolog. - [PPI](https://github.com/ppi/framework) comes out of the box with Monolog. - [CakePHP](http://cakephp.org/) is usable with Monolog via the [cakephp-monolog](https://github.com/jadb/cakephp-monolog) plugin. - [Slim](http://www.slimframework.com/) is usable with Monolog via the [Slim-Monolog](https://github.com/Flynsarmy/Slim-Monolog) log writer. - [XOOPS 2.6](http://xoops.org/) comes out of the box with Monolog. - [Aura.Web_Project](https://github.com/auraphp/Aura.Web_Project) comes out of the box with Monolog. - [Nette Framework](http://nette.org/en/) is usable with Monolog via the [contributte/monolog](https://github.com/contributte/monolog) or [orisai/nette-monolog](https://github.com/orisai/nette-monolog) extensions. - [Proton Micro Framework](https://github.com/alexbilbie/Proton) comes out of the box with Monolog. - [FuelPHP](http://fuelphp.com/) comes out of the box with Monolog. - [Equip Framework](https://github.com/equip/framework) comes out of the box with Monolog. - [Yii 2](http://www.yiiframework.com/) is usable with Monolog via the [yii2-monolog](https://github.com/merorafael/yii2-monolog) or [yii2-psr-log-target](https://github.com/samdark/yii2-psr-log-target) plugins. - [Hawkbit Micro Framework](https://github.com/HawkBitPhp/hawkbit) comes out of the box with Monolog. - [SilverStripe 4](https://www.silverstripe.org/) comes out of the box with Monolog. - [Drupal](https://www.drupal.org/) is usable with Monolog via the [monolog](https://www.drupal.org/project/monolog) module. - [Aimeos ecommerce framework](https://aimeos.org/) is usable with Monolog via the [ai-monolog](https://github.com/aimeos/ai-monolog) extension. - [Magento](https://magento.com/) comes out of the box with Monolog. - [Spiral Framework](https://spiral.dev) comes out of the box with Monolog bridge. ### Author Jordi Boggiano - <j.boggiano@seld.be> - <http://twitter.com/seldaek><br /> See also the list of [contributors](https://github.com/Seldaek/monolog/contributors) who participated in this project. ### License Monolog is licensed under the MIT License - see the [LICENSE](LICENSE) file for details ### Acknowledgements This library is heavily inspired by Python's [Logbook](https://logbook.readthedocs.io/en/stable/) library, although most concepts have been adjusted to fit to the PHP world. home/fluxyjvi/public_html/project/vendor/masterminds/html5/README.md 0000644 00000023141 15107467624 0021474 0 ustar 00 > # UKRAINE NEEDS YOUR HELP NOW! > > On 24 February 2022, Russian [President Vladimir Putin ordered an invasion of Ukraine by Russian Armed Forces](https://www.bbc.com/news/world-europe-60504334). > > Your support is urgently needed. > > - Donate to the volunteers. Here is the volunteer fund helping the Ukrainian army to provide all the necessary equipment: > https://bank.gov.ua/en/news/all/natsionalniy-bank-vidkriv-spetsrahunok-dlya-zboru-koshtiv-na-potrebi-armiyi or https://savelife.in.ua/en/donate/ > - Triple-check social media sources. Russian disinformation is attempting to coverup and distort the reality in Ukraine. > - Help Ukrainian refugees who are fleeing Russian attacks and shellings: https://www.globalcitizen.org/en/content/ways-to-help-ukraine-conflict/ > - Put pressure on your political representatives to provide help to Ukraine. > - Believe in the Ukrainian people, they will not surrender, they don't have another Ukraine. > > THANK YOU! ---- # HTML5-PHP HTML5 is a standards-compliant HTML5 parser and writer written entirely in PHP. It is stable and used in many production websites, and has well over [five million downloads](https://packagist.org/packages/masterminds/html5). HTML5 provides the following features. - An HTML5 serializer - Support for PHP namespaces - Composer support - Event-based (SAX-like) parser - A DOM tree builder - Interoperability with [QueryPath](https://github.com/technosophos/querypath) - Runs on **PHP** 5.3.0 or newer [](https://travis-ci.org/Masterminds/html5-php) [](https://packagist.org/packages/masterminds/html5) [](https://scrutinizer-ci.com/g/Masterminds/html5-php/?branch=master) [](https://scrutinizer-ci.com/g/Masterminds/html5-php/?branch=master) [](https://masterminds.github.io/stability/sustained.html) ## Installation Install HTML5-PHP using [composer](http://getcomposer.org/). By adding the `masterminds/html5` dependency to your `composer.json` file: ```json { "require" : { "masterminds/html5": "^2.0" }, } ``` By invoking require command via composer executable: ```bash composer require masterminds/html5 ``` ## Basic Usage HTML5-PHP has a high-level API and a low-level API. Here is how you use the high-level `HTML5` library API: ```php <?php // Assuming you installed from Composer: require "vendor/autoload.php"; use Masterminds\HTML5; // An example HTML document: $html = <<< 'HERE' <html> <head> <title>TEST</title> </head> <body id='foo'> <h1>Hello World</h1> <p>This is a test of the HTML5 parser.</p> </body> </html> HERE; // Parse the document. $dom is a DOMDocument. $html5 = new HTML5(); $dom = $html5->loadHTML($html); // Render it as HTML5: print $html5->saveHTML($dom); // Or save it to a file: $html5->save($dom, 'out.html'); ``` The `$dom` created by the parser is a full `DOMDocument` object. And the `save()` and `saveHTML()` methods will take any DOMDocument. ### Options It is possible to pass in an array of configuration options when loading an HTML5 document. ```php // An associative array of options $options = array( 'option_name' => 'option_value', ); // Provide the options to the constructor $html5 = new HTML5($options); $dom = $html5->loadHTML($html); ``` The following options are supported: * `encode_entities` (boolean): Indicates that the serializer should aggressively encode characters as entities. Without this, it only encodes the bare minimum. * `disable_html_ns` (boolean): Prevents the parser from automatically assigning the HTML5 namespace to the DOM document. This is for non-namespace aware DOM tools. * `target_document` (\DOMDocument): A DOM document that will be used as the destination for the parsed nodes. * `implicit_namespaces` (array): An assoc array of namespaces that should be used by the parser. Name is tag prefix, value is NS URI. ## The Low-Level API This library provides the following low-level APIs that you can use to create more customized HTML5 tools: - A SAX-like event-based parser that you can hook into for special kinds of parsing. - A flexible error-reporting mechanism that can be tuned to document syntax checking. - A DOM implementation that uses PHP's built-in DOM library. The unit tests exercise each piece of the API, and every public function is well-documented. ### Parser Design The parser is designed as follows: - The `Scanner` handles scanning on behalf of the parser. - The `Tokenizer` requests data off of the scanner, parses it, clasifies it, and sends it to an `EventHandler`. It is a *recursive descent parser.* - The `EventHandler` receives notifications and data for each specific semantic event that occurs during tokenization. - The `DOMBuilder` is an `EventHandler` that listens for tokenizing events and builds a document tree (`DOMDocument`) based on the events. ### Serializer Design The serializer takes a data structure (the `DOMDocument`) and transforms it into a character representation -- an HTML5 document. The serializer is broken into three parts: - The `OutputRules` contain the rules to turn DOM elements into strings. The rules are an implementation of the interface `RulesInterface` allowing for different rule sets to be used. - The `Traverser`, which is a special-purpose tree walker. It visits each node node in the tree and uses the `OutputRules` to transform the node into a string. - `HTML5` manages the `Traverser` and stores the resultant data in the correct place. The serializer (`save()`, `saveHTML()`) follows the [section 8.9 of the HTML 5.0 spec](http://www.w3.org/TR/2012/CR-html5-20121217/syntax.html#serializing-html-fragments). So tags are serialized according to these rules: - A tag with children: <foo>CHILDREN</foo> - A tag that cannot have content: <foo> (no closing tag) - A tag that could have content, but doesn't: <foo></foo> ## Known Issues (Or, Things We Designed Against the Spec) Please check the issue queue for a full list, but the following are issues known issues that are not presently on the roadmap: - Namespaces: HTML5 only [supports a selected list of namespaces](http://www.w3.org/TR/html5/infrastructure.html#namespaces) and they do not operate in the same way as XML namespaces. A `:` has no special meaning. By default the parser does not support XML style namespaces via `:`; to enable the XML namespaces see the [XML Namespaces section](#xml-namespaces) - Scripts: This parser does not contain a JavaScript or a CSS interpreter. While one may be supplied, not all features will be supported. - Reentrance: The current parser is not re-entrant. (Thus you can't pause the parser to modify the HTML string mid-parse.) - Validation: The current tree builder is **not** a validating parser. While it will correct some HTML, it does not check that the HTML conforms to the standard. (Should you wish, you can build a validating parser by extending DOMTree or building your own EventHandler implementation.) * There is limited support for insertion modes. * Some autocorrection is done automatically. * Per the spec, many legacy tags are admitted and correctly handled, even though they are technically not part of HTML5. - Attribute names and values: Due to the implementation details of the PHP implementation of DOM, attribute names that do not follow the XML 1.0 standard are not inserted into the DOM. (Effectively, they are ignored.) If you've got a clever fix for this, jump in! - Processor Instructions: The HTML5 spec does not allow processor instructions. We do. Since this is a server-side library, we think this is useful. And that means, dear reader, that in some cases you can parse the HTML from a mixed PHP/HTML document. This, however, is an incidental feature, not a core feature. - HTML manifests: Unsupported. - PLAINTEXT: Unsupported. - Adoption Agency Algorithm: Not yet implemented. (8.2.5.4.7) ## XML Namespaces To use XML style namespaces you have to configure well the main `HTML5` instance. ```php use Masterminds\HTML5; $html = new HTML5(array( "xmlNamespaces" => true )); $dom = $html->loadHTML('<t:tag xmlns:t="http://www.example.com"/>'); $dom->documentElement->namespaceURI; // http://www.example.com ``` You can also add some default prefixes that will not require the namespace declaration, but its elements will be namespaced. ```php use Masterminds\HTML5; $html = new HTML5(array( "implicitNamespaces"=>array( "t"=>"http://www.example.com" ) )); $dom = $html->loadHTML('<t:tag/>'); $dom->documentElement->namespaceURI; // http://www.example.com ``` ## Thanks to... The dedicated (and patient) contributors of patches small and large, who have already made this library better.See the CREDITS file for a list of contributors. We owe a huge debt of gratitude to the original authors of html5lib. While not much of the original parser remains, we learned a lot from reading the html5lib library. And some pieces remain here. In particular, much of the UTF-8 and Unicode handling is derived from the html5lib project. ## License This software is released under the MIT license. The original html5lib library was also released under the MIT license. See LICENSE.txt Certain files contain copyright assertions by specific individuals involved with html5lib. Those have been retained where appropriate. home/fluxyjvi/public_html/project/vendor/sebastian/complexity/README.md 0000644 00000002033 15107471353 0022252 0 ustar 00 [](https://packagist.org/packages/sebastian/complexity) [](https://github.com/sebastianbergmann/complexity/actions) [](https://shepherd.dev/github/sebastianbergmann/complexity) [](https://codecov.io/gh/sebastianbergmann/complexity) # sebastian/complexity Library for calculating the complexity of PHP code units. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/complexity ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/complexity ``` home/fluxyjvi/public_html/project/vendor/phpunit/php-timer/README.md 0000644 00000004732 15107474600 0021506 0 ustar 00 # phpunit/php-timer [](https://packagist.org/packages/phpunit/php-timer) [](https://github.com/sebastianbergmann/php-timer/actions) [](https://shepherd.dev/github/sebastianbergmann/php-timer) [](https://codecov.io/gh/sebastianbergmann/php-timer) Utility class for timing things, factored out of PHPUnit into a stand-alone component. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require phpunit/php-timer ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev phpunit/php-timer ``` ## Usage ### Basic Timing ```php require __DIR__ . '/vendor/autoload.php'; use SebastianBergmann\Timer\Timer; $timer = new Timer; $timer->start(); foreach (\range(0, 100000) as $i) { // ... } $duration = $timer->stop(); var_dump(get_class($duration)); var_dump($duration->asString()); var_dump($duration->asSeconds()); var_dump($duration->asMilliseconds()); var_dump($duration->asMicroseconds()); var_dump($duration->asNanoseconds()); ``` The code above yields the output below: ``` string(32) "SebastianBergmann\Timer\Duration" string(9) "00:00.002" float(0.002851062) float(2.851062) float(2851.062) int(2851062) ``` ### Resource Consumption #### Explicit duration ```php require __DIR__ . '/vendor/autoload.php'; use SebastianBergmann\Timer\ResourceUsageFormatter; use SebastianBergmann\Timer\Timer; $timer = new Timer; $timer->start(); foreach (\range(0, 100000) as $i) { // ... } print (new ResourceUsageFormatter)->resourceUsage($timer->stop()); ``` The code above yields the output below: ``` Time: 00:00.002, Memory: 6.00 MB ``` #### Duration since PHP Startup (using unreliable `$_SERVER['REQUEST_TIME_FLOAT']`) ```php require __DIR__ . '/vendor/autoload.php'; use SebastianBergmann\Timer\ResourceUsageFormatter; foreach (\range(0, 100000) as $i) { // ... } print (new ResourceUsageFormatter)->resourceUsageSinceStartOfRequest(); ``` The code above yields the output below: ``` Time: 00:00.002, Memory: 6.00 MB ``` home/fluxyjvi/public_html/project/vendor/league/config/README.md 0000644 00000016002 15107507415 0020613 0 ustar 00 # league/config [](https://packagist.org/packages/league/config) [](https://packagist.org/packages/league/config) [](LICENSE) [](https://github.com/thephpleague/config/actions?query=workflow%3ATests+branch%3Amain) [](https://scrutinizer-ci.com/g/thephpleague/config/code-structure) [](https://scrutinizer-ci.com/g/thephpleague/config) [](https://www.colinodell.com/sponsor) **league/config** helps you define nested configuration arrays with strict schemas and access configuration values with dot notation. It was created by [Colin O'Dell][@colinodell]. ## π¦ Installation This project requires PHP 7.4 or higher. To install it via [Composer] simply run: ```bash composer require league/config ``` ## π§°οΈ Basic Usage The `Configuration` class provides everything you need to define the configuration structure and fetch values: ```php use League\Config\Configuration; use Nette\Schema\Expect; // Define your configuration schema $config = new Configuration([ 'database' => Expect::structure([ 'driver' => Expect::anyOf('mysql', 'postgresql', 'sqlite')->required(), 'host' => Expect::string()->default('localhost'), 'port' => Expect::int()->min(1)->max(65535), 'ssl' => Expect::bool(), 'database' => Expect::string()->required(), 'username' => Expect::string()->required(), 'password' => Expect::string()->nullable(), ]), 'logging' => Expect::structure([ 'enabled' => Expect::bool()->default($_ENV['DEBUG'] == true), 'file' => Expect::string()->deprecated("use logging.path instead"), 'path' => Expect::string()->assert(function ($path) { return \is_writeable($path); })->required(), ]), ]); // Set the values, either all at once with `merge()`: $config->merge([ 'database' => [ 'driver' => 'mysql', 'port' => 3306, 'database' => 'mydb', 'username' => 'user', 'password' => 'secret', ], ]); // Or one-at-a-time with `set()`: $config->set('logging.path', '/var/log/myapp.log'); // You can now retrieve those values with `get()`. // Validation and defaults will be applied for you automatically $config->get('database'); // Fetches the entire "database" section as an array $config->get('database.driver'); // Fetch a specific nested value with dot notation $config->get('database/driver'); // Fetch a specific nested value with slash notation $config->get('database.host'); // Returns the default value "localhost" $config->get('logging.path'); // Guaranteed to be writeable thanks to the assertion in the schema // If validation fails an `InvalidConfigurationException` will be thrown: $config->set('database.driver', 'mongodb'); $config->get('database.driver'); // InvalidConfigurationException // Attempting to fetch a non-existent key will result in an `InvalidConfigurationException` $config->get('foo.bar'); // You could avoid this by checking whether that item exists: $config->exists('foo.bar'); // Returns `false` ``` ## π Documentation Full documentation can be found at [config.thephpleague.com][docs]. ## π Philosophy This library aims to provide a **simple yet opinionated** approach to configuration with the following goals: - The configuration should operate on **arrays with nested values** which are easily accessible - The configuration structure should be **defined with strict schemas** defining the overall structure, allowed types, and allowed values - Schemas should be defined using a **simple, fluent interface** - You should be able to **add and combine schemas but never modify existing ones** - Both the configuration values and the schema should be **defined and managed with PHP code** - Schemas should be **immutable**; they should never change once they are set - Configuration values should never define or influence the schemas As a result, this library will likely **never** support features like: - Loading and/or exporting configuration values or schemas using YAML, XML, or other files - Parsing configuration values from a command line or other user interface - Dynamically changing the schema, allowed values, or default values based on other configuration values If you need that functionality you should check out other libraries like: - [symfony/config] - [symfony/options-resolver] - [hassankhan/config] - [consolidation/config] - [laminas/laminas-config] ## π·οΈ Versioning [SemVer](http://semver.org/) is followed closely. Minor and patch releases should not introduce breaking changes to the codebase. Any classes or methods marked `@internal` are not intended for use outside this library and are subject to breaking changes at any time, so please avoid using them. ## π οΈ Maintenance & Support When a new **minor** version (e.g. `1.0` -> `1.1`) is released, the previous one (`1.0`) will continue to receive security and critical bug fixes for *at least* 3 months. When a new **major** version is released (e.g. `1.1` -> `2.0`), the previous one (`1.1`) will receive critical bug fixes for *at least* 3 months and security updates for 6 months after that new release comes out. (This policy may change in the future and exceptions may be made on a case-by-case basis.) ## π·βοΈ Contributing Contributions to this library are **welcome**! We only ask that you adhere to our [contributor guidelines] and avoid making changes that conflict with our Philosophy above. ## π§ͺ Testing ```bash composer test ``` ## π License **league/config** is licensed under the BSD-3 license. See the [`LICENSE.md`][license] file for more details. ## πΊοΈ Who Uses It? This project is used by [league/commonmark][league-commonmark]. [docs]: https://config.thephpleague.com/ [@colinodell]: https://www.twitter.com/colinodell [Composer]: https://getcomposer.org/ [PHP League]: https://thephpleague.com [symfony/config]: https://symfony.com/doc/current/components/config.html [symfony/options-resolver]: https://symfony.com/doc/current/components/options_resolver.html [hassankhan/config]: https://github.com/hassankhan/config [consolidation/config]: https://github.com/consolidation/config [laminas/laminas-config]: https://docs.laminas.dev/laminas-config/ [contributor guidelines]: https://github.com/thephpleague/config/blob/main/.github/CONTRIBUTING.md [license]: https://github.com/thephpleague/config/blob/main/LICENSE.md [league-commonmark]: https://commonmark.thephpleague.com home/fluxyjvi/public_html/project/vendor/mockery/mockery/README.md 0000644 00000024526 15107533605 0021240 0 ustar 00 Mockery ======= [](https://github.com/mockery/mockery/actions) [](https://www.php.net/supported-versions) [](https://codecov.io/gh/mockery/mockery) [](https://shepherd.dev/github/mockery/mockery) [](https://packagist.org/packages/mockery/mockery) [](https://packagist.org/packages/mockery/mockery) Mockery is a simple yet flexible PHP mock object framework for use in unit testing with PHPUnit, PHPSpec or any other testing framework. Its core goal is to offer a test double framework with a succinct API capable of clearly defining all possible object operations and interactions using a human readable Domain Specific Language (DSL). Designed as a drop in alternative to PHPUnit's phpunit-mock-objects library, Mockery is easy to integrate with PHPUnit and can operate alongside phpunit-mock-objects without the World ending. Mockery is released under a New BSD License. ## Installation To install Mockery, run the command below and you will get the latest version ```sh composer require --dev mockery/mockery ``` ## Documentation In older versions, this README file was the documentation for Mockery. Over time we have improved this, and have created an extensive documentation for you. Please use this README file as a starting point for Mockery, but do read the documentation to learn how to use Mockery. The current version can be seen at [docs.mockery.io](http://docs.mockery.io). ## PHPUnit Integration Mockery ships with some helpers if you are using PHPUnit. You can extend the [`Mockery\Adapter\Phpunit\MockeryTestCase`](library/Mockery/Adapter/Phpunit/MockeryTestCase.php) class instead of `PHPUnit\Framework\TestCase`, or if you are already using a custom base class for your tests, take a look at the traits available in the [`Mockery\Adapter\Phpunit`](library/Mockery/Adapter/Phpunit) namespace. ## Test Doubles Test doubles (often called mocks) simulate the behaviour of real objects. They are commonly utilised to offer test isolation, to stand in for objects which do not yet exist, or to allow for the exploratory design of class APIs without requiring actual implementation up front. The benefits of a test double framework are to allow for the flexible generation and configuration of test doubles. They allow the setting of expected method calls and/or return values using a flexible API which is capable of capturing every possible real object behaviour in way that is stated as close as possible to a natural language description. Use the `Mockery::mock` method to create a test double. ``` php $double = Mockery::mock(); ``` If you need Mockery to create a test double to satisfy a particular type hint, you can pass the type to the `mock` method. ``` php class Book {} interface BookRepository { function find($id): Book; function findAll(): array; function add(Book $book): void; } $double = Mockery::mock(BookRepository::class); ``` A detailed explanation of creating and working with test doubles is given in the documentation, [Creating test doubles](http://docs.mockery.io/en/latest/reference/creating_test_doubles.html) section. ## Method Stubs π« A method stub is a mechanism for having your test double return canned responses to certain method calls. With stubs, you don't care how many times, if at all, the method is called. Stubs are used to provide indirect input to the system under test. ``` php $double->allows()->find(123)->andReturns(new Book()); $book = $double->find(123); ``` If you have used Mockery before, you might see something new in the example above — we created a method stub using `allows`, instead of the "old" `shouldReceive` syntax. This is a new feature of Mockery v1, but fear not, the trusty ol' `shouldReceive` is still here. For new users of Mockery, the above example can also be written as: ``` php $double->shouldReceive('find')->with(123)->andReturn(new Book()); $book = $double->find(123); ``` If your stub doesn't require specific arguments, you can also use this shortcut for setting up multiple calls at once: ``` php $double->allows([ "findAll" => [new Book(), new Book()], ]); ``` or ``` php $double->shouldReceive('findAll') ->andReturn([new Book(), new Book()]); ``` You can also use this shortcut, which creates a double and sets up some stubs in one call: ``` php $double = Mockery::mock(BookRepository::class, [ "findAll" => [new Book(), new Book()], ]); ``` ## Method Call Expectations π² A Method call expectation is a mechanism to allow you to verify that a particular method has been called. You can specify the parameters and you can also specify how many times you expect it to be called. Method call expectations are used to verify indirect output of the system under test. ``` php $book = new Book(); $double = Mockery::mock(BookRepository::class); $double->expects()->add($book); ``` During the test, Mockery accept calls to the `add` method as prescribed. After you have finished exercising the system under test, you need to tell Mockery to check that the method was called as expected, using the `Mockery::close` method. One way to do that is to add it to your `tearDown` method in PHPUnit. ``` php public function tearDown() { Mockery::close(); } ``` The `expects()` method automatically sets up an expectation that the method call (and matching parameters) is called **once and once only**. You can choose to change this if you are expecting more calls. ``` php $double->expects()->add($book)->twice(); ``` If you have used Mockery before, you might see something new in the example above — we created a method expectation using `expects`, instead of the "old" `shouldReceive` syntax. This is a new feature of Mockery v1, but same as with `allows` in the previous section, it can be written in the "old" style. For new users of Mockery, the above example can also be written as: ``` php $double->shouldReceive('find') ->with(123) ->once() ->andReturn(new Book()); $book = $double->find(123); ``` A detailed explanation of declaring expectations on method calls, please read the documentation, the [Expectation declarations](http://docs.mockery.io/en/latest/reference/expectations.html) section. After that, you can also learn about the new `allows` and `expects` methods in the [Alternative shouldReceive syntax](http://docs.mockery.io/en/latest/reference/alternative_should_receive_syntax.html) section. It is worth mentioning that one way of setting up expectations is no better or worse than the other. Under the hood, `allows` and `expects` are doing the same thing as `shouldReceive`, at times in "less words", and as such it comes to a personal preference of the programmer which way to use. ## Test Spies π΅οΈ By default, all test doubles created with the `Mockery::mock` method will only accept calls that they have been configured to `allow` or `expect` (or in other words, calls that they `shouldReceive`). Sometimes we don't necessarily care about all of the calls that are going to be made to an object. To facilitate this, we can tell Mockery to ignore any calls it has not been told to expect or allow. To do so, we can tell a test double `shouldIgnoreMissing`, or we can create the double using the `Mocker::spy` shortcut. ``` php // $double = Mockery::mock()->shouldIgnoreMissing(); $double = Mockery::spy(); $double->foo(); // null $double->bar(); // null ``` Further to this, sometimes we want to have the object accept any call during the test execution and then verify the calls afterwards. For these purposes, we need our test double to act as a Spy. All mockery test doubles record the calls that are made to them for verification afterwards by default: ``` php $double->baz(123); $double->shouldHaveReceived()->baz(123); // null $double->shouldHaveReceived()->baz(12345); // Uncaught Exception Mockery\Exception\InvalidCountException... ``` Please refer to the [Spies](http://docs.mockery.io/en/latest/reference/spies.html) section of the documentation to learn more about the spies. ## Utilities π ### Global Helpers Mockery ships with a handful of global helper methods, you just need to ask Mockery to declare them. ``` php Mockery::globalHelpers(); $mock = mock(Some::class); $spy = spy(Some::class); $spy->shouldHaveReceived() ->foo(anyArgs()); ``` All of the global helpers are wrapped in a `!function_exists` call to avoid conflicts. So if you already have a global function called `spy`, Mockery will silently skip the declaring its own `spy` function. ### Testing Traits As Mockery ships with code generation capabilities, it was trivial to add functionality allowing users to create objects on the fly that use particular traits. Any abstract methods defined by the trait will be created and can have expectations or stubs configured like normal Test Doubles. ``` php trait Foo { function foo() { return $this->doFoo(); } abstract function doFoo(); } $double = Mockery::mock(Foo::class); $double->allows()->doFoo()->andReturns(123); $double->foo(); // int(123) ``` ## Versioning The Mockery team attempts to adhere to [Semantic Versioning](http://semver.org), however, some of Mockery's internals are considered private and will be open to change at any time. Just because a class isn't final, or a method isn't marked private, does not mean it constitutes part of the API we guarantee under the versioning scheme. ### Alternative Runtimes Mockery 1.3 was the last version to support HHVM 3 and PHP 5. There is no support for HHVM 4+. ## A new home for Mockery β οΈοΈ Update your remotes! Mockery has transferred to a new location. While it was once at `padraic/mockery`, it is now at `mockery/mockery`. While your existing repositories will redirect transparently for any operations, take some time to transition to the new URL. ```sh $ git remote set-url upstream https://github.com/mockery/mockery.git ``` Replace `upstream` with the name of the remote you use locally; `upstream` is commonly used but you may be using something else. Run `git remote -v` to see what you're actually using. home/fluxyjvi/public_html/project/vendor/sebastian/exporter/README.md 0000644 00000006343 15107546510 0021733 0 ustar 00 [](https://packagist.org/packages/sebastian/exporter) [](https://github.com/sebastianbergmann/exporter/actions) [](https://shepherd.dev/github/sebastianbergmann/exporter) [](https://codecov.io/gh/sebastianbergmann/exporter) # sebastian/exporter This component provides the functionality to export PHP variables for visualization. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/exporter ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/exporter ``` ## Usage Exporting: ```php <?php use SebastianBergmann\Exporter\Exporter; $exporter = new Exporter; /* Exception Object &0000000078de0f0d000000002003a261 ( 'message' => '' 'string' => '' 'code' => 0 'file' => '/home/sebastianbergmann/test.php' 'line' => 34 'previous' => null ) */ print $exporter->export(new Exception); ``` ## Data Types Exporting simple types: ```php <?php use SebastianBergmann\Exporter\Exporter; $exporter = new Exporter; // 46 print $exporter->export(46); // 4.0 print $exporter->export(4.0); // 'hello, world!' print $exporter->export('hello, world!'); // false print $exporter->export(false); // NAN print $exporter->export(acos(8)); // -INF print $exporter->export(log(0)); // null print $exporter->export(null); // resource(13) of type (stream) print $exporter->export(fopen('php://stderr', 'w')); // Binary String: 0x000102030405 print $exporter->export(chr(0) . chr(1) . chr(2) . chr(3) . chr(4) . chr(5)); ``` Exporting complex types: ```php <?php use SebastianBergmann\Exporter\Exporter; $exporter = new Exporter; /* Array &0 ( 0 => Array &1 ( 0 => 1 1 => 2 2 => 3 ) 1 => Array &2 ( 0 => '' 1 => 0 2 => false ) ) */ print $exporter->export(array(array(1,2,3), array("",0,FALSE))); /* Array &0 ( 'self' => Array &1 ( 'self' => Array &1 ) ) */ $array = array(); $array['self'] = &$array; print $exporter->export($array); /* stdClass Object &0000000003a66dcc0000000025e723e2 ( 'self' => stdClass Object &0000000003a66dcc0000000025e723e2 ) */ $obj = new stdClass(); $obj->self = $obj; print $exporter->export($obj); ``` Compact exports: ```php <?php use SebastianBergmann\Exporter\Exporter; $exporter = new Exporter; // Array () print $exporter->shortenedExport(array()); // Array (...) print $exporter->shortenedExport(array(1,2,3,4,5)); // stdClass Object () print $exporter->shortenedExport(new stdClass); // Exception Object (...) print $exporter->shortenedExport(new Exception); // this\nis\na\nsuper\nlong\nstring\nt...\nspace print $exporter->shortenedExport( <<<LONG_STRING this is a super long string that wraps a lot and eats up a lot of space LONG_STRING ); ``` home/fluxyjvi/public_html/project/vendor/doctrine/common/README.md 0000644 00000001120 15107676141 0021201 0 ustar 00 # Doctrine Common [](https://github.com/doctrine/common/actions) [](https://codecov.io/gh/doctrine/common) The Doctrine Common project is a library that provides extensions to core PHP functionality. ## More resources: * [Website](https://www.doctrine-project.org/) * [Documentation](https://www.doctrine-project.org/projects/doctrine-common/en/current/) * [Downloads](https://github.com/doctrine/common/releases) home/fluxyjvi/public_html/project/vendor/spatie/crawler/README.md 0000644 00000037500 15110731734 0021033 0 ustar 00 # πΈ Crawl the web using PHP π· [](https://packagist.org/packages/spatie/crawler) [](LICENSE.md)   [](https://packagist.org/packages/spatie/crawler) This package provides a class to crawl links on a website. Under the hood Guzzle promises are used to [crawl multiple urls concurrently](http://docs.guzzlephp.org/en/latest/quickstart.html?highlight=pool#concurrent-requests). Because the crawler can execute JavaScript, it can crawl JavaScript rendered sites. Under the hood [Chrome and Puppeteer](https://github.com/spatie/browsershot) are used to power this feature. ## Support us [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/crawler.jpg?t=1" width="419px" />](https://spatie.be/github-ad-click/crawler) We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us). We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards). ## Installation This package can be installed via Composer: ``` bash composer require spatie/crawler ``` ## Usage The crawler can be instantiated like this ```php use Spatie\Crawler\Crawler; Crawler::create() ->setCrawlObserver(<class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>) ->startCrawling($url); ``` The argument passed to `setCrawlObserver` must be an object that extends the `\Spatie\Crawler\CrawlObservers\CrawlObserver` abstract class: ```php namespace Spatie\Crawler\CrawlObservers; use GuzzleHttp\Exception\RequestException; use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\UriInterface; abstract class CrawlObserver { /** * Called when the crawler will crawl the url. * * @param \Psr\Http\Message\UriInterface $url */ public function willCrawl(UriInterface $url): void { } /** * Called when the crawler has crawled the given url successfully. * * @param \Psr\Http\Message\UriInterface $url * @param \Psr\Http\Message\ResponseInterface $response * @param \Psr\Http\Message\UriInterface|null $foundOnUrl */ abstract public function crawled( UriInterface $url, ResponseInterface $response, ?UriInterface $foundOnUrl = null ): void; /** * Called when the crawler had a problem crawling the given url. * * @param \Psr\Http\Message\UriInterface $url * @param \GuzzleHttp\Exception\RequestException $requestException * @param \Psr\Http\Message\UriInterface|null $foundOnUrl */ abstract public function crawlFailed( UriInterface $url, RequestException $requestException, ?UriInterface $foundOnUrl = null ): void; /** * Called when the crawl has ended. */ public function finishedCrawling(): void { } } ``` ### Using multiple observers You can set multiple observers with `setCrawlObservers`: ```php Crawler::create() ->setCrawlObservers([ <class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>, <class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>, ... ]) ->startCrawling($url); ``` Alternatively you can set multiple observers one by one with `addCrawlObserver`: ```php Crawler::create() ->addCrawlObserver(<class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>) ->addCrawlObserver(<class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>) ->addCrawlObserver(<class that extends \Spatie\Crawler\CrawlObservers\CrawlObserver>) ->startCrawling($url); ``` ### Executing JavaScript By default, the crawler will not execute JavaScript. This is how you can enable the execution of JavaScript: ```php Crawler::create() ->executeJavaScript() ... ``` In order to make it possible to get the body html after the javascript has been executed, this package depends on our [Browsershot](https://github.com/spatie/browsershot) package. This package uses [Puppeteer](https://github.com/puppeteer/puppeteer) under the hood. Here are some pointers on [how to install it on your system](https://spatie.be/docs/browsershot/v2/requirements). Browsershot will make an educated guess as to where its dependencies are installed on your system. By default, the Crawler will instantiate a new Browsershot instance. You may find the need to set a custom created instance using the `setBrowsershot(Browsershot $browsershot)` method. ```php Crawler::create() ->setBrowsershot($browsershot) ->executeJavaScript() ... ``` Note that the crawler will still work even if you don't have the system dependencies required by Browsershot. These system dependencies are only required if you're calling `executeJavaScript()`. ### Filtering certain urls You can tell the crawler not to visit certain urls by using the `setCrawlProfile`-function. That function expects an object that extends `Spatie\Crawler\CrawlProfiles\CrawlProfile`: ```php /* * Determine if the given url should be crawled. */ public function shouldCrawl(UriInterface $url): bool; ``` This package comes with three `CrawlProfiles` out of the box: - `CrawlAllUrls`: this profile will crawl all urls on all pages including urls to an external site. - `CrawlInternalUrls`: this profile will only crawl the internal urls on the pages of a host. - `CrawlSubdomains`: this profile will only crawl the internal urls and its subdomains on the pages of a host. ### Ignoring robots.txt and robots meta By default, the crawler will respect robots data. It is possible to disable these checks like so: ```php Crawler::create() ->ignoreRobots() ... ``` Robots data can come from either a `robots.txt` file, meta tags or response headers. More information on the spec can be found here: [http://www.robotstxt.org/](http://www.robotstxt.org/). Parsing robots data is done by our package [spatie/robots-txt](https://github.com/spatie/robots-txt). ### Accept links with rel="nofollow" attribute By default, the crawler will reject all links containing attribute rel="nofollow". It is possible to disable these checks like so: ```php Crawler::create() ->acceptNofollowLinks() ... ``` ### Using a custom User Agent ### In order to respect robots.txt rules for a custom User Agent you can specify your own custom User Agent. ```php Crawler::create() ->setUserAgent('my-agent') ``` You can add your specific crawl rule group for 'my-agent' in robots.txt. This example disallows crawling the entire site for crawlers identified by 'my-agent'. ```txt // Disallow crawling for my-agent User-agent: my-agent Disallow: / ``` ## Setting the number of concurrent requests To improve the speed of the crawl the package concurrently crawls 10 urls by default. If you want to change that number you can use the `setConcurrency` method. ```php Crawler::create() ->setConcurrency(1) // now all urls will be crawled one by one ``` ## Defining Crawl Limits By default, the crawler continues until it has crawled every page it can find. This behavior might cause issues if you are working in an environment with limitations such as a serverless environment. The crawl behavior can be controlled with the following two options: - **Total Crawl Limit** (`setTotalCrawlLimit`): This limit defines the maximal count of URLs to crawl. - **Current Crawl Limit** (`setCurrentCrawlLimit`): This defines how many URLs are processed during the current crawl. Let's take a look at some examples to clarify the difference between these two methods. ### Example 1: Using the total crawl limit The `setTotalCrawlLimit` method allows to limit the total number of URLs to crawl, no matter often you call the crawler. ```php $queue = <your selection/implementation of a queue>; // Crawls 5 URLs and ends. Crawler::create() ->setCrawlQueue($queue) ->setTotalCrawlLimit(5) ->startCrawling($url); // Doesn't crawl further as the total limit is reached. Crawler::create() ->setCrawlQueue($queue) ->setTotalCrawlLimit(5) ->startCrawling($url); ``` ### Example 2: Using the current crawl limit The `setCurrentCrawlLimit` will set a limit on how many URls will be crawled per execution. This piece of code will process 5 pages with each execution, without a total limit of pages to crawl. ```php $queue = <your selection/implementation of a queue>; // Crawls 5 URLs and ends. Crawler::create() ->setCrawlQueue($queue) ->setCurrentCrawlLimit(5) ->startCrawling($url); // Crawls the next 5 URLs and ends. Crawler::create() ->setCrawlQueue($queue) ->setCurrentCrawlLimit(5) ->startCrawling($url); ``` ### Example 3: Combining the total and crawl limit Both limits can be combined to control the crawler: ```php $queue = <your selection/implementation of a queue>; // Crawls 5 URLs and ends. Crawler::create() ->setCrawlQueue($queue) ->setTotalCrawlLimit(10) ->setCurrentCrawlLimit(5) ->startCrawling($url); // Crawls the next 5 URLs and ends. Crawler::create() ->setCrawlQueue($queue) ->setTotalCrawlLimit(10) ->setCurrentCrawlLimit(5) ->startCrawling($url); // Doesn't crawl further as the total limit is reached. Crawler::create() ->setCrawlQueue($queue) ->setTotalCrawlLimit(10) ->setCurrentCrawlLimit(5) ->startCrawling($url); ``` ### Example 4: Crawling across requests You can use the `setCurrentCrawlLimit` to break up long running crawls. The following example demonstrates a (simplified) approach. It's made up of an initial request and any number of follow-up requests continuing the crawl. #### Initial Request To start crawling across different requests, you will need to create a new queue of your selected queue-driver. Start by passing the queue-instance to the crawler. The crawler will start filling the queue as pages are processed and new URLs are discovered. Serialize and store the queue reference after the crawler has finished (using the current crawl limit). ```php // Create a queue using your queue-driver. $queue = <your selection/implementation of a queue>; // Crawl the first set of URLs Crawler::create() ->setCrawlQueue($queue) ->setCurrentCrawlLimit(10) ->startCrawling($url); // Serialize and store your queue $serializedQueue = serialize($queue); ``` #### Subsequent Requests For any following requests you will need to unserialize your original queue and pass it to the crawler: ```php // Unserialize queue $queue = unserialize($serializedQueue); // Crawls the next set of URLs Crawler::create() ->setCrawlQueue($queue) ->setCurrentCrawlLimit(10) ->startCrawling($url); // Serialize and store your queue $serialized_queue = serialize($queue); ``` The behavior is based on the information in the queue. Only if the same queue-instance is passed in the behavior works as described. When a completely new queue is passed in, the limits of previous crawls -even for the same website- won't apply. An example with more details can be found [here](https://github.com/spekulatius/spatie-crawler-cached-queue-example). ## Setting the maximum crawl depth By default, the crawler continues until it has crawled every page of the supplied URL. If you want to limit the depth of the crawler you can use the `setMaximumDepth` method. ```php Crawler::create() ->setMaximumDepth(2) ``` ## Setting the maximum response size Most html pages are quite small. But the crawler could accidentally pick up on large files such as PDFs and MP3s. To keep memory usage low in such cases the crawler will only use the responses that are smaller than 2 MB. If, when streaming a response, it becomes larger than 2 MB, the crawler will stop streaming the response. An empty response body will be assumed. You can change the maximum response size. ```php // let's use a 3 MB maximum. Crawler::create() ->setMaximumResponseSize(1024 * 1024 * 3) ``` ## Add a delay between requests In some cases you might get rate-limited when crawling too aggressively. To circumvent this, you can use the `setDelayBetweenRequests()` method to add a pause between every request. This value is expressed in milliseconds. ```php Crawler::create() ->setDelayBetweenRequests(150) // After every page crawled, the crawler will wait for 150ms ``` ## Limiting which content-types to parse By default, every found page will be downloaded (up to `setMaximumResponseSize()` in size) and parsed for additional links. You can limit which content-types should be downloaded and parsed by setting the `setParseableMimeTypes()` with an array of allowed types. ```php Crawler::create() ->setParseableMimeTypes(['text/html', 'text/plain']) ``` This will prevent downloading the body of pages that have different mime types, like binary files, audio/video, ... that are unlikely to have links embedded in them. This feature mostly saves bandwidth. ## Using a custom crawl queue When crawling a site the crawler will put urls to be crawled in a queue. By default, this queue is stored in memory using the built-in `ArrayCrawlQueue`. When a site is very large you may want to store that queue elsewhere, maybe a database. In such cases, you can write your own crawl queue. A valid crawl queue is any class that implements the `Spatie\Crawler\CrawlQueues\CrawlQueue`-interface. You can pass your custom crawl queue via the `setCrawlQueue` method on the crawler. ```php Crawler::create() ->setCrawlQueue(<implementation of \Spatie\Crawler\CrawlQueues\CrawlQueue>) ``` Here - [ArrayCrawlQueue](https://github.com/spatie/crawler/blob/master/src/CrawlQueues/ArrayCrawlQueue.php) - [RedisCrawlQueue (third-party package)](https://github.com/repat/spatie-crawler-redis) - [CacheCrawlQueue for Laravel (third-party package)](https://github.com/spekulatius/spatie-crawler-toolkit-for-laravel) - [Laravel Model as Queue (third-party example app)](https://github.com/insign/spatie-crawler-queue-with-laravel-model) ## Change the default base url scheme By default, the crawler will set the base url scheme to `http` if none. You have the ability to change that with `setDefaultScheme`. ```php Crawler::create() ->setDefaultScheme('https') ``` ## Changelog Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently. ## Contributing Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details. ## Testing First, install the Puppeteer dependency, or your tests will fail. ``` npm install puppeteer ``` To run the tests you'll have to start the included node based server first in a separate terminal window. ```bash cd tests/server npm install node server.js ``` With the server running, you can start testing. ```bash composer test ``` ## Security If you've found a bug regarding security please mail [security@spatie.be](mailto:security@spatie.be) instead of using the issue tracker. ## Postcardware You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium. We publish all received postcards [on our company website](https://spatie.be/en/opensource/postcards). ## Credits - [Freek Van der Herten](https://github.com/freekmurze) - [All Contributors](../../contributors) ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. home/fluxyjvi/public_html/project/vendor/sebastian/type/README.md 0000644 00000001754 15110752344 0021043 0 ustar 00 [](https://packagist.org/packages/sebastian/type) [](https://github.com/sebastianbergmann/type/actions) [](https://shepherd.dev/github/sebastianbergmann/type) [](https://codecov.io/gh/sebastianbergmann/type) # sebastian/type Collection of value objects that represent the types of the PHP type system. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/type ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/type ``` home/fluxyjvi/public_html/project/vendor/razorpay/razorpay/README.md 0000644 00000007242 15111062120 0021610 0 ustar 00 # razorpay-php [](https://travis-ci.org/razorpay/razorpay-php) [](https://packagist.org/packages/razorpay/razorpay#2.8.0) [](https://packagist.org/packages/razorpay/razorpay) Official PHP library for [Razorpay API](https://docs.razorpay.com/docs/payments). Read up here for getting started and understanding the payment flow with Razorpay: <https://docs.razorpay.com/docs/getting-started> ### Prerequisites - A minimum of PHP 7.3 upto 8.1 ## Installation - If your project using composer, run the below command ``` composer require razorpay/razorpay:2.* ``` - If you are not using composer, download the latest release from [the releases section](https://github.com/razorpay/razorpay-php/releases). **You should download the `razorpay-php.zip` file**. After that, include `Razorpay.php` in your application and you can use the API as usual. ##Note: This PHP library follows the following practices: - Namespaced under `Razorpay\Api` - API throws exceptions instead of returning errors - Options are passed as an array instead of multiple arguments wherever possible - All requests and responses are communicated over JSON ## Documentation Documentation of Razorpay's API and their usage is available at <https://docs.razorpay.com> ## Basic Usage Instantiate the razorpay php instance with `key_id` & `key_secret`. You can obtain the keys from the dashboard app ([https://dashboard.razorpay.com/#/app/keys](https://dashboard.razorpay.com/#/app/keys)) ```php use Razorpay\Api\Api; $api = new Api($api_key, $api_secret); ``` The resources can be accessed via the `$api` object. All the methods invocations follows the following pattern ```php // $api->class->function() to access the API //Example $api->payment->fetch($paymentId); ``` ## Supported Resources - [Account](documents/account.md) - [Customer](documents/customer.md) - [Token](documents/token.md) - [Order](documents/order.md) - [Payments](documents/payment.md) - [Settlements](documents/settlement.md) - [Refunds](documents/refund.md) - [Fund](documents/fund.md) - [Invoice](documents/invoice.md) - [Plan](documents/plan.md) - [Item](documents/item.md) - [Subscriptions](documents/subscription.md) - [Add-on](documents/addon.md) - [Payment Links](documents/paymentLink.md) - [Product Configuration](documents/productConfiguration.md) - [Smart Collect](documents/virtualaccount.md) - [Stakeholder](documents/stakeholder.md) - [Transfer](documents/transfer.md) - [QR Code](documents/qrcode.md) - [Emandate](documents/emandate.md) - [Cards](documents/card.md) - [Paper NACH](documents/papernach.md) - [UPI](documents/upi.md) - [Register Emandate and Charge First Payment Together](documents/registeremandate.md) - [Register NACH and Charge First Payment Together](documents/registernach.md) - [Payment Verification](documents/paymentVerfication.md) - [Webhook](documents/webhook.md) ## Development See the [doc.md](doc.md) file for getting started with development. ## Release Steps to follow for a release: 0. Merge the branch with the new code to master. 1. Bump the Version in `src/Api.php`. 2. Rename Unreleased to the new tag in `CHANGELOG.md` 3. Add a new empty "Unreleased" section at the top of `CHANGELOG.md` 4. Fix links at bottom in `CHANGELOG.md` 5. Commit 6. Tag the release and push to GitHub 7. A release should automatically be created once the travis build passes. Edit the release to add some description. ## License The Razorpay PHP SDK is released under the MIT License. See [LICENSE](LICENSE) file for more details. home/fluxyjvi/public_html/project/vendor/sebastian/diff/README.md 0000644 00000020170 15111065115 0020755 0 ustar 00 [](https://packagist.org/packages/sebastian/diff) [](https://github.com/sebastianbergmann/diff/actions) [](https://shepherd.dev/github/sebastianbergmann/diff) [](https://codecov.io/gh/sebastianbergmann/diff) # sebastian/diff Diff implementation for PHP, factored out of PHPUnit into a stand-alone component. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/diff ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/diff ``` ### Usage #### Generating diff The `Differ` class can be used to generate a textual representation of the difference between two strings: ```php <?php use SebastianBergmann\Diff\Differ; $differ = new Differ; print $differ->diff('foo', 'bar'); ``` The code above yields the output below: ```diff --- Original +++ New @@ @@ -foo +bar ``` There are three output builders available in this package: #### UnifiedDiffOutputBuilder This is default builder, which generates the output close to udiff and is used by PHPUnit. ```php <?php use SebastianBergmann\Diff\Differ; use SebastianBergmann\Diff\Output\UnifiedDiffOutputBuilder; $builder = new UnifiedDiffOutputBuilder( "--- Original\n+++ New\n", // custom header false // do not add line numbers to the diff ); $differ = new Differ($builder); print $differ->diff('foo', 'bar'); ``` #### StrictUnifiedDiffOutputBuilder Generates (strict) Unified diff's (unidiffs) with hunks, similar to `diff -u` and compatible with `patch` and `git apply`. ```php <?php use SebastianBergmann\Diff\Differ; use SebastianBergmann\Diff\Output\StrictUnifiedDiffOutputBuilder; $builder = new StrictUnifiedDiffOutputBuilder([ 'collapseRanges' => true, // ranges of length one are rendered with the trailing `,1` 'commonLineThreshold' => 6, // number of same lines before ending a new hunk and creating a new one (if needed) 'contextLines' => 3, // like `diff: -u, -U NUM, --unified[=NUM]`, for patch/git apply compatibility best to keep at least @ 3 'fromFile' => '', 'fromFileDate' => null, 'toFile' => '', 'toFileDate' => null, ]); $differ = new Differ($builder); print $differ->diff('foo', 'bar'); ``` #### DiffOnlyOutputBuilder Output only the lines that differ. ```php <?php use SebastianBergmann\Diff\Differ; use SebastianBergmann\Diff\Output\DiffOnlyOutputBuilder; $builder = new DiffOnlyOutputBuilder( "--- Original\n+++ New\n" ); $differ = new Differ($builder); print $differ->diff('foo', 'bar'); ``` #### DiffOutputBuilderInterface You can pass any output builder to the `Differ` class as longs as it implements the `DiffOutputBuilderInterface`. #### Parsing diff The `Parser` class can be used to parse a unified diff into an object graph: ```php use SebastianBergmann\Diff\Parser; use SebastianBergmann\Git; $git = new Git('/usr/local/src/money'); $diff = $git->getDiff( '948a1a07768d8edd10dcefa8315c1cbeffb31833', 'c07a373d2399f3e686234c4f7f088d635eb9641b' ); $parser = new Parser; print_r($parser->parse($diff)); ``` The code above yields the output below: Array ( [0] => SebastianBergmann\Diff\Diff Object ( [from:SebastianBergmann\Diff\Diff:private] => a/tests/MoneyTest.php [to:SebastianBergmann\Diff\Diff:private] => b/tests/MoneyTest.php [chunks:SebastianBergmann\Diff\Diff:private] => Array ( [0] => SebastianBergmann\Diff\Chunk Object ( [start:SebastianBergmann\Diff\Chunk:private] => 87 [startRange:SebastianBergmann\Diff\Chunk:private] => 7 [end:SebastianBergmann\Diff\Chunk:private] => 87 [endRange:SebastianBergmann\Diff\Chunk:private] => 7 [lines:SebastianBergmann\Diff\Chunk:private] => Array ( [0] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => * @covers SebastianBergmann\Money\Money::add ) [1] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => * @covers SebastianBergmann\Money\Money::newMoney ) [2] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => */ ) [3] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 2 [content:SebastianBergmann\Diff\Line:private] => public function testAnotherMoneyWithSameCurrencyObjectCanBeAdded() ) [4] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 1 [content:SebastianBergmann\Diff\Line:private] => public function testAnotherMoneyObjectWithSameCurrencyCanBeAdded() ) [5] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => { ) [6] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => $a = new Money(1, new Currency('EUR')); ) [7] => SebastianBergmann\Diff\Line Object ( [type:SebastianBergmann\Diff\Line:private] => 3 [content:SebastianBergmann\Diff\Line:private] => $b = new Money(2, new Currency('EUR')); ) ) ) ) ) ) Note: If the chunk size is 0 lines, i.e., `getStartRange()` or `getEndRange()` return 0, the number of line returned by `getStart()` or `getEnd()` is one lower than one would expect. It is the line number after which the chunk should be inserted or deleted; in all other cases, it gives the first line number of the replaced range of lines. home/fluxyjvi/public_html/project/vendor/laravel/framework/README.md 0000644 00000006651 15111065223 0021527 0 ustar 00 <p align="center"><a href="https://laravel.com" target="_blank"><img src="https://raw.githubusercontent.com/laravel/art/master/logo-lockup/5%20SVG/2%20CMYK/1%20Full%20Color/laravel-logolockup-cmyk-red.svg" width="400"></a></p> <p align="center"> <a href="https://github.com/laravel/framework/actions"><img src="https://github.com/laravel/framework/workflows/tests/badge.svg" alt="Build Status"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/dt/laravel/framework" alt="Total Downloads"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/v/laravel/framework" alt="Latest Stable Version"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/l/laravel/framework" alt="License"></a> </p> ## About Laravel > **Note:** This repository contains the core code of the Laravel framework. If you want to build an application using Laravel, visit the main [Laravel repository](https://github.com/laravel/laravel). Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable, creative experience to be truly fulfilling. Laravel attempts to take the pain out of development by easing common tasks used in the majority of web projects, such as: - [Simple, fast routing engine](https://laravel.com/docs/routing). - [Powerful dependency injection container](https://laravel.com/docs/container). - Multiple back-ends for [session](https://laravel.com/docs/session) and [cache](https://laravel.com/docs/cache) storage. - Database agnostic [schema migrations](https://laravel.com/docs/migrations). - [Robust background job processing](https://laravel.com/docs/queues). - [Real-time event broadcasting](https://laravel.com/docs/broadcasting). Laravel is accessible, yet powerful, providing tools needed for large, robust applications. A superb combination of simplicity, elegance, and innovation gives you a complete toolset required to build any application with which you are tasked. ## Learning Laravel Laravel has the most extensive and thorough documentation and video tutorial library of any modern web application framework. The [Laravel documentation](https://laravel.com/docs) is in-depth and complete, making it a breeze to get started learning the framework. You may also try the [Laravel Bootcamp](https://bootcamp.laravel.com), where you will be guided through building a modern Laravel application from scratch. If you're not in the mood to read, [Laracasts](https://laracasts.com) contains over 1100 video tutorials covering a range of topics including Laravel, modern PHP, unit testing, JavaScript, and more. Boost the skill level of yourself and your entire team by digging into our comprehensive video library. ## Contributing Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities Please review [our security policy](https://github.com/laravel/framework/security/policy) on how to report security vulnerabilities. ## License The Laravel framework is open-sourced software licensed under the [MIT license](LICENSE.md). home/fluxyjvi/public_html/project/vendor/spatie/ignition/README.md 0000644 00000034450 15111074114 0021206 0 ustar 00 # Ignition: a beautiful error page for PHP apps [](https://packagist.org/packages/spatie/ignition) [](https://github.com/spatie/ignition/actions/workflows/run-tests.yml) [](https://packagist.org/packages/spatie/ignition) [Ignition](https://flareapp.io/docs/ignition-for-laravel/introduction) is a beautiful and customizable error page for PHP applications Here's a minimal example on how to register ignition. ```php use Spatie\Ignition\Ignition; include 'vendor/autoload.php'; Ignition::make()->register(); ``` Let's now throw an exception during a web request. ```php throw new Exception('Bye world'); ``` This is what you'll see in the browser.  There's also a beautiful dark mode.  ## Are you a visual learner? In [this video on YouTube](https://youtu.be/LEY0N0Bteew?t=739), you'll see a demo of all of the features. Do know more about the design decisions we made, read [this blog post](https://freek.dev/2168-ignition-the-most-beautiful-error-page-for-laravel-and-php-got-a-major-redesign). ## Support us [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/ignition.jpg?t=1" width="419px" />](https://spatie.be/github-ad-click/ignition) We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us). We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards). ## Installation For Laravel apps, head over to [laravel-ignition](https://github.com/spatie/laravel-ignition). For Symfony apps, go to [symfony-ignition-bundle](https://github.com/spatie/symfony-ignition-bundle). For Drupal 10+ websites, use the [Ignition module](https://www.drupal.org/project/ignition). For all other PHP projects, install the package via composer: ```bash composer require spatie/ignition ``` ## Usage In order to display the Ignition error page when an error occurs in your project, you must add this code. Typically, this would be done in the bootstrap part of your application. ```php \Spatie\Ignition\Ignition::make()->register(); ``` ### Setting the application path When setting the application path, Ignition will trim the given value from all paths. This will make the error page look more cleaner. ```php \Spatie\Ignition\Ignition::make() ->applicationPath($basePathOfYourApplication) ->register(); ``` ### Using dark mode By default, Ignition uses a nice white based theme. If this is too bright for your eyes, you can use dark mode. ```php \Spatie\Ignition\Ignition::make() ->useDarkMode() ->register(); ``` ### Avoid rendering Ignition in a production environment You don't want to render the Ignition error page in a production environment, as it potentially can display sensitive information. To avoid rendering Ignition, you can call `shouldDisplayException` and pass it a falsy value. ```php \Spatie\Ignition\Ignition::make() ->shouldDisplayException($inLocalEnvironment) ->register(); ``` ### Displaying solutions In addition to displaying an exception, Ignition can display a solution as well. Out of the box, Ignition will display solutions for common errors such as bad methods calls, or using undefined properties. #### Adding a solution directly to an exception To add a solution text to your exception, let the exception implement the `Spatie\Ignition\Contracts\ProvidesSolution` interface. This interface requires you to implement one method, which is going to return the `Solution` that users will see when the exception gets thrown. ```php use Spatie\Ignition\Contracts\Solution; use Spatie\Ignition\Contracts\ProvidesSolution; class CustomException extends Exception implements ProvidesSolution { public function getSolution(): Solution { return new CustomSolution(); } } ``` ```php use Spatie\Ignition\Contracts\Solution; class CustomSolution implements Solution { public function getSolutionTitle(): string { return 'The solution title goes here'; } public function getSolutionDescription(): string { return 'This is a longer description of the solution that you want to show.'; } public function getDocumentationLinks(): array { return [ 'Your documentation' => 'https://your-project.com/relevant-docs-page', ]; } } ``` This is how the exception would be displayed if you were to throw it.  #### Using solution providers Instead of adding solutions to exceptions directly, you can also create a solution provider. While exceptions that return a solution, provide the solution directly to Ignition, a solution provider allows you to figure out if an exception can be solved. For example, you could create a custom "Stack Overflow solution provider", that will look up if a solution can be found for a given throwable. Solution providers can be added by third party packages or within your own application. A solution provider is any class that implements the \Spatie\Ignition\Contracts\HasSolutionsForThrowable interface. This is how the interface looks like: ```php interface HasSolutionsForThrowable { public function canSolve(Throwable $throwable): bool; /** @return \Spatie\Ignition\Contracts\Solution[] */ public function getSolutions(Throwable $throwable): array; } ``` When an error occurs in your app, the class will receive the `Throwable` in the `canSolve` method. In that method you can decide if your solution provider is applicable to the `Throwable` passed. If you return `true`, `getSolutions` will get called. To register a solution provider to Ignition you must call the `addSolutionProviders` method. ```php \Spatie\Ignition\Ignition::make() ->addSolutionProviders([ YourSolutionProvider::class, AnotherSolutionProvider::class, ]) ->register(); ``` ### AI powered solutions Ignition can send your exception to Open AI that will attempt to automatically suggest a solution. In many cases, the suggested solutions is quite useful, but keep in mind that the solution may not be 100% correct for your context. To generate AI powered solutions, you must first install this optional dependency. ```bash composer require openai-php/client ``` To start sending your errors to OpenAI, you must instanciate the `OpenAiSolutionProvider`. The constructor expects a OpenAI API key to be passed, you should generate this key [at OpenAI](https://platform.openai.com). ```php use \Spatie\Ignition\Solutions\OpenAi\OpenAiSolutionProvider; $aiSolutionProvider = new OpenAiSolutionProvider($openAiKey); ``` To use the solution provider, you should pass it to `addSolutionProviders` when registering Ignition. ```php \Spatie\Ignition\Ignition::make() ->addSolutionProviders([ $aiSolutionProvider, // other solution providers... ]) ->register(); ``` By default, the solution provider will send these bits of info to Open AI: - the error message - the error class - the stack frame - other small bits of info of context surrounding your error It will not send the request payload or any environment variables to avoid sending sensitive data to OpenAI. #### Caching requests to AI By default, all errors will be sent to OpenAI. Optionally, you can add caching so similar errors will only get sent to OpenAI once. To cache errors, you can call `useCache` on `$aiSolutionProvider`. You should pass [a simple-cache-implementation](https://packagist.org/providers/psr/simple-cache-implementation). Here's the signature of the `useCache` method. ```php public function useCache(CacheInterface $cache, int $cacheTtlInSeconds = 60 * 60) ``` #### Hinting the application type To increase the quality of the suggested solutions, you can send along the application type (Symfony, Drupal, WordPress, ...) to the AI. To send the application type call `applicationType` on the solution provider. ```php $aiSolutionProvider->applicationType('WordPress 6.2') ``` ### Sending exceptions to Flare Ignition comes with the ability to send exceptions to [Flare](https://flareapp.io), an exception monitoring service. Flare can notify you when new exceptions are occurring in your production environment. To send exceptions to Flare, simply call the `sendToFlareMethod` and pass it the API key you got when creating a project on Flare. You probably want to combine this with calling `runningInProductionEnvironment`. That method will, when passed a truthy value, not display the Ignition error page, but only send the exception to Flare. ```php \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->register(); ``` When you pass a falsy value to `runningInProductionEnvironment`, the Ignition error page will get shown, but no exceptions will be sent to Flare. ### Sending custom context to Flare When you send an error to Flare, you can add custom information that will be sent along with every exception that happens in your application. This can be very useful if you want to provide key-value related information that furthermore helps you to debug a possible exception. ```php use Spatie\FlareClient\Flare; \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->configureFlare(function(Flare $flare) { $flare->context('Tenant', 'My-Tenant-Identifier'); }) ->register(); ``` Sometimes you may want to group your context items by a key that you provide to have an easier visual differentiation when you look at your custom context items. The Flare client allows you to also provide your own custom context groups like this: ```php use Spatie\FlareClient\Flare; \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->configureFlare(function(Flare $flare) { $flare->group('Custom information', [ 'key' => 'value', 'another key' => 'another value', ]); }) ->register(); ``` ### Anonymize request to Flare By default, the Ignition collects information about the IP address of your application users. If you don't want to send this information to Flare, call `anonymizeIp()`. ```php use Spatie\FlareClient\Flare; \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->configureFlare(function(Flare $flare) { $flare->anonymizeIp(); }) ->register(); ``` ### Censoring request body fields When an exception occurs in a web request, the Flare client will pass on any request fields that are present in the body. In some cases, such as a login page, these request fields may contain a password that you don't want to send to Flare. To censor out values of certain fields, you can use `censorRequestBodyFields`. You should pass it the names of the fields you wish to censor. ```php use Spatie\FlareClient\Flare; \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->configureFlare(function(Flare $flare) { $flare->censorRequestBodyFields(['password']); }) ->register(); ``` This will replace the value of any sent fields named "password" with the value "<CENSORED>". ### Using middleware to modify data sent to Flare Before Flare receives the data that was collected from your local exception, we give you the ability to call custom middleware methods. These methods retrieve the report that should be sent to Flare and allow you to add custom information to that report. A valid middleware is any class that implements `FlareMiddleware`. ```php use Spatie\FlareClient\Report; use Spatie\FlareClient\FlareMiddleware\FlareMiddleware; class MyMiddleware implements FlareMiddleware { public function handle(Report $report, Closure $next) { $report->message("{$report->getMessage()}, now modified"); return $next($report); } } ``` ```php use Spatie\FlareClient\Flare; \Spatie\Ignition\Ignition::make() ->runningInProductionEnvironment($boolean) ->sendToFlare($yourApiKey) ->configureFlare(function(Flare $flare) { $flare->registerMiddleware([ MyMiddleware::class, ]) }) ->register(); ``` ### Changelog Please see [CHANGELOG](CHANGELOG.md) for more information about what has changed recently. ## Contributing Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details. ## Dev setup Here are the steps you'll need to perform if you want to work on the UI of Ignition. - clone (or move) `spatie/ignition`, `spatie/ignition-ui`, `spatie/laravel-ignition`, `spatie/flare-client-php` and `spatie/ignition-test` into the same directory (e.g. `~/code/flare`) - create a new `package.json` file in `~/code/flare` directory: ```json { "private": true, "workspaces": [ "ignition-ui", "ignition" ] } ``` - run `yarn install` in the `~/code/flare` directory - in the `~/code/flare/ignition-test` directory - run `composer update` - run `cp .env.example .env` - run `php artisan key:generate` - run `yarn dev` in both the `ignition` and `ignition-ui` project - http://ignition-test.test/ should now work (= show the new UI). If you use valet, you might want to run `valet park` inside the `~/code/flare` directory. - http://ignition-test.test/ has a bit of everything - http://ignition-test.test/sql-error has a solution and SQL exception ## Security Vulnerabilities Please review [our security policy](../../security/policy) on how to report security vulnerabilities. ## Credits - [Spatie](https://spatie.be) - [All Contributors](../../contributors) ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. home/fluxyjvi/public_html/project/vendor/composer/ca-bundle/README.md 0000644 00000004061 15111100137 0021550 0 ustar 00 composer/ca-bundle ================== Small utility library that lets you find a path to the system CA bundle, and includes a fallback to the Mozilla CA bundle. Originally written as part of [composer/composer](https://github.com/composer/composer), now extracted and made available as a stand-alone library. Installation ------------ Install the latest version with: ```bash $ composer require composer/ca-bundle ``` Requirements ------------ * PHP 5.3.2 is required but using the latest version of PHP is highly recommended. Basic usage ----------- ### `Composer\CaBundle\CaBundle` - `CaBundle::getSystemCaRootBundlePath()`: Returns the system CA bundle path, or a path to the bundled one as fallback - `CaBundle::getBundledCaBundlePath()`: Returns the path to the bundled CA file - `CaBundle::validateCaFile($filename)`: Validates a CA file using openssl_x509_parse only if it is safe to use - `CaBundle::isOpensslParseSafe()`: Test if it is safe to use the PHP function openssl_x509_parse() - `CaBundle::reset()`: Resets the static caches #### To use with curl ```php $curl = curl_init("https://example.org/"); $caPathOrFile = \Composer\CaBundle\CaBundle::getSystemCaRootBundlePath(); if (is_dir($caPathOrFile)) { curl_setopt($curl, CURLOPT_CAPATH, $caPathOrFile); } else { curl_setopt($curl, CURLOPT_CAINFO, $caPathOrFile); } $result = curl_exec($curl); ``` #### To use with php streams ```php $opts = array( 'http' => array( 'method' => "GET" ) ); $caPathOrFile = \Composer\CaBundle\CaBundle::getSystemCaRootBundlePath(); if (is_dir($caPathOrFile)) { $opts['ssl']['capath'] = $caPathOrFile; } else { $opts['ssl']['cafile'] = $caPathOrFile; } $context = stream_context_create($opts); $result = file_get_contents('https://example.com', false, $context); ``` #### To use with Guzzle ```php $client = new \GuzzleHttp\Client([ \GuzzleHttp\RequestOptions::VERIFY => \Composer\CaBundle\CaBundle::getSystemCaRootBundlePath() ]); ``` License ------- composer/ca-bundle is licensed under the MIT License, see the LICENSE file for details. home/fluxyjvi/public_html/project/vendor/psr/http-client/README.md 0000644 00000001045 15111123143 0021127 0 ustar 00 HTTP Client =========== This repository holds all the common code related to [PSR-18 (HTTP Client)][psr-url]. Note that this is not a HTTP Client implementation of its own. It is merely abstractions that describe the components of a HTTP Client. The installable [package][package-url] and [implementations][implementation-url] are listed on Packagist. [psr-url]: https://www.php-fig.org/psr/psr-18 [package-url]: https://packagist.org/packages/psr/http-client [implementation-url]: https://packagist.org/providers/psr/http-client-implementation home/fluxyjvi/public_html/project/vendor/psr/http-message/README.md 0000644 00000000774 15111127530 0021311 0 ustar 00 PSR Http Message ================ This repository holds all interfaces/classes/traits related to [PSR-7](http://www.php-fig.org/psr/psr-7/). Note that this is not a HTTP message implementation of its own. It is merely an interface that describes a HTTP message. See the specification for more details. Usage ----- Before reading the usage guide we recommend reading the PSR-7 interfaces method list: * [`PSR-7 Interfaces Method List`](docs/PSR7-Interfaces.md) * [`PSR-7 Usage Guide`](docs/PSR7-Usage.md) home/fluxyjvi/public_html/project/vendor/psr/event-dispatcher/README.md 0000644 00000000505 15111137566 0022157 0 ustar 00 PSR Event Dispatcher ==================== This repository holds the interfaces related to [PSR-14](http://www.php-fig.org/psr/psr-14/). Note that this is not an Event Dispatcher implementation of its own. It is merely interfaces that describe the components of an Event Dispatcher. See the specification for more details. home/fluxyjvi/public_html/project/vendor/doctrine/persistence/README.md 0000644 00000001166 15111153341 0022232 0 ustar 00 # Doctrine Persistence [](https://travis-ci.org/doctrine/persistence) [](https://codecov.io/gh/doctrine/persistence/branch/2.1.x) The Doctrine Persistence project is a library that provides common abstractions for object mapper persistence. ## More resources: * [Website](https://www.doctrine-project.org/) * [Documentation](https://www.doctrine-project.org/projects/doctrine-persistence/en/latest/index.html) * [Downloads](https://github.com/doctrine/persistence/releases) home/fluxyjvi/public_html/project/vendor/stripe/stripe-php/README.md 0000644 00000031105 15111156103 0021473 0 ustar 00 # Stripe PHP bindings [](https://github.com/stripe/stripe-php/actions?query=branch%3Amaster) [](https://packagist.org/packages/stripe/stripe-php) [](https://packagist.org/packages/stripe/stripe-php) [](https://packagist.org/packages/stripe/stripe-php) [](https://coveralls.io/r/stripe/stripe-php?branch=master) The Stripe PHP library provides convenient access to the Stripe API from applications written in the PHP language. It includes a pre-defined set of classes for API resources that initialize themselves dynamically from API responses which makes it compatible with a wide range of versions of the Stripe API. ## Requirements PHP 5.6.0 and later. ## Composer You can install the bindings via [Composer](http://getcomposer.org/). Run the following command: ```bash composer require stripe/stripe-php ``` To use the bindings, use Composer's [autoload](https://getcomposer.org/doc/01-basic-usage.md#autoloading): ```php require_once 'vendor/autoload.php'; ``` ## Manual Installation If you do not wish to use Composer, you can download the [latest release](https://github.com/stripe/stripe-php/releases). Then, to use the bindings, include the `init.php` file. ```php require_once '/path/to/stripe-php/init.php'; ``` ## Dependencies The bindings require the following extensions in order to work properly: - [`curl`](https://secure.php.net/manual/en/book.curl.php), although you can use your own non-cURL client if you prefer - [`json`](https://secure.php.net/manual/en/book.json.php) - [`mbstring`](https://secure.php.net/manual/en/book.mbstring.php) (Multibyte String) If you use Composer, these dependencies should be handled automatically. If you install manually, you'll want to make sure that these extensions are available. ## Getting Started Simple usage looks like: ```php $stripe = new \Stripe\StripeClient('sk_test_BQokikJOvBiI2HlWgH4olfQ2'); $customer = $stripe->customers->create([ 'description' => 'example customer', 'email' => 'email@example.com', 'payment_method' => 'pm_card_visa', ]); echo $customer; ``` ### Client/service patterns vs legacy patterns You can continue to use the legacy integration patterns used prior to version [7.33.0](https://github.com/stripe/stripe-php/blob/master/CHANGELOG.md#7330---2020-05-14). Review the [migration guide](https://github.com/stripe/stripe-php/wiki/Migration-to-StripeClient-and-services-in-7.33.0) for the backwards-compatible client/services pattern changes. ## Documentation See the [PHP API docs](https://stripe.com/docs/api/?lang=php#intro). See [video demonstrations][youtube-playlist] covering how to use the library. ## Legacy Version Support ### PHP 5.4 & 5.5 If you are using PHP 5.4 or 5.5, you should consider upgrading your environment as those versions have been past end of life since September 2015 and July 2016 respectively. Otherwise, you can still use Stripe by downloading stripe-php v6.43.1 ([zip](https://github.com/stripe/stripe-php/archive/v6.43.1.zip), [tar.gz](https://github.com/stripe/stripe-php/archive/6.43.1.tar.gz)) from our [releases page](https://github.com/stripe/stripe-php/releases). This version will work but might not support recent features we added since the version was released and upgrading PHP is the best course of action. ### PHP 5.3 If you are using PHP 5.3, you should upgrade your environment as this version has been past end of life since August 2014. Otherwise, you can download v5.9.2 ([zip](https://github.com/stripe/stripe-php/archive/v5.9.2.zip), [tar.gz](https://github.com/stripe/stripe-php/archive/v5.9.2.tar.gz)) from our [releases page](https://github.com/stripe/stripe-php/releases). This version will continue to work with new versions of the Stripe API for all common uses. ## Custom Request Timeouts > **Note** > We do not recommend decreasing the timeout for non-read-only calls (e.g. charge creation), since even if you locally timeout, the request on Stripe's side can still complete. If you are decreasing timeouts on these calls, make sure to use [idempotency tokens](https://stripe.com/docs/api/?lang=php#idempotent_requests) to avoid executing the same transaction twice as a result of timeout retry logic. To modify request timeouts (connect or total, in seconds) you'll need to tell the API client to use a CurlClient other than its default. You'll set the timeouts in that CurlClient. ```php // set up your tweaked Curl client $curl = new \Stripe\HttpClient\CurlClient(); $curl->setTimeout(10); // default is \Stripe\HttpClient\CurlClient::DEFAULT_TIMEOUT $curl->setConnectTimeout(5); // default is \Stripe\HttpClient\CurlClient::DEFAULT_CONNECT_TIMEOUT echo $curl->getTimeout(); // 10 echo $curl->getConnectTimeout(); // 5 // tell Stripe to use the tweaked client \Stripe\ApiRequestor::setHttpClient($curl); // use the Stripe API client as you normally would ``` ## Custom cURL Options (e.g. proxies) Need to set a proxy for your requests? Pass in the requisite `CURLOPT_*` array to the CurlClient constructor, using the same syntax as `curl_stopt_array()`. This will set the default cURL options for each HTTP request made by the SDK, though many more common options (e.g. timeouts; see above on how to set those) will be overridden by the client even if set here. ```php // set up your tweaked Curl client $curl = new \Stripe\HttpClient\CurlClient([CURLOPT_PROXY => 'proxy.local:80']); // tell Stripe to use the tweaked client \Stripe\ApiRequestor::setHttpClient($curl); ``` Alternately, a callable can be passed to the CurlClient constructor that returns the above array based on request inputs. See `testDefaultOptions()` in `tests/CurlClientTest.php` for an example of this behavior. Note that the callable is called at the beginning of every API request, before the request is sent. ### Configuring a Logger The library does minimal logging, but it can be configured with a [`PSR-3` compatible logger][psr3] so that messages end up there instead of `error_log`: ```php \Stripe\Stripe::setLogger($logger); ``` ### Accessing response data You can access the data from the last API response on any object via `getLastResponse()`. ```php $customer = $stripe->customers->create([ 'description' => 'example customer', ]); echo $customer->getLastResponse()->headers['Request-Id']; ``` ### SSL / TLS compatibility issues Stripe's API now requires that [all connections use TLS 1.2](https://stripe.com/blog/upgrading-tls). Some systems (most notably some older CentOS and RHEL versions) are capable of using TLS 1.2 but will use TLS 1.0 or 1.1 by default. In this case, you'd get an `invalid_request_error` with the following error message: "Stripe no longer supports API requests made with TLS 1.0. Please initiate HTTPS connections with TLS 1.2 or later. You can learn more about this at [https://stripe.com/blog/upgrading-tls](https://stripe.com/blog/upgrading-tls).". The recommended course of action is to [upgrade your cURL and OpenSSL packages](https://support.stripe.com/questions/how-do-i-upgrade-my-stripe-integration-from-tls-1-0-to-tls-1-2#php) so that TLS 1.2 is used by default, but if that is not possible, you might be able to solve the issue by setting the `CURLOPT_SSLVERSION` option to either `CURL_SSLVERSION_TLSv1` or `CURL_SSLVERSION_TLSv1_2`: ```php $curl = new \Stripe\HttpClient\CurlClient([CURLOPT_SSLVERSION => CURL_SSLVERSION_TLSv1]); \Stripe\ApiRequestor::setHttpClient($curl); ``` ### Per-request Configuration For apps that need to use multiple keys during the lifetime of a process, like one that uses [Stripe Connect][connect], it's also possible to set a per-request key and/or account: ```php $customers = $stripe->customers->all([],[ 'api_key' => 'sk_test_...', 'stripe_account' => 'acct_...' ]); $stripe->customers->retrieve('cus_123456789', [], [ 'api_key' => 'sk_test_...', 'stripe_account' => 'acct_...' ]); ``` ### Configuring CA Bundles By default, the library will use its own internal bundle of known CA certificates, but it's possible to configure your own: ```php \Stripe\Stripe::setCABundlePath("path/to/ca/bundle"); ``` ### Configuring Automatic Retries The library can be configured to automatically retry requests that fail due to an intermittent network problem: ```php \Stripe\Stripe::setMaxNetworkRetries(2); ``` [Idempotency keys][idempotency-keys] are added to requests to guarantee that retries are safe. ### Request latency telemetry By default, the library sends request latency telemetry to Stripe. These numbers help Stripe improve the overall latency of its API for all users. You can disable this behavior if you prefer: ```php \Stripe\Stripe::setEnableTelemetry(false); ``` ### Beta SDKs Stripe has features in the beta phase that can be accessed via the beta version of this package. We would love for you to try these and share feedback with us before these features reach the stable phase. Use the `composer require` command with an exact version specified to install the beta version of the stripe-php pacakge. ```bash composer require stripe/stripe-php:v9.2.0-beta.1 ``` > **Note** > There can be breaking changes between beta versions. Therefore we recommend pinning the package version to a specific beta version in your composer.json file. This way you can install the same version each time without breaking changes unless you are intentionally looking for the latest beta version. We highly recommend keeping an eye on when the beta feature you are interested in goes from beta to stable so that you can move from using a beta version of the SDK to the stable version. If your beta feature requires a `Stripe-Version` header to be sent, use the `apiVersion` property of `config` object to set it: ```php Stripe::setApiVersion(Stripe::getApiVersion() . '; feature_beta=v3'); ``` ## Support New features and bug fixes are released on the latest major version of the Stripe PHP library. If you are on an older major version, we recommend that you upgrade to the latest in order to use the new features and bug fixes including those for security vulnerabilities. Older major versions of the package will continue to be available for use, but will not be receiving any updates. ## Development Get [Composer][composer]. For example, on Mac OS: ```bash brew install composer ``` Install dependencies: ```bash composer install ``` The test suite depends on [stripe-mock], so make sure to fetch and run it from a background terminal ([stripe-mock's README][stripe-mock] also contains instructions for installing via Homebrew and other methods): ```bash go install github.com/stripe/stripe-mock@latest stripe-mock ``` Install dependencies as mentioned above (which will resolve [PHPUnit](http://packagist.org/packages/phpunit/phpunit)), then you can run the test suite: ```bash ./vendor/bin/phpunit ``` Or to run an individual test file: ```bash ./vendor/bin/phpunit tests/Stripe/UtilTest.php ``` Update bundled CA certificates from the [Mozilla cURL release][curl]: ```bash ./update_certs.php ``` The library uses [PHP CS Fixer][php-cs-fixer] for code formatting. Code must be formatted before PRs are submitted, otherwise CI will fail. Run the formatter with: ```bash ./vendor/bin/php-cs-fixer fix -v . ``` ## Attention plugin developers Are you writing a plugin that integrates Stripe and embeds our library? Then please use the `setAppInfo` function to identify your plugin. For example: ```php \Stripe\Stripe::setAppInfo("MyAwesomePlugin", "1.2.34", "https://myawesomeplugin.info"); ``` The method should be called once, before any request is sent to the API. The second and third parameters are optional. ### SSL / TLS configuration option See the "SSL / TLS compatibility issues" paragraph above for full context. If you want to ensure that your plugin can be used on all systems, you should add a configuration option to let your users choose between different values for `CURLOPT_SSLVERSION`: none (default), `CURL_SSLVERSION_TLSv1` and `CURL_SSLVERSION_TLSv1_2`. [composer]: https://getcomposer.org/ [connect]: https://stripe.com/connect [curl]: http://curl.haxx.se/docs/caextract.html [idempotency-keys]: https://stripe.com/docs/api/?lang=php#idempotent_requests [php-cs-fixer]: https://github.com/FriendsOfPHP/PHP-CS-Fixer [psr3]: http://www.php-fig.org/psr/psr-3/ [stripe-mock]: https://github.com/stripe/stripe-mock [youtube-playlist]: https://www.youtube.com/playlist?list=PLy1nL-pvL2M6cUbiHrfMkXxZ9j9SGBxFE home/fluxyjvi/public_html/project/vendor/php-http/message/README.md 0000644 00000002460 15111160716 0021271 0 ustar 00 # HTTP Message [](https://github.com/php-http/message/releases) [](LICENSE) [](https://github.com/php-http/message/actions/workflows/ci.yml) [](https://packagist.org/packages/php-http/message) **HTTP Message related tools.** ## Install Via Composer ``` bash $ composer require php-http/message ``` ## Intro This package contains various PSR-7 tools which might be useful in an HTTP workflow: - Authentication method implementations - Various Stream encoding tools - Message decorators - Message factory implementations for Guzzle PSR-7 and Diactoros - Cookie implementation - Request matchers ## Documentation Please see the [official documentation](http://docs.php-http.org/en/latest/message.html). ## Testing ``` bash $ composer test ``` ## Credits Thanks to [Cuzzle](https://github.com/namshi/cuzzle) for inpiration for the `CurlCommandFormatter`. ## License The MIT License (MIT). Please see [License File](LICENSE) for more information. home/fluxyjvi/public_html/project/vendor/php-http/httplug/README.md 0000644 00000003554 15111163370 0021340 0 ustar 00 # HTTPlug [](https://github.com/php-http/httplug/releases) [](LICENSE) [](https://github.com/php-http/httplug/actions/workflows/ci.yml) [](https://scrutinizer-ci.com/g/php-http/httplug) [](https://scrutinizer-ci.com/g/php-http/httplug) [](https://packagist.org/packages/php-http/httplug) [](mailto:team@httplug.io) **HTTPlug, the HTTP client abstraction for PHP.** ## Intro HTTP client standard built on [PSR-7](http://www.php-fig.org/psr/psr-7/) HTTP messages. The HttpAsyncClient defines an asynchronous HTTP client for PHP. This package also provides a synchronous HttpClient interface with the same method signature as the [PSR-18](http://www.php-fig.org/psr/psr-18/) client. For synchronous requests, we recommend using PSR-18 directly. ## History HTTPlug is the official successor of the [ivory http adapter](https://github.com/egeloen/ivory-http-adapter). HTTPlug is a predecessor of [PSR-18](http://www.php-fig.org/psr/psr-18/) ## Install Via Composer ``` bash $ composer require php-http/httplug ``` ## Documentation Please see the [official documentation](http://docs.php-http.org). ## Testing ``` bash $ composer test ``` ## License The MIT License (MIT). Please see [License File](LICENSE) for more information. home/fluxyjvi/public_html/project/vendor/symfony/finder/README.md 0000644 00000000757 15111164355 0021066 0 ustar 00 Finder Component ================ The Finder component finds files and directories via an intuitive fluent interface. Resources --------- * [Documentation](https://symfony.com/doc/current/components/finder.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) home/fluxyjvi/public_html/project/vendor/symfony/mailer/README.md 0000644 00000004115 15111164507 0021057 0 ustar 00 Mailer Component ================ The Mailer component helps sending emails. Getting Started --------------- ``` $ composer require symfony/mailer ``` ```php use Symfony\Component\Mailer\Transport; use Symfony\Component\Mailer\Mailer; use Symfony\Component\Mime\Email; $transport = Transport::fromDsn('smtp://localhost'); $mailer = new Mailer($transport); $email = (new Email()) ->from('hello@example.com') ->to('you@example.com') //->cc('cc@example.com') //->bcc('bcc@example.com') //->replyTo('fabien@example.com') //->priority(Email::PRIORITY_HIGH) ->subject('Time for Symfony Mailer!') ->text('Sending emails is fun again!') ->html('<p>See Twig integration for better HTML integration!</p>'); $mailer->send($email); ``` To enable the Twig integration of the Mailer, require `symfony/twig-bridge` and set up the `BodyRenderer`: ```php use Symfony\Bridge\Twig\Mime\BodyRenderer; use Symfony\Bridge\Twig\Mime\TemplatedEmail; use Symfony\Component\EventDispatcher\EventDispatcher; use Symfony\Component\Mailer\EventListener\MessageListener; use Symfony\Component\Mailer\Mailer; use Symfony\Component\Mailer\Transport; use Twig\Environment as TwigEnvironment; $twig = new TwigEnvironment(...); $messageListener = new MessageListener(null, new BodyRenderer($twig)); $eventDispatcher = new EventDispatcher(); $eventDispatcher->addSubscriber($messageListener); $transport = Transport::fromDsn('smtp://localhost', $eventDispatcher); $mailer = new Mailer($transport, null, $eventDispatcher); $email = (new TemplatedEmail()) // ... ->htmlTemplate('emails/signup.html.twig') ->context([ 'expiration_date' => new \DateTime('+7 days'), 'username' => 'foo', ]) ; $mailer->send($email); ``` Resources --------- * [Documentation](https://symfony.com/doc/current/mailer.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) home/fluxyjvi/public_html/project/vendor/php-http/promise/README.md 0000644 00000003115 15111165636 0021327 0 ustar 00 # Promise [](https://github.com/php-http/promise/releases) [](LICENSE) [](https://github.com/php-http/promise/actions/workflows/tests.yml) [](https://scrutinizer-ci.com/g/php-http/promise) [](https://scrutinizer-ci.com/g/php-http/promise) [](https://packagist.org/packages/php-http/promise) **Promise used for asynchronous HTTP requests.** **Note:** This will eventually be removed/deprecated and replaced with the upcoming Promise PSR. ## Install Via Composer ``` bash $ composer require php-http/promise ``` ## Documentation Please see the [official documentation](http://docs.php-http.org/en/latest/components/promise.html). ## Testing ``` bash $ composer test ``` ## Contributing Please see our [contributing guide](http://docs.php-http.org/en/latest/development/contributing.html). ## Security If you discover any security related issues, please contact us at [security@php-http.org](mailto:security@php-http.org). ## License The MIT License (MIT). Please see [License File](LICENSE) for more information. home/fluxyjvi/public_html/project/vendor/symfony/uid/README.md 0000644 00000001134 15111167757 0020377 0 ustar 00 Uid Component ============= The UID component provides an object-oriented API to generate and represent UIDs. It provides implementations that work on 32-bit and 64-bit CPUs for ULIDs and for UUIDs version 1 and versions 3 to 8. Resources --------- * [Documentation](https://symfony.com/doc/current/components/uid.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) home/fluxyjvi/public_html/project/vendor/symfony/dom-crawler/README.md 0000644 00000000762 15111171743 0022026 0 ustar 00 DomCrawler Component ==================== The DomCrawler component eases DOM navigation for HTML and XML documents. Resources --------- * [Documentation](https://symfony.com/doc/current/components/dom_crawler.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) home/fluxyjvi/public_html/project/vendor/spatie/browsershot/README.md 0000644 00000007767 15111172756 0021775 0 ustar 00 <p align="center"><img src="/art/socialcard.png" alt="Social Card of Spatie's Browsershot"></p> # Convert a webpage to an image or pdf using headless Chrome [](https://github.com/spatie/browsershot/releases) [](LICENSE.md) [](https://github.com/spatie/browsershot/actions) [](https://packagist.org/packages/spatie/browsershot) The package can convert a webpage to an image or pdf. The conversion is done behind the scenes by [Puppeteer](https://github.com/GoogleChrome/puppeteer) which controls a headless version of Google Chrome. Here's a quick example: ```php use Spatie\Browsershot\Browsershot; // an image will be saved Browsershot::url('https://example.com')->save($pathToImage); ``` It will save a pdf if the path passed to the `save` method has a `pdf` extension. ```php // a pdf will be saved Browsershot::url('https://example.com')->save('example.pdf'); ``` You can also use an arbitrary html input, simply replace the `url` method with `html`: ```php Browsershot::html('<h1>Hello world!!</h1>')->save('example.pdf'); ``` If your HTML input is already in a file locally use the : ```php Browsershot::htmlFromFilePath('/local/path/to/file.html')->save('example.pdf'); ``` Browsershot also can get the body of an html page after JavaScript has been executed: ```php Browsershot::url('https://example.com')->bodyHtml(); // returns the html of the body ``` If you wish to retrieve an array list with all of the requests that the page triggered you can do so: ```php $requests = Browsershot::url('https://example.com') ->triggeredRequests(); foreach ($requests as $request) { $url = $request['url']; //https://example.com/ } ``` To use Chrome's new [headless mode](https://developers.google.com/web/updates/2017/04/headless-chrome) pass the `newHeadless` method: ```php Browsershot::url('https://example.com')->newHeadless()->save($pathToImage); ``` ## Support us Learn how to create a package like this one, by watching our premium video course: [](https://laravelpackage.training) We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us). We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards). ## Documentation All documentation is available [on our documentation site](https://spatie.be/docs/browsershot). ## Contributing Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details. ## Security If you've found a bug regarding security please mail [security@spatie.be](mailto:security@spatie.be) instead of using the issue tracker. ## Alternatives If you're not able to install Node and Puppeteer, take a look at [v2 of browsershot](https://github.com/spatie/browsershot/tree/2.4.1), which uses Chrome headless CLI to take a screenshot. `v2` is not maintained anymore, but should work pretty well. If using headless Chrome does not work for you take a look at at `v1` of this package which uses the abandoned `PhantomJS` binary. ## Credits - [Freek Van der Herten](https://github.com/freekmurze) - [All Contributors](../../contributors) And a special thanks to [Caneco](https://twitter.com/caneco) for the logo β¨ ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. home/fluxyjvi/public_html/project/vendor/psr/container/README.md 0000644 00000001102 15111174066 0020662 0 ustar 00 Container interface ============== This repository holds all interfaces related to [PSR-11 (Container Interface)][psr-url]. Note that this is not a Container implementation of its own. It is merely abstractions that describe the components of a Dependency Injection Container. The installable [package][package-url] and [implementations][implementation-url] are listed on Packagist. [psr-url]: https://www.php-fig.org/psr/psr-11/ [package-url]: https://packagist.org/packages/psr/container [implementation-url]: https://packagist.org/providers/psr/container-implementation home/fluxyjvi/public_html/project/vendor/phpunit/phpunit/README.md 0000644 00000004202 15111174376 0021262 0 ustar 00 <h1 align="center">πΊπ¦ <a href="https://phpunit.de/stand-with-ukraine.html">UKRAINE NEEDS YOUR HELP NOW!</a></h1> # PHPUnit [](https://packagist.org/packages/phpunit/phpunit) [](https://github.com/sebastianbergmann/phpunit/actions) [](https://shepherd.dev/github/sebastianbergmann/phpunit) [](https://codecov.io/gh/sebastianbergmann/phpunit) PHPUnit is a programmer-oriented testing framework for PHP. It is an instance of the xUnit architecture for unit testing frameworks. ## Installation We distribute a [PHP Archive (PHAR)](https://php.net/phar) that has all required (as well as some optional) dependencies of PHPUnit bundled in a single file: ```bash $ wget https://phar.phpunit.de/phpunit-X.Y.phar $ php phpunit-X.Y.phar --version ``` Please replace `X.Y` with the version of PHPUnit you are interested in. Alternatively, you may use [Composer](https://getcomposer.org/) to download and install PHPUnit as well as its dependencies. Please refer to the "[Getting Started](https://phpunit.de/getting-started-with-phpunit.html)" guide for details on how to install PHPUnit. ## Contribute Please refer to [CONTRIBUTING.md](https://github.com/sebastianbergmann/phpunit/blob/main/.github/CONTRIBUTING.md) for information on how to contribute to PHPUnit and its related projects. ## List of Contributors Thanks to everyone who has contributed to PHPUnit! You can find a detailed list of contributors on every PHPUnit related package on GitHub. This list shows only the major components: * [PHPUnit](https://github.com/sebastianbergmann/phpunit/graphs/contributors) * [php-code-coverage](https://github.com/sebastianbergmann/php-code-coverage/graphs/contributors) A very special thanks to everyone who has contributed to the [documentation](https://github.com/sebastianbergmann/phpunit-documentation-english/graphs/contributors). home/fluxyjvi/public_html/project/vendor/webmozart/assert/README.md 0000644 00000037316 15111175553 0021431 0 ustar 00 Webmozart Assert ================ [](https://packagist.org/packages/webmozart/assert) [](https://packagist.org/packages/webmozart/assert) This library contains efficient assertions to test the input and output of your methods. With these assertions, you can greatly reduce the amount of coding needed to write a safe implementation. All assertions in the [`Assert`] class throw an `Webmozart\Assert\InvalidArgumentException` if they fail. FAQ --- **What's the difference to [beberlei/assert]?** This library is heavily inspired by Benjamin Eberlei's wonderful [assert package], but fixes a usability issue with error messages that can't be fixed there without breaking backwards compatibility. This package features usable error messages by default. However, you can also easily write custom error messages: ``` Assert::string($path, 'The path is expected to be a string. Got: %s'); ``` In [beberlei/assert], the ordering of the `%s` placeholders is different for every assertion. This package, on the contrary, provides consistent placeholder ordering for all assertions: * `%s`: The tested value as string, e.g. `"/foo/bar"`. * `%2$s`, `%3$s`, ...: Additional assertion-specific values, e.g. the minimum/maximum length, allowed values, etc. Check the source code of the assertions to find out details about the additional available placeholders. Installation ------------ Use [Composer] to install the package: ```bash composer require webmozart/assert ``` Example ------- ```php use Webmozart\Assert\Assert; class Employee { public function __construct($id) { Assert::integer($id, 'The employee ID must be an integer. Got: %s'); Assert::greaterThan($id, 0, 'The employee ID must be a positive integer. Got: %s'); } } ``` If you create an employee with an invalid ID, an exception is thrown: ```php new Employee('foobar'); // => Webmozart\Assert\InvalidArgumentException: // The employee ID must be an integer. Got: string new Employee(-10); // => Webmozart\Assert\InvalidArgumentException: // The employee ID must be a positive integer. Got: -10 ``` Assertions ---------- The [`Assert`] class provides the following assertions: ### Type Assertions Method | Description -------------------------------------------------------- | -------------------------------------------------- `string($value, $message = '')` | Check that a value is a string `stringNotEmpty($value, $message = '')` | Check that a value is a non-empty string `integer($value, $message = '')` | Check that a value is an integer `integerish($value, $message = '')` | Check that a value casts to an integer `positiveInteger($value, $message = '')` | Check that a value is a positive (non-zero) integer `float($value, $message = '')` | Check that a value is a float `numeric($value, $message = '')` | Check that a value is numeric `natural($value, $message= ''')` | Check that a value is a non-negative integer `boolean($value, $message = '')` | Check that a value is a boolean `scalar($value, $message = '')` | Check that a value is a scalar `object($value, $message = '')` | Check that a value is an object `resource($value, $type = null, $message = '')` | Check that a value is a resource `isCallable($value, $message = '')` | Check that a value is a callable `isArray($value, $message = '')` | Check that a value is an array `isTraversable($value, $message = '')` (deprecated) | Check that a value is an array or a `\Traversable` `isIterable($value, $message = '')` | Check that a value is an array or a `\Traversable` `isCountable($value, $message = '')` | Check that a value is an array or a `\Countable` `isInstanceOf($value, $class, $message = '')` | Check that a value is an `instanceof` a class `isInstanceOfAny($value, array $classes, $message = '')` | Check that a value is an `instanceof` at least one class on the array of classes `notInstanceOf($value, $class, $message = '')` | Check that a value is not an `instanceof` a class `isAOf($value, $class, $message = '')` | Check that a value is of the class or has one of its parents `isAnyOf($value, array $classes, $message = '')` | Check that a value is of at least one of the classes or has one of its parents `isNotA($value, $class, $message = '')` | Check that a value is not of the class or has not one of its parents `isArrayAccessible($value, $message = '')` | Check that a value can be accessed as an array `uniqueValues($values, $message = '')` | Check that the given array contains unique values ### Comparison Assertions Method | Description ----------------------------------------------- | ------------------------------------------------------------------ `true($value, $message = '')` | Check that a value is `true` `false($value, $message = '')` | Check that a value is `false` `notFalse($value, $message = '')` | Check that a value is not `false` `null($value, $message = '')` | Check that a value is `null` `notNull($value, $message = '')` | Check that a value is not `null` `isEmpty($value, $message = '')` | Check that a value is `empty()` `notEmpty($value, $message = '')` | Check that a value is not `empty()` `eq($value, $value2, $message = '')` | Check that a value equals another (`==`) `notEq($value, $value2, $message = '')` | Check that a value does not equal another (`!=`) `same($value, $value2, $message = '')` | Check that a value is identical to another (`===`) `notSame($value, $value2, $message = '')` | Check that a value is not identical to another (`!==`) `greaterThan($value, $value2, $message = '')` | Check that a value is greater than another `greaterThanEq($value, $value2, $message = '')` | Check that a value is greater than or equal to another `lessThan($value, $value2, $message = '')` | Check that a value is less than another `lessThanEq($value, $value2, $message = '')` | Check that a value is less than or equal to another `range($value, $min, $max, $message = '')` | Check that a value is within a range `inArray($value, array $values, $message = '')` | Check that a value is one of a list of values `oneOf($value, array $values, $message = '')` | Check that a value is one of a list of values (alias of `inArray`) ### String Assertions You should check that a value is a string with `Assert::string()` before making any of the following assertions. Method | Description --------------------------------------------------- | ----------------------------------------------------------------- `contains($value, $subString, $message = '')` | Check that a string contains a substring `notContains($value, $subString, $message = '')` | Check that a string does not contain a substring `startsWith($value, $prefix, $message = '')` | Check that a string has a prefix `notStartsWith($value, $prefix, $message = '')` | Check that a string does not have a prefix `startsWithLetter($value, $message = '')` | Check that a string starts with a letter `endsWith($value, $suffix, $message = '')` | Check that a string has a suffix `notEndsWith($value, $suffix, $message = '')` | Check that a string does not have a suffix `regex($value, $pattern, $message = '')` | Check that a string matches a regular expression `notRegex($value, $pattern, $message = '')` | Check that a string does not match a regular expression `unicodeLetters($value, $message = '')` | Check that a string contains Unicode letters only `alpha($value, $message = '')` | Check that a string contains letters only `digits($value, $message = '')` | Check that a string contains digits only `alnum($value, $message = '')` | Check that a string contains letters and digits only `lower($value, $message = '')` | Check that a string contains lowercase characters only `upper($value, $message = '')` | Check that a string contains uppercase characters only `length($value, $length, $message = '')` | Check that a string has a certain number of characters `minLength($value, $min, $message = '')` | Check that a string has at least a certain number of characters `maxLength($value, $max, $message = '')` | Check that a string has at most a certain number of characters `lengthBetween($value, $min, $max, $message = '')` | Check that a string has a length in the given range `uuid($value, $message = '')` | Check that a string is a valid UUID `ip($value, $message = '')` | Check that a string is a valid IP (either IPv4 or IPv6) `ipv4($value, $message = '')` | Check that a string is a valid IPv4 `ipv6($value, $message = '')` | Check that a string is a valid IPv6 `email($value, $message = '')` | Check that a string is a valid e-mail address `notWhitespaceOnly($value, $message = '')` | Check that a string contains at least one non-whitespace character ### File Assertions Method | Description ----------------------------------- | -------------------------------------------------- `fileExists($value, $message = '')` | Check that a value is an existing path `file($value, $message = '')` | Check that a value is an existing file `directory($value, $message = '')` | Check that a value is an existing directory `readable($value, $message = '')` | Check that a value is a readable path `writable($value, $message = '')` | Check that a value is a writable path ### Object Assertions Method | Description ----------------------------------------------------- | -------------------------------------------------- `classExists($value, $message = '')` | Check that a value is an existing class name `subclassOf($value, $class, $message = '')` | Check that a class is a subclass of another `interfaceExists($value, $message = '')` | Check that a value is an existing interface name `implementsInterface($value, $class, $message = '')` | Check that a class implements an interface `propertyExists($value, $property, $message = '')` | Check that a property exists in a class/object `propertyNotExists($value, $property, $message = '')` | Check that a property does not exist in a class/object `methodExists($value, $method, $message = '')` | Check that a method exists in a class/object `methodNotExists($value, $method, $message = '')` | Check that a method does not exist in a class/object ### Array Assertions Method | Description -------------------------------------------------- | ------------------------------------------------------------------ `keyExists($array, $key, $message = '')` | Check that a key exists in an array `keyNotExists($array, $key, $message = '')` | Check that a key does not exist in an array `validArrayKey($key, $message = '')` | Check that a value is a valid array key (int or string) `count($array, $number, $message = '')` | Check that an array contains a specific number of elements `minCount($array, $min, $message = '')` | Check that an array contains at least a certain number of elements `maxCount($array, $max, $message = '')` | Check that an array contains at most a certain number of elements `countBetween($array, $min, $max, $message = '')` | Check that an array has a count in the given range `isList($array, $message = '')` | Check that an array is a non-associative list `isNonEmptyList($array, $message = '')` | Check that an array is a non-associative list, and not empty `isMap($array, $message = '')` | Check that an array is associative and has strings as keys `isNonEmptyMap($array, $message = '')` | Check that an array is associative and has strings as keys, and is not empty ### Function Assertions Method | Description ------------------------------------------- | ----------------------------------------------------------------------------------------------------- `throws($closure, $class, $message = '')` | Check that a function throws a certain exception. Subclasses of the exception class will be accepted. ### Collection Assertions All of the above assertions can be prefixed with `all*()` to test the contents of an array or a `\Traversable`: ```php Assert::allIsInstanceOf($employees, 'Acme\Employee'); ``` ### Nullable Assertions All of the above assertions can be prefixed with `nullOr*()` to run the assertion only if it the value is not `null`: ```php Assert::nullOrString($middleName, 'The middle name must be a string or null. Got: %s'); ``` ### Extending Assert The `Assert` class comes with a few methods, which can be overridden to change the class behaviour. You can also extend it to add your own assertions. #### Overriding methods Overriding the following methods in your assertion class allows you to change the behaviour of the assertions: * `public static function __callStatic($name, $arguments)` * This method is used to 'create' the `nullOr` and `all` versions of the assertions. * `protected static function valueToString($value)` * This method is used for error messages, to convert the value to a string value for displaying. You could use this for representing a value object with a `__toString` method for example. * `protected static function typeToString($value)` * This method is used for error messages, to convert the a value to a string representing its type. * `protected static function strlen($value)` * This method is used to calculate string length for relevant methods, using the `mb_strlen` if available and useful. * `protected static function reportInvalidArgument($message)` * This method is called when an assertion fails, with the specified error message. Here you can throw your own exception, or log something. ## Static analysis support Where applicable, assertion functions are annotated to support Psalm's [Assertion syntax](https://psalm.dev/docs/annotating_code/assertion_syntax/). A dedicated [PHPStan Plugin](https://github.com/phpstan/phpstan-webmozart-assert) is required for proper type support. Authors ------- * [Bernhard Schussek] a.k.a. [@webmozart] * [The Community Contributors] Contribute ---------- Contributions to the package are always welcome! * Report any bugs or issues you find on the [issue tracker]. * You can grab the source code at the package's [Git repository]. License ------- All contents of this package are licensed under the [MIT license]. [beberlei/assert]: https://github.com/beberlei/assert [assert package]: https://github.com/beberlei/assert [Composer]: https://getcomposer.org [Bernhard Schussek]: https://webmozarts.com [The Community Contributors]: https://github.com/webmozart/assert/graphs/contributors [issue tracker]: https://github.com/webmozart/assert/issues [Git repository]: https://github.com/webmozart/assert [@webmozart]: https://twitter.com/webmozart [MIT license]: LICENSE [`Assert`]: src/Assert.php home/fluxyjvi/public_html/project/vendor/guzzlehttp/promises/README.md 0000644 00000042362 15111200351 0022155 0 ustar 00 # Guzzle Promises [Promises/A+](https://promisesaplus.com/) implementation that handles promise chaining and resolution iteratively, allowing for "infinite" promise chaining while keeping the stack size constant. Read [this blog post](https://blog.domenic.me/youre-missing-the-point-of-promises/) for a general introduction to promises. - [Features](#features) - [Quick start](#quick-start) - [Synchronous wait](#synchronous-wait) - [Cancellation](#cancellation) - [API](#api) - [Promise](#promise) - [FulfilledPromise](#fulfilledpromise) - [RejectedPromise](#rejectedpromise) - [Promise interop](#promise-interop) - [Implementation notes](#implementation-notes) ## Features - [Promises/A+](https://promisesaplus.com/) implementation. - Promise resolution and chaining is handled iteratively, allowing for "infinite" promise chaining. - Promises have a synchronous `wait` method. - Promises can be cancelled. - Works with any object that has a `then` function. - C# style async/await coroutine promises using `GuzzleHttp\Promise\Coroutine::of()`. ## Installation ```shell composer require guzzlehttp/promises ``` ## Version Guidance | Version | Status | PHP Version | |---------|------------------------|--------------| | 1.x | Bug and security fixes | >=5.5,<8.3 | | 2.x | Latest | >=7.2.5,<8.4 | ## Quick Start A *promise* represents the eventual result of an asynchronous operation. The primary way of interacting with a promise is through its `then` method, which registers callbacks to receive either a promise's eventual value or the reason why the promise cannot be fulfilled. ### Callbacks Callbacks are registered with the `then` method by providing an optional `$onFulfilled` followed by an optional `$onRejected` function. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $promise->then( // $onFulfilled function ($value) { echo 'The promise was fulfilled.'; }, // $onRejected function ($reason) { echo 'The promise was rejected.'; } ); ``` *Resolving* a promise means that you either fulfill a promise with a *value* or reject a promise with a *reason*. Resolving a promise triggers callbacks registered with the promise's `then` method. These callbacks are triggered only once and in the order in which they were added. ### Resolving a Promise Promises are fulfilled using the `resolve($value)` method. Resolving a promise with any value other than a `GuzzleHttp\Promise\RejectedPromise` will trigger all of the onFulfilled callbacks (resolving a promise with a rejected promise will reject the promise and trigger the `$onRejected` callbacks). ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $promise ->then(function ($value) { // Return a value and don't break the chain return "Hello, " . $value; }) // This then is executed after the first then and receives the value // returned from the first then. ->then(function ($value) { echo $value; }); // Resolving the promise triggers the $onFulfilled callbacks and outputs // "Hello, reader." $promise->resolve('reader.'); ``` ### Promise Forwarding Promises can be chained one after the other. Each then in the chain is a new promise. The return value of a promise is what's forwarded to the next promise in the chain. Returning a promise in a `then` callback will cause the subsequent promises in the chain to only be fulfilled when the returned promise has been fulfilled. The next promise in the chain will be invoked with the resolved value of the promise. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $nextPromise = new Promise(); $promise ->then(function ($value) use ($nextPromise) { echo $value; return $nextPromise; }) ->then(function ($value) { echo $value; }); // Triggers the first callback and outputs "A" $promise->resolve('A'); // Triggers the second callback and outputs "B" $nextPromise->resolve('B'); ``` ### Promise Rejection When a promise is rejected, the `$onRejected` callbacks are invoked with the rejection reason. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $promise->then(null, function ($reason) { echo $reason; }); $promise->reject('Error!'); // Outputs "Error!" ``` ### Rejection Forwarding If an exception is thrown in an `$onRejected` callback, subsequent `$onRejected` callbacks are invoked with the thrown exception as the reason. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $promise->then(null, function ($reason) { throw new Exception($reason); })->then(null, function ($reason) { assert($reason->getMessage() === 'Error!'); }); $promise->reject('Error!'); ``` You can also forward a rejection down the promise chain by returning a `GuzzleHttp\Promise\RejectedPromise` in either an `$onFulfilled` or `$onRejected` callback. ```php use GuzzleHttp\Promise\Promise; use GuzzleHttp\Promise\RejectedPromise; $promise = new Promise(); $promise->then(null, function ($reason) { return new RejectedPromise($reason); })->then(null, function ($reason) { assert($reason === 'Error!'); }); $promise->reject('Error!'); ``` If an exception is not thrown in a `$onRejected` callback and the callback does not return a rejected promise, downstream `$onFulfilled` callbacks are invoked using the value returned from the `$onRejected` callback. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise(); $promise ->then(null, function ($reason) { return "It's ok"; }) ->then(function ($value) { assert($value === "It's ok"); }); $promise->reject('Error!'); ``` ## Synchronous Wait You can synchronously force promises to complete using a promise's `wait` method. When creating a promise, you can provide a wait function that is used to synchronously force a promise to complete. When a wait function is invoked it is expected to deliver a value to the promise or reject the promise. If the wait function does not deliver a value, then an exception is thrown. The wait function provided to a promise constructor is invoked when the `wait` function of the promise is called. ```php $promise = new Promise(function () use (&$promise) { $promise->resolve('foo'); }); // Calling wait will return the value of the promise. echo $promise->wait(); // outputs "foo" ``` If an exception is encountered while invoking the wait function of a promise, the promise is rejected with the exception and the exception is thrown. ```php $promise = new Promise(function () use (&$promise) { throw new Exception('foo'); }); $promise->wait(); // throws the exception. ``` Calling `wait` on a promise that has been fulfilled will not trigger the wait function. It will simply return the previously resolved value. ```php $promise = new Promise(function () { die('this is not called!'); }); $promise->resolve('foo'); echo $promise->wait(); // outputs "foo" ``` Calling `wait` on a promise that has been rejected will throw an exception. If the rejection reason is an instance of `\Exception` the reason is thrown. Otherwise, a `GuzzleHttp\Promise\RejectionException` is thrown and the reason can be obtained by calling the `getReason` method of the exception. ```php $promise = new Promise(); $promise->reject('foo'); $promise->wait(); ``` > PHP Fatal error: Uncaught exception 'GuzzleHttp\Promise\RejectionException' with message 'The promise was rejected with value: foo' ### Unwrapping a Promise When synchronously waiting on a promise, you are joining the state of the promise into the current state of execution (i.e., return the value of the promise if it was fulfilled or throw an exception if it was rejected). This is called "unwrapping" the promise. Waiting on a promise will by default unwrap the promise state. You can force a promise to resolve and *not* unwrap the state of the promise by passing `false` to the first argument of the `wait` function: ```php $promise = new Promise(); $promise->reject('foo'); // This will not throw an exception. It simply ensures the promise has // been resolved. $promise->wait(false); ``` When unwrapping a promise, the resolved value of the promise will be waited upon until the unwrapped value is not a promise. This means that if you resolve promise A with a promise B and unwrap promise A, the value returned by the wait function will be the value delivered to promise B. **Note**: when you do not unwrap the promise, no value is returned. ## Cancellation You can cancel a promise that has not yet been fulfilled using the `cancel()` method of a promise. When creating a promise you can provide an optional cancel function that when invoked cancels the action of computing a resolution of the promise. ## API ### Promise When creating a promise object, you can provide an optional `$waitFn` and `$cancelFn`. `$waitFn` is a function that is invoked with no arguments and is expected to resolve the promise. `$cancelFn` is a function with no arguments that is expected to cancel the computation of a promise. It is invoked when the `cancel()` method of a promise is called. ```php use GuzzleHttp\Promise\Promise; $promise = new Promise( function () use (&$promise) { $promise->resolve('waited'); }, function () { // do something that will cancel the promise computation (e.g., close // a socket, cancel a database query, etc...) } ); assert('waited' === $promise->wait()); ``` A promise has the following methods: - `then(callable $onFulfilled, callable $onRejected) : PromiseInterface` Appends fulfillment and rejection handlers to the promise, and returns a new promise resolving to the return value of the called handler. - `otherwise(callable $onRejected) : PromiseInterface` Appends a rejection handler callback to the promise, and returns a new promise resolving to the return value of the callback if it is called, or to its original fulfillment value if the promise is instead fulfilled. - `wait($unwrap = true) : mixed` Synchronously waits on the promise to complete. `$unwrap` controls whether or not the value of the promise is returned for a fulfilled promise or if an exception is thrown if the promise is rejected. This is set to `true` by default. - `cancel()` Attempts to cancel the promise if possible. The promise being cancelled and the parent most ancestor that has not yet been resolved will also be cancelled. Any promises waiting on the cancelled promise to resolve will also be cancelled. - `getState() : string` Returns the state of the promise. One of `pending`, `fulfilled`, or `rejected`. - `resolve($value)` Fulfills the promise with the given `$value`. - `reject($reason)` Rejects the promise with the given `$reason`. ### FulfilledPromise A fulfilled promise can be created to represent a promise that has been fulfilled. ```php use GuzzleHttp\Promise\FulfilledPromise; $promise = new FulfilledPromise('value'); // Fulfilled callbacks are immediately invoked. $promise->then(function ($value) { echo $value; }); ``` ### RejectedPromise A rejected promise can be created to represent a promise that has been rejected. ```php use GuzzleHttp\Promise\RejectedPromise; $promise = new RejectedPromise('Error'); // Rejected callbacks are immediately invoked. $promise->then(null, function ($reason) { echo $reason; }); ``` ## Promise Interoperability This library works with foreign promises that have a `then` method. This means you can use Guzzle promises with [React promises](https://github.com/reactphp/promise) for example. When a foreign promise is returned inside of a then method callback, promise resolution will occur recursively. ```php // Create a React promise $deferred = new React\Promise\Deferred(); $reactPromise = $deferred->promise(); // Create a Guzzle promise that is fulfilled with a React promise. $guzzlePromise = new GuzzleHttp\Promise\Promise(); $guzzlePromise->then(function ($value) use ($reactPromise) { // Do something something with the value... // Return the React promise return $reactPromise; }); ``` Please note that wait and cancel chaining is no longer possible when forwarding a foreign promise. You will need to wrap a third-party promise with a Guzzle promise in order to utilize wait and cancel functions with foreign promises. ### Event Loop Integration In order to keep the stack size constant, Guzzle promises are resolved asynchronously using a task queue. When waiting on promises synchronously, the task queue will be automatically run to ensure that the blocking promise and any forwarded promises are resolved. When using promises asynchronously in an event loop, you will need to run the task queue on each tick of the loop. If you do not run the task queue, then promises will not be resolved. You can run the task queue using the `run()` method of the global task queue instance. ```php // Get the global task queue $queue = GuzzleHttp\Promise\Utils::queue(); $queue->run(); ``` For example, you could use Guzzle promises with React using a periodic timer: ```php $loop = React\EventLoop\Factory::create(); $loop->addPeriodicTimer(0, [$queue, 'run']); ``` ## Implementation Notes ### Promise Resolution and Chaining is Handled Iteratively By shuffling pending handlers from one owner to another, promises are resolved iteratively, allowing for "infinite" then chaining. ```php <?php require 'vendor/autoload.php'; use GuzzleHttp\Promise\Promise; $parent = new Promise(); $p = $parent; for ($i = 0; $i < 1000; $i++) { $p = $p->then(function ($v) { // The stack size remains constant (a good thing) echo xdebug_get_stack_depth() . ', '; return $v + 1; }); } $parent->resolve(0); var_dump($p->wait()); // int(1000) ``` When a promise is fulfilled or rejected with a non-promise value, the promise then takes ownership of the handlers of each child promise and delivers values down the chain without using recursion. When a promise is resolved with another promise, the original promise transfers all of its pending handlers to the new promise. When the new promise is eventually resolved, all of the pending handlers are delivered the forwarded value. ### A Promise is the Deferred Some promise libraries implement promises using a deferred object to represent a computation and a promise object to represent the delivery of the result of the computation. This is a nice separation of computation and delivery because consumers of the promise cannot modify the value that will be eventually delivered. One side effect of being able to implement promise resolution and chaining iteratively is that you need to be able for one promise to reach into the state of another promise to shuffle around ownership of handlers. In order to achieve this without making the handlers of a promise publicly mutable, a promise is also the deferred value, allowing promises of the same parent class to reach into and modify the private properties of promises of the same type. While this does allow consumers of the value to modify the resolution or rejection of the deferred, it is a small price to pay for keeping the stack size constant. ```php $promise = new Promise(); $promise->then(function ($value) { echo $value; }); // The promise is the deferred value, so you can deliver a value to it. $promise->resolve('foo'); // prints "foo" ``` ## Upgrading from Function API A static API was first introduced in 1.4.0, in order to mitigate problems with functions conflicting between global and local copies of the package. The function API was removed in 2.0.0. A migration table has been provided here for your convenience: | Original Function | Replacement Method | |----------------|----------------| | `queue` | `Utils::queue` | | `task` | `Utils::task` | | `promise_for` | `Create::promiseFor` | | `rejection_for` | `Create::rejectionFor` | | `exception_for` | `Create::exceptionFor` | | `iter_for` | `Create::iterFor` | | `inspect` | `Utils::inspect` | | `inspect_all` | `Utils::inspectAll` | | `unwrap` | `Utils::unwrap` | | `all` | `Utils::all` | | `some` | `Utils::some` | | `any` | `Utils::any` | | `settle` | `Utils::settle` | | `each` | `Each::of` | | `each_limit` | `Each::ofLimit` | | `each_limit_all` | `Each::ofLimitAll` | | `!is_fulfilled` | `Is::pending` | | `is_fulfilled` | `Is::fulfilled` | | `is_rejected` | `Is::rejected` | | `is_settled` | `Is::settled` | | `coroutine` | `Coroutine::of` | ## Security If you discover a security vulnerability within this package, please send an email to security@tidelift.com. All security vulnerabilities will be promptly addressed. Please do not disclose security-related issues publicly until a fix has been announced. Please see [Security Policy](https://github.com/guzzle/promises/security/policy) for more information. ## License Guzzle is made available under the MIT License (MIT). Please see [License File](LICENSE) for more information. ## For Enterprise Available as part of the Tidelift Subscription The maintainers of Guzzle and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-guzzlehttp-promises?utm_source=packagist-guzzlehttp-promises&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) home/fluxyjvi/public_html/project/README.md 0000644 00000010076 15111206062 0014601 0 ustar 00 <p align="center"><a href="https://laravel.com" target="_blank"><img src="https://raw.githubusercontent.com/laravel/art/master/logo-lockup/5%20SVG/2%20CMYK/1%20Full%20Color/laravel-logolockup-cmyk-red.svg" width="400" alt="Laravel Logo"></a></p> <p align="center"> <a href="https://github.com/laravel/framework/actions"><img src="https://github.com/laravel/framework/workflows/tests/badge.svg" alt="Build Status"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/dt/laravel/framework" alt="Total Downloads"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/v/laravel/framework" alt="Latest Stable Version"></a> <a href="https://packagist.org/packages/laravel/framework"><img src="https://img.shields.io/packagist/l/laravel/framework" alt="License"></a> </p> ## About Laravel Laravel is a web application framework with expressive, elegant syntax. We believe development must be an enjoyable and creative experience to be truly fulfilling. Laravel takes the pain out of development by easing common tasks used in many web projects, such as: - [Simple, fast routing engine](https://laravel.com/docs/routing). - [Powerful dependency injection container](https://laravel.com/docs/container). - Multiple back-ends for [session](https://laravel.com/docs/session) and [cache](https://laravel.com/docs/cache) storage. - Expressive, intuitive [database ORM](https://laravel.com/docs/eloquent). - Database agnostic [schema migrations](https://laravel.com/docs/migrations). - [Robust background job processing](https://laravel.com/docs/queues). - [Real-time event broadcasting](https://laravel.com/docs/broadcasting). Laravel is accessible, powerful, and provides tools required for large, robust applications. ## Learning Laravel Laravel has the most extensive and thorough [documentation](https://laravel.com/docs) and video tutorial library of all modern web application frameworks, making it a breeze to get started with the framework. You may also try the [Laravel Bootcamp](https://bootcamp.laravel.com), where you will be guided through building a modern Laravel application from scratch. If you don't feel like reading, [Laracasts](https://laracasts.com) can help. Laracasts contains over 2000 video tutorials on a range of topics including Laravel, modern PHP, unit testing, and JavaScript. Boost your skills by digging into our comprehensive video library. ## Laravel Sponsors We would like to extend our thanks to the following sponsors for funding Laravel development. If you are interested in becoming a sponsor, please visit the Laravel [Patreon page](https://patreon.com/taylorotwell). ### Premium Partners - **[Vehikl](https://vehikl.com/)** - **[Tighten Co.](https://tighten.co)** - **[Kirschbaum Development Group](https://kirschbaumdevelopment.com)** - **[64 Robots](https://64robots.com)** - **[Cubet Techno Labs](https://cubettech.com)** - **[Cyber-Duck](https://cyber-duck.co.uk)** - **[Many](https://www.many.co.uk)** - **[Webdock, Fast VPS Hosting](https://www.webdock.io/en)** - **[DevSquad](https://devsquad.com)** - **[Curotec](https://www.curotec.com/services/technologies/laravel/)** - **[OP.GG](https://op.gg)** - **[WebReinvent](https://webreinvent.com/?utm_source=laravel&utm_medium=github&utm_campaign=patreon-sponsors)** - **[Lendio](https://lendio.com)** ## Contributing Thank you for considering contributing to the Laravel framework! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities If you discover a security vulnerability within Laravel, please send an e-mail to Taylor Otwell via [taylor@laravel.com](mailto:taylor@laravel.com). All security vulnerabilities will be promptly addressed. ## License The Laravel framework is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT). home/fluxyjvi/public_html/project/vendor/spatie/robots-txt/README.md 0000644 00000006173 15111210022 0021502 0 ustar 00 [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/support-ukraine.svg?t=1" />](https://supportukrainenow.org) # Parse `robots.txt`, `robots` meta and headers [](https://packagist.org/packages/spatie/robots-txt)  [](https://scrutinizer-ci.com/g/spatie/robots-txt) [](https://packagist.org/packages/spatie/robots-txt) Determine if a page may be crawled from robots.txt, robots meta tags and robot headers. ## Support us [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/robots-txt.jpg?t=1" width="419px" />](https://spatie.be/github-ad-click/robots-txt) We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us). We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards). ## Installation You can install the package via composer: ```bash composer require spatie/robots-txt ``` ## Usage ``` php $robots = Spatie\Robots\Robots::create(); $robots->mayIndex('https://www.spatie.be/nl/admin'); $robots->mayFollowOn('https://www.spatie.be/nl/admin'); ``` You can also specify a user agent: ``` php $robots = Spatie\Robots\Robots::create('UserAgent007'); ``` By default, `Robots` will look for a `robots.txt` file on `https://host.com/robots.txt`. Another location can be specified like so: ``` php $robots = Spatie\Robots\Robots::create() ->withTxt('https://www.spatie.be/robots-custom.txt'); $robots = Spatie\Robots\Robots::create() ->withTxt(__DIR__ . '/public/robots.txt'); ``` ### Testing ``` bash composer test ``` ### Changelog Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently. ## Contributing Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details. ## Security Vulnerabilities Please review [our security policy](../../security/policy) on how to report security vulnerabilities. ## Postcardware You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium. We publish all received postcards [on our company website](https://spatie.be/en/opensource/postcards). ## Credits - [Brent Roose](https://github.com/brendt) - [All Contributors](../../contributors) ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. home/fluxyjvi/public_html/project/vendor/nunomaduro/collision/README.md 0000644 00000005603 15111210336 0022257 0 ustar 00 <p align="center"> <img src="https://raw.githubusercontent.com/nunomaduro/collision/v7.x/docs/logo.png" alt="Collision logo" width="480"> <br> <img src="https://raw.githubusercontent.com/nunomaduro/collision/v7.x/docs/example.png" alt="Collision code example" height="300"> </p> <p align="center"> <a href="https://github.com/nunomaduro/collision/actions"><img src="https://img.shields.io/github/actions/workflow/status/nunomaduro/collision/tests.yml?branch=v7.x&label=tests&style=round-square" alt="Build Status"></img></a> <a href="https://scrutinizer-ci.com/g/nunomaduro/collision"><img src="https://img.shields.io/scrutinizer/g/nunomaduro/collision.svg" alt="Quality Score"></img></a> <a href="https://packagist.org/packages/nunomaduro/collision"><img src="https://poser.pugx.org/nunomaduro/collision/d/total.svg" alt="Total Downloads"></a> <a href="https://packagist.org/packages/nunomaduro/collision"><img src="https://poser.pugx.org/nunomaduro/collision/license.svg" alt="License"></a> </p> --- Collision was created by, and is maintained by **[Nuno Maduro](https://github.com/nunomaduro)**, and is a package designed to give you beautiful error reporting when interacting with your app through the command line. * It's included on **[Laravel](https://laravel.com)**, the most popular free, open-source PHP framework in the world. * Built on top of the **[Whoops](https://github.com/filp/whoops)** error handler. * Supports [Laravel](https://github.com/laravel/laravel), [Symfony](https://symfony.com), [PHPUnit](https://github.com/sebastianbergmann/phpunit), and many other frameworks. ## Installation & Usage > **Requires [PHP 8.1+](https://php.net/releases/)** Require Collision using [Composer](https://getcomposer.org): ```bash composer require nunomaduro/collision --dev ``` ## Version Compatibility Laravel | Collision | PHPUnit | Pest :---------|:----------|:----------|:---------- 6.x | 3.x | | 7.x | 4.x | | 8.x | 5.x | | 9.x | 6.x | | 10.x | 6.x | 9.x | 1.x 10.x | 7.x | 10.x | 2.x As an example, here is how to require Collision on Laravel 8.x: ```bash composer require nunomaduro/collision:^5.0 --dev ``` ## No adapter You need to register the handler in your code: ```php (new \NunoMaduro\Collision\Provider)->register(); ``` ## Contributing Thank you for considering to contribute to Collision. All the contribution guidelines are mentioned [here](CONTRIBUTING.md). You can have a look at the [CHANGELOG](CHANGELOG.md) for constant updates & detailed information about the changes. You can also follow the twitter account for latest announcements or just come say hi!: [@enunomaduro](https://twitter.com/enunomaduro) ## License Collision is an open-sourced software licensed under the [MIT license](LICENSE.md). Logo by [Caneco](https://twitter.com/caneco). home/fluxyjvi/public_html/project/vendor/phar-io/version/README.md 0000644 00000004471 15111217352 0021130 0 ustar 00 # Version Library for handling version information and constraints [](https://travis-ci.org/phar-io/version) ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): composer require phar-io/version If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: composer require --dev phar-io/version ## Version constraints A Version constraint describes a range of versions or a discrete version number. The format of version numbers follows the schema of [semantic versioning](http://semver.org): `<major>.<minor>.<patch>`. A constraint might contain an operator that describes the range. Beside the typical mathematical operators like `<=`, `>=`, there are two special operators: *Caret operator*: `^1.0` can be written as `>=1.0.0 <2.0.0` and read as Β»every Version within major version `1`Β«. *Tilde operator*: `~1.0.0` can be written as `>=1.0.0 <1.1.0` and read as Β»every version within minor version `1.1`. The behavior of tilde operator depends on whether a patch level version is provided or not. If no patch level is provided, tilde operator behaves like the caret operator: `~1.0` is identical to `^1.0`. ## Usage examples Parsing version constraints and check discrete versions for compliance: ```php use PharIo\Version\Version; use PharIo\Version\VersionConstraintParser; $parser = new VersionConstraintParser(); $caret_constraint = $parser->parse( '^7.0' ); $caret_constraint->complies( new Version( '7.0.17' ) ); // true $caret_constraint->complies( new Version( '7.1.0' ) ); // true $caret_constraint->complies( new Version( '6.4.34' ) ); // false $tilde_constraint = $parser->parse( '~1.1.0' ); $tilde_constraint->complies( new Version( '1.1.4' ) ); // true $tilde_constraint->complies( new Version( '1.2.0' ) ); // false ``` As of version 2.0.0, pre-release labels are supported and taken into account when comparing versions: ```php $leftVersion = new PharIo\Version\Version('3.0.0-alpha.1'); $rightVersion = new PharIo\Version\Version('3.0.0-alpha.2'); $leftVersion->isGreaterThan($rightVersion); // false $rightVersion->isGreaterThan($leftVersion); // true ``` home/fluxyjvi/public_html/project/vendor/symfony/mime/README.md 0000644 00000000713 15111217751 0020535 0 ustar 00 MIME Component ============== The MIME component allows manipulating MIME messages. Resources --------- * [Documentation](https://symfony.com/doc/current/components/mime.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) home/fluxyjvi/public_html/project/vendor/phpunit/php-invoker/README.md 0000644 00000001741 15111220515 0022025 0 ustar 00 # phpunit/php-invoker [](https://packagist.org/packages/phpunit/php-invoker) [](https://github.com/sebastianbergmann/php-invoker/actions) [](https://shepherd.dev/github/sebastianbergmann/php-invoker) [](https://codecov.io/gh/sebastianbergmann/php-invoker) ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require phpunit/php-invoker ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev phpunit/php-invoker ``` home/fluxyjvi/public_html/project/vendor/phpmailer/phpmailer/README.md 0000644 00000040123 15111223152 0022033 0 ustar 00 [](https://supportukrainenow.org/)  # PHPMailer β A full-featured email creation and transfer class for PHP [](https://github.com/PHPMailer/PHPMailer/actions) [](https://codecov.io/gh/PHPMailer/PHPMailer) [](https://packagist.org/packages/phpmailer/phpmailer) [](https://packagist.org/packages/phpmailer/phpmailer) [](https://packagist.org/packages/phpmailer/phpmailer) [](https://phpmailer.github.io/PHPMailer/) [](https://api.securityscorecards.dev/projects/github.com/PHPMailer/PHPMailer) ## Features - Probably the world's most popular code for sending email from PHP! - Used by many open-source projects: WordPress, Drupal, 1CRM, SugarCRM, Yii, Joomla! and many more - Integrated SMTP support β send without a local mail server - Send emails with multiple To, CC, BCC, and Reply-to addresses - Multipart/alternative emails for mail clients that do not read HTML email - Add attachments, including inline - Support for UTF-8 content and 8bit, base64, binary, and quoted-printable encodings - SMTP authentication with LOGIN, PLAIN, CRAM-MD5, and XOAUTH2 mechanisms over SMTPS and SMTP+STARTTLS transports - Validates email addresses automatically - Protects against header injection attacks - Error messages in over 50 languages! - DKIM and S/MIME signing support - Compatible with PHP 5.5 and later, including PHP 8.2 - Namespaced to prevent name clashes - Much more! ## Why you might need it Many PHP developers need to send email from their code. The only PHP function that supports this directly is [`mail()`](https://www.php.net/manual/en/function.mail.php). However, it does not provide any assistance for making use of popular features such as encryption, authentication, HTML messages, and attachments. Formatting email correctly is surprisingly difficult. There are myriad overlapping (and conflicting) standards, requiring tight adherence to horribly complicated formatting and encoding rules β the vast majority of code that you'll find online that uses the `mail()` function directly is just plain wrong, if not unsafe! The PHP `mail()` function usually sends via a local mail server, typically fronted by a `sendmail` binary on Linux, BSD, and macOS platforms, however, Windows usually doesn't include a local mail server; PHPMailer's integrated SMTP client allows email sending on all platforms without needing a local mail server. Be aware though, that the `mail()` function should be avoided when possible; it's both faster and [safer](https://exploitbox.io/paper/Pwning-PHP-Mail-Function-For-Fun-And-RCE.html) to use SMTP to localhost. *Please* don't be tempted to do it yourself β if you don't use PHPMailer, there are many other excellent libraries that you should look at before rolling your own. Try [SwiftMailer](https://swiftmailer.symfony.com/) , [Laminas/Mail](https://docs.laminas.dev/laminas-mail/), [ZetaComponents](https://github.com/zetacomponents/Mail), etc. ## License This software is distributed under the [LGPL 2.1](http://www.gnu.org/licenses/lgpl-2.1.html) license, along with the [GPL Cooperation Commitment](https://gplcc.github.io/gplcc/). Please read [LICENSE](https://github.com/PHPMailer/PHPMailer/blob/master/LICENSE) for information on the software availability and distribution. ## Installation & loading PHPMailer is available on [Packagist](https://packagist.org/packages/phpmailer/phpmailer) (using semantic versioning), and installation via [Composer](https://getcomposer.org) is the recommended way to install PHPMailer. Just add this line to your `composer.json` file: ```json "phpmailer/phpmailer": "^6.8.1" ``` or run ```sh composer require phpmailer/phpmailer ``` Note that the `vendor` folder and the `vendor/autoload.php` script are generated by Composer; they are not part of PHPMailer. If you want to use the Gmail XOAUTH2 authentication class, you will also need to add a dependency on the `league/oauth2-client` package in your `composer.json`. Alternatively, if you're not using Composer, you can [download PHPMailer as a zip file](https://github.com/PHPMailer/PHPMailer/archive/master.zip), (note that docs and examples are not included in the zip file), then copy the contents of the PHPMailer folder into one of the `include_path` directories specified in your PHP configuration and load each class file manually: ```php <?php use PHPMailer\PHPMailer\PHPMailer; use PHPMailer\PHPMailer\Exception; require 'path/to/PHPMailer/src/Exception.php'; require 'path/to/PHPMailer/src/PHPMailer.php'; require 'path/to/PHPMailer/src/SMTP.php'; ``` If you're not using the `SMTP` class explicitly (you're probably not), you don't need a `use` line for the SMTP class. Even if you're not using exceptions, you do still need to load the `Exception` class as it is used internally. ## Legacy versions PHPMailer 5.2 (which is compatible with PHP 5.0 β 7.0) is no longer supported, even for security updates. You will find the latest version of 5.2 in the [5.2-stable branch](https://github.com/PHPMailer/PHPMailer/tree/5.2-stable). If you're using PHP 5.5 or later (which you should be), switch to the 6.x releases. ### Upgrading from 5.2 The biggest changes are that source files are now in the `src/` folder, and PHPMailer now declares the namespace `PHPMailer\PHPMailer`. This has several important effects β [read the upgrade guide](https://github.com/PHPMailer/PHPMailer/tree/master/UPGRADING.md) for more details. ### Minimal installation While installing the entire package manually or with Composer is simple, convenient, and reliable, you may want to include only vital files in your project. At the very least you will need [src/PHPMailer.php](https://github.com/PHPMailer/PHPMailer/tree/master/src/PHPMailer.php). If you're using SMTP, you'll need [src/SMTP.php](https://github.com/PHPMailer/PHPMailer/tree/master/src/SMTP.php), and if you're using POP-before SMTP (*very* unlikely!), you'll need [src/POP3.php](https://github.com/PHPMailer/PHPMailer/tree/master/src/POP3.php). You can skip the [language](https://github.com/PHPMailer/PHPMailer/tree/master/language/) folder if you're not showing errors to users and can make do with English-only errors. If you're using XOAUTH2 you will need [src/OAuth.php](https://github.com/PHPMailer/PHPMailer/tree/master/src/OAuth.php) as well as the Composer dependencies for the services you wish to authenticate with. Really, it's much easier to use Composer! ## A Simple Example ```php <?php //Import PHPMailer classes into the global namespace //These must be at the top of your script, not inside a function use PHPMailer\PHPMailer\PHPMailer; use PHPMailer\PHPMailer\SMTP; use PHPMailer\PHPMailer\Exception; //Load Composer's autoloader require 'vendor/autoload.php'; //Create an instance; passing `true` enables exceptions $mail = new PHPMailer(true); try { //Server settings $mail->SMTPDebug = SMTP::DEBUG_SERVER; //Enable verbose debug output $mail->isSMTP(); //Send using SMTP $mail->Host = 'smtp.example.com'; //Set the SMTP server to send through $mail->SMTPAuth = true; //Enable SMTP authentication $mail->Username = 'user@example.com'; //SMTP username $mail->Password = 'secret'; //SMTP password $mail->SMTPSecure = PHPMailer::ENCRYPTION_SMTPS; //Enable implicit TLS encryption $mail->Port = 465; //TCP port to connect to; use 587 if you have set `SMTPSecure = PHPMailer::ENCRYPTION_STARTTLS` //Recipients $mail->setFrom('from@example.com', 'Mailer'); $mail->addAddress('joe@example.net', 'Joe User'); //Add a recipient $mail->addAddress('ellen@example.com'); //Name is optional $mail->addReplyTo('info@example.com', 'Information'); $mail->addCC('cc@example.com'); $mail->addBCC('bcc@example.com'); //Attachments $mail->addAttachment('/var/tmp/file.tar.gz'); //Add attachments $mail->addAttachment('/tmp/image.jpg', 'new.jpg'); //Optional name //Content $mail->isHTML(true); //Set email format to HTML $mail->Subject = 'Here is the subject'; $mail->Body = 'This is the HTML message body <b>in bold!</b>'; $mail->AltBody = 'This is the body in plain text for non-HTML mail clients'; $mail->send(); echo 'Message has been sent'; } catch (Exception $e) { echo "Message could not be sent. Mailer Error: {$mail->ErrorInfo}"; } ``` You'll find plenty to play with in the [examples](https://github.com/PHPMailer/PHPMailer/tree/master/examples) folder, which covers many common scenarios including sending through Gmail, building contact forms, sending to mailing lists, and more. If you are re-using the instance (e.g. when sending to a mailing list), you may need to clear the recipient list to avoid sending duplicate messages. See [the mailing list example](https://github.com/PHPMailer/PHPMailer/blob/master/examples/mailing_list.phps) for further guidance. That's it. You should now be ready to use PHPMailer! ## Localization PHPMailer defaults to English, but in the [language](https://github.com/PHPMailer/PHPMailer/tree/master/language/) folder, you'll find many translations for PHPMailer error messages that you may encounter. Their filenames contain [ISO 639-1](http://en.wikipedia.org/wiki/ISO_639-1) language code for the translations, for example `fr` for French. To specify a language, you need to tell PHPMailer which one to use, like this: ```php //To load the French version $mail->setLanguage('fr', '/optional/path/to/language/directory/'); ``` We welcome corrections and new languages β if you're looking for corrections, run the [Language/TranslationCompletenessTest.php](https://github.com/PHPMailer/PHPMailer/blob/master/test/Language/TranslationCompletenessTest.php) script in the tests folder and it will show any missing translations. ## Documentation Start reading at the [GitHub wiki](https://github.com/PHPMailer/PHPMailer/wiki). If you're having trouble, head for [the troubleshooting guide](https://github.com/PHPMailer/PHPMailer/wiki/Troubleshooting) as it's frequently updated. Examples of how to use PHPMailer for common scenarios can be found in the [examples](https://github.com/PHPMailer/PHPMailer/tree/master/examples) folder. If you're looking for a good starting point, we recommend you start with [the Gmail example](https://github.com/PHPMailer/PHPMailer/tree/master/examples/gmail.phps). To reduce PHPMailer's deployed code footprint, examples are not included if you load PHPMailer via Composer or via [GitHub's zip file download](https://github.com/PHPMailer/PHPMailer/archive/master.zip), so you'll need to either clone the git repository or use the above links to get to the examples directly. Complete generated API documentation is [available online](https://phpmailer.github.io/PHPMailer/). You can generate complete API-level documentation by running `phpdoc` in the top-level folder, and documentation will appear in the `docs` folder, though you'll need to have [PHPDocumentor](http://www.phpdoc.org) installed. You may find [the unit tests](https://github.com/PHPMailer/PHPMailer/blob/master/test/PHPMailerTest.php) a good reference for how to do various operations such as encryption. If the documentation doesn't cover what you need, search the [many questions on Stack Overflow](http://stackoverflow.com/questions/tagged/phpmailer), and before you ask a question about "SMTP Error: Could not connect to SMTP host.", [read the troubleshooting guide](https://github.com/PHPMailer/PHPMailer/wiki/Troubleshooting). ## Tests [PHPMailer tests](https://github.com/PHPMailer/PHPMailer/tree/master/test/) use PHPUnit 9, with [a polyfill](https://github.com/Yoast/PHPUnit-Polyfills) to let 9-style tests run on older PHPUnit and PHP versions. [](https://github.com/PHPMailer/PHPMailer/actions) If this isn't passing, is there something you can do to help? ## Security Please disclose any vulnerabilities found responsibly β report security issues to the maintainers privately. See [SECURITY](https://github.com/PHPMailer/PHPMailer/tree/master/SECURITY.md) and [PHPMailer's security advisories on GitHub](https://github.com/PHPMailer/PHPMailer/security). ## Contributing Please submit bug reports, suggestions, and pull requests to the [GitHub issue tracker](https://github.com/PHPMailer/PHPMailer/issues). We're particularly interested in fixing edge cases, expanding test coverage, and updating translations. If you found a mistake in the docs, or want to add something, go ahead and amend the wiki β anyone can edit it. If you have git clones from prior to the move to the PHPMailer GitHub organisation, you'll need to update any remote URLs referencing the old GitHub location with a command like this from within your clone: ```sh git remote set-url upstream https://github.com/PHPMailer/PHPMailer.git ``` Please *don't* use the SourceForge or Google Code projects any more; they are obsolete and no longer maintained. ## Sponsorship Development time and resources for PHPMailer are provided by [Smartmessages.net](https://info.smartmessages.net/), the world's only privacy-first email marketing system. <a href="https://info.smartmessages.net/"><img src="https://www.smartmessages.net/img/smartmessages-logo.svg" width="550" alt="Smartmessages.net privacy-first email marketing logo"></a> Donations are very welcome, whether in beer πΊ, T-shirts π, or cold, hard cash π°. Sponsorship through GitHub is a simple and convenient way to say "thank you" to PHPMailer's maintainers and contributors β just click the "Sponsor" button [on the project page](https://github.com/PHPMailer/PHPMailer). If your company uses PHPMailer, consider taking part in Tidelift's enterprise support programme. ## PHPMailer For Enterprise Available as part of the Tidelift Subscription. The maintainers of PHPMailer and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open-source packages you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact packages you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-phpmailer-phpmailer?utm_source=packagist-phpmailer-phpmailer&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) ## Changelog See [changelog](changelog.md). ## History - PHPMailer was originally written in 2001 by Brent R. Matzelle as a [SourceForge project](http://sourceforge.net/projects/phpmailer/). - [Marcus Bointon](https://github.com/Synchro) (`coolbru` on SF) and Andy Prevost (`codeworxtech`) took over the project in 2004. - Became an Apache incubator project on Google Code in 2010, managed by Jim Jagielski. - Marcus created [his fork on GitHub](https://github.com/Synchro/PHPMailer) in 2008. - Jim and Marcus decide to join forces and use GitHub as the canonical and official repo for PHPMailer in 2013. - PHPMailer moves to [the PHPMailer organisation](https://github.com/PHPMailer) on GitHub in 2013. ### What's changed since moving from SourceForge? - Official successor to the SourceForge and Google Code projects. - Test suite. - Continuous integration with GitHub Actions. - Composer support. - Public development. - Additional languages and language strings. - CRAM-MD5 authentication support. - Preserves full repo history of authors, commits, and branches from the original SourceForge project. home/fluxyjvi/public_html/project/vendor/voku/portable-ascii/README.md 0000644 00000043554 15111225414 0021771 0 ustar 00 [//]: # (AUTO-GENERATED BY "PHP README Helper": base file -> docs/base.md) [](https://github.com/vshymanskyy/StandWithUkraine/blob/main/docs/README.md) [](https://github.com/voku/portable-ascii/actions) [](https://ci.appveyor.com/project/voku/portable-ascii/branch/master) [](https://codecov.io/github/voku/portable-ascii?branch=master) [](https://www.codacy.com/app/voku/portable-ascii) [](https://packagist.org/packages/voku/portable-ascii) [](https://packagist.org/packages/voku/portable-ascii) [](https://packagist.org/packages/voku/portable-ascii) [](https://www.paypal.me/moelleken) [](https://www.patreon.com/voku) # π‘ Portable ASCII ## Description It is written in PHP (PHP 7+) and can work without "mbstring", "iconv" or any other extra encoding php-extension on your server. The benefit of Portable ASCII is that it is easy to use, easy to bundle. The project based on ... + Sean M. Burke's work (https://metacpan.org/pod/Text::Unidecode) + Tomaz Solc's work (https://pypi.org/project/Unidecode/) + Portable UTF-8 work (https://github.com/voku/portable-utf8) + Daniel St. Jules's work (https://github.com/danielstjules/Stringy) + Johnny Broadway's work (https://github.com/jbroadway/urlify) + and many cherry-picks from "github"-gists and "Stack Overflow"-snippets ... ## Index * [Alternative](#alternative) * [Install](#install-portable-ascii-via-composer-require) * [Why Portable ASCII?](#why-portable-ascii) * [Requirements and Recommendations](#requirements-and-recommendations) * [Usage](#usage) * [Class methods](#class-methods) * [Unit Test](#unit-test) * [License and Copyright](#license-and-copyright) ## Alternative If you like a more Object Oriented Way to edit strings, then you can take a look at [voku/Stringy](https://github.com/voku/Stringy), it's a fork of "danielstjules/Stringy" but it used the "Portable ASCII"-Class and some extra methods. ```php // Portable ASCII use voku\helper\ASCII; ASCII::to_transliterate('dΓ©jΓ ΟΟΟ iΔ±ii'); // 'deja sss iiii' // voku/Stringy use Stringy\Stringy as S; $stringy = S::create('dΓ©jΓ ΟΟΟ iΔ±ii'); $stringy->toTransliterate(); // 'deja sss iiii' ``` ## Install "Portable ASCII" via "composer require" ```shell composer require voku/portable-ascii ``` ## Why Portable ASCII?[]() I need ASCII char handling in different classes and before I added this functions into "Portable UTF-8", but this repo is more modular and portable, because it has no dependencies. ## Requirements and Recommendations * No extensions are required to run this library. Portable ASCII only needs PCRE library that is available by default since PHP 4.2.0 and cannot be disabled since PHP 5.3.0. "\u" modifier support in PCRE for ASCII handling is not a must. * PHP 7.0 is the minimum requirement * PHP 8.0 is also supported ## Usage Example: ASCII::to_ascii() ```php echo ASCII::to_ascii('οΏ½DΓΌsseldorfοΏ½', 'de'); // will output // Duesseldorf echo ASCII::to_ascii('οΏ½DΓΌsseldorfοΏ½', 'en'); // will output // Dusseldorf ``` # Portable ASCII | API The API from the "ASCII"-Class is written as small static methods. ## Class methods <p id="voku-php-readme-class-methods"></p><table><tr><td><a href="#charsarraybool-replace_extra_symbols-array">charsArray</a> </td><td><a href="#charsarraywithmultilanguagevaluesbool-replace_extra_symbols-array">charsArrayWithMultiLanguageValues</a> </td><td><a href="#charsarraywithonelanguagestring-language-bool-replace_extra_symbols-bool-asorigreplacearray-array">charsArrayWithOneLanguage</a> </td><td><a href="#charsarraywithsinglelanguagevaluesbool-replace_extra_symbols-bool-asorigreplacearray-array">charsArrayWithSingleLanguageValues</a> </td></tr><tr><td><a href="#cleanstring-str-bool-normalize_whitespace-bool-keep_non_breaking_space-bool-normalize_msword-bool-remove_invisible_characters-string">clean</a> </td><td><a href="#getalllanguages-string">getAllLanguages</a> </td><td><a href="#is_asciistring-str-bool">is_ascii</a> </td><td><a href="#normalize_mswordstring-str-string">normalize_msword</a> </td></tr><tr><td><a href="#normalize_whitespacestring-str-bool-keepnonbreakingspace-bool-keepbidiunicodecontrols-bool-normalize_control_characters-string">normalize_whitespace</a> </td><td><a href="#remove_invisible_charactersstring-str-bool-url_encoded-string-replacement-bool-keep_basic_control_characters-string">remove_invisible_characters</a> </td><td><a href="#to_asciistring-str-string-language-bool-remove_unsupported_chars-bool-replace_extra_symbols-bool-use_transliterate-boolnull-replace_single_chars_only-string">to_ascii</a> </td><td><a href="#to_ascii_remapstring-str1-string-str2-string">to_ascii_remap</a> </td></tr><tr><td><a href="#to_filenamestring-str-bool-use_transliterate-string-fallback_char-string">to_filename</a> </td><td><a href="#to_slugifystring-str-string-separator-string-language-string-replacements-bool-replace_extra_symbols-bool-use_str_to_lower-bool-use_transliterate-string">to_slugify</a> </td><td><a href="#to_transliteratestring-str-stringnull-unknown-bool-strict-string">to_transliterate</a> </td></tr></table> #### charsArray(bool $replace_extra_symbols): array <a href="#voku-php-readme-class-methods">β</a> Returns an replacement array for ASCII methods. EXAMPLE: <code> $array = ASCII::charsArray(); var_dump($array['ru']['Π±']); // 'b' </code> **Parameters:** - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` **Return:** - `array` -------- #### charsArrayWithMultiLanguageValues(bool $replace_extra_symbols): array <a href="#voku-php-readme-class-methods">β</a> Returns an replacement array for ASCII methods with a mix of multiple languages. EXAMPLE: <code> $array = ASCII::charsArrayWithMultiLanguageValues(); var_dump($array['b']); // ['Ξ²', 'Π±', 'α', 'α', 'Ψ¨'] </code> **Parameters:** - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` **Return:** - `array <p>An array of replacements.</p>` -------- #### charsArrayWithOneLanguage(string $language, bool $replace_extra_symbols, bool $asOrigReplaceArray): array <a href="#voku-php-readme-class-methods">β</a> Returns an replacement array for ASCII methods with one language. For example, German will map 'Γ€' to 'ae', while other languages will simply return e.g. 'a'. EXAMPLE: <code> $array = ASCII::charsArrayWithOneLanguage('ru'); $tmpKey = \array_search('yo', $array['replace']); echo $array['orig'][$tmpKey]; // 'Ρ' </code> **Parameters:** - `ASCII::* $language [optional] <p>Language of the source string e.g.: en, de_at, or de-ch. (default is 'en') | ASCII::*_LANGUAGE_CODE</p>` - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` - `bool $asOrigReplaceArray [optional] <p>TRUE === return {orig: string[], replace: string[]} array</p>` **Return:** - `array <p>An array of replacements.</p>` -------- #### charsArrayWithSingleLanguageValues(bool $replace_extra_symbols, bool $asOrigReplaceArray): array <a href="#voku-php-readme-class-methods">β</a> Returns an replacement array for ASCII methods with multiple languages. EXAMPLE: <code> $array = ASCII::charsArrayWithSingleLanguageValues(); $tmpKey = \array_search('hnaik', $array['replace']); echo $array['orig'][$tmpKey]; // 'α' </code> **Parameters:** - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` - `bool $asOrigReplaceArray [optional] <p>TRUE === return {orig: string[], replace: string[]} array</p>` **Return:** - `array <p>An array of replacements.</p>` -------- #### clean(string $str, bool $normalize_whitespace, bool $keep_non_breaking_space, bool $normalize_msword, bool $remove_invisible_characters): string <a href="#voku-php-readme-class-methods">β</a> Accepts a string and removes all non-UTF-8 characters from it + extras if needed. **Parameters:** - `string $str <p>The string to be sanitized.</p>` - `bool $normalize_whitespace [optional] <p>Set to true, if you need to normalize the whitespace.</p>` - `bool $keep_non_breaking_space [optional] <p>Set to true, to keep non-breaking-spaces, in combination with $normalize_whitespace</p>` - `bool $normalize_msword [optional] <p>Set to true, if you need to normalize MS Word chars e.g.: "β¦" => "..."</p>` - `bool $remove_invisible_characters [optional] <p>Set to false, if you not want to remove invisible characters e.g.: "\0"</p>` **Return:** - `string <p>A clean UTF-8 string.</p>` -------- #### getAllLanguages(): string[] <a href="#voku-php-readme-class-methods">β</a> Get all languages from the constants "ASCII::.*LANGUAGE_CODE". **Parameters:** __nothing__ **Return:** - `string[]` -------- #### is_ascii(string $str): bool <a href="#voku-php-readme-class-methods">β</a> Checks if a string is 7 bit ASCII. EXAMPLE: <code> ASCII::is_ascii('η½'); // false </code> **Parameters:** - `string $str <p>The string to check.</p>` **Return:** - `bool <p> <strong>true</strong> if it is ASCII<br> <strong>false</strong> otherwise </p>` -------- #### normalize_msword(string $str): string <a href="#voku-php-readme-class-methods">β</a> Returns a string with smart quotes, ellipsis characters, and dashes from Windows-1252 (commonly used in Word documents) replaced by their ASCII equivalents. EXAMPLE: <code> ASCII::normalize_msword('βAbcdefβ¦β'); // '"Abcdef..."' </code> **Parameters:** - `string $str <p>The string to be normalized.</p>` **Return:** - `string <p>A string with normalized characters for commonly used chars in Word documents.</p>` -------- #### normalize_whitespace(string $str, bool $keepNonBreakingSpace, bool $keepBidiUnicodeControls, bool $normalize_control_characters): string <a href="#voku-php-readme-class-methods">β</a> Normalize the whitespace. EXAMPLE: <code> ASCII::normalize_whitespace("abc-\xc2\xa0-âÀü-\xe2\x80\xaf-\xE2\x80\xAC", true); // "abc-\xc2\xa0-âÀü- -" </code> **Parameters:** - `string $str <p>The string to be normalized.</p>` - `bool $keepNonBreakingSpace [optional] <p>Set to true, to keep non-breaking-spaces.</p>` - `bool $keepBidiUnicodeControls [optional] <p>Set to true, to keep non-printable (for the web) bidirectional text chars.</p>` - `bool $normalize_control_characters [optional] <p>Set to true, to convert e.g. LINE-, PARAGRAPH-SEPARATOR with "\n" and LINE TABULATION with "\t".</p>` **Return:** - `string <p>A string with normalized whitespace.</p>` -------- #### remove_invisible_characters(string $str, bool $url_encoded, string $replacement, bool $keep_basic_control_characters): string <a href="#voku-php-readme-class-methods">β</a> Remove invisible characters from a string. e.g.: This prevents sandwiching null characters between ascii characters, like Java\0script. copy&past from https://github.com/bcit-ci/CodeIgniter/blob/develop/system/core/Common.php **Parameters:** - `string $str` - `bool $url_encoded` - `string $replacement` - `bool $keep_basic_control_characters` **Return:** - `string` -------- #### to_ascii(string $str, string $language, bool $remove_unsupported_chars, bool $replace_extra_symbols, bool $use_transliterate, bool|null $replace_single_chars_only): string <a href="#voku-php-readme-class-methods">β</a> Returns an ASCII version of the string. A set of non-ASCII characters are replaced with their closest ASCII counterparts, and the rest are removed by default. The language or locale of the source string can be supplied for language-specific transliteration in any of the following formats: en, en_GB, or en-GB. For example, passing "de" results in "Àâü" mapping to "aeoeue" rather than "aou" as in other languages. EXAMPLE: <code> ASCII::to_ascii('οΏ½DΓΌsseldorfοΏ½', 'en'); // Dusseldorf </code> **Parameters:** - `string $str <p>The input string.</p>` - `ASCII::* $language [optional] <p>Language of the source string. (default is 'en') | ASCII::*_LANGUAGE_CODE</p>` - `bool $remove_unsupported_chars [optional] <p>Whether or not to remove the unsupported characters.</p>` - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` - `bool $use_transliterate [optional] <p>Use ASCII::to_transliterate() for unknown chars.</p>` - `bool|null $replace_single_chars_only [optional] <p>Single char replacement is better for the performance, but some languages need to replace more then one char at the same time. | NULL === auto-setting, depended on the language</p>` **Return:** - `string <p>A string that contains only ASCII characters.</p>` -------- #### to_ascii_remap(string $str1, string $str2): string[] <a href="#voku-php-readme-class-methods">β</a> WARNING: This method will return broken characters and is only for special cases. Convert two UTF-8 encoded string to a single-byte strings suitable for functions that need the same string length after the conversion. The function simply uses (and updates) a tailored dynamic encoding (in/out map parameter) where non-ascii characters are remapped to the range [128-255] in order of appearance. **Parameters:** - `string $str1` - `string $str2` **Return:** - `string[]` -------- #### to_filename(string $str, bool $use_transliterate, string $fallback_char): string <a href="#voku-php-readme-class-methods">β</a> Convert given string to safe filename (and keep string case). EXAMPLE: <code> ASCII::to_filename('Χ©ΧΧΧ©ΧΧ.png', true)); // 'shdgshdg.png' </code> **Parameters:** - `string $str` - `bool $use_transliterate <p>ASCII::to_transliterate() is used by default - unsafe characters are simply replaced with hyphen otherwise.</p>` - `string $fallback_char` **Return:** - `string <p>A string that contains only safe characters for a filename.</p>` -------- #### to_slugify(string $str, string $separator, string $language, string[] $replacements, bool $replace_extra_symbols, bool $use_str_to_lower, bool $use_transliterate): string <a href="#voku-php-readme-class-methods">β</a> Converts the string into an URL slug. This includes replacing non-ASCII characters with their closest ASCII equivalents, removing remaining non-ASCII and non-alphanumeric characters, and replacing whitespace with $separator. The separator defaults to a single dash, and the string is also converted to lowercase. The language of the source string can also be supplied for language-specific transliteration. **Parameters:** - `string $str` - `string $separator [optional] <p>The string used to replace whitespace.</p>` - `ASCII::* $language [optional] <p>Language of the source string. (default is 'en') | ASCII::*_LANGUAGE_CODE</p>` - `array<string, string> $replacements [optional] <p>A map of replaceable strings.</p>` - `bool $replace_extra_symbols [optional] <p>Add some more replacements e.g. "Β£" with " pound ".</p>` - `bool $use_str_to_lower [optional] <p>Use "string to lower" for the input.</p>` - `bool $use_transliterate [optional] <p>Use ASCII::to_transliterate() for unknown chars.</p>` **Return:** - `string <p>A string that has been converted to an URL slug.</p>` -------- #### to_transliterate(string $str, string|null $unknown, bool $strict): string <a href="#voku-php-readme-class-methods">β</a> Returns an ASCII version of the string. A set of non-ASCII characters are replaced with their closest ASCII counterparts, and the rest are removed unless instructed otherwise. EXAMPLE: <code> ASCII::to_transliterate('dΓ©jΓ ΟΟΟ iΔ±ii'); // 'deja sss iiii' </code> **Parameters:** - `string $str <p>The input string.</p>` - `string|null $unknown [optional] <p>Character use if character unknown. (default is '?') But you can also use NULL to keep the unknown chars.</p>` - `bool $strict [optional] <p>Use "transliterator_transliterate()" from PHP-Intl` **Return:** - `string <p>A String that contains only ASCII characters.</p>` -------- ## Unit Test 1) [Composer](https://getcomposer.org) is a prerequisite for running the tests. ``` composer install ``` 2) The tests can be executed by running this command from the root directory: ```bash ./vendor/bin/phpunit ``` ### Support For support and donations please visit [Github](https://github.com/voku/portable-ascii/) | [Issues](https://github.com/voku/portable-ascii/issues) | [PayPal](https://paypal.me/moelleken) | [Patreon](https://www.patreon.com/voku). For status updates and release announcements please visit [Releases](https://github.com/voku/portable-ascii/releases) | [Twitter](https://twitter.com/suckup_de) | [Patreon](https://www.patreon.com/voku/posts). For professional support please contact [me](https://about.me/voku). ### Thanks - Thanks to [GitHub](https://github.com) (Microsoft) for hosting the code and a good infrastructure including Issues-Managment, etc. - Thanks to [IntelliJ](https://www.jetbrains.com) as they make the best IDEs for PHP and they gave me an open source license for PhpStorm! - Thanks to [Travis CI](https://travis-ci.com/) for being the most awesome, easiest continous integration tool out there! - Thanks to [StyleCI](https://styleci.io/) for the simple but powerful code style check. - Thanks to [PHPStan](https://github.com/phpstan/phpstan) && [Psalm](https://github.com/vimeo/psalm) for really great Static analysis tools and for discover bugs in the code! ### License and Copyright Released under the MIT License - see `LICENSE.txt` for details. home/fluxyjvi/public_html/project/vendor/vonage/nexmo-bridge/README.md 0000644 00000003334 15111232414 0021734 0 ustar 00 Vonage Nexmo Bridge =================== [](https://github.com/nexmo/vonage-php-nexmo-bridge/actions?query=workflow%3Abuild) [](./LICENSE) [](https://codecov.io/gh/nexmo/vonage-php-nexmo-bridge) <img src="https://developer.nexmo.com/assets/images/Vonage_Nexmo.svg" height="48px" alt="Nexmo is now known as Vonage" /> This library provides a custom autoloader that aliases legacy Nexmo classes, traits, and interfaces to their replacements under the Vonage namespace. This library is handy if you want to switch over to the newer `vonage/client` or `vonage/client-core` libraries but have a lot of older code that utilizes the `\Nexmo` namespace. If you are starting a project from scratch, we recommend immediately using the `\Vonage` namespace. Much of this code has been ported from the [`laminas/laminas-zendframework-bridge`](https://github.com/laminas/laminas-zendframework-bridge) project. ## Installation Run the following to install this library: ```bash $ composer require vonage/nexmo-bridge ``` ## Usage There is none! By including this package, the autoloader will be automatically invoked and will do all the work for you. ## Contributing This library is actively developed and we love to hear from you! Please feel free to [create an issue][issues] or [open a pull request][pulls] with your questions, comments, suggestions and feedback. [issues]: https://github.com/Nexmo/vonage-php-nexmo-bridge/issues [pulls]: https://github.com/Nexmo/vonage-php-nexmo-bridge/pulls home/fluxyjvi/public_html/project/vendor/rmccue/requests/README.md 0000644 00000014713 15111254321 0021232 0 ustar 00 Requests for PHP ================ [](https://github.com/WordPress/Requests/actions/workflows/cs.yml) [](https://github.com/WordPress/Requests/actions/workflows/lint.yml) [](https://github.com/WordPress/Requests/actions/workflows/test.yml) [](https://codecov.io/gh/WordPress/Requests?branch=stable) Requests is a HTTP library written in PHP, for human beings. It is roughly based on the API from the excellent [Requests Python library](http://python-requests.org/). Requests is [ISC Licensed](https://github.com/WordPress/Requests/blob/stable/LICENSE) (similar to the new BSD license) and has no dependencies, except for PHP 5.6+. Despite PHP's use as a language for the web, its tools for sending HTTP requests are severely lacking. cURL has an [interesting API](https://www.php.net/curl-setopt), to say the least, and you can't always rely on it being available. Sockets provide only low level access, and require you to build most of the HTTP response parsing yourself. We all have better things to do. That's why Requests was born. ```php $headers = array('Accept' => 'application/json'); $options = array('auth' => array('user', 'pass')); $request = WpOrg\Requests\Requests::get('https://api.github.com/gists', $headers, $options); var_dump($request->status_code); // int(200) var_dump($request->headers['content-type']); // string(31) "application/json; charset=utf-8" var_dump($request->body); // string(26891) "[...]" ``` Requests allows you to send **HEAD**, **GET**, **POST**, **PUT**, **DELETE**, and **PATCH** HTTP requests. You can add headers, form data, multipart files, and parameters with basic arrays, and access the response data in the same way. Requests uses cURL and fsockopen, depending on what your system has available, but abstracts all the nasty stuff out of your way, providing a consistent API. Features -------- - International Domains and URLs - Browser-style SSL Verification - Basic/Digest Authentication - Automatic Decompression - Connection Timeouts Installation ------------ ### Install with Composer If you're using [Composer](https://getcomposer.org/) to manage dependencies, you can add Requests with it. ```sh composer require rmccue/requests ``` or ```json { "require": { "rmccue/requests": "^2.0" } } ``` ### Install source from GitHub To install the source code: ```bash $ git clone git://github.com/WordPress/Requests.git ``` Next, include the autoloader in your scripts: ```php require_once '/path/to/Requests/src/Autoload.php'; ``` You'll probably also want to register the autoloader: ```php WpOrg\Requests\Autoload::register(); ``` ### Install source from zip/tarball Alternatively, you can fetch a [tarball][] or [zipball][]: ```bash $ curl -L https://github.com/WordPress/Requests/tarball/stable | tar xzv (or) $ wget https://github.com/WordPress/Requests/tarball/stable -O - | tar xzv ``` [tarball]: https://github.com/WordPress/Requests/tarball/stable [zipball]: https://github.com/WordPress/Requests/zipball/stable ### Using a Class Loader If you're using a class loader (e.g., [Symfony Class Loader][]) for [PSR-4][]-style class loading: ```php $loader = new Psr4ClassLoader(); $loader->addPrefix('WpOrg\\Requests\\', 'path/to/vendor/Requests/src'); $loader->register(); ``` [Symfony Class Loader]: https://github.com/symfony/ClassLoader [PSR-4]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4.md Documentation ------------- The best place to start is our [prose-based documentation][], which will guide you through using Requests. After that, take a look at [the documentation for `\WpOrg\Requests\Requests::request()`][request_method], where all the parameters are fully documented. Requests is [100% documented with PHPDoc](https://requests.ryanmccue.info/api-2.x/). If you find any problems with it, [create a new issue](https://github.com/WordPress/Requests/issues/new)! [prose-based documentation]: https://github.com/WordPress/Requests/blob/stable/docs/README.md [request_method]: https://requests.ryanmccue.info/api-2.x/classes/WpOrg-Requests-Requests.html#method_request Testing ------- Requests strives to have 100% code-coverage of the library with an extensive set of tests. We're not quite there yet, but [we're getting close][codecov]. [codecov]: https://codecov.io/github/WordPress/Requests/ To run the test suite, first check that you have the [PHP JSON extension ](https://www.php.net/book.json) enabled. Then simply: ```bash $ phpunit ``` If you'd like to run a single set of tests, specify just the name: ```bash $ phpunit Transport/cURL ``` Requests and PSR-7/PSR-18 ------------------------- [PSR-7][psr-7] describes common interfaces for representing HTTP messages. [PSR-18][psr-18] describes a common interface for sending HTTP requests and receiving HTTP responses. Both PSR-7 as well as PSR-18 were created after Requests' conception. At this time, there is no intention to add a native PSR-7/PSR-18 implementation to the Requests library. However, the amazing [Artur Weigandt][art4] has created a [package][requests-psr-18], which allows you to use Requests as a PSR-7 compatible PSR-18 HTTP Client. If you are interested in a PSR-7/PSR-18 compatible version of Requests, we highly recommend you check out [this package][requests-psr-18]. [psr-7]: https://www.php-fig.org/psr/psr-7/ [psr-18]: https://www.php-fig.org/psr/psr-18/ [art4]: https://github.com/Art4 [requests-psr-18]: https://packagist.org/packages/art4/requests-psr18-adapter Contribute ---------- 1. Check for open issues or open a new issue for a feature request or a bug. 2. Fork [the repository][] on Github to start making your changes to the `develop` branch (or branch off of it). 3. Write one or more tests which show that the bug was fixed or that the feature works as expected. 4. Send in a pull request. If you have questions while working on your contribution and you use Slack, there is a [#core-http-api] channel available in the [WordPress Slack] in which contributions can be discussed. [the repository]: https://github.com/WordPress/Requests [#core-http-api]: https://wordpress.slack.com/archives/C02BBE29V42 [WordPress Slack]: https://make.wordpress.org/chat/ home/fluxyjvi/public_html/project/vendor/laravel/sanctum/README.md 0000644 00000003020 15111255224 0021171 0 ustar 00 <p align="center"><img src="/art/logo.svg" alt="Logo Laravel Sanctum"></p> <p align="center"> <a href="https://github.com/laravel/sanctum/actions"><img src="https://github.com/laravel/sanctum/workflows/tests/badge.svg" alt="Build Status"></a> <a href="https://packagist.org/packages/laravel/sanctum"><img src="https://img.shields.io/packagist/dt/laravel/sanctum" alt="Total Downloads"></a> <a href="https://packagist.org/packages/laravel/sanctum"><img src="https://img.shields.io/packagist/v/laravel/sanctum" alt="Latest Stable Version"></a> <a href="https://packagist.org/packages/laravel/sanctum"><img src="https://img.shields.io/packagist/l/laravel/sanctum" alt="License"></a> </p> ## Introduction Laravel Sanctum provides a featherweight authentication system for SPAs and simple APIs. ## Official Documentation Documentation for Sanctum can be found on the [Laravel website](https://laravel.com/docs/sanctum). ## Contributing Thank you for considering contributing to Sanctum! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities Please review [our security policy](https://github.com/laravel/sanctum/security/policy) on how to report security vulnerabilities. ## License Laravel Sanctum is open-sourced software licensed under the [MIT license](LICENSE.md). home/fluxyjvi/public_html/project/vendor/stella-maris/clock/README.md 0000644 00000004576 15111260704 0021601 0 ustar 00 # Clock An implementation of the proposed PSR-20 clock-interface [](https://packagist.org/packages/stella-maris/clock) [](https://packagist.org/packages/stella-maris/clock) [](https://packagist.org/packages/stella-maris/clock) [](https://gitlab.com/stella-maris/clock/-/commits/main) ## Installation ```bash composer require stella-maris/clock ``` ## Usage This interface allows one to inject one of the implemntations that provide the clock-interface. ```php use StellaMaris/Clock/CLockInterface; final class PastChecker { public function __construct(private ClockInterface $clock) {} public function hasDateTimeAlreadyPassed(DateTimeImmutable $item): bool { return $item < $this->clock->now(); } } ``` ## Why Within the Framework Interoperability Group (FIG) a working group has started in 2021 to create a ClockInterface. The works on that have been rather fast and already in the mid of 2021 the interface was more or less finally decided upon. ### So why this Interface? Since mid 2021 no further work has been happening on the Working Group. All requests towards the editor and the sponsor weren't met with any reaction. So after a lot of discussions on the official working group channel I decided to bring this interface forward by providing the currently agreed upon interface as a separate package on packagist. ### But what when the PSR Interface is provided? There are two possibilities: * Either the interface will be provided by the FIG as it is currently, then this interface will extend the PSR-20 one so that all implementations of this interface will be immediately PSR20 compatible. * Or the PSR20 interface will look different: Then all current implementations will need to provide a spearate implementation for PSR20 compatibility and this interface will simply coexist with the PSR20 one. ## Documentation For a more thorough information about the interface please check the PSR-20 documentation at https://github.com/php-fig/fig-standards/blob/master/proposed/clock.md and https://github.com/php-fig/fig-standards/blob/master/proposed/clock-meta.md home/fluxyjvi/public_html/project/vendor/guzzlehttp/guzzle/README.md 0000644 00000011636 15111261103 0021636 0 ustar 00  # Guzzle, PHP HTTP client [](https://github.com/guzzle/guzzle/releases) [](https://github.com/guzzle/guzzle/actions?query=workflow%3ACI) [](https://packagist.org/packages/guzzlehttp/guzzle) Guzzle is a PHP HTTP client that makes it easy to send HTTP requests and trivial to integrate with web services. - Simple interface for building query strings, POST requests, streaming large uploads, streaming large downloads, using HTTP cookies, uploading JSON data, etc... - Can send both synchronous and asynchronous requests using the same interface. - Uses PSR-7 interfaces for requests, responses, and streams. This allows you to utilize other PSR-7 compatible libraries with Guzzle. - Supports PSR-18 allowing interoperability between other PSR-18 HTTP Clients. - Abstracts away the underlying HTTP transport, allowing you to write environment and transport agnostic code; i.e., no hard dependency on cURL, PHP streams, sockets, or non-blocking event loops. - Middleware system allows you to augment and compose client behavior. ```php $client = new \GuzzleHttp\Client(); $response = $client->request('GET', 'https://api.github.com/repos/guzzle/guzzle'); echo $response->getStatusCode(); // 200 echo $response->getHeaderLine('content-type'); // 'application/json; charset=utf8' echo $response->getBody(); // '{"id": 1420053, "name": "guzzle", ...}' // Send an asynchronous request. $request = new \GuzzleHttp\Psr7\Request('GET', 'http://httpbin.org'); $promise = $client->sendAsync($request)->then(function ($response) { echo 'I completed! ' . $response->getBody(); }); $promise->wait(); ``` ## Help and docs We use GitHub issues only to discuss bugs and new features. For support please refer to: - [Documentation](https://docs.guzzlephp.org) - [Stack Overflow](https://stackoverflow.com/questions/tagged/guzzle) - [#guzzle](https://app.slack.com/client/T0D2S9JCT/CE6UAAKL4) channel on [PHP-HTTP Slack](https://slack.httplug.io/) - [Gitter](https://gitter.im/guzzle/guzzle) ## Installing Guzzle The recommended way to install Guzzle is through [Composer](https://getcomposer.org/). ```bash composer require guzzlehttp/guzzle ``` ## Version Guidance | Version | Status | Packagist | Namespace | Repo | Docs | PSR-7 | PHP Version | |---------|---------------------|---------------------|--------------|---------------------|---------------------|-------|--------------| | 3.x | EOL | `guzzle/guzzle` | `Guzzle` | [v3][guzzle-3-repo] | [v3][guzzle-3-docs] | No | >=5.3.3,<7.0 | | 4.x | EOL | `guzzlehttp/guzzle` | `GuzzleHttp` | [v4][guzzle-4-repo] | N/A | No | >=5.4,<7.0 | | 5.x | EOL | `guzzlehttp/guzzle` | `GuzzleHttp` | [v5][guzzle-5-repo] | [v5][guzzle-5-docs] | No | >=5.4,<7.4 | | 6.x | Security fixes only | `guzzlehttp/guzzle` | `GuzzleHttp` | [v6][guzzle-6-repo] | [v6][guzzle-6-docs] | Yes | >=5.5,<8.0 | | 7.x | Latest | `guzzlehttp/guzzle` | `GuzzleHttp` | [v7][guzzle-7-repo] | [v7][guzzle-7-docs] | Yes | >=7.2.5,<8.3 | [guzzle-3-repo]: https://github.com/guzzle/guzzle3 [guzzle-4-repo]: https://github.com/guzzle/guzzle/tree/4.x [guzzle-5-repo]: https://github.com/guzzle/guzzle/tree/5.3 [guzzle-6-repo]: https://github.com/guzzle/guzzle/tree/6.5 [guzzle-7-repo]: https://github.com/guzzle/guzzle [guzzle-3-docs]: https://guzzle3.readthedocs.io/ [guzzle-5-docs]: https://docs.guzzlephp.org/en/5.3/ [guzzle-6-docs]: https://docs.guzzlephp.org/en/6.5/ [guzzle-7-docs]: https://docs.guzzlephp.org/en/latest/ ## Security If you discover a security vulnerability within this package, please send an email to security@tidelift.com. All security vulnerabilities will be promptly addressed. Please do not disclose security-related issues publicly until a fix has been announced. Please see [Security Policy](https://github.com/guzzle/guzzle/security/policy) for more information. ## License Guzzle is made available under the MIT License (MIT). Please see [License File](LICENSE) for more information. ## For Enterprise Available as part of the Tidelift Subscription The maintainers of Guzzle and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/packagist-guzzlehttp-guzzle?utm_source=packagist-guzzlehttp-guzzle&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) home/fluxyjvi/public_html/project/vendor/laravel/prompts/README.md 0000644 00000003526 15111261213 0021231 0 ustar 00 <p align="center"><img width="386" height="68" src="/art/logo.svg" alt="Laravel Prompts"></p> <p align="center"> <a href="https://github.com/laravel/prompts/actions"><img src="https://github.com/laravel/prompts/workflows/tests/badge.svg" alt="Build Status"></a> <a href="https://packagist.org/packages/laravel/prompts"><img src="https://img.shields.io/packagist/dt/laravel/prompts" alt="Total Downloads"></a> <a href="https://packagist.org/packages/laravel/prompts"><img src="https://img.shields.io/packagist/v/laravel/prompts" alt="Latest Stable Version"></a> <a href="https://packagist.org/packages/laravel/prompts"><img src="https://img.shields.io/packagist/l/laravel/prompts" alt="License"></a> </p> ## Introduction Laravel Prompts is a PHP package for adding beautiful and user-friendly forms to your command-line applications, with browser-like features including placeholder text and validation. Laravel Prompts is perfect for accepting user input in your [Artisan console commands](https://laravel.com/docs/artisan#writing-commands), but it may also be used in any command-line PHP project. ## Official Documentation Documentation for Laravel Prompts can be found on the [Laravel website](https://laravel.com/docs/prompts). ## Contributing Thank you for considering contributing to Laravel Prompts! The contribution guide can be found in the [Laravel documentation](https://laravel.com/docs/contributions). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities Please review [our security policy](https://github.com/laravel/prompts/security/policy) on how to report security vulnerabilities. ## License Laravel Prompts is open-sourced software licensed under the [MIT license](LICENSE.md). home/fluxyjvi/public_html/project/vendor/sebastian/version/README.md 0000644 00000004234 15111261636 0021543 0 ustar 00 [](https://packagist.org/packages/sebastian/version) # sebastian/version **sebastian/version** is a library that helps with managing the version number of Git-hosted PHP projects. ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): ``` composer require sebastian/version ``` If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: ``` composer require --dev sebastian/version ``` ## Usage The constructor of the `SebastianBergmann\Version` class expects two parameters: * `$release` is the version number of the latest release (`X.Y.Z`, for instance) or the name of the release series (`X.Y`) when no release has been made from that branch / for that release series yet. * `$path` is the path to the directory (or a subdirectory thereof) where the sourcecode of the project can be found. Simply passing `__DIR__` here usually suffices. Apart from the constructor, the `SebastianBergmann\Version` class has a single public method: `asString()`. Here is a contrived example that shows the basic usage: ```php <?php declare(strict_types=1); use SebastianBergmann\Version; $version = new Version('1.0.0', __DIR__); var_dump($version->asString()); ``` ``` string(18) "1.0.0-17-g00f3408" ``` When a new release is prepared, the string that is passed to the constructor as the first argument needs to be updated. ### How SebastianBergmann\Version::asString() works * If `$path` is not (part of) a Git repository and `$release` is in `X.Y.Z` format then `$release` is returned as-is. * If `$path` is not (part of) a Git repository and `$release` is in `X.Y` format then `$release` is returned suffixed with `-dev`. * If `$path` is (part of) a Git repository and `$release` is in `X.Y.Z` format then the output of `git describe --tags` is returned as-is. * If `$path` is (part of) a Git repository and `$release` is in `X.Y` format then a string is returned that begins with `X.Y` and ends with information from `git describe --tags`. home/fluxyjvi/public_html/project/vendor/dompdf/dompdf/README.md 0000644 00000016744 15111310776 0020640 0 ustar 00 Dompdf ====== [](https://github.com/dompdf/dompdf/actions/workflows/test.yml) [](https://packagist.org/packages/dompdf/dompdf) [](https://packagist.org/packages/dompdf/dompdf) [](https://packagist.org/packages/dompdf/dompdf) **Dompdf is an HTML to PDF converter** At its heart, dompdf is (mostly) a [CSS 2.1](http://www.w3.org/TR/CSS2/) compliant HTML layout and rendering engine written in PHP. It is a style-driven renderer: it will download and read external stylesheets, inline style tags, and the style attributes of individual HTML elements. It also supports most presentational HTML attributes. *This document applies to the latest stable code which may not reflect the current release. For released code please [navigate to the appropriate tag](https://github.com/dompdf/dompdf/tags).* ---- **Check out the [demo](http://eclecticgeek.com/dompdf/debug.php) and ask any question on [StackOverflow](https://stackoverflow.com/questions/tagged/dompdf) or in [Discussions](https://github.com/dompdf/dompdf/discussions).** Follow us on [](http://www.twitter.com/dompdf). --- ## Features * Handles most CSS 2.1 and a few CSS3 properties, including @import, @media & @page rules * Supports most presentational HTML 4.0 attributes * Supports external stylesheets, either local or through http/ftp (via fopen-wrappers) * Supports complex tables, including row & column spans, separate & collapsed border models, individual cell styling * Image support (gif, png (8, 24 and 32 bit with alpha channel), bmp & jpeg) * No dependencies on external PDF libraries, thanks to the R&OS PDF class * Inline PHP support * Basic SVG support (see "Limitations" below) ## Requirements * PHP version 7.1 or higher * DOM extension * MBString extension * php-font-lib * php-svg-lib Note that some required dependencies may have further dependencies (notably php-svg-lib requires sabberworm/php-css-parser). ### Recommendations * OPcache (OPcache, XCache, APC, etc.): improves performance * GD (for image processing) * IMagick or GMagick extension: improves image processing performance Visit the wiki for more information: https://github.com/dompdf/dompdf/wiki/Requirements ## About Fonts & Character Encoding PDF documents internally support the following fonts: Helvetica, Times-Roman, Courier, Zapf-Dingbats, & Symbol. These fonts only support Windows ANSI encoding. In order for a PDF to display characters that are not available in Windows ANSI, you must supply an external font. Dompdf will embed any referenced font in the PDF so long as it has been pre-loaded or is accessible to dompdf and reference in CSS @font-face rules. See the [font overview](https://github.com/dompdf/dompdf/wiki/About-Fonts-and-Character-Encoding) for more information on how to use fonts. The [DejaVu TrueType fonts](https://dejavu-fonts.github.io/) have been pre-installed to give dompdf decent Unicode character coverage by default. To use the DejaVu fonts reference the font in your stylesheet, e.g. `body { font-family: DejaVu Sans; }` (for DejaVu Sans). The following DejaVu 2.34 fonts are available: DejaVu Sans, DejaVu Serif, and DejaVu Sans Mono. ## Easy Installation ### Install with composer To install with [Composer](https://getcomposer.org/), simply require the latest version of this package. ```bash composer require dompdf/dompdf ``` Make sure that the autoload file from Composer is loaded. ```php // somewhere early in your project's loading, require the Composer autoloader // see: http://getcomposer.org/doc/00-intro.md require 'vendor/autoload.php'; ``` ### Download and install Download a packaged archive of dompdf and extract it into the directory where dompdf will reside * You can download stable copies of dompdf from https://github.com/dompdf/dompdf/releases * Or download a nightly (the latest, unreleased code) from http://eclecticgeek.com/dompdf Use the packaged release autoloader to load dompdf, libraries, and helper functions in your PHP: ```php // include autoloader require_once 'dompdf/autoload.inc.php'; ``` Note: packaged releases are named according using semantic versioning (_dompdf_MAJOR-MINOR-PATCH.zip_). So the 1.0.0 release would be dompdf_1-0-0.zip. This is the only download that includes the autoloader for Dompdf and all its dependencies. ### Install with git From the command line, switch to the directory where dompdf will reside and run the following commands: ```sh git clone https://github.com/dompdf/dompdf.git cd dompdf/lib git clone https://github.com/PhenX/php-font-lib.git php-font-lib cd php-font-lib git checkout 0.5.1 cd .. git clone https://github.com/PhenX/php-svg-lib.git php-svg-lib cd php-svg-lib git checkout v0.3.2 cd .. git clone https://github.com/sabberworm/PHP-CSS-Parser.git php-css-parser cd php-css-parser git checkout 8.1.0 ``` Require dompdf and it's dependencies in your PHP. For details see the [autoloader in the utils project](https://github.com/dompdf/utils/blob/master/autoload.inc.php). ## Quick Start Just pass your HTML in to dompdf and stream the output: ```php // reference the Dompdf namespace use Dompdf\Dompdf; // instantiate and use the dompdf class $dompdf = new Dompdf(); $dompdf->loadHtml('hello world'); // (Optional) Setup the paper size and orientation $dompdf->setPaper('A4', 'landscape'); // Render the HTML as PDF $dompdf->render(); // Output the generated PDF to Browser $dompdf->stream(); ``` ### Setting Options Set options during dompdf instantiation: ```php use Dompdf\Dompdf; use Dompdf\Options; $options = new Options(); $options->set('defaultFont', 'Courier'); $dompdf = new Dompdf($options); ``` or at run time ```php use Dompdf\Dompdf; $dompdf = new Dompdf(); $options = $dompdf->getOptions(); $options->setDefaultFont('Courier'); $dompdf->setOptions($options); ``` See [Dompdf\Options](src/Options.php) for a list of available options. ### Resource Reference Requirements In order to protect potentially sensitive information Dompdf imposes restrictions on files referenced from the local file system or the web. Files accessed through web-based protocols have the following requirements: * The Dompdf option "isRemoteEnabled" must be set to "true" * PHP must either have the curl extension enabled or the allow_url_fopen setting set to true Files accessed through the local file system have the following requirement: * The file must fall within the path(s) specified for the Dompdf "chroot" option ## Limitations (Known Issues) * Table cells are not pageable, meaning a table row must fit on a single page. * Elements are rendered on the active page when they are parsed. * Embedding "raw" SVG's (`<svg><path...></svg>`) isn't working yet, you need to either link to an external SVG file, or use a DataURI like this: ```php $html = '<img src="data:image/svg+xml;base64,' . base64_encode($svg) . '" ...>'; ``` Watch https://github.com/dompdf/dompdf/issues/320 for progress * Does not support CSS flexbox. * Does not support CSS Grid. --- [](http://goo.gl/DSvWf) *If you find this project useful, please consider making a donation. Any funds donated will be used to help further development on this project.)* home/fluxyjvi/public_html/project/vendor/symfony/css-selector/README.md 0000644 00000001260 15111316471 0022211 0 ustar 00 CssSelector Component ===================== The CssSelector component converts CSS selectors to XPath expressions. Resources --------- * [Documentation](https://symfony.com/doc/current/components/css_selector.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) Credits ------- This component is a port of the Python cssselect library [v0.7.1](https://github.com/SimonSapin/cssselect/releases/tag/v0.7.1), which is distributed under the BSD license. home/fluxyjvi/public_html/project/vendor/spatie/image/README.md 0000644 00000007254 15111323002 0020443 0 ustar 00 # Manipulate images with an expressive API [](https://packagist.org/packages/spatie/image) [](LICENSE.md) [](https://github.com/spatie/image/actions/workflows/run-tests.yml) [](https://packagist.org/packages/spatie/image) Image manipulation doesn't have to be hard. Here are a few examples on how this package makes it very easy to manipulate images. ```php use Spatie\Image\Image; // modifying the image so it fits in a 100x100 rectangle without altering aspect ratio Image::load($pathToImage) ->width(100) ->height(100) ->save($pathToNewImage); // overwriting the original image with a greyscale version Image::load($pathToImage) ->greyscale() ->save(); // make image darker and save it in low quality Image::load($pathToImage) ->brightness(-30) ->quality(25) ->save(); // rotate the image and sharpen it Image::load($pathToImage) ->orientation(90) ->sharpen(15) ->save(); ``` You'll find more examples in [the full documentation](https://docs.spatie.be/image). Under the hood [Glide](http://glide.thephpleague.com/) by [Jonathan Reinink](https://twitter.com/reinink) is used. ## Support us [<img src="https://github-ads.s3.eu-central-1.amazonaws.com/image.jpg?t=1" width="419px" />](https://spatie.be/github-ad-click/image) We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us). We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards). ## Installation You can install the package via composer: ``` bash composer require spatie/image ``` Please note that since version 1.5.3 this package requires exif extension to be enabled: http://php.net/manual/en/exif.installation.php ## Usage Head over to [the full documentation](https://spatie.be/docs/image). ## Changelog Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently. ## Testing ``` bash composer test ``` ## Contributing Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details. ## Security If you've found a bug regarding security please mail [security@spatie.be](mailto:security@spatie.be) instead of using the issue tracker. ## Postcardware You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium. We publish all received postcards [on our company website](https://spatie.be/en/opensource/postcards). ## Credits - [Freek Van der Herten](https://github.com/freekmurze) - [All Contributors](../../contributors) Under the hood [Glide](http://glide.thephpleague.com/) by [Jonathan Reinink](https://twitter.com/reinink) is used. We've based our documentation and docblocks on text found in [the Glide documentation](http://glide.thephpleague.com/) ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. home/fluxyjvi/public_html/project/vendor/nikic/php-parser/README.md 0000644 00000013676 15111363711 0021272 0 ustar 00 PHP Parser ========== [](https://coveralls.io/github/nikic/PHP-Parser?branch=master) This is a PHP 5.2 to PHP 8.2 parser written in PHP. Its purpose is to simplify static code analysis and manipulation. [**Documentation for version 4.x**][doc_4_x] (stable; for running on PHP >= 7.0; for parsing PHP 5.2 to PHP 8.2). [Documentation for version 3.x][doc_3_x] (unsupported; for running on PHP >= 5.5; for parsing PHP 5.2 to PHP 7.2). Features -------- The main features provided by this library are: * Parsing PHP 5, PHP 7, and PHP 8 code into an abstract syntax tree (AST). * Invalid code can be parsed into a partial AST. * The AST contains accurate location information. * Dumping the AST in human-readable form. * Converting an AST back to PHP code. * Experimental: Formatting can be preserved for partially changed ASTs. * Infrastructure to traverse and modify ASTs. * Resolution of namespaced names. * Evaluation of constant expressions. * Builders to simplify AST construction for code generation. * Converting an AST into JSON and back. Quick Start ----------- Install the library using [composer](https://getcomposer.org): php composer.phar require nikic/php-parser Parse some PHP code into an AST and dump the result in human-readable form: ```php <?php use PhpParser\Error; use PhpParser\NodeDumper; use PhpParser\ParserFactory; $code = <<<'CODE' <?php function test($foo) { var_dump($foo); } CODE; $parser = (new ParserFactory)->create(ParserFactory::PREFER_PHP7); try { $ast = $parser->parse($code); } catch (Error $error) { echo "Parse error: {$error->getMessage()}\n"; return; } $dumper = new NodeDumper; echo $dumper->dump($ast) . "\n"; ``` This dumps an AST looking something like this: ``` array( 0: Stmt_Function( byRef: false name: Identifier( name: test ) params: array( 0: Param( type: null byRef: false variadic: false var: Expr_Variable( name: foo ) default: null ) ) returnType: null stmts: array( 0: Stmt_Expression( expr: Expr_FuncCall( name: Name( parts: array( 0: var_dump ) ) args: array( 0: Arg( value: Expr_Variable( name: foo ) byRef: false unpack: false ) ) ) ) ) ) ) ``` Let's traverse the AST and perform some kind of modification. For example, drop all function bodies: ```php use PhpParser\Node; use PhpParser\Node\Stmt\Function_; use PhpParser\NodeTraverser; use PhpParser\NodeVisitorAbstract; $traverser = new NodeTraverser(); $traverser->addVisitor(new class extends NodeVisitorAbstract { public function enterNode(Node $node) { if ($node instanceof Function_) { // Clean out the function body $node->stmts = []; } } }); $ast = $traverser->traverse($ast); echo $dumper->dump($ast) . "\n"; ``` This gives us an AST where the `Function_::$stmts` are empty: ``` array( 0: Stmt_Function( byRef: false name: Identifier( name: test ) params: array( 0: Param( type: null byRef: false variadic: false var: Expr_Variable( name: foo ) default: null ) ) returnType: null stmts: array( ) ) ) ``` Finally, we can convert the new AST back to PHP code: ```php use PhpParser\PrettyPrinter; $prettyPrinter = new PrettyPrinter\Standard; echo $prettyPrinter->prettyPrintFile($ast); ``` This gives us our original code, minus the `var_dump()` call inside the function: ```php <?php function test($foo) { } ``` For a more comprehensive introduction, see the documentation. Documentation ------------- 1. [Introduction](doc/0_Introduction.markdown) 2. [Usage of basic components](doc/2_Usage_of_basic_components.markdown) Component documentation: * [Walking the AST](doc/component/Walking_the_AST.markdown) * Node visitors * Modifying the AST from a visitor * Short-circuiting traversals * Interleaved visitors * Simple node finding API * Parent and sibling references * [Name resolution](doc/component/Name_resolution.markdown) * Name resolver options * Name resolution context * [Pretty printing](doc/component/Pretty_printing.markdown) * Converting AST back to PHP code * Customizing formatting * Formatting-preserving code transformations * [AST builders](doc/component/AST_builders.markdown) * Fluent builders for AST nodes * [Lexer](doc/component/Lexer.markdown) * Lexer options * Token and file positions for nodes * Custom attributes * [Error handling](doc/component/Error_handling.markdown) * Column information for errors * Error recovery (parsing of syntactically incorrect code) * [Constant expression evaluation](doc/component/Constant_expression_evaluation.markdown) * Evaluating constant/property/etc initializers * Handling errors and unsupported expressions * [JSON representation](doc/component/JSON_representation.markdown) * JSON encoding and decoding of ASTs * [Performance](doc/component/Performance.markdown) * Disabling Xdebug * Reusing objects * Garbage collection impact * [Frequently asked questions](doc/component/FAQ.markdown) * Parent and sibling references [doc_3_x]: https://github.com/nikic/PHP-Parser/tree/3.x/doc [doc_4_x]: https://github.com/nikic/PHP-Parser/tree/4.x/doc home/fluxyjvi/public_html/project/vendor/psr/simple-cache/README.md 0000644 00000001063 15111402722 0021231 0 ustar 00 PHP FIG Simple Cache PSR ======================== This repository holds all interfaces related to PSR-16. Note that this is not a cache implementation of its own. It is merely an interface that describes a cache implementation. See [the specification](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-16-simple-cache.md) for more details. You can find implementations of the specification by looking for packages providing the [psr/simple-cache-implementation](https://packagist.org/providers/psr/simple-cache-implementation) virtual package. home/fluxyjvi/public_html/project/vendor/symfony/console/README.md 0000644 00000002322 15111403511 0021235 0 ustar 00 Console Component ================= The Console component eases the creation of beautiful and testable command line interfaces. Sponsor ------- The Console component for Symfony 6.3 is [backed][1] by [Les-Tilleuls.coop][2]. Les-Tilleuls.coop is a team of 70+ Symfony experts who can help you design, develop and fix your projects. They provide a wide range of professional services including development, consulting, coaching, training and audits. They also are highly skilled in JS, Go and DevOps. They are a worker cooperative! Help Symfony by [sponsoring][3] its development! Resources --------- * [Documentation](https://symfony.com/doc/current/components/console.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony) Credits ------- `Resources/bin/hiddeninput.exe` is a third party binary provided within this component. Find sources and license at https://github.com/Seldaek/hidden-input. [1]: https://symfony.com/backers [2]: https://les-tilleuls.coop [3]: https://symfony.com/sponsor home/fluxyjvi/public_html/project/vendor/psy/psysh/README.md 0000644 00000004504 15111403632 0020060 0 ustar 00 # PsySH PsySH is a runtime developer console, interactive debugger and [REPL](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop) for PHP. Learn more at [psysh.org](http://psysh.org/) and [in the manual](https://github.com/bobthecow/psysh/wiki/Home). [](https://packagist.org/packages/psy/psysh) [](https://packagist.org/packages/psy/psysh) [](http://psysh.org) [](https://github.com/bobthecow/psysh/actions?query=branch:main) [](https://styleci.io/repos/4549925) <a id="downloading-the-manual"></a> ## [PsySH manual](https://github.com/bobthecow/psysh/wiki/Home) ### [πΎ Installation](https://github.com/bobthecow/psysh/wiki/Installation) * [π PHP manual installation](https://github.com/bobthecow/psysh/wiki/PHP-manual) * <a class="internal present" href="https://github.com/bobthecow/psysh/wiki/Windows"><img src="https://user-images.githubusercontent.com/53660/40878809-407e8368-664b-11e8-8455-f11602c41dfe.png" width="18"> Windows</a> ### [π₯ Usage](https://github.com/bobthecow/psysh/wiki/Usage) * [β¨ Magic variables](https://github.com/bobthecow/psysh/wiki/Magic-variables) * [β³ Managing history](https://github.com/bobthecow/psysh/wiki/History) * [π² System shell integration](https://github.com/bobthecow/psysh/wiki/Shell-integration) * [π₯ Tutorials & guides](https://github.com/bobthecow/psysh/wiki/Tutorials) * [π Troubleshooting](https://github.com/bobthecow/psysh/wiki/Troubleshooting) ### [π’ Commands](https://github.com/bobthecow/psysh/wiki/Commands) ### [π Configuration](https://github.com/bobthecow/psysh/wiki/Configuration) * [π Config options](https://github.com/bobthecow/psysh/wiki/Config-options) * [π¨ Themes](https://github.com/bobthecow/psysh/wiki/Themes) * [π Sample config file](https://github.com/bobthecow/psysh/wiki/Sample-config) ### [π Integrations](https://github.com/bobthecow/psysh/wiki/Integrations) home/fluxyjvi/public_html/project/vendor/php-http/discovery/README.md 0000644 00000007302 15111426164 0021656 0 ustar 00 # HTTPlug Discovery [](https://github.com/php-http/discovery/releases) [](LICENSE) [](https://github.com/php-http/discovery/actions/workflows/ci.yml?query=branch%3Amaster) [](https://scrutinizer-ci.com/g/php-http/discovery) [](https://scrutinizer-ci.com/g/php-http/discovery) [](https://packagist.org/packages/php-http/discovery) **This library provides auto-discovery and auto-installation of well-known PSR-17, PSR-18 and HTTPlug implementations.** ## Install Via Composer ``` bash composer require php-http/discovery ``` ## Usage as a library author Please see the [official documentation](http://php-http.readthedocs.org/en/latest/discovery.html). If your library/SDK needs a PSR-18 client, here is a quick example. First, you need to install a PSR-18 client and a PSR-17 factory implementations. This should be done only for dev dependencies as you don't want to force a specific implementation on your users: ```bash composer require --dev symfony/http-client composer require --dev nyholm/psr7 ``` Then, you can disable the Composer plugin embeded in `php-http/discovery` because you just installed the dev dependencies you need for testing: ```bash composer config allow-plugins.php-http/discovery false ``` Finally, you need to require `php-http/discovery` and the generic implementations that your library is going to need: ```bash composer require 'php-http/discovery:^1.17' composer require 'psr/http-client-implementation:*' composer require 'psr/http-factory-implementation:*' ``` Now, you're ready to make an HTTP request: ```php use Http\Discovery\Psr18Client; $client = new Psr18Client(); $request = $client->createRequest('GET', 'https://example.com'); $response = $client->sendRequest($request); ``` Internally, this code will use whatever PSR-7, PSR-17 and PSR-18 implementations that your users have installed. ## Usage as a library user If you use a library/SDK that requires `php-http/discovery`, you can configure the auto-discovery mechanism to use a specific implementation when many are available in your project. For example, if you have both `nyholm/psr7` and `guzzlehttp/guzzle` in your project, you can tell `php-http/discovery` to use `guzzlehttp/guzzle` instead of `nyholm/psr7` by running the following command: ```bash composer config extra.discovery.psr/http-factory-implementation GuzzleHttp\\Psr7\\HttpFactory ``` This will update your `composer.json` file to add the following configuration: ```json { "extra": { "discovery": { "psr/http-factory-implementation": "GuzzleHttp\\Psr7\\HttpFactory" } } } ``` Don't forget to run `composer install` to apply the changes, and ensure that the composer plugin is enabled: ```bash composer config allow-plugins.php-http/discovery true composer install ``` ## Testing ``` bash composer test ``` ## Contributing Please see our [contributing guide](http://docs.php-http.org/en/latest/development/contributing.html). ## Security If you discover any security related issues, please contact us at [security@php-http.org](mailto:security@php-http.org). ## License The MIT License (MIT). Please see [License File](LICENSE) for more information. home/fluxyjvi/public_html/project/vendor/theseer/tokenizer/README.md 0000644 00000003631 15111446512 0021554 0 ustar 00 # Tokenizer A small library for converting tokenized PHP source code into XML. [](https://github.com/theseer/tokenizer/actions/workflows/ci.yml) [](https://scrutinizer-ci.com/g/theseer/tokenizer/?branch=master) [](https://scrutinizer-ci.com/g/theseer/tokenizer/?branch=master) [](https://scrutinizer-ci.com/g/theseer/tokenizer/build-status/master) ## Installation You can add this library as a local, per-project dependency to your project using [Composer](https://getcomposer.org/): composer require theseer/tokenizer If you only need this library during development, for instance to run your project's test suite, then you should add it as a development-time dependency: composer require --dev theseer/tokenizer ## Usage examples ```php $tokenizer = new TheSeer\Tokenizer\Tokenizer(); $tokens = $tokenizer->parse(file_get_contents(__DIR__ . '/src/XMLSerializer.php')); $serializer = new TheSeer\Tokenizer\XMLSerializer(); $xml = $serializer->toXML($tokens); echo $xml; ``` The generated XML structure looks something like this: ```xml <?xml version="1.0"?> <source xmlns="https://github.com/theseer/tokenizer"> <line no="1"> <token name="T_OPEN_TAG"><?php </token> <token name="T_DECLARE">declare</token> <token name="T_OPEN_BRACKET">(</token> <token name="T_STRING">strict_types</token> <token name="T_WHITESPACE"> </token> <token name="T_EQUAL">=</token> <token name="T_WHITESPACE"> </token> <token name="T_LNUMBER">1</token> <token name="T_CLOSE_BRACKET">)</token> <token name="T_SEMICOLON">;</token> </line> </source> ``` home/fluxyjvi/public_html/project/vendor/omnipay/common/README.md 0000644 00000004451 15111446563 0021056 0 ustar 00 # Omnipay Common **Core components for the Omnipay PHP payment processing library** [](https://github.com/thephpleague/omnipay-common/actions/workflows/phpunit.yml) [![Latest Version on Packagist][ico-version]][link-packagist] [![Software License][ico-license]](LICENSE.md) [![Total Downloads][ico-downloads]][link-downloads] [Omnipay](https://github.com/thephpleague/omnipay) is a framework agnostic, multi-gateway payment processing library for PHP. This package implements common classes required by Omnipay. ## Documentation Please see [https://omnipay.thephpleague.com/](https://omnipay.thephpleague.com/) for the installation & usage documentation. ## Change log Please see [UPGRADE](UPGRADE.md) for more information on how to upgrade to the latest version. ## Support If you are having general issues with Omnipay, we suggest posting on [Stack Overflow](http://stackoverflow.com/). Be sure to add the [omnipay tag](http://stackoverflow.com/questions/tagged/omnipay) so it can be easily found. If you want to keep up to date with release anouncements, discuss ideas for the project, or ask more detailed questions, there is also a [mailing list](https://groups.google.com/forum/#!forum/omnipay) which you can subscribe to. If you believe you have found a bug, please report it using the [GitHub issue tracker](https://github.com/thephpleague/omnipay-common/issues), or better yet, fork the library and submit a pull request. ## Security If you discover any security related issues, please email barryvdh@gmail.com instead of using the issue tracker. ## License The MIT License (MIT). Please see [License File](LICENSE.md) for more information. [ico-version]: https://img.shields.io/packagist/v/omnipay/common.svg?style=flat [ico-license]: https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat [ico-build]: https://img.shields.io/travis/thephpleague/omnipay-common/master.svg?style=flat [ico-downloads]: https://img.shields.io/packagist/dt/omnipay/common.svg?style=flat [link-packagist]: https://packagist.org/packages/omnipay/common [link-travis]: https://travis-ci.org/thephpleague/omnipay-common [link-downloads]: https://packagist.org/packages/omnipay/common [link-contributors]: ../../contributors home/fluxyjvi/public_html/project/vendor/laravel/sail/README.md 0000644 00000003722 15111460633 0020462 0 ustar 00 <p align="center"><img src="https://github.com/laravel/sail/raw/HEAD/art/logo.svg" alt="Logo Laravel Sail"></p> <p align="center"> <a href="https://packagist.org/packages/laravel/sail"> <img src="https://img.shields.io/packagist/dt/laravel/sail" alt="Total Downloads"> </a> <a href="https://packagist.org/packages/laravel/sail"> <img src="https://img.shields.io/packagist/v/laravel/sail" alt="Latest Stable Version"> </a> <a href="https://packagist.org/packages/laravel/sail"> <img src="https://img.shields.io/packagist/l/laravel/sail" alt="License"> </a> </p> ## Introduction Sail provides a Docker powered local development experience for Laravel that is compatible with macOS, Windows (WSL2), and Linux. Other than Docker, no software or libraries are required to be installed on your local computer before using Sail. Sail's simple CLI means you can start building your Laravel application without any previous Docker experience. #### Inspiration Laravel Sail is inspired by and derived from [Vessel](https://github.com/shipping-docker/vessel) by [Chris Fidao](https://github.com/fideloper). If you're looking for a thorough introduction to Docker, check out Chris' course: [Shipping Docker](https://serversforhackers.com/shipping-docker). ## Official Documentation Documentation for Sail can be found on the [Laravel website](https://laravel.com/docs/sail). ## Contributing Thank you for considering contributing to Sail! You can read the contribution guide [here](.github/CONTRIBUTING.md). ## Code of Conduct In order to ensure that the Laravel community is welcoming to all, please review and abide by the [Code of Conduct](https://laravel.com/docs/contributions#code-of-conduct). ## Security Vulnerabilities Please review [our security policy](https://github.com/laravel/sail/security/policy) on how to report security vulnerabilities. ## License Laravel Sail is open-sourced software licensed under the [MIT license](LICENSE.md). home/fluxyjvi/public_html/project/vendor/symfony/yaml/README.md 0000644 00000000704 15111673261 0020552 0 ustar 00 Yaml Component ============== The Yaml component loads and dumps YAML files. Resources --------- * [Documentation](https://symfony.com/doc/current/components/yaml.html) * [Contributing](https://symfony.com/doc/current/contributing/index.html) * [Report issues](https://github.com/symfony/symfony/issues) and [send Pull Requests](https://github.com/symfony/symfony/pulls) in the [main Symfony repository](https://github.com/symfony/symfony)