<?php


< 
< 
< 
< 
< 
< 
< 
< 
< 



> /*
>  * This file is part of Composer.
>  *
>  * (c) Nils Adermann <naderman@naderman.de>
>  *     Jordi Boggiano <j.boggiano@seld.be>
>  *
>  * For the full copyright and license information, please view the LICENSE
>  * file that was distributed with this source code.
>  */



namespace Composer;


> use Composer\Autoload\ClassLoader;


use Composer\Semver\VersionParser;


< 
< 
< 
< 
< 



> /**
>  * This class is copied in every Composer installed project and available to all
>  *
>  * See also https://getcomposer.org/doc/07-runtime.md#installed-versions
>  *
>  * To require its presence, you can require `composer-runtime-api ^2.0`
>  *
>  * @final
>  */


class InstalledVersions
{

< private static $installed = array (
<   'root' => 
<   array (
<     'pretty_version' => 'dev-master',
<     'version' => 'dev-master',
<     'aliases' => 
<     array (
<     ),
<     'reference' => '70d1b7d67bc280b21f450db41728869bd1bda8d8',
<     'name' => '__root__',
<   ),
<   'versions' => 
<   array (
<     '__root__' => 
<     array (
<       'pretty_version' => 'dev-master',
<       'version' => 'dev-master',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '70d1b7d67bc280b21f450db41728869bd1bda8d8',
<     ),
<     'ezyang/htmlpurifier' => 
<     array (
<       'pretty_version' => 'v4.13.0',
<       'version' => '4.13.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '08e27c97e4c6ed02f37c5b2b20488046c8d90d75',
<     ),
<     'maennchen/zipstream-php' => 
<     array (
<       'pretty_version' => '2.1.0',
<       'version' => '2.1.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => 'c4c5803cc1f93df3d2448478ef79394a5981cc58',
<     ),
<     'markbaker/complex' => 
<     array (
<       'pretty_version' => '2.0.0',
<       'version' => '2.0.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '9999f1432fae467bc93c53f357105b4c31bb994c',
<     ),
<     'markbaker/matrix' => 
<     array (
<       'pretty_version' => '2.0.0',
<       'version' => '2.0.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '9567d9c4c519fbe40de01dbd1e4469dbbb66f46a',
<     ),
<     'myclabs/php-enum' => 
<     array (
<       'pretty_version' => '1.7.7',
<       'version' => '1.7.7.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => 'd178027d1e679832db9f38248fcc7200647dc2b7',
<     ),
<     'phpoffice/phpspreadsheet' => 
<     array (
<       'pretty_version' => '1.16.0',
<       'version' => '1.16.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '76d4323b85129d0c368149c831a07a3e258b2b50',
<     ),
<     'psr/http-client' => 
<     array (
<       'pretty_version' => '1.0.1',
<       'version' => '1.0.1.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '2dfb5f6c5eff0e91e20e913f8c5452ed95b86621',
<     ),
<     'psr/http-factory' => 
<     array (
<       'pretty_version' => '1.0.1',
<       'version' => '1.0.1.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '12ac7fcd07e5b077433f5f2bee95b3a771bf61be',
<     ),
<     'psr/http-message' => 
<     array (
<       'pretty_version' => '1.0.1',
<       'version' => '1.0.1.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => 'f6561bf28d520154e4b0ec72be95418abe6d9363',
<     ),
<     'psr/simple-cache' => 
<     array (
<       'pretty_version' => '1.0.1',
<       'version' => '1.0.1.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => '408d5eafb83c57f6365a3ca330ff23aa4a5fa39b',
<     ),
<     'symfony/polyfill-mbstring' => 
<     array (
<       'pretty_version' => 'v1.22.0',
<       'version' => '1.22.0.0',
<       'aliases' => 
<       array (
<       ),
<       'reference' => 'f377a3dd1fde44d37b9831d68dc8dea3ffd28e13',
<     ),
<   ),
< );
< 
< 
< 
< 
< 
< 
< 



>     /**
>      * @var mixed[]|null
>      * @psalm-var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}|array{}|null
>      */
>     private static $installed;
> 
>     /**
>      * @var bool|null
>      */
>     private static $canGetVendors;
> 
>     /**
>      * @var array[]
>      * @psalm-var array<string, array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
>      */
>     private static $installedByVendor = array();
> 
>     /**
>      * Returns a list of all package names which are present, either by being installed, replaced or provided
>      *
>      * @return string[]
>      * @psalm-return list<string>
>      */


public static function getInstalledPackages()
{

< return array_keys(self::$installed['versions']);



>         $packages = array();
>         foreach (self::getInstalled() as $installed) {
>             $packages[] = array_keys($installed['versions']);


}


>         if (1 === \count($packages)) {

>             return $packages[0];

>         }




>         return array_keys(array_flip(\call_user_func_array('array_merge', $packages)));

>     }




>     /**

>      * Returns a list of all package names with a specific type e.g. 'library'

>      *

>      * @param  string   $type
public static function isInstalled($packageName)
>      * @return string[]
{
>      * @psalm-return list<string>
return isset(self::$installed['versions'][$packageName]);
>      */
}
>     public static function getInstalledPackagesByType($type)

>     {

>         $packagesByType = array();




>         foreach (self::getInstalled() as $installed) {

>             foreach ($installed['versions'] as $name => $package) {

>                 if (isset($package['type']) && $package['type'] === $type) {

>                     $packagesByType[] = $name;

>                 }

>             }

>         }




>         return $packagesByType;

>     }



< 
< 
< 
< public static function isInstalled($packageName)



>     /**
>      * Checks whether the given package is installed
>      *
>      * This also returns true if the package name is provided or replaced by another package
>      *
>      * @param  string $packageName
>      * @param  bool   $includeDevRequirements
>      * @return bool
>      */
>     public static function isInstalled($packageName, $includeDevRequirements = true)



< return isset(self::$installed['versions'][$packageName]);



>         foreach (self::getInstalled() as $installed) {
>             if (isset($installed['versions'][$packageName])) {
>                 return $includeDevRequirements || empty($installed['versions'][$packageName]['dev_requirement']);
>             }


$constraint = $parser->parseConstraints($constraint);

>         return false;
$provided = $parser->parseConstraints(self::getVersionRanges($packageName));
>     }



< 
< 
< 
< 
< 
< 
< 
< 
< 
< 
< 
< 



>     /**
>      * Checks whether the given package satisfies a version constraint
>      *
>      * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call:
>      *
>      *   Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3')
>      *
>      * @param  VersionParser $parser      Install composer/semver to have access to this class and functionality
>      * @param  string        $packageName
>      * @param  string|null   $constraint  A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package
>      * @return bool
>      */



< 
< 
< 
< 
< 
< 
< 
< 
< 



>     /**
>      * Returns a version constraint representing all the range(s) which are installed for a given package
>      *
>      * It is easier to use this via isInstalled() with the $constraint argument if you need to check
>      * whether a given version of a package is installed, and not just whether it exists
>      *
>      * @param  string $packageName
>      * @return string Version constraint usable with composer/semver
>      */



< if (!isset(self::$installed['versions'][$packageName])) {
< throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');



>         foreach (self::getInstalled() as $installed) {
>             if (!isset($installed['versions'][$packageName])) {
>                 continue;



< if (isset(self::$installed['versions'][$packageName]['pretty_version'])) {
< $ranges[] = self::$installed['versions'][$packageName]['pretty_version'];



>             if (isset($installed['versions'][$packageName]['pretty_version'])) {
>                 $ranges[] = $installed['versions'][$packageName]['pretty_version'];



< if (array_key_exists('aliases', self::$installed['versions'][$packageName])) {
< $ranges = array_merge($ranges, self::$installed['versions'][$packageName]['aliases']);



>             if (array_key_exists('aliases', $installed['versions'][$packageName])) {
>                 $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']);



< if (array_key_exists('replaced', self::$installed['versions'][$packageName])) {
< $ranges = array_merge($ranges, self::$installed['versions'][$packageName]['replaced']);



>             if (array_key_exists('replaced', $installed['versions'][$packageName])) {
>                 $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']);



< if (array_key_exists('provided', self::$installed['versions'][$packageName])) {
< $ranges = array_merge($ranges, self::$installed['versions'][$packageName]['provided']);



>             if (array_key_exists('provided', $installed['versions'][$packageName])) {
>                 $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']);


}

return implode(' || ', $ranges);
}


>         throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');

>     }



< 
< 
< 



>     /**
>      * @param  string      $packageName
>      * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
>      */


public static function getVersion($packageName)
{

< if (!isset(self::$installed['versions'][$packageName])) {
< throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');



>         foreach (self::getInstalled() as $installed) {
>             if (!isset($installed['versions'][$packageName])) {
>                 continue;


}


< if (!isset(self::$installed['versions'][$packageName]['version'])) {



>             if (!isset($installed['versions'][$packageName]['version'])) {


return null;
}


< return self::$installed['versions'][$packageName]['version'];



>             return $installed['versions'][$packageName]['version'];


}


>         throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');

>     }



< 
< 
< 



>     /**
>      * @param  string      $packageName
>      * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present
>      */


public static function getPrettyVersion($packageName)
{

< if (!isset(self::$installed['versions'][$packageName])) {
< throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');



>         foreach (self::getInstalled() as $installed) {
>             if (!isset($installed['versions'][$packageName])) {
>                 continue;


}


< if (!isset(self::$installed['versions'][$packageName]['pretty_version'])) {



>             if (!isset($installed['versions'][$packageName]['pretty_version'])) {


return null;
}


< return self::$installed['versions'][$packageName]['pretty_version'];



>             return $installed['versions'][$packageName]['pretty_version'];


}


>         throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');

>     }



< 
< 
< 



>     /**
>      * @param  string      $packageName
>      * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference
>      */


public static function getReference($packageName)
{

< if (!isset(self::$installed['versions'][$packageName])) {
< throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');



>         foreach (self::getInstalled() as $installed) {
>             if (!isset($installed['versions'][$packageName])) {
>                 continue;


}


< if (!isset(self::$installed['versions'][$packageName]['reference'])) {



>             if (!isset($installed['versions'][$packageName]['reference'])) {


return null;
}


< return self::$installed['versions'][$packageName]['reference'];



>             return $installed['versions'][$packageName]['reference'];


}


>         throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');

>     }




>     /**

>      * @param  string      $packageName

>      * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path.
public static function getRootPackage()
>      */
{
>     public static function getInstallPath($packageName)
return self::$installed['root'];
>     {
}
>         foreach (self::getInstalled() as $installed) {

>             if (!isset($installed['versions'][$packageName])) {

>                 continue;

>             }




>             return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null;

>         }




>         throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed');

>     }


public static function getRawData()

>     /**
{
>      * @return array
return self::$installed;
>      * @psalm-return array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}
}
>      */



< return self::$installed['root'];
< }
< 
< 
< 
< 
< 



>         $installed = self::getInstalled();




>         return $installed[0]['root'];

>     }




>     /**

>      * Returns the raw installed.php data for custom implementations

>      *

>      * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect.

>      * @return array[]

>      * @psalm-return array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}

>      */



< return self::$installed;
< }
< 
< 
< 
< 
< 
< 
< 
< 
< 
< 
< 



>         @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED);



>         if (null === self::$installed) {
>             // only require the installed.php file if this file is loaded from its dumped location,
>             // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
>             if (substr(__DIR__, -8, 1) !== 'C') {
>                 self::$installed = include __DIR__ . '/installed.php';
>             } else {
>                 self::$installed = array();
>             }
>         }



>         return self::$installed;
>     }



>     /**
>      * Returns the raw data of all installed.php which are currently loaded for custom implementations
>      *
>      * @return array[]
>      * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
>      */
>     public static function getAllRawData()
>     {
>         return self::getInstalled();
>     }
> 
>     /**
>      * Lets you reload the static array from another file
>      *
>      * This is only useful for complex integrations in which a project needs to use
>      * this class but then also needs to execute another project's autoloader in process,
>      * and wants to ensure both projects have access to their version of installed.php.
>      *
>      * A typical case would be PHPUnit, where it would need to make sure it reads all
>      * the data it needs from this class, then call reload() with
>      * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure
>      * the project in which it runs can then also use this class safely, without
>      * interference between PHPUnit's dependencies and the project's dependencies.
>      *
>      * @param  array[] $data A vendor/composer/installed.php data set
>      * @return void
>      *
>      * @psalm-param array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>} $data
>      */
>     public static function reload($data)
>     {
>         self::$installed = $data;
>         self::$installedByVendor = array();
>     }



>     /**
>      * @return array[]
>      * @psalm-return list<array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array<string, array{pretty_version?: string, version?: string, reference?: string|null, type?: string, install_path?: string, aliases?: string[], dev_requirement: bool, replaced?: string[], provided?: string[]}>}>
>      */
>     private static function getInstalled()
>     {
>         if (null === self::$canGetVendors) {
>             self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders');
>         }



>         $installed = array();



>         if (self::$canGetVendors) {
>             foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) {
>                 if (isset(self::$installedByVendor[$vendorDir])) {
>                     $installed[] = self::$installedByVendor[$vendorDir];
>                 } elseif (is_file($vendorDir.'/composer/installed.php')) {
>                     $installed[] = self::$installedByVendor[$vendorDir] = require $vendorDir.'/composer/installed.php';
>                     if (null === self::$installed && strtr($vendorDir.'/composer', '\\', '/') === strtr(__DIR__, '\\', '/')) {
>                         self::$installed = $installed[count($installed) - 1];
>                     }
>                 }
>             }
>         }



>         if (null === self::$installed) {
>             // only require the installed.php file if this file is loaded from its dumped location,
>             // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937
>             if (substr(__DIR__, -8, 1) !== 'C') {
>                 self::$installed = require __DIR__ . '/installed.php';
>             } else {
>                 self::$installed = array();
>             }
>         }
>         $installed[] = self::$installed;



< public static function reload($data)
< {
< self::$installed = $data;



>         return $installed;