├── .gitignore
├── phpunit.xml
├── composer.json
├── .github
    └── workflows
    │   └── main.yml
├── tests
    ├── CheckerTest.php
    ├── WhoisHandlerTest.php
    └── IntegrationTest.php
├── src
    ├── Checker.php
    ├── WhoisHandler.php
    ├── Whois.php
    ├── AvailabilityDetector.php
    └── dist.whois.json
├── README.md
└── composer.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor/
2 | .idea
3 | .phpunit.result.cache
4 | .github
5 | test_domain.php
6 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit bootstrap="vendor/autoload.php">
 2 |     <testsuites>
 3 |         <testsuite name="WhoisPhp Test Suite">
 4 |             <directory>tests</directory>
 5 |         </testsuite>
 6 |     </testsuites>
 7 |     <coverage>
 8 |         <include>
 9 |             <directory>src/</directory>
10 |         </include>
11 |     </coverage>
12 | </phpunit>
13 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "monovm/whois-php",
 3 |   "description": "This PHP package enables developers to retrieve domain registration information and check domain availability via socket protocol. It's a useful tool for web developers and domain name registrars.",
 4 |   "type": "library",
 5 |   "keywords": [
 6 |     "whois",
 7 |     "php"
 8 |   ],
 9 |   "license": "MIT",
10 |   "autoload": {
11 |     "psr-4": {
12 |       "MonoVM\\WhoisPhp\\": "src/"
13 |     }
14 |   },
15 |   "authors": [
16 |     {
17 |       "name": "MonoVM",
18 |       "email": "dev@monovm.com"
19 |     }
20 |   ],
21 |   "require": {
22 |     "php": ">=7.4",
23 |     "ext-json": "*"
24 |   },
25 |   "require-dev": {
26 |     "phpunit/phpunit": "^9.0",
27 |     "squizlabs/php_codesniffer": "^3.7"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/.github/workflows/main.yml:
--------------------------------------------------------------------------------
 1 | name: Build Workflow
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - main
 7 |   pull_request:
 8 |     branches:
 9 |       - main
10 | 
11 | jobs:
12 |   test:
13 |     runs-on: ubuntu-latest
14 |     steps:
15 |       - name: Checkout code
16 |         uses: actions/checkout@v3.3.0
17 | 
18 |       - name: Set up PHP
19 |         uses: shivammathur/setup-php@v2
20 |         with:
21 |           php-version: "7.4"
22 |           coverage: "pcov"
23 |           extensions: mbstring, pcov
24 | 
25 |       - name: Install dependencies
26 |         run: composer install --prefer-dist --no-interaction
27 |         
28 |       - name: PHP Code Sniffer - Fix
29 |         run: vendor/bin/phpcbf --standard=PSR12 src/
30 | 
31 |       - name: PHP Code Sniffer
32 |         run: vendor/bin/phpcs --standard=PSR12  src/
33 | 
34 |       - name: Run Tests
35 |         run: vendor/bin/phpunit tests/
36 | 


--------------------------------------------------------------------------------
/tests/CheckerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use MonoVM\WhoisPhp\Checker;
 4 | use PHPUnit\Framework\TestCase;
 5 | 
 6 | 
 7 | final class CheckerTest extends TestCase
 8 | {
 9 |     public function testSingleDomainWhoisWithTLD()
10 |     {
11 |         $this->assertArrayHasKey('monovm.com', Checker::whois('monovm.com'), 'No whois result for monovm.com');
12 |     }
13 | 
14 |     public function testSingleDomainWhoisWithInvalidTLD()
15 |     {
16 |         $this->assertEquals('invalid', Checker::whois('monovm.aninvalidtld')['monovm.aninvalidtld'], 'Invalid status for invalid tld');
17 |     }
18 | 
19 |     public function testSingleDomainWhoisWithoutTLD()
20 |     {
21 |         $result = Checker::whois('monovm', ['popularTLDs' => ['.info', '.net']]);
22 |         $this->assertArrayHasKey('monovm.net', $result, 'No whois result for monovm.net');
23 |     }
24 | 
25 |     public function testMultipleDomainsWhois()
26 |     {
27 |         $domains = ['monovm.com', 'google.com', 'bing'];
28 |         $result = Checker::whois($domains);
29 |         $this->assertGreaterThanOrEqual(count($domains), count(array_keys($result)), 'Group whois results count should at least be equal to domains count');
30 |     }
31 | }


--------------------------------------------------------------------------------
/src/Checker.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace MonoVM\WhoisPhp;
 4 | 
 5 | class Checker extends Whois
 6 | {
 7 |     private $parts;
 8 |     private $popularTLDs = ['.com', '.net', '.org', '.info'];
 9 | 
10 |     protected function __construct(string $domain, array $options = [])
11 |     {
12 |         $parts = explode('.', $domain, 2);
13 |         $this->parts = [
14 |             'sld' => array_shift($parts),
15 |             'tld' => count($parts) ? '.' . $parts[0] : null
16 |         ];
17 | 
18 |         if (isset($options['popularTLDs']) && is_array($options['popularTLDs'])) {
19 |             $this->popularTLDs = array_map(function ($tld) {
20 |                 if (strpos($tld, '.') === 0) {
21 |                     return $tld;
22 |                 }
23 |                 return '.' . $tld;
24 |             }, $options['popularTLDs']);
25 |         }
26 | 
27 |         parent::__construct();
28 |     }
29 | 
30 | 
31 |     /**
32 |      * Run whois lookup for domain(s).
33 |      *
34 |      * @param string|array $domains Domain or array of domains to lookup, TLD is optional for each domain.
35 |      * @param array $options Options for WhoisGroup Class,
36 |      ** you can set your own custom popularTLDs to lookup if tld is not provided in domain string.
37 |      ** (eg: ["popularTLDs"=>[".info",".net"]])
38 |      *
39 |      * @return array An associative array with domain as key and status as value.
40 |      */
41 |     public static function whois($domains, array $options = []): array
42 |     {
43 | 
44 |         if (is_string($domains)) {
45 |             $domains = [$domains];
46 |         }
47 | 
48 |         $results = [];
49 |         array_map(function ($domain) use (&$results, $options) {
50 |             $results = array_merge($results, (new self($domain, $options))->doLookup());
51 |         }, $domains);
52 | 
53 |         return $results;
54 |     }
55 | 
56 |     /**
57 |      * Performs lookup for a domain by it parts.
58 |      *
59 |      * @return array An associative array with domain as key and status as value.
60 |      */
61 |     public function doLookup(): array
62 |     {
63 |         $parts = $this->parts;
64 | 
65 |         $tldsToLoop = $parts['tld'] ? [$parts['tld']] : $this->popularTLDs;
66 |         $results = [];
67 |         foreach ($tldsToLoop as $tld) {
68 |             if (!parent::canLookup($tld)) {
69 |                 $results[$this->getDomainNameFromParts($parts)] = 'invalid';
70 |                 continue;
71 |             }
72 | 
73 |             $parts['tld'] = $tld;
74 |             $lookup = parent::lookup($parts);
75 |             $results[$this->getDomainNameFromParts($parts)] = isset($lookup['result']) ? $lookup['result'] : 'unknown';
76 |         }
77 | 
78 |         return $results;
79 |     }
80 | 
81 |     /**
82 |      * Get full domain name from array of sld and tld.
83 |      *
84 |      * @param array $parts An array containing domain parts (eg: ["sld"=>"monovm","tld"=>".com"]).
85 |      * @return string Full domain name. (eg: monovm.com)
86 |      */
87 |     private function getDomainNameFromParts(array $parts): string
88 |     {
89 |         return $parts['sld'] . $parts['tld'];
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/tests/WhoisHandlerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use PHPUnit\Framework\TestCase;
 4 | use MonoVM\WhoisPhp\WhoisHandler;
 5 | 
 6 | class WhoisHandlerTest extends TestCase
 7 | {
 8 |     public function testGetTld()
 9 |     {
10 |         $whoisHandler = WhoisHandler::whois('example.com');
11 |         $this->assertEquals('.com', $whoisHandler->getTld());
12 |     }
13 | 
14 |     public function testGetSld()
15 |     {
16 |         $whoisHandler = WhoisHandler::whois('example.com');
17 |         $this->assertEquals('example', $whoisHandler->getSld());
18 |     }
19 | 
20 |     public function testIsAvailable()
21 |     {
22 |         $whoisHandler = WhoisHandler::whois('example.com');
23 |         $this->assertFalse($whoisHandler->isAvailable());
24 |     }
25 | 
26 |     public function testIsValid()
27 |     {
28 |         $whoisHandler = WhoisHandler::whois('example.com');
29 |         $this->assertTrue($whoisHandler->isValid());
30 |     }
31 | 
32 |     public function testGetWhoisMessage()
33 |     {
34 |         $whoisHandler = WhoisHandler::whois('example.com');
35 |         $this->assertStringContainsString('Domain Name: EXAMPLE.COM', $whoisHandler->getWhoisMessage());
36 |     }
37 | 
38 |     public function testGetAvailabilityDetails()
39 |     {
40 |         $whoisHandler = WhoisHandler::whois('example.com');
41 |         $details = $whoisHandler->getAvailabilityDetails();
42 |         
43 |         $this->assertArrayHasKey('original_library_result', $details);
44 |         $this->assertArrayHasKey('contains_availability_keywords', $details);
45 |         $this->assertArrayHasKey('is_response_too_short', $details);
46 |         $this->assertArrayHasKey('contains_no_match_patterns', $details);
47 |         $this->assertArrayHasKey('tld_specific_patterns', $details);
48 |         $this->assertArrayHasKey('domain_status_indicators', $details);
49 |         $this->assertArrayHasKey('final_availability', $details);
50 |         $this->assertArrayHasKey('whois_message_length', $details);
51 |         $this->assertArrayHasKey('whois_message_preview', $details);
52 |         
53 |         $this->assertIsBool($details['original_library_result']);
54 |         $this->assertIsBool($details['contains_availability_keywords']);
55 |         $this->assertIsBool($details['is_response_too_short']);
56 |         $this->assertIsBool($details['contains_no_match_patterns']);
57 |         $this->assertIsBool($details['tld_specific_patterns']);
58 |         $this->assertIsBool($details['domain_status_indicators']);
59 |         $this->assertIsBool($details['final_availability']);
60 |         $this->assertIsInt($details['whois_message_length']);
61 |         $this->assertIsString($details['whois_message_preview']);
62 |     }
63 | 
64 |     public function testEnhancedAvailabilityDetection()
65 |     {
66 |         // Test with a very likely available domain
67 |         $availableDomain = 'thisisaveryunusualdomain' . time() . '.com';
68 |         $whoisHandler = WhoisHandler::whois($availableDomain);
69 |         
70 |         // The enhanced detection should catch availability even if original library doesn't
71 |         $details = $whoisHandler->getAvailabilityDetails();
72 |         
73 |         // At least one detection method should trigger for an available domain
74 |         $detectionMethods = [
75 |             $details['contains_availability_keywords'],
76 |             $details['is_response_too_short'],
77 |             $details['contains_no_match_patterns'],
78 |             $details['tld_specific_patterns'],
79 |             $details['domain_status_indicators']
80 |         ];
81 |         
82 |         $this->assertTrue(
83 |             in_array(true, $detectionMethods),
84 |             'At least one enhanced detection method should work for available domains'
85 |         );
86 |     }
87 | }
88 | 


--------------------------------------------------------------------------------
/src/WhoisHandler.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace MonoVM\WhoisPhp;
  4 | 
  5 | class WhoisHandler
  6 | {
  7 |     private string $sld;
  8 |     private string $tld;
  9 |     private bool $isAvailable = false;
 10 |     private bool $isValid = true;
 11 |     private string $whoisMessage;
 12 | 
 13 |     /**
 14 |      * Handler construct.
 15 |      */
 16 |     protected function __construct(?string $domain = null)
 17 |     {
 18 |         if ($domain) {
 19 |             $domainParts = explode('.', $domain, 2);
 20 |             $this->sld = $domainParts[0];
 21 |             $this->tld = '.' . $domainParts[1];
 22 | 
 23 |             $whois = new Whois();
 24 | 
 25 |             if ($whois->canLookup($this->tld)) {
 26 |                 $result = $whois->lookup(['sld' => $this->sld, 'tld' => $this->tld]);
 27 |                 if ($result === false || !is_array($result)) {
 28 |                     $this->whoisMessage = 'WHOIS lookup failed for ' . $domain;
 29 |                     $this->isValid = false;
 30 |                 } elseif (isset($result['result']) && $result['result'] === 'error') {
 31 |                     $this->whoisMessage = $result['errordetail'] ?? 'WHOIS lookup error for ' . $domain;
 32 |                     $this->isValid = false;
 33 |                 } elseif ($result['result'] == 'available' && !isset($result['whois'])) {
 34 |                     $this->whoisMessage = $domain . ' is available for registration.';
 35 |                     $this->isAvailable = true;
 36 |                 } else {
 37 |                     $this->whoisMessage = $result['whois'] ?? 'No WHOIS information available.';
 38 |                 }
 39 |             } else {
 40 |                 $this->whoisMessage =
 41 |                     'Unable to lookup whois information for ' . $domain;
 42 |                 $this->isValid = false;
 43 |             }
 44 |         }
 45 |     }
 46 | 
 47 |     /**
 48 |      * Starts the whois operation.
 49 |      */
 50 |     public static function whois(string $domain): WhoisHandler
 51 |     {
 52 |         return new self($domain);
 53 |     }
 54 | 
 55 |     /**
 56 |      * Returns Top-Level Domain.
 57 |      */
 58 |     public function getTld(): string
 59 |     {
 60 |         return $this->tld;
 61 |     }
 62 | 
 63 |     /**
 64 |      * Returns Second-Level Domain.
 65 |      */
 66 |     public function getSld(): string
 67 |     {
 68 |         return $this->sld;
 69 |     }
 70 | 
 71 |     /**
 72 |      * Determines if the domain is available for registration using multiple detection methods.
 73 |      */
 74 |     public function isAvailable(): bool
 75 |     {
 76 |         // If the lookup is not valid (TLD not supported, error, etc.), domain availability is unknown
 77 |         if (!$this->isValid) {
 78 |             return false;
 79 |         }
 80 |         // Use enhanced availability detection
 81 |         return $this->isDomainAvailableEnhanced();
 82 |     }
 83 | 
 84 |     /**
 85 |      * Determines if the domain can be looked up.
 86 |      */
 87 |     public function isValid(): bool
 88 |     {
 89 |         return $this->isValid;
 90 |     }
 91 | 
 92 |     /**
 93 |      * Returns the whois server message.
 94 |      */
 95 |     public function getWhoisMessage(): string
 96 |     {
 97 |         return $this->whoisMessage;
 98 |     }
 99 | 
100 |     /**
101 |      * Enhanced domain availability detection using multiple methods
102 |      */
103 |     private function isDomainAvailableEnhanced(): bool
104 |     {
105 |         try {
106 |             return AvailabilityDetector::isAvailable($this->whoisMessage, $this->tld, $this->isAvailable);
107 |         } catch (\Exception $e) {
108 |             // If TLD is not supported, mark as invalid and unavailable
109 |             $this->isValid = false;
110 |             return false;
111 |         }
112 |     }
113 | 
114 |     /**
115 |      * Get detailed availability information for debugging
116 |      */
117 |     public function getAvailabilityDetails(): array
118 |     {
119 |         try {
120 |             return AvailabilityDetector::getAvailabilityDetails($this->whoisMessage, $this->tld, $this->isAvailable);
121 |         } catch (\Exception $e) {
122 |             // Return details with unsupported TLD information
123 |             return [
124 |                 'original_library_result' => $this->isAvailable,
125 |                 'contains_unsupported_tld_messages' => true,
126 |                 'contains_unavailability_indicators' => false,
127 |                 'contains_registration_indicators' => false,
128 |                 'contains_availability_keywords' => false,
129 |                 'is_response_too_short' => false,
130 |                 'contains_no_match_patterns' => false,
131 |                 'tld_specific_patterns' => false,
132 |                 'domain_status_indicators' => false,
133 |                 'final_availability' => 'unsupported_tld',
134 |                 'whois_message_length' => strlen($this->whoisMessage),
135 |                 'whois_message_preview' => substr($this->whoisMessage, 0, 200) . (strlen($this->whoisMessage) > 200 ? '...' : ''),
136 |                 'error_message' => $e->getMessage(),
137 |             ];
138 |         }
139 |     }
140 | }
141 | 


--------------------------------------------------------------------------------
/src/Whois.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace MonoVM\WhoisPhp;
  4 | 
  5 | use Exception;
  6 | 
  7 | class Whois
  8 | {
  9 |     protected $definitions = [];
 10 | 
 11 |     protected $socketPrefix = 'socket://';
 12 | 
 13 |     public function __construct()
 14 |     {
 15 |         $this->load();
 16 |     }
 17 | 
 18 |     protected function load()
 19 |     {
 20 |         $path = __DIR__ . '/dist.whois.json';
 21 |         $overridePath = __DIR__ . '/whois.json';
 22 |         $this->definitions = array_merge(
 23 |             $this->parseFile($path),
 24 |             $this->parseFile($overridePath),
 25 |         );
 26 |     }
 27 | 
 28 |     protected function parseFile($path)
 29 |     {
 30 |         $return = [];
 31 |         if (file_exists($path)) {
 32 |             $definitions = file_get_contents($path);
 33 |             if ($definitions = @json_decode($definitions, true)) {
 34 |                 foreach ($definitions as $definition) {
 35 |                     $extensions = explode(',', $definition['extensions']);
 36 |                     unset($definition['extensions']);
 37 |                     foreach ($extensions as $extension) {
 38 |                         $return[$extension] = $definition;
 39 |                     }
 40 |                 }
 41 |             } else {
 42 |                 throw new Exception('dist.whois.json file not found!');
 43 |             }
 44 |         }
 45 | 
 46 |         return $return;
 47 |     }
 48 | 
 49 |     public function getSocketPrefix()
 50 |     {
 51 |         return $this->socketPrefix;
 52 |     }
 53 | 
 54 |     public function canLookup($tld)
 55 |     {
 56 |         return array_key_exists($tld, $this->definitions);
 57 |     }
 58 | 
 59 |     public function getFromDefinitions($tld, $key)
 60 |     {
 61 |         return isset($this->definitions[$tld][$key])
 62 |             ? $this->definitions[$tld][$key]
 63 |             : '';
 64 |     }
 65 | 
 66 |     protected function getUri($tld)
 67 |     {
 68 |         if ($this->canLookup($tld)) {
 69 |             $uri = $this->getFromDefinitions($tld, 'uri');
 70 |             if (empty($uri)) {
 71 |                 throw new Exception('Uri not defined for whois service');
 72 |             }
 73 | 
 74 |             return $uri;
 75 |         }
 76 |         throw new Exception('Whois server not known for ' . $tld);
 77 |     }
 78 | 
 79 |     protected function isSocketLookup($tld)
 80 |     {
 81 |         if ($this->canLookup($tld)) {
 82 |             $uri = $this->getUri($tld);
 83 | 
 84 |             return substr($uri, 0, strlen($this->getSocketPrefix())) ==
 85 |                 $this->getSocketPrefix();
 86 |         }
 87 |         throw new Exception('Whois server not known for ' . $tld);
 88 |     }
 89 | 
 90 |     protected function getAvailableMatchString($tld)
 91 |     {
 92 |         if ($this->canLookup($tld)) {
 93 |             return $this->getFromDefinitions($tld, 'available');
 94 |         }
 95 |         throw new Exception('Whois server not known for ' . $tld);
 96 |     }
 97 | 
 98 |     protected function getPremiumMatchString($tld)
 99 |     {
100 |         if ($this->canLookup($tld)) {
101 |             return $this->getFromDefinitions($tld, 'premium');
102 |         }
103 |         throw new Exception('Whois server not known for ' . $tld);
104 |     }
105 | 
106 |     protected function httpWhoisLookup($domain, $uri)
107 |     {
108 |         $url = $uri . $domain;
109 |         $ch = curl_init();
110 |         curl_setopt($ch, CURLOPT_URL, $url);
111 |         curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 0);
112 |         curl_setopt($ch, CURLOPT_TIMEOUT, 60);
113 |         curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
114 |         curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
115 |         curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
116 |         $data = curl_exec($ch);
117 |         if (curl_error($ch)) {
118 |             curl_close($ch);
119 |             throw new Exception(
120 |                 'Error: ' . curl_errno($ch) . ' - ' . curl_error($ch),
121 |             );
122 |         }
123 |         curl_close($ch);
124 | 
125 |         return $data;
126 |     }
127 | 
128 |     protected function socketWhoisLookup($domain, $server, $port)
129 |     {
130 |         $fp = @fsockopen($server, $port, $errorNumber, $errorMessage, 10);
131 |         if ($fp === false) {
132 |             throw new Exception(
133 |                 'Error: ' . $errorNumber . ' - ' . $errorMessage,
134 |             );
135 |         }
136 |         @fwrite($fp, $domain . "\r\n");
137 |         @stream_set_timeout($fp, 10);
138 |         $data = '';
139 |         while (!@feof($fp)) {
140 |             $data .= @fread($fp, 4096);
141 |         }
142 |         @fclose($fp);
143 | 
144 |         return $data;
145 |     }
146 | 
147 |     public function lookup($parts)
148 |     {
149 |         $sld = $parts['sld'];
150 |         $tld = $parts['tld'];
151 | 
152 |         try {
153 |             $uri = $this->getUri($tld);
154 |             $availableMatchString = $this->getAvailableMatchString($tld);
155 |             $premiumMatchString = $this->getPremiumMatchString($tld);
156 |             $isSocketLookup = $this->isSocketLookup($tld);
157 |         } catch (Exception $e) {
158 |             return false;
159 |         }
160 |         $domain = $sld . $tld;
161 | 
162 |         try {
163 |             if ($isSocketLookup) {
164 |                 $uri = substr($uri, strlen($this->getSocketPrefix()));
165 |                 $port = 43;
166 |                 if (strpos($uri, ':')) {
167 |                     $port = explode(':', $uri, 2);
168 |                     [$uri, $port] = $port;
169 |                 }
170 |                 $lookupResult = $this->socketWhoisLookup(
171 |                     $domain,
172 |                     $uri,
173 |                     $port,
174 |                 );
175 |             } else {
176 |                 $lookupResult = $this->httpWhoisLookup($domain, $uri);
177 |             }
178 |         } catch (\Exception $e) {
179 |             $results = [];
180 |             $results['result'] = 'error';
181 |             $results['errordetail'] = $e->getMessage();
182 | 
183 |             return $results;
184 |         }
185 |         $lookupResult = ' ---' . $lookupResult;
186 |         $results = [];
187 |         
188 |         // First check using original logic for backward compatibility
189 |         $originalAvailable = strpos(strtolower($lookupResult), strtolower($availableMatchString)) !== false;
190 |         $isPremium = $premiumMatchString && strpos(strtolower($lookupResult), strtolower($premiumMatchString)) !== false;
191 |         
192 |         // Use enhanced detection for better accuracy
193 |         try {
194 |             $enhancedAvailable = AvailabilityDetector::isAvailable($lookupResult, $tld, $originalAvailable);
195 |         } catch (\Exception $e) {
196 |             // If TLD is not supported, return error result
197 |             $results['result'] = 'error';
198 |             $results['errordetail'] = $e->getMessage();
199 |             return $results;
200 |         }
201 |         
202 |         if ($enhancedAvailable) {
203 |             $results['result'] = 'available';
204 |         } else if ($isPremium) {
205 |             $results['result'] = 'premium';
206 |         } else {
207 |             $results['result'] = 'unavailable';
208 |             if ($isSocketLookup) {
209 |                 $results['whois'] = nl2br(htmlentities($lookupResult));
210 |             } else {
211 |                 $results['whois'] = nl2br(
212 |                     htmlentities(strip_tags($lookupResult)),
213 |                 );
214 |             }
215 |         }
216 | 
217 |         return $results;
218 |     }
219 | }
220 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # :zap: Simple and Fast Domain Whois Lookup in PHP :zap:
  2 | 
  3 | Simple and Fast Domain Whois Lookup in PHP
  4 | 
  5 | This PHP whois package enables developers to retrieve domain registration information and check domain availability via socket
  6 | protocol. It's a useful tool for web developers and domain name registrars.
  7 | 
  8 | based on WHMCS domain Whois class.
  9 | 
 10 | ## :scroll: Installation
 11 | 
 12 | You can install the whois package via composer:
 13 | 
 14 | ```bash
 15 | composer require monovm/whois-php
 16 | ```
 17 | 
 18 | ## :arrow_forward: Checker class
 19 | 
 20 | You can use this class to check one or multiple domains availability.
 21 | 
 22 | ## :mortar_board: Usage/Examples
 23 | 
 24 | ```PHP
 25 | use MonoVM\WhoisPhp\Checker;
 26 | 
 27 | // Single Domain whois
 28 | $result1 = Checker::whois('monovm.com');
 29 | 
 30 | // Single Domain whois without specifying TLD
 31 | $result2 = Checker::whois('monovm');
 32 | 
 33 | // Multiple domains whois
 34 | $result3 = Checker::whois(['monovm','google.com','bing']);
 35 | ```
 36 | 
 37 | - ### Response
 38 | 
 39 | An associative array with domains as keys and status as values.
 40 | Current statuses: available, unavailable, premium
 41 | 
 42 | ```code
 43 | $result1: ['monovm.com'=>'unavailable']
 44 | $result2: ['monovm.com'=>'unavailable','monovm.net'=>'unavailable','monovm.org'=>'unavailable','monovm.info'=>'unavailable']
 45 | $result3: [
 46 |             'monovm.com'=>'premium',
 47 |             'monovm.net'=>'unavailable',
 48 |             'monovm.org'=>'unavailable',
 49 |             'monovm.info'=>'unavailable',
 50 |             'google.com'=>'premium',
 51 |             'bing.com'=>'unavailable',
 52 |             'bing.net'=>'unavailable',
 53 |             'bing.org'=>'available',
 54 |             'bing.info'=>'unavailable'
 55 |            ]
 56 | ```
 57 | 
 58 | ### :fire: popularTLDs Configuration
 59 | 
 60 | When TLD is not specified in the domain string (eg:monovm instead of monovm.com), Checker class will automatically
 61 | lookup a list of popular TLDs for the entered name.
 62 | 
 63 | You can customize this list by passing an options array as second parameter of whois method.
 64 | 
 65 | ```PHP
 66 | use MonoVM\WhoisPhp\Checker;
 67 | 
 68 | $result = Checker::whois('monovm', ['popularTLDs' => ['.com', '.net', '.org', '.info']]);
 69 | ```
 70 | 
 71 | 
 72 | 
 73 | ## :arrow_forward: WhoisHandler class
 74 | 
 75 | ## :mortar_board: Usage/Examples
 76 | 
 77 | ```PHP
 78 | use MonoVM\WhoisPhp\WhoisHandler;
 79 | 
 80 | $whoisHandler = WhoisHandler::whois('monovm.com');
 81 | ```
 82 | 
 83 | #### Available methods:
 84 | 
 85 | **After initiating the handler method you will have access to the following methods:**
 86 | 
 87 | | Method        | Description                                                                                                      |
 88 | |---------------|------------------------------------------------------------------------------------------------------------------|
 89 | | `isAvailable` | Returns true if the domain is available for registration (uses enhanced detection)                               |
 90 | | `isValid`     | Returns true if the domain can be looked up                                                                      |
 91 | | `getWhoisMessage` | Returns the whois server message as a string including availability, validation or the domain whois information  |
 92 | | `getTld`      | Returns the top level domain of the entered domain as a string                                                   |
 93 | | `getSld`      | Returns the second level domain of the entered domain as a string                                                |
 94 | | `getAvailabilityDetails` | Returns detailed information about how availability was determined (debug method)                        |
 95 | 
 96 | :green_circle: `isAvailable()` method uses enhanced detection with multiple methods to accurately determine domain availability. It combines the original library's built-in check with additional detection methods including:
 97 | 
 98 | - **Availability keywords detection**: Searches for phrases like "no match", "not found", "available", etc.
 99 | - **Response length analysis**: Short responses often indicate availability
100 | - **Pattern matching**: Uses regex patterns to identify availability indicators
101 | - **TLD-specific patterns**: Different TLDs use different availability messages
102 | - **Domain status indicators**: Checks for explicit status fields
103 | - **Registration field analysis**: Absence of registration details may indicate availability
104 | 
105 | ```PHP
106 | $available = $whoisHandler->isAvailable();
107 | ```
108 | 
109 | :green_circle: `isValid()` method checks whether the entered domain name is valid and can be looked up or not.
110 | 
111 | ```PHP
112 | $valid = $whoisHandler->isValid();
113 | ```
114 | 
115 | :green_circle: The `getWhoisMessage()` method is used to retrieve the WHOIS information of a domain. This method returns
116 | a string that includes the WHOIS server message, which may contain information about the availability and validation of
117 | the domain, as well as its WHOIS information.
118 | 
119 | ```PHP
120 | $message = $whoisHandler->getWhoisMessage();
121 | ```
122 | 
123 | :green_circle: `getTld()` method is used to extract the top level domain (TLD) of a given domain. For example, if the
124 | domain name passed to the handler is "monovm.com", the method will return "com" as the TLD. Similarly, if the domain
125 | name is "monovm.co.uk", the method will return "co.uk" as the TLD.
126 | 
127 | ```PHP
128 | $tld = $whoisHandler->getTld();
129 | ```
130 | 
131 | :green_circle: `getSld()` method returns the second level domain of the entered domain as a string. The second level
132 | domain is the part of the domain name that comes before the top level domain, and it is typically the main part of the
133 | domain that identifies the website or organization. For example, in the domain name "monovm.com", the second level
134 | domain is "monovm".
135 | 
136 | ```PHP
137 | $sld = $whoisHandler->getSld();
138 | ```
139 | 
140 | :green_circle: `getAvailabilityDetails()` method provides detailed debugging information about how the domain availability was determined. This method returns an array containing the results of each detection method:
141 | 
142 | ```PHP
143 | $details = $whoisHandler->getAvailabilityDetails();
144 | 
145 | // Example output:
146 | // Array
147 | // (
148 | //     [original_library_result] => false
149 | //     [contains_availability_keywords] => true
150 | //     [is_response_too_short] => false
151 | //     [contains_no_match_patterns] => true
152 | //     [tld_specific_patterns] => false
153 | //     [domain_status_indicators] => false
154 | //     [final_availability] => true
155 | //     [whois_message_length] => 1234
156 | //     [whois_message_preview] => "No match for domain example123.com..."
157 | // )
158 | ```
159 | 
160 | ## :sparkles: Enhanced Availability Detection
161 | 
162 | The enhanced availability detection system uses 6 different methods to ensure accurate results:
163 | 
164 | 1. **Original Library Check**: Uses the built-in whois server response analysis
165 | 2. **Keyword Detection**: Searches for over 40 availability-related keywords in multiple languages
166 | 3. **Response Length Analysis**: Analyzes response size and meaningful content lines
167 | 4. **Pattern Matching**: Uses regex patterns to identify availability indicators
168 | 5. **TLD-Specific Patterns**: Applies specialized patterns for different TLDs (.com, .uk, .de, etc.)
169 | 6. **Status Indicators**: Checks for explicit domain status fields and registration data presence
170 | 
171 | This multi-layered approach significantly improves accuracy across different WHOIS servers and TLD registries.
172 | 
173 | ## :globe_with_meridians: Whois Server List
174 | ### Almost all TLDs are supported.
175 | 
176 | ## :globe_with_meridians: Contributing
177 | If you want to add support for new TLD, extend functionality or correct a bug, feel free to create a new pull request at Github's repository
178 | 
179 | ## :balance_scale: License
180 | 
181 | [MIT](https://choosealicense.com/licenses/mit/)
182 | 
183 | ## :computer: Support
184 | 
185 | For support, email dev@monovm.com.
186 | 
187 | [MonoVM.com](https://monovm.com)
188 | 
189 | ![Logo](https://monovm.com/site-assets/images/logo-monovm.svg)
190 | 
191 | 


--------------------------------------------------------------------------------
/tests/IntegrationTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use PHPUnit\Framework\TestCase;
  4 | use MonoVM\WhoisPhp\WhoisHandler;
  5 | use MonoVM\WhoisPhp\Checker;
  6 | use MonoVM\WhoisPhp\AvailabilityDetector;
  7 | 
  8 | class IntegrationTest extends TestCase
  9 | {
 10 |     public function testAvailabilityDetectorStandalone()
 11 |     {
 12 |         // Test the availability detector with known available indicators
 13 |         $availableMessage = "No match for domain test123.com";
 14 |         $this->assertTrue(AvailabilityDetector::isAvailable($availableMessage, '.com'));
 15 |         
 16 |         // Use a more realistic unavailable message with registration details
 17 |         $unavailableMessage = "Domain Name: EXAMPLE.COM\n" .
 18 |                              "Registrar: Example Registrar Inc.\n" .
 19 |                              "Registrar WHOIS Server: whois.example.com\n" .
 20 |                              "Registrar URL: http://www.example.com\n" .
 21 |                              "Updated Date: 2023-01-01T00:00:00Z\n" .
 22 |                              "Creation Date: 2020-01-01T00:00:00Z\n" .
 23 |                              "Registry Expiry Date: 2025-01-01T00:00:00Z\n" .
 24 |                              "Registrant Name: Example Organization\n" .
 25 |                              "Name Server: NS1.EXAMPLE.COM\n" .
 26 |                              "Name Server: NS2.EXAMPLE.COM\n" .
 27 |                              "DNSSEC: unsigned";
 28 |         $this->assertFalse(AvailabilityDetector::isAvailable($unavailableMessage, '.com'));
 29 |     }
 30 | 
 31 |     public function testWhoisHandlerIntegration()
 32 |     {
 33 |         // Test with a likely available domain
 34 |         $timestamp = time();
 35 |         $testDomain = "very-unusual-test-domain-{$timestamp}.com";
 36 |         
 37 |         $whoisHandler = WhoisHandler::whois($testDomain);
 38 |         $details = $whoisHandler->getAvailabilityDetails();
 39 |         
 40 |         // Should have all the expected keys
 41 |         $expectedKeys = [
 42 |             'original_library_result',
 43 |             'contains_availability_keywords',
 44 |             'is_response_too_short',
 45 |             'contains_no_match_patterns',
 46 |             'tld_specific_patterns',
 47 |             'domain_status_indicators',
 48 |             'final_availability',
 49 |             'whois_message_length',
 50 |             'whois_message_preview'
 51 |         ];
 52 |         
 53 |         foreach ($expectedKeys as $key) {
 54 |             $this->assertArrayHasKey($key, $details);
 55 |         }
 56 |         
 57 |         // For a very unusual domain, enhanced detection should work
 58 |         $this->assertTrue($details['final_availability']);
 59 |     }
 60 | 
 61 |     public function testCheckerIntegration()
 62 |     {
 63 |         // Test with multiple domains using Checker class
 64 |         $timestamp = time();
 65 |         $testDomains = [
 66 |             "unusual-test-domain-{$timestamp}.com",
 67 |             "another-test-domain-{$timestamp}.net"
 68 |         ];
 69 |         
 70 |         $results = Checker::whois($testDomains);
 71 |         
 72 |         // Should return results for both domains
 73 |         $this->assertCount(2, $results);
 74 |         
 75 |         foreach ($testDomains as $domain) {
 76 |             $this->assertArrayHasKey($domain, $results);
 77 |             // Should be either 'available' or 'unavailable' (enhanced detection should work)
 78 |             $this->assertContains($results[$domain], ['available', 'unavailable', 'premium']);
 79 |         }
 80 |     }
 81 | 
 82 |     public function testCheckerWithoutTLD()
 83 |     {
 84 |         // Test Checker with domain without TLD (should check popular TLDs)
 85 |         $timestamp = time();
 86 |         $domainBase = "unusual-test-{$timestamp}";
 87 |         
 88 |         $results = Checker::whois($domainBase);
 89 |         
 90 |         // Should return multiple results for popular TLDs
 91 |         $this->assertGreaterThan(1, count($results));
 92 |         
 93 |         // Should include .com, .net, .org, .info
 94 |         $expectedDomains = [
 95 |             $domainBase . '.com',
 96 |             $domainBase . '.net',
 97 |             $domainBase . '.org',
 98 |             $domainBase . '.info'
 99 |         ];
100 |         
101 |         foreach ($expectedDomains as $expectedDomain) {
102 |             $this->assertArrayHasKey($expectedDomain, $results);
103 |         }
104 |     }
105 | 
106 |     public function testRegisteredDomainDetection()
107 |     {
108 |         // Test with a known registered domain
109 |         $whoisHandler = WhoisHandler::whois('example.com');
110 |         $this->assertFalse($whoisHandler->isAvailable());
111 |         
112 |         $checker = Checker::whois(['example.com']);
113 |         $this->assertEquals('unavailable', $checker['example.com']);
114 |     }
115 | 
116 |     public function testEnhancedDetectionAccuracy()
117 |     {
118 |         // Test that enhanced detection is more accurate than original
119 |         $timestamp = time();
120 |         $testDomain = "this-should-be-available-{$timestamp}.com";
121 |         
122 |         $whoisHandler = WhoisHandler::whois($testDomain);
123 |         $details = $whoisHandler->getAvailabilityDetails();
124 |         
125 |         // At least one enhanced detection method should trigger for available domain
126 |         $enhancedMethods = [
127 |             $details['contains_availability_keywords'],
128 |             $details['is_response_too_short'],
129 |             $details['contains_no_match_patterns'],
130 |             $details['tld_specific_patterns'],
131 |             $details['domain_status_indicators']
132 |         ];
133 |         
134 |         $this->assertTrue(
135 |             in_array(true, $enhancedMethods),
136 |             'Enhanced detection should identify available domain using at least one method'
137 |         );
138 |     }
139 | 
140 |     public function testBackwardCompatibility()
141 |     {
142 |         // Test that the integration doesn't break existing functionality
143 |         
144 |         // WhoisHandler basic methods should still work
145 |         $whoisHandler = WhoisHandler::whois('example.com');
146 |         $this->assertIsString($whoisHandler->getTld());
147 |         $this->assertIsString($whoisHandler->getSld());
148 |         $this->assertIsBool($whoisHandler->isValid());
149 |         $this->assertIsBool($whoisHandler->isAvailable());
150 |         $this->assertIsString($whoisHandler->getWhoisMessage());
151 |         
152 |         // Checker should still work
153 |         $results = Checker::whois('example.com');
154 |         $this->assertIsArray($results);
155 |         $this->assertArrayHasKey('example.com', $results);
156 |         
157 |         // Should return known status values
158 |         $this->assertContains($results['example.com'], ['available', 'unavailable', 'premium', 'invalid']);                                                     
159 |     }
160 | 
161 |     public function testUnsupportedTldDetection()
162 |     {
163 |         // Test various unsupported TLD messages
164 |         $unsupportedMessages = [
165 |             'TLD is not supported',
166 |             'The domain extension .test is not supported by this WHOIS server',
167 |             'Whois server not known for .example',
168 |             'No WHOIS server available for this TLD',
169 |             'Unsupported domain extension: .internal',
170 |             'Extension not supported',
171 |             'WHOIS SERVER NOT KNOWN',
172 |         ];
173 | 
174 |         foreach ($unsupportedMessages as $message) {
175 |             // Should throw exception when detecting unsupported TLD
176 |             try {
177 |                 AvailabilityDetector::isAvailable($message, '.test', false);
178 |                 $this->fail('Expected exception for unsupported TLD message: ' . $message);
179 |             } catch (\Exception $e) {
180 |                 $this->assertEquals('TLD is not supported by the WHOIS server', $e->getMessage());
181 |             }
182 |         }
183 | 
184 |         // Test that normal messages don't trigger unsupported TLD detection
185 |         $normalMessages = [
186 |             'This is a very short response',
187 |             'google.com is available for registration.',
188 |             'Domain not found',
189 |             'No match for domain',
190 |         ];
191 | 
192 |         foreach ($normalMessages as $message) {
193 |             // Should not throw exception for normal messages
194 |             try {
195 |                 $result = AvailabilityDetector::isAvailable($message, '.com', false);
196 |                 $this->assertTrue(true, 'Normal message should not throw exception');
197 |             } catch (\Exception $e) {
198 |                 $this->fail('Normal message should not throw unsupported TLD exception: ' . $e->getMessage());
199 |             }
200 |         }
201 | 
202 |         // Test getAvailabilityDetails with unsupported TLD
203 |         $details = AvailabilityDetector::getAvailabilityDetails('TLD is not supported', '.test', false);
204 |         $this->assertTrue($details['contains_unsupported_tld_messages'], 'Should detect unsupported TLD messages');
205 |         $this->assertEquals('unsupported_tld', $details['final_availability'], 'Final availability should be unsupported_tld');
206 |     }
207 | 
208 |     public function testRedemptionPeriodDetection()
209 |     {
210 |         // Test redemption period detection for .de domain
211 |         $redemptionResponse = " ---Domain: elitefollow.de<br />\nStatus: redemptionPeriod<br />";
212 |         
213 |         $isAvailable = AvailabilityDetector::isAvailable($redemptionResponse, '.de', false);
214 |         $this->assertFalse($isAvailable, 'Domain in redemption period should be detected as unavailable');
215 |         
216 |         $details = AvailabilityDetector::getAvailabilityDetails($redemptionResponse, '.de', false);
217 |         $this->assertTrue($details['contains_unavailability_indicators'], 'Should detect redemptionPeriod as unavailability indicator');
218 |         $this->assertFalse($details['final_availability'], 'Final result should be unavailable for redemption period domain');
219 |         
220 |         // Test other domain status that should be unavailable
221 |         $statusesToTest = [
222 |             'Status: redemptionPeriod',
223 |             'Status: redemption period',
224 |             'Status: redemption',
225 |             'Status: pendingDelete',
226 |             'Status: pending delete',
227 |             'Status: serverHold',
228 |             'Status: server hold',
229 |         ];
230 |         
231 |         foreach ($statusesToTest as $status) {
232 |             $response = " ---Domain: test.de<br />\n$status<br />";
233 |             $isAvailable = AvailabilityDetector::isAvailable($response, '.de', false);
234 |             $this->assertFalse($isAvailable, "Domain with '$status' should be detected as unavailable");
235 |         }
236 |         
237 |         // Test that normal registered status also works
238 |         $registeredResponse = " ---Domain: test.de<br />\nStatus: connect<br />";
239 |         $isAvailable = AvailabilityDetector::isAvailable($registeredResponse, '.de', false);
240 |         $this->assertFalse($isAvailable, 'Domain with Status: connect should be detected as unavailable');
241 |     }
242 | 
243 |     public function testServerBusyAndRateLimitDetection()
244 |     {
245 |         // Test server busy and rate limit messages
246 |         $serverErrorMessages = [
247 |             'Server is busy now, please try again later.',
248 |             'Server busy, try again later',
249 |             'Please try again later',
250 |             'Service temporarily unavailable',
251 |             'Rate limit exceeded',
252 |             'Too many requests',
253 |             'Quota exceeded',
254 |             'Connection timed out',
255 |             'Request timeout',
256 |         ];
257 |         
258 |         foreach ($serverErrorMessages as $message) {
259 |             try {
260 |                 AvailabilityDetector::isAvailable($message, '.shop', false);
261 |                 $this->fail("Expected exception for server error message: $message");
262 |             } catch (\Exception $e) {
263 |                 // Should throw an exception
264 |                 $this->assertStringContainsString('unavailable', strtolower($e->getMessage()), 
265 |                     "Exception message should indicate unavailability for: $message");
266 |             }
267 |         }
268 |         
269 |         // Test that proper WHOIS responses still work
270 |         $validRegisteredResponse = "Domain Name: GOLDOZI.SHOP\nRegistrar: PDR Ltd.\nCreation Date: 2019-05-26\nName Server: AV1.7HOSTIR.COM";
271 |         $isAvailable = AvailabilityDetector::isAvailable($validRegisteredResponse, '.shop', false);
272 |         $this->assertFalse($isAvailable, 'Valid registered domain response should be detected as unavailable');
273 |         
274 |         $validAvailableResponse = "DOMAIN NOT FOUND";
275 |         $isAvailable = AvailabilityDetector::isAvailable($validAvailableResponse, '.shop', false);
276 |         $this->assertTrue($isAvailable, 'Valid available domain response should be detected as available');
277 |     }
278 | }
279 | 


--------------------------------------------------------------------------------
/src/AvailabilityDetector.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace MonoVM\WhoisPhp;
  4 | 
  5 | class AvailabilityDetector
  6 | {
  7 |     /**
  8 |      * Enhanced domain availability detection using multiple methods
  9 |      */
 10 |     public static function isAvailable(string $whoisMessage, string $tld = '', bool $originalResult = false): bool
 11 |     {
 12 |         // Method 1: Use the original library's built-in check
 13 |         if ($originalResult) {
 14 |             return true;
 15 |         }
 16 | 
 17 |         // PRIORITY 1: Check for unsupported TLD or server error messages (highest priority)
 18 |         if (self::containsUnsupportedTldMessages($whoisMessage)) {
 19 |             // Determine the specific error type
 20 |             $lowerMessage = strtolower($whoisMessage);
 21 |             if (strpos($lowerMessage, 'server is busy') !== false || 
 22 |                 strpos($lowerMessage, 'server busy') !== false ||
 23 |                 strpos($lowerMessage, 'try again later') !== false ||
 24 |                 strpos($lowerMessage, 'temporarily unavailable') !== false ||
 25 |                 strpos($lowerMessage, 'rate limit') !== false ||
 26 |                 strpos($lowerMessage, 'too many requests') !== false ||
 27 |                 strpos($lowerMessage, 'quota exceeded') !== false ||
 28 |                 strpos($lowerMessage, 'timeout') !== false ||
 29 |                 strpos($lowerMessage, 'timed out') !== false ||
 30 |                 strpos($lowerMessage, 'connection') !== false) {
 31 |                 throw new \Exception('WHOIS server is temporarily unavailable or rate-limited. Please try again later.');
 32 |             }
 33 |             throw new \Exception('TLD is not supported by the WHOIS server');
 34 |         }
 35 | 
 36 |         // PRIORITY 2: Check for explicit UNAVAILABILITY indicators
 37 |         if (self::containsUnavailabilityIndicators($whoisMessage, $tld)) {
 38 |             return false;
 39 |         }
 40 | 
 41 |         // PRIORITY 3: If domain contains clear registration indicators, it's NOT available
 42 |         if (self::containsRegistrationIndicators($whoisMessage, $tld)) {
 43 |             return false;
 44 |         }
 45 | 
 46 |         // PRIORITY 4: Check for availability keywords in the response
 47 |         if (self::containsAvailabilityKeywords($whoisMessage)) {
 48 |             return true;
 49 |         }
 50 | 
 51 |         // PRIORITY 5: Check for "No match" or similar patterns
 52 |         if (self::containsNoMatchPatterns($whoisMessage)) {
 53 |             return true;
 54 |         }
 55 | 
 56 |         // PRIORITY 6: Check for TLD-specific availability patterns
 57 |         if (!empty($tld) && self::checkTldSpecificPatterns($whoisMessage, $tld)) {
 58 |             return true;
 59 |         }
 60 | 
 61 |         // // PRIORITY 7: Check if the response is too short/empty (likely available)
 62 |         // if (self::isResponseTooShort($whoisMessage)) {
 63 |         //     return true;
 64 |         // }
 65 | 
 66 |         // PRIORITY 8: Check for domain status indicators
 67 |         if (self::checkDomainStatusIndicators($whoisMessage)) {
 68 |             return true;
 69 |         }
 70 | 
 71 |         return false;
 72 |     }
 73 | 
 74 |     /**
 75 |      * Get detailed availability information for debugging
 76 |      */
 77 |     public static function getAvailabilityDetails(string $whoisMessage, string $tld = '', bool $originalResult = false): array
 78 |     {
 79 |         // Check for unsupported TLD first
 80 |         $containsUnsupportedTld = self::containsUnsupportedTldMessages($whoisMessage);
 81 |         
 82 |         return [
 83 |             'original_library_result' => $originalResult,
 84 |             'contains_unsupported_tld_messages' => $containsUnsupportedTld,
 85 |             'contains_unavailability_indicators' => self::containsUnavailabilityIndicators($whoisMessage, $tld),
 86 |             'contains_registration_indicators' => self::containsRegistrationIndicators($whoisMessage, $tld),
 87 |             'contains_availability_keywords' => self::containsAvailabilityKeywords($whoisMessage),
 88 |             'is_response_too_short' => self::isResponseTooShort($whoisMessage),
 89 |             'contains_no_match_patterns' => self::containsNoMatchPatterns($whoisMessage),
 90 |             'tld_specific_patterns' => !empty($tld) ? self::checkTldSpecificPatterns($whoisMessage, $tld) : false,
 91 |             'domain_status_indicators' => self::checkDomainStatusIndicators($whoisMessage),
 92 |             'final_availability' => $containsUnsupportedTld ? 'unsupported_tld' : self::isAvailable($whoisMessage, $tld, $originalResult),
 93 |             'whois_message_length' => strlen($whoisMessage),
 94 |             'whois_message_preview' => substr($whoisMessage, 0, 200) . (strlen($whoisMessage) > 200 ? '...' : ''),
 95 |         ];
 96 |     }
 97 | 
 98 |     /**
 99 |      * Check for keywords that indicate domain availability
100 |      */
101 |     private static function containsAvailabilityKeywords(string $whoisMessage): bool
102 |     {
103 |         $availabilityKeywords = [
104 |             'no match',
105 |             'not found',
106 |             'no data found',
107 |             'no entries found',
108 |             'available for registration',
109 |             'domain status: available',
110 |             'no matching record',
111 |             'not registered',
112 |             'free',
113 |             'no object found',
114 |             'no such domain',
115 |             'object does not exist',
116 |             'nothing found',
117 |             'no domain',
118 |             'domain not found',
119 |             'status: available',
120 |             'registration status: available',
121 |             'status:\tavailable',
122 |             'status:\t\tavailable',
123 |             'status: free',
124 |             'is free',
125 |             'domain name not known',
126 |             'domain has not been registered',
127 |             'domain name has not been registered',
128 |             'is available for purchase',
129 |             'no se encontro el objeto',
130 |             'object_not_found',
131 |             'el dominio no se encuentra registrado',
132 |             'domain is available',
133 |             'domain does not exist',
134 |             'does not exist in database',
135 |             'was not found',
136 |             'not exist',
137 |             'no está registrado',
138 |             'is available for registration',
139 |             'not registered',
140 |             'no entries found',
141 |             'not found...',
142 |         ];
143 | 
144 |         // Filter out comment lines and informational text
145 |         $lines = explode("\n", $whoisMessage);
146 |         $relevantLines = [];
147 |         
148 |         foreach ($lines as $line) {
149 |             $line = trim($line);
150 |             // Skip comment lines, empty lines, and informational lines
151 |             if (empty($line) || 
152 |                 str_starts_with($line, '%') || 
153 |                 str_starts_with($line, '#') || 
154 |                 str_starts_with($line, ';') ||
155 |                 str_starts_with($line, '>>>') ||
156 |                 str_starts_with($line, '---') ||
157 |                 stripos($line, 'available on web at') !== false ||
158 |                 stripos($line, 'find the terms and conditions') !== false) {
159 |                 continue;
160 |             }
161 |             $relevantLines[] = $line;
162 |         }
163 |         
164 |         $filteredMessage = strtolower(implode(' ', $relevantLines));
165 | 
166 |         foreach ($availabilityKeywords as $keyword) {
167 |             if (strpos($filteredMessage, strtolower($keyword)) !== false) {
168 |                 return true;
169 |             }
170 |         }
171 | 
172 |         return false;
173 |     }
174 | 
175 |     /**
176 |      * Check for unsupported TLD or server error messages (highest priority)
177 |      * This includes rate limiting, server busy, timeouts, etc.
178 |      */
179 |     private static function containsUnsupportedTldMessages(string $whoisMessage): bool
180 |     {
181 |         $lowerMessage = strtolower($whoisMessage);
182 |         
183 |         // Common patterns for unsupported TLD messages and server errors
184 |         $unsupportedPatterns = [
185 |             'tld is not supported',
186 |             'tld not supported',
187 |             'extension not supported',
188 |             'domain extension not supported',
189 |             'unsupported tld',
190 |             'unsupported domain extension',
191 |             'this tld is not supported',
192 |             'the tld is not supported',
193 |             'whois server not known',
194 |             'no whois server',
195 |             'whois service not available',
196 |             'not supported by this whois server',
197 |             'extension is not supported',
198 |             'domain type not supported',
199 |             'tld not available',
200 |             'extension not available',
201 |             'no server found for',
202 |             'server not found for',
203 |             'whois not available for',
204 |             'no whois available for',
205 |             'server is busy',
206 |             'server busy',
207 |             'please try again later',
208 |             'try again later',
209 |             'service temporarily unavailable',
210 |             'temporarily unavailable',
211 |             'rate limit exceeded',
212 |             'too many requests',
213 |             'quota exceeded',
214 |             'connection timed out',
215 |             'connection timeout',
216 |             'request timeout',
217 |             'timeout',
218 |         ];
219 |         
220 |         foreach ($unsupportedPatterns as $pattern) {
221 |             if (strpos($lowerMessage, $pattern) !== false) {
222 |                 return true;
223 |             }
224 |         }
225 |         
226 |         // Check for regex patterns
227 |         $unsupportedRegexPatterns = [
228 |             '/tld\s+(?:is\s+)?not\s+supported/i',
229 |             '/extension\s+(?:is\s+)?not\s+supported/i',
230 |             '/unsupported\s+(?:tld|extension|domain)/i',
231 |             '/no\s+whois\s+(?:server|service)\s+(?:available|found)/i',
232 |             '/whois\s+(?:server\s+)?not\s+(?:known|available|found)/i',
233 |             '/(?:server|service)\s+not\s+(?:available|found)\s+for/i',
234 |         ];
235 |         
236 |         foreach ($unsupportedRegexPatterns as $pattern) {
237 |             if (preg_match($pattern, $whoisMessage)) {
238 |                 return true;
239 |             }
240 |         }
241 |         
242 |         return false;
243 |     }
244 | 
245 |     /**
246 |      * Check for explicit UNAVAILABILITY indicators (high priority)
247 |      */
248 |     private static function containsUnavailabilityIndicators(string $whoisMessage, string $tld = ''): bool
249 |     {
250 |         $lowerMessage = strtolower($whoisMessage);
251 | 
252 |         // TLD-specific unavailability patterns (highest priority)
253 |         $tldUnavailabilityPatterns = [
254 |             '.com.au' => ['/---not available/i', '/---not found/i', '/not available/i', '/domain not available/i'],
255 |             '.au' => ['/---not available/i', '/---not found/i', '/not available/i', '/domain not available/i'],
256 |             '.uk' => ['/this domain has been registered/i', '/registered/i'],
257 |             '.de' => ['/status:\s*connect/i', '/status:\s*registered/i', '/status:\s*active/i', '/status:\s*redemptionPeriod/i', '/status:\s*redemption/i'],
258 |             '.it' => ['/status:\s*active/i', '/status:\s*registered/i'],
259 |             '.fr' => ['/status:\s*active/i', '/status:\s*registered/i'],
260 |             '.ca' => ['/domain registered/i', '/status:\s*registered/i'],
261 |             '.nl' => ['/status:\s*active/i', '/status:\s*in use/i'],
262 |             '.be' => ['/status:\s*registered/i', '/status:\s*allocated/i'],
263 |             '.eu' => ['/status:\s*registered/i'],
264 |             '.ch' => ['/status:\s*registered/i'],
265 |             '.li' => ['/status:\s*registered/i'],
266 |             '.at' => ['/status:\s*registered/i'],
267 |             '.dk' => ['/status:\s*active/i'],
268 |             '.no' => ['/status:\s*active/i'],
269 |             '.se' => ['/status:\s*active/i'],
270 |             '.fi' => ['/status:\s*registered/i'],
271 |             '.pt' => ['/status:\s*active/i'],
272 |             '.es' => ['/status:\s*registered/i'],
273 |             '.mx' => ['/status:\s*registered/i'],
274 |             '.ar' => ['/status:\s*registered/i'],
275 |             '.br' => ['/status:\s*registered/i'],
276 |             '.cl' => ['/status:\s*registered/i'],
277 |             '.pe' => ['/status:\s*registered/i'],
278 |             '.co' => ['/status:\s*registered/i'],
279 |             '.ve' => ['/status:\s*registered/i'],
280 |             '.ec' => ['/status:\s*registered/i'],
281 |             '.uy' => ['/status:\s*registered/i'],
282 |             '.py' => ['/status:\s*registered/i'],
283 |             '.bo' => ['/status:\s*registered/i'],
284 |             '.hn' => ['/status:\s*registered/i'],
285 |             '.ni' => ['/status:\s*registered/i'],
286 |             '.cr' => ['/status:\s*registered/i'],
287 |             '.gt' => ['/status:\s*registered/i'],
288 |             '.sv' => ['/status:\s*registered/i'],
289 |             '.pa' => ['/status:\s*registered/i'],
290 |             '.do' => ['/status:\s*registered/i'],
291 |             '.pr' => ['/status:\s*registered/i'],
292 |             '.cu' => ['/status:\s*registered/i'],
293 |             '.tt' => ['/status:\s*registered/i'],
294 |             '.gy' => ['/status:\s*registered/i'],
295 |             '.sr' => ['/status:\s*registered/i'],
296 |             '.jm' => ['/status:\s*registered/i'],
297 |             '.bb' => ['/status:\s*registered/i'],
298 |             '.lc' => ['/status:\s*registered/i'],
299 |             '.gd' => ['/status:\s*registered/i'],
300 |             '.vc' => ['/status:\s*registered/i'],
301 |             '.dm' => ['/status:\s*registered/i'],
302 |             '.ag' => ['/status:\s*registered/i'],
303 |             '.kn' => ['/status:\s*registered/i'],
304 |             '.ai' => ['/status:\s*registered/i'],
305 |             '.ms' => ['/status:\s*registered/i'],
306 |             '.tc' => ['/status:\s*registered/i'],
307 |             '.vg' => ['/status:\s*registered/i'],
308 |             '.fk' => ['/status:\s*registered/i'],
309 |             '.gs' => ['/status:\s*registered/i'],
310 |             '.sh' => ['/status:\s*registered/i'],
311 |             '.pn' => ['/status:\s*registered/i'],
312 |             '.ki' => ['/status:\s*registered/i'],
313 |             '.nr' => ['/status:\s*registered/i'],
314 |             '.tv' => ['/status:\s*registered/i'],
315 |             '.ws' => ['/status:\s*registered/i'],
316 |             '.cc' => ['/status:\s*registered/i'],
317 |             '.cx' => ['/status:\s*registered/i'],
318 |             '.hm' => ['/status:\s*registered/i'],
319 |             '.nf' => ['/status:\s*registered/i'],
320 |             '.sj' => ['/status:\s*registered/i'],
321 |             '.bv' => ['/status:\s*registered/i'],
322 |             '.tf' => ['/status:\s*registered/i'],
323 |             '.pm' => ['/status:\s*registered/i'],
324 |             '.wf' => ['/status:\s*registered/i'],
325 |             '.yt' => ['/status:\s*registered/i'],
326 |             '.re' => ['/status:\s*registered/i'],
327 |             '.mq' => ['/status:\s*registered/i'],
328 |             '.gp' => ['/status:\s*registered/i'],
329 |             '.gf' => ['/status:\s*registered/i'],
330 |             '.pf' => ['/status:\s*registered/i'],
331 |             '.nc' => ['/status:\s*registered/i'],
332 |             '.vu' => ['/status:\s*registered/i'],
333 |             '.tk' => ['/status:\s*registered/i'],
334 |             '.to' => ['/status:\s*registered/i'],
335 |             '.ws' => ['/status:\s*registered/i'],
336 |             '.cc' => ['/status:\s*registered/i'],
337 |             '.as' => ['/status:\s*registered/i'],
338 |             '.ki' => ['/status:\s*registered/i'],
339 |             '.fm' => ['/status:\s*registered/i'],
340 |             '.nr' => ['/status:\s*registered/i'],
341 |             '.pw' => ['/status:\s*registered/i'],
342 |             '.cf' => ['/status:\s*registered/i'],
343 |             '.ml' => ['/status:\s*registered/i'],
344 |             '.ga' => ['/status:\s*registered/i'],
345 |             '.gq' => ['/status:\s*registered/i'],
346 |             '.cm' => ['/status:\s*registered/i'],
347 |             '.bi' => ['/status:\s*registered/i'],
348 |             '.ne' => ['/status:\s*registered/i'],
349 |             '.cd' => ['/status:\s*registered/i'],
350 |             '.dj' => ['/status:\s*registered/i'],
351 |             '.km' => ['/status:\s*registered/i'],
352 |             '.mg' => ['/status:\s*registered/i'],
353 |             '.rw' => ['/status:\s*registered/i'],
354 |             '.sc' => ['/status:\s*registered/i'],
355 |             '.so' => ['/status:\s*registered/i'],
356 |             '.st' => ['/status:\s*registered/i'],
357 |             '.tz' => ['/status:\s*registered/i'],
358 |             '.ug' => ['/status:\s*registered/i'],
359 |             '.zm' => ['/status:\s*registered/i'],
360 |             '.zw' => ['/status:\s*registered/i'],
361 |         ];
362 | 
363 |         if (isset($tldUnavailabilityPatterns[$tld])) {
364 |             foreach ($tldUnavailabilityPatterns[$tld] as $pattern) {
365 |                 if (preg_match($pattern, $whoisMessage)) {
366 |                     return true; // Explicitly NOT available
367 |                 }
368 |             }
369 |         }
370 | 
371 |         // General unavailability patterns
372 |         $generalUnavailabilityPatterns = [
373 |             '/---not available/i',
374 |             '/---not\s+found/i',
375 |             '/---domain not found/i',
376 |             '/not available/i',
377 |             '/domain not available/i',
378 |             '/status:\s*not available/i',
379 |             '/registration status:\s*not available/i',
380 |             '/domain status:\s*not available/i',
381 |             '/status:\s*unavailable/i',
382 |             '/status:\s*registered/i',
383 |             '/status:\s*active/i',
384 |             '/status:\s*connect/i',
385 |             '/status:\s*client/i',
386 |             '/status:\s*redemptionPeriod/i',
387 |             '/status:\s*redemption\s*period/i',
388 |             '/status:\s*redemption/i',
389 |             '/status:\s*pendingDelete/i',
390 |             '/status:\s*pending\s*delete/i',
391 |             '/status:\s*serverHold/i',
392 |             '/status:\s*server\s*hold/i',
393 |             '/this domain has been registered/i',
394 |             '/domain registered/i',
395 |             '/already registered/i',
396 |             '/currently registered/i',
397 |             '/is registered/i',
398 |             '/registration:\s*registered/i',
399 |         ];
400 | 
401 |         foreach ($generalUnavailabilityPatterns as $pattern) {
402 |             if (preg_match($pattern, $whoisMessage)) {
403 |                 return true; // Explicitly NOT available
404 |             }
405 |         }
406 | 
407 |         return false;
408 |     }
409 | 
410 |     /**
411 |      * Check for clear registration indicators that mean domain is NOT available
412 |      */
413 |     private static function containsRegistrationIndicators(string $whoisMessage, string $tld = ''): bool
414 |     {
415 |         $lowerMessage = strtolower($whoisMessage);
416 | 
417 |         // Strong indicators that domain is registered
418 |         $registrationIndicators = [
419 |             'domain:',
420 |             'ascii:',
421 |             'nserver:',
422 |             'nameserver:',
423 |             'name server:',
424 |             'registrar:',
425 |             'registrant:',
426 |             'creation date:',
427 |             'created:',
428 |             'changed:',
429 |             'expiry date:',
430 |             'expires:',
431 |             'updated:',
432 |             'last updated:',
433 |             'admin contact:',
434 |             'technical contact:',
435 |             'billing contact:',
436 |             'registry domain id:',
437 |             'registrar whois server:',
438 |             'domain status: client',
439 |             'dnssec:',
440 |         ];
441 | 
442 |         $foundIndicators = 0;
443 |         foreach ($registrationIndicators as $indicator) {
444 |             if (strpos($lowerMessage, $indicator) !== false) {
445 |                 $foundIndicators++;
446 |             }
447 |         }
448 | 
449 |         // For .ir domains, be extra careful - if we see domain: and nserver: it's definitely registered
450 |         if ($tld === '.ir') {
451 |             if (strpos($lowerMessage, 'domain:') !== false && strpos($lowerMessage, 'nserver:') !== false) {
452 |                 return true;
453 |             }
454 |         }
455 | 
456 |         // For .de domains, "Status: connect" means registered
457 |         if ($tld === '.de' && strpos($lowerMessage, 'status: connect') !== false) {
458 |             return true;
459 |         }
460 | 
461 |         // If we find 3 or more registration indicators, it's likely registered
462 |         return $foundIndicators >= 3;
463 |     }
464 | 
465 |     /**
466 |      * Check if WHOIS response is too short to contain real registration data
467 |      */
468 |     private static function isResponseTooShort(string $whoisMessage): bool
469 |     {
470 |         $trimmedMessage = trim($whoisMessage);
471 |         $lowerMessage = strtolower($trimmedMessage);
472 | 
473 |         // Don't treat explicit unavailability messages as "short" (even if they are short)
474 |         if (strpos($lowerMessage, 'not available') !== false ||
475 |             strpos($lowerMessage, 'not found') !== false ||
476 |             strpos($lowerMessage, 'unavailable') !== false ||
477 |             strpos($lowerMessage, 'domain not found') !== false ||
478 |             strpos($lowerMessage, 'no match') !== false ||
479 |             strpos($lowerMessage, 'no entries found') !== false ||
480 |             strpos($lowerMessage, '---not available') !== false ||
481 |             strpos($lowerMessage, '---not found') !== false) {
482 |             return false; // This is an explicit unavailability message, not "short"
483 |         }
484 | 
485 |         // If message is very short (less than 100 characters) and doesn't contain unavailability indicators, likely available
486 |         if (strlen($trimmedMessage) < 100) {
487 |             return true;
488 |         }
489 | 
490 |         // Count meaningful lines (ignore empty lines and comments)
491 |         $lines = explode("\n", $trimmedMessage);
492 |         $meaningfulLines = 0;
493 | 
494 |         foreach ($lines as $line) {
495 |             $line = trim($line);
496 |             if (!empty($line) && 
497 |                 !str_starts_with($line, '%') && 
498 |                 !str_starts_with($line, '#') && 
499 |                 !str_starts_with($line, ';') &&
500 |                 !str_starts_with($line, '>>>') &&
501 |                 !str_starts_with($line, '---')) {
502 |                 $meaningfulLines++;
503 |             }
504 |         }
505 | 
506 |         // If less than 5 meaningful lines, likely available
507 |         return $meaningfulLines < 5;
508 |     }
509 | 
510 |     /**
511 |      * Check for "No match" type patterns that indicate availability
512 |      */
513 |     private static function containsNoMatchPatterns(string $whoisMessage): bool
514 |     {
515 |         $noMatchPatterns = [
516 |             '/no\s+match/i',
517 |             '/not\s+found/i',
518 |             '/no\s+data\s+found/i',
519 |             '/no\s+entries\s+found/i',
520 |             '/no\s+matching\s+record/i',
521 |             '/object\s+does\s+not\s+exist/i',
522 |             '/no\s+such\s+domain/i',
523 |             '/domain\s+not\s+found/i',
524 |             '/status:\s*available/i',
525 |             '/registration\s+status:\s*available/i',
526 |             '/status:\s*free/i',
527 |             '/\bis\s+free\b/i',
528 |             '/domain\s+name\s+not\s+known/i',
529 |             '/domain\s+has\s+not\s+been\s+registered/i',
530 |             '/domain\s+name\s+has\s+not\s+been\s+registered/i',
531 |             '/\bis\s+available\s+for/i',
532 |             '/no\s+se\s+encontro\s+el\s+objeto/i',
533 |             '/object_not_found/i',
534 |             '/el\s+dominio\s+no\s+se\s+encuentra\s+registrado/i',
535 |             '/domain\s+is\s+available/i',
536 |             '/domain\s+does\s+not\s+exist/i',
537 |             '/does\s+not\s+exist\s+in\s+database/i',
538 |             '/was\s+not\s+found/i',
539 |             '/not\s+exist/i',
540 |             '/no\s+está\s+registrado/i',
541 |             '/---available/i',
542 |             '/---not\s+found/i',
543 |             '/---domain\s+not\s+found/i',
544 |             '/%error:103/i',
545 |             '/404/i', // For RDAP servers
546 |         ];
547 | 
548 |         foreach ($noMatchPatterns as $pattern) {
549 |             if (preg_match($pattern, $whoisMessage)) {
550 |                 return true;
551 |             }
552 |         }
553 | 
554 |         return false;
555 |     }
556 | 
557 |     /**
558 |      * Check for TLD-specific availability patterns
559 |      */
560 |     private static function checkTldSpecificPatterns(string $whoisMessage, string $tld): bool
561 |     {
562 |         $tldPatterns = [
563 |             // Major TLDs
564 |             '.com' => ['/no\s+match\s+for/i', '/domain\s+not\s+found/i'],
565 |             '.net' => ['/no\s+match\s+for/i', '/domain\s+not\s+found/i'],
566 |             '.org' => ['/domain\s+not\s+found/i', '/not\s+found/i'],
567 |             '.uk' => ['/no\s+match/i', '/this\s+domain\s+is\s+available/i'],
568 |             '.de' => ['/is\s+available\s+for\s+registration/i', '/status:\s*free/i'],
569 |             '.fr' => ['/not\s+found/i', '/available/i'],
570 |             '.it' => ['/available/i', '/status:\s*available/i'],
571 |             '.au' => ['/---available/i', '/is\s+available\s+for\s+registration/i'],
572 |             '.com.au' => ['/is\s+available\s+for\s+registration/i', '/available/i'],
573 |             '.org.au' => ['/is\s+available\s+for\s+registration/i', '/available/i'],
574 |             '.net.au' => ['/is\s+available\s+for\s+registration/i', '/available/i'],
575 |             '.be' => ['/status:\s*available/i', '/free/i'],
576 |             '.ca' => ['/not\s+found/i', '/available/i'],
577 |             '.ch' => ['/---1:/i', '/available/i'],
578 |             '.li' => ['/available/i', '/is\s+available/i'],
579 |             '.eu' => ['/status:\s*available/i', '/available/i'],
580 |             '.nl' => ['/\bis\s+free/i', '/available/i'],
581 |             '.dk' => ['/available/i', '/is\s+available/i'],
582 |             '.no' => ['/available/i', '/is\s+available/i'],
583 |             '.se' => ['/available/i', '/is\s+available/i'],
584 |             '.fi' => ['/available/i', '/is\s+available/i'],
585 |             '.pt' => ['/available/i', '/is\s+available/i'],
586 |             '.es' => ['/available/i', '/is\s+available/i'],
587 | 
588 |             // Asian TLDs
589 |             '.jp' => ['/no\s+match!!/i', '/no\s+match/i'],
590 |             '.cn' => ['/no\s+matching\s+record/i', '/not\s+found/i'],
591 |             '.in' => ['/not\s+found/i', '/no\s+data\s+found/i'],
592 |             '.hk' => ['/the\s+domain\s+has\s+not\s+been\s+registered/i'],
593 |             '.tw' => ['/no\s+found/i', '/not\s+found/i'],
594 |             '.sg' => ['/---not\s+found/i', '/domain\s+not\s+found/i'],
595 |             '.my' => ['/does\s+not\s+exist\s+in\s+database/i'],
596 |             '.ph' => ['/domain\s+is\s+available/i'],
597 |             '.th' => ['/no\s+match\s+found/i'],
598 |             '.vn' => ['/available/i', '/not\s+found/i'],
599 |             '.id' => ['/domain\s+not\s+found/i', '/available/i'],
600 | 
601 |             // American TLDs
602 |             '.us' => ['/not\s+found/i', '/domain\s+not\s+found/i'],
603 |             '.mx' => ['/no_se_encontro_el_objeto/i', '/not\s+found/i'],
604 |             '.br' => ['/no\s+match\s+for/i', '/domain\s+not\s+found/i'],
605 |             '.ar' => ['/el\s+dominio\s+no\s+se\s+encuentra\s+registrado/i'],
606 |             '.co' => ['/not\s+found/i', '/available/i'],
607 |             '.cl' => ['/no\s+entries\s+found/i', '/available/i'],
608 |             '.pe' => ['/not\s+found/i', '/available/i'],
609 |             '.ve' => ['/no\s+entries\s+found/i', '/available/i'],
610 |             '.ec' => ['/404/i', '/available/i'],
611 | 
612 |             // European TLDs
613 |             '.ru' => ['/no\s+entries\s+found/i', '/not\s+found/i'],
614 |             '.pl' => ['/no\s+information\s+available/i', '/available/i'],
615 |             '.cz' => ['/no\s+entries\s+found/i', '/available/i'],
616 |             '.sk' => ['/domain\s+not\s+found/i', '/available/i'],
617 |             '.hu' => ['/no\s+match/i', '/available/i'],
618 |             '.ro' => ['/no\s+entries\s+found/i', '/available/i'],
619 |             '.rs' => ['/not\s+found/i', '/available/i'],
620 |             '.me' => ['/not\s+found/i', '/available/i'],
621 |             '.ba' => ['/not\s+found/i', '/available/i'],
622 |             '.mk' => ['/no\s+entries\s+found/i', '/available/i'],
623 |             '.al' => ['/no\s+entries\s+found/i', '/available/i'],
624 |             '.md' => ['/no\s+object\s+found/i', '/available/i'],
625 |             '.ua' => ['/no\s+entries\s+found/i', '/available/i'],
626 | 
627 |             // African TLDs
628 |             '.za' => ['/available/i', '/not\s+found/i'],
629 |             '.co.za' => ['/available/i', '/not\s+found/i'],
630 |             '.ng' => ['/not\s+found/i', '/available/i'],
631 |             '.ke' => ['/no\s+object\s+found/i', '/available/i'],
632 |             '.ma' => ['/no\s+object\s+found/i', '/available/i'],
633 |             '.tn' => ['/not\s+found/i', '/available/i'],
634 |             '.eg' => ['/not\s+found/i', '/available/i'],
635 |             '.ci' => ['/not\s+found/i', '/available/i'],
636 |             '.sn' => ['/not\s+found/i', '/available/i'],
637 | 
638 |             // Oceanian TLDs
639 |             '.nz' => ['/not\s+found/i', '/available/i'],
640 |             '.ws' => ['/the\s+queried\s+object\s+does\s+not\s+exist/i'],
641 |             '.cc' => ['/no\s+match/i', '/available/i'],
642 |             '.to' => ['/no\s+match\s+for/i', '/available/i'],
643 | 
644 |             // Other TLDs
645 |             '.im' => ['/was\s+not\s+found/i', '/available/i'],
646 |             '.io' => ['/---domain\s+not\s+found/i', '/available/i'],
647 |             '.sh' => ['/domain\s+not\s+found/i', '/available/i'],
648 |             '.ac' => ['/domain\s+not\s+found/i', '/available/i'],
649 |             '.gg' => ['/not\s+found/i', '/available/i'],
650 |             '.je' => ['/not\s+found/i', '/available/i'],
651 |             '.as' => ['/not\s+found/i', '/available/i'],
652 |             '.ms' => ['/no\s+object\s+found/i', '/available/i'],
653 |             '.tc' => ['/no\s+object\s+found/i', '/available/i'],
654 |             '.vg' => ['/domain\s+not\s+found/i', '/available/i'],
655 |             '.gs' => ['/no\s+object\s+found/i', '/available/i'],
656 |             '.fm' => ['/domain\s+not\s+found/i', '/available/i'],
657 |             '.nr' => ['/no\s+object\s+found/i', '/available/i'],
658 |             '.pw' => ['/domain\s+not\s+found/i', '/available/i'],
659 |             '.tk' => ['/domain\s+name\s+not\s+known/i', '/available/i'],
660 |             '.ml' => ['/domain\s+not\s+found/i', '/available/i'],
661 |             '.ga' => ['/domain\s+not\s+found/i', '/available/i'],
662 |             '.cf' => ['/domain\s+not\s+found/i', '/available/i'],
663 |             '.gq' => ['/domain\s+not\s+found/i', '/available/i'],
664 |             '.cm' => ['/not\s+registered/i', '/available/i'],
665 |             '.bi' => ['/domain\s+not\s+found/i', '/available/i'],
666 |             '.ne' => ['/no\s+object\s+found/i', '/available/i'],
667 |             '.cd' => ['/no\s+object\s+found/i', '/available/i'],
668 |             '.dj' => ['/not\s+found/i', '/available/i'],
669 |             '.km' => ['/not\s+found/i', '/available/i'],
670 |             '.mg' => ['/no\s+object\s+found/i', '/available/i'],
671 |             '.rw' => ['/not\s+found/i', '/available/i'],
672 |             '.sc' => ['/not\s+found/i', '/available/i'],
673 |             '.so' => ['/not\s+found/i', '/available/i'],
674 |             '.st' => ['/not\s+found/i', '/available/i'],
675 |             '.tz' => ['/no\s+entries\s+found/i', '/available/i'],
676 |             '.ug' => ['/no\s+entries\s+found/i', '/available/i'],
677 |             '.zm' => ['/not\s+found/i', '/available/i'],
678 |             '.zw' => ['/no\s+information\s+available/i', '/available/i'],
679 | 
680 |             // Special cases
681 |             '.ir' => ['/no\s+entries\s+found/i'],
682 |             '.gr' => ['/not\s+exist/i'],
683 |         ];
684 | 
685 |         if (isset($tldPatterns[$tld])) {
686 |             foreach ($tldPatterns[$tld] as $pattern) {
687 |                 if (preg_match($pattern, $whoisMessage)) {
688 |                     return true;
689 |                 }
690 |             }
691 |         }
692 | 
693 |         return false;
694 |     }
695 | 
696 |     /**
697 |      * Check for domain status indicators that suggest availability
698 |      */
699 |     private static function checkDomainStatusIndicators(string $whoisMessage): bool
700 |     {
701 |         $lowerMessage = strtolower($whoisMessage);
702 |         
703 |         // Check for explicit availability status indicators
704 |         $statusIndicators = [
705 |             'status: available',
706 |             'status:\tavailable',
707 |             'status: free',
708 |             'registration status: available',
709 |             'domain status: available',
710 |             'availability: available',
711 |             'state: available',
712 |             'status = available',
713 |             'status=available',
714 |         ];
715 | 
716 |         foreach ($statusIndicators as $indicator) {
717 |             if (strpos($lowerMessage, $indicator) !== false) {
718 |                 return true;
719 |             }
720 |         }
721 | 
722 |         // Check for absence of typical registration fields
723 |         $registrationFields = [
724 |             'registrar:',
725 |             'creation date:',
726 |             'created:',
727 |             'expiry date:',
728 |             'expires:',
729 |             'name server:',
730 |             'nameserver:',
731 |             'nserver:',
732 |             'registrant:',
733 |             'admin contact:',
734 |             'technical contact:',
735 |         ];
736 | 
737 |         $foundFields = 0;
738 |         foreach ($registrationFields as $field) {
739 |             if (strpos($lowerMessage, $field) !== false) {
740 |                 $foundFields++;
741 |             }
742 |         }
743 | 
744 |         // If we find very few registration fields, domain might be available
745 |         return $foundFields < 2;
746 |     }
747 | }
748 | 


--------------------------------------------------------------------------------
/src/dist.whois.json:
--------------------------------------------------------------------------------
   1 | [
   2 |     {
   3 |         "extensions": ".com,.net,.es,.com.es,.nom.es,.gob.es,.edu.es",
   4 |         "uri": "socket:\/\/whois.crsnic.net",
   5 |         "available": "No match for"
   6 |     },
   7 |     {
   8 |         "extensions": ".org,.ngo,.ong",
   9 |         "uri": "socket:\/\/whois.publicinterestregistry.net",
  10 |         "available": "Domain not found"
  11 |     },
  12 |     {
  13 |         "extensions": ".uk,.co.uk,.net.uk,.org.uk,.ltd.uk,.plc.uk,.me.uk",
  14 |         "uri": "socket:\/\/whois.nic.uk",
  15 |         "available": "No match"
  16 |     },
  17 |     {
  18 |         "extensions": ".edu,.mil",
  19 |         "uri": "socket:\/\/whois.internic.net",
  20 |         "available": "No match for"
  21 |     },
  22 |     {
  23 |         "extensions": ".br.com,.cn.com,.eu.com,.no.com,.qc.com,.sa.com,.se.com,.se.net,.us.com,.uy.com,.za.com,.uk.com,.uk.net,.gb.com,.gb.net,.online,.site",
  24 |         "uri": "socket:\/\/whois.centralnic.com",
  25 |         "available": "DOMAIN NOT FOUND"
  26 |     },
  27 |     {
  28 |         "extensions": ".ink",
  29 |         "uri": "socket:\/\/whois.nic.ink",
  30 |         "available": "No Data Found"
  31 |     },
  32 |     {
  33 |         "extensions": ".com.de",
  34 |         "uri": "socket:\/\/whois.centralnic.com",
  35 |         "available": "Status: free"
  36 |     },
  37 |     {
  38 |         "extensions": ".ac,.co.ac",
  39 |         "uri": "socket:\/\/whois.nic.ac",
  40 |         "available": "Domain not found"
  41 |     },
  42 |     {
  43 |         "extensions": ".af",
  44 |         "uri": "socket:\/\/whois.nic.af",
  45 |         "available": "No Object Found"
  46 |     },
  47 |     {
  48 |         "extensions": ".am",
  49 |         "uri": "socket:\/\/whois.amnic.net",
  50 |         "available": "No match"
  51 |     },
  52 |     {
  53 |         "extensions": ".as",
  54 |         "uri": "socket:\/\/whois.nic.as",
  55 |         "available": "NOT FOUND"
  56 |     },
  57 |     {
  58 |         "extensions": ".at,.ac.at,.co.at,.gv.at,.or.at",
  59 |         "uri": "socket:\/\/whois.nic.at",
  60 |         "available": "nothing found"
  61 |     },
  62 |     {
  63 |         "extensions": ".au,.asn.au,.com.au,.edu.au,.org.au,.net.au,.id.au",
  64 |         "uri": "socket:\/\/domaincheck.auda.org.au",
  65 |         "available": "---Available"
  66 |     },
  67 |     {
  68 |         "extensions": ".be,.ac.be",
  69 |         "uri": "socket:\/\/whois.dns.be",
  70 |         "available": "Status:\tAVAILABLE"
  71 |     },
  72 |     {
  73 |         "extensions": ".br,.adm.br,.adv.br,.am.br,.arq.br,.art.br,.bio.br,.cng.br,.cnt.br,.com.br,.ecn.br,.eng.br,.esp.br,.etc.br,.eti.br,.fm.br,.fot.br,.fst.br,.g12.br,.gov.br,.ind.br,.inf.br,.jor.br,.lel.br,.med.br,.mil.br,.net.br,.nom.br,.ntr.br,.odo.br,.org.br,.ppg.br,.pro.br,.psc.br,.psi.br,.rec.br,.slg.br,.tmp.br,.tur.br,.tv.br,.vet.br,.zlg.br",
  74 |         "uri": "socket:\/\/whois.nic.br",
  75 |         "available": "No match for"
  76 |     },
  77 |     {
  78 |         "extensions": ".ca",
  79 |         "uri": "socket:\/\/whois.cira.ca",
  80 |         "available": "Not found"
  81 |     },
  82 |     {
  83 |         "extensions": ".cc",
  84 |         "uri": "socket:\/\/whois.nic.cc",
  85 |         "available": "No match"
  86 |     },
  87 |     {
  88 |         "extensions": ".cn,.ac.cn,.com.cn,.edu.cn,.gov.cn,.net.cn,.org.cn,.bj.cn,.sh.cn,.tj.cn,.cq.cn,.he.cn,.nm.cn,.ln.cn,.jl.cn,.hl.cn,.js.cn,.zj.cn,.ah.cn,.hb.cn,.hn.cn,.gd.cn,.gx.cn,.hi.cn,.sc.cn,.gz.cn,.yn.cn,.xz.cn,.sn.cn,.gs.cn,.qh.cn,.nx.cn,.xj.cn,.tw.cn,.hk.cn,.mo.cn",
  89 |         "uri": "socket:\/\/whois.cnnic.net.cn",
  90 |         "available": "No matching record"
  91 |     },
  92 |     {
  93 |         "extensions": ".scot",
  94 |         "uri": "socket:\/\/whois.nic.scot",
  95 |         "available": "no matching objects found"
  96 |     },
  97 |     {
  98 |         "extensions": ".cx",
  99 |         "uri": "socket:\/\/whois.nic.cx",
 100 |         "available": "No Object Found"
 101 |     },
 102 |     {
 103 |         "extensions": ".cz",
 104 |         "uri": "socket:\/\/whois.nic.cz",
 105 |         "available": "No entries found"
 106 |     },
 107 |     {
 108 |         "extensions": ".de",
 109 |         "uri": "socket:\/\/whois.denic.de",
 110 |         "available": "Status: free"
 111 |     },
 112 |     {
 113 |         "extensions": ".dk",
 114 |         "uri": "socket:\/\/whois.dk-hostmaster.dk",
 115 |         "available": "No entries found"
 116 |     },
 117 |     {
 118 |         "extensions": ".fo",
 119 |         "uri": "socket:\/\/whois.nic.fo",
 120 |         "available": "DOMAIN NOT FOUND"
 121 |     },
 122 |     {
 123 |         "extensions": ".com.ec,.org.ec,.net.ec,.mil.ec,.fin.ec,.med.ec,.gob.ec,.ec",
 124 |         "uri": "https:\/\/rdap.registry.ec\/domain\/",
 125 |         "available": "404",
 126 |         "comment": "Updated to use RDAP server instead of traditional whois"
 127 |     },
 128 |     {
 129 |         "extensions": ".fr,.tm.fr,.com.fr,.asso.fr,.presse.fr",
 130 |         "uri": "socket:\/\/whois.nic.fr",
 131 |         "available": "NOT FOUND"
 132 |     },
 133 |     {
 134 |         "extensions": ".gf",
 135 |         "uri": "socket:\/\/whois.mediaserv.net",
 136 |         "available": "NO OBJECT FOUND"
 137 |     },
 138 |     {
 139 |         "extensions": ".co.il,.org.il,.net.il,.ac.il,.k12.il,.gov.il,.muni.il",
 140 |         "uri": "socket:\/\/whois.isoc.org.il",
 141 |         "available": "No data was found"
 142 |     },
 143 |     {
 144 |         "extensions": ".ac.in,.co.in,.org.in,.ernet.in,.gov.in,.net.in,.res.in,.in",
 145 |         "uri": "socket:\/\/whois.registry.in",
 146 |         "available": "No Data Found"
 147 |     },
 148 |     {
 149 |         "extensions": ".is",
 150 |         "uri": "socket:\/\/whois.isnic.is",
 151 |         "available": "No entries found"
 152 |     },
 153 |     {
 154 |         "extensions": ".it",
 155 |         "uri": "socket:\/\/whois.nic.it",
 156 |         "available": "AVAILABLE"
 157 |     },
 158 |     {
 159 |         "extensions": ".ac.jp,.co.jp,.go.jp,.or.jp,.ne.jp",
 160 |         "uri": "socket:\/\/whois.jprs.jp",
 161 |         "available": "No match!!"
 162 |     },
 163 |     {
 164 |         "extensions": ".ac.kr,.co.kr,.go.kr,.ne.kr,.ne.kr,.or.kr,.re.kr",
 165 |         "uri": "socket:\/\/whois.nic.or.kr",
 166 |         "available": "domain was not found"
 167 |     },
 168 |     {
 169 |         "extensions": ".li",
 170 |         "uri": "socket:\/\/whois.nic.li",
 171 |         "available": "We do not have an entry in our database matching your query"
 172 |     },
 173 |     {
 174 |         "extensions": ".lt",
 175 |         "uri": "socket:\/\/das.domreg.lt",
 176 |         "available": "Status:\t\t\tavailable"
 177 |     },
 178 |     {
 179 |         "extensions": ".lu",
 180 |         "uri": "socket:\/\/whois.dns.lu",
 181 |         "available": "No such domain"
 182 |     },
 183 |     {
 184 |         "extensions": ".asso.mc,.tm.mc,.ad",
 185 |         "uri": "socket:\/\/whois.ripe.net",
 186 |         "available": "no entries found"
 187 |     },
 188 |     {
 189 |         "extensions": ".com.mm,.org.mm,.net.mm,.edu.mm,.gov.mm",
 190 |         "uri": "socket:\/\/whois.registry.gov.mm",
 191 |         "available": "DOMAIN NOT FOUND"
 192 |     },
 193 |     {
 194 |         "extensions": ".mx,.com.mx,.org.mx,.net.mx,.edu.mx,.gob.mx",
 195 |         "uri": "socket:\/\/whois.mx",
 196 |         "available": "No_Se_Encontro_El_Objeto\/Object_Not_Found"
 197 |     },
 198 |     {
 199 |         "extensions": ".nl",
 200 |         "uri": "socket:\/\/whois.domain-registry.nl",
 201 |         "available": "is free"
 202 |     },
 203 |     {
 204 |         "extensions": ".no,.priv.no,.idrett.no",
 205 |         "uri": "socket:\/\/whois.norid.no",
 206 |         "available": "No match"
 207 |     },
 208 |     {
 209 |         "extensions": ".nu",
 210 |         "uri": "socket:\/\/whois.iis.nu",
 211 |         "available": "not found"
 212 |     },
 213 |     {
 214 |         "extensions": ".pl,.com.pl,.net.pl,.org.pl,.aid.pl,.agro.pl,.atm.pl,.auto.pl,.biz.pl,.edu.pl,.gmina.pl,.gsm.pl,.info.pl,.mail.pl,.miasta.pl,.media.pl,.mil.pl,.nom.pl,.pc.pl,.priv.pl,.realestate.pl,.rel.pl,.shop.pl,.sklep.pl,.sos.pl,.targi.pl,.tm.pl,.tourism.pl,.turystyka.pl",
 215 |         "uri": "socket:\/\/whois.dns.pl",
 216 |         "available": "No information available"
 217 |     },
 218 |     {
 219 |         "extensions": ".ro,.com.ro,.org.ro,.store.ro,.tm.ro,.firm.ro,.www.ro,.arts.ro,.rec.ro,.info.ro,.nom.ro,.nt.ro",
 220 |         "uri": "socket:\/\/whois.rotld.ro",
 221 |         "available": "No entries found"
 222 |     },
 223 |     {
 224 |         "extensions": ".se",
 225 |         "uri": "socket:\/\/whois.iis.se",
 226 |         "available": "not found"
 227 |     },
 228 |     {
 229 |         "extensions": ".si",
 230 |         "uri": "socket:\/\/whois.arnes.si",
 231 |         "available": "No entries found"
 232 |     },
 233 |     {
 234 |         "extensions": ".com.sg,.org.sg,.net.sg,.gov.sg,.sg,.edu.sg,.sg",
 235 |         "uri": "socket:\/\/whois.sgnic.sg",
 236 |         "available": "---Not found"
 237 |     },
 238 |     {
 239 |         "extensions": ".sk",
 240 |         "uri": "socket:\/\/whois.sk-nic.sk",
 241 |         "available": "Domain not found"
 242 |     },
 243 |     {
 244 |         "extensions": ".st",
 245 |         "uri": "socket:\/\/whois.nic.st",
 246 |         "available": "No entries found"
 247 |     },
 248 |     {
 249 |         "extensions": ".tf",
 250 |         "uri": "socket:\/\/whois.nic.tf",
 251 |         "available": "No entries found"
 252 |     },
 253 |     {
 254 |         "extensions": ".ac.th,.co.th,.go.th,.mi.th,.net.th,.or.th,.in.th",
 255 |         "uri": "socket:\/\/whois.thnic.net",
 256 |         "available": "No match found"
 257 |     },
 258 |     {
 259 |         "extensions": ".tj",
 260 |         "uri": "socket:\/\/whois.nic.tj",
 261 |         "available": "No match"
 262 |     },
 263 |     {
 264 |         "extensions": ".to",
 265 |         "uri": "socket:\/\/whois.tonic.to",
 266 |         "available": "No match for"
 267 |     },
 268 |     {
 269 |         "extensions": ".bbs.tr,.com.tr,.edu.tr,.gov.tr,.k12.tr,.tsk.tr,.net.tr,.org.tr,.biz.tr,.name.tr,.tel.tr,.bel.tr,.gen.tr,.info.tr,.web.tr",
 270 |         "uri": "socket:\/\/whois.nic.tr",
 271 |         "available": "No match found"
 272 |     },
 273 |     {
 274 |         "extensions": ".istanbul",
 275 |         "uri": "socket:\/\/whois.afilias-srs.net",
 276 |         "available": "NOT FOUND"
 277 |     },
 278 |     {
 279 |         "extensions": ".com.tw,.org.tw,.net.tw",
 280 |         "uri": "socket:\/\/whois.twnic.net",
 281 |         "available": "No Found"
 282 |     },
 283 |     {
 284 |         "extensions": ".ac.uk",
 285 |         "uri": "socket:\/\/whois.ja.net",
 286 |         "available": "No such domain"
 287 |     },
 288 |     {
 289 |         "extensions": ".ac.za,.alt.za,.edu.za,.gov.za,.mil.za,.ngo.za,.nom.za,.school.za,.tm.za",
 290 |         "uri": "socket:\/\/whois.co.za",
 291 |         "available": "No information available"
 292 |     },
 293 |     {
 294 |         "extensions": ".co.za",
 295 |         "uri": "socket:\/\/whois.registry.net.za",
 296 |         "available": "Available"
 297 |     },
 298 |     {
 299 |         "extensions": ".net.za",
 300 |         "uri": "socket:\/\/net-whois.registry.net.za",
 301 |         "available": "Available"
 302 |     },
 303 |     {
 304 |         "extensions": ".org.za",
 305 |         "uri": "socket:\/\/org-whois.registry.net.za",
 306 |         "available": "Available"
 307 |     },
 308 |     {
 309 |         "extensions": ".web.za",
 310 |         "uri": "socket:\/\/web-whois.registry.net.za",
 311 |         "available": "Available"
 312 |     },
 313 |     {
 314 |         "extensions": ".kz",
 315 |         "uri": "socket:\/\/whois.nic.kz",
 316 |         "available": "Nothing found"
 317 |     },
 318 |     {
 319 |         "extensions": ".ch",
 320 |         "uri": "socket:\/\/whois.nic.ch:4343",
 321 |         "available": "---1:"
 322 |     },
 323 |     {
 324 |         "extensions": ".info,.blue,.kim,.pink,.black,.green,.lgbt,.poker,.red,.vote,.voto,.archi,.bio,.ski,.bet,.promo,.pet,.lotto",
 325 |         "uri": "socket:\/\/whois.afilias.net",
 326 |         "available": "Domain not found"
 327 |     },
 328 |     {
 329 |         "extensions": ".ua",
 330 |         "uri": "socket:\/\/whois.ua",
 331 |         "available": "No entries found"
 332 |     },
 333 |     {
 334 |         "extensions": ".biz",
 335 |         "uri": "socket:\/\/whois.biz",
 336 |         "available": "No Data Found"
 337 |     },
 338 |     {
 339 |         "extensions": ".ws",
 340 |         "uri": "socket:\/\/whois.website.ws",
 341 |         "available": "The queried object does not exist"
 342 |     },
 343 |     {
 344 |         "extensions": ".gov",
 345 |         "uri": "socket:\/\/whois.nic.gov",
 346 |         "available": "No match for"
 347 |     },
 348 |     {
 349 |         "extensions": ".name",
 350 |         "uri": "socket:\/\/whois.nic.name",
 351 |         "available": "No match"
 352 |     },
 353 |     {
 354 |         "extensions": ".ie",
 355 |         "uri": "socket:\/\/whois.domainregistry.ie",
 356 |         "available": "Not found"
 357 |     },
 358 |     {
 359 |         "extensions": ".hk,.com.hk,.org.hk,.net.hk,.edu.hk",
 360 |         "uri": "socket:\/\/whois.hkirc.hk",
 361 |         "available": "The domain has not been registered"
 362 |     },
 363 |     {
 364 |         "extensions": ".us",
 365 |         "uri": "socket:\/\/whois.nic.us",
 366 |         "available": "No Data Found"
 367 |     },
 368 |     {
 369 |         "extensions": ".tk",
 370 |         "uri": "socket:\/\/whois.dot.tk",
 371 |         "available": "domain name not known"
 372 |     },
 373 |     {
 374 |         "extensions": ".cd",
 375 |         "uri": "socket:\/\/whois.nic.cd",
 376 |         "available": "No Object Found"
 377 |     },
 378 |     {
 379 |         "extensions": ".aero",
 380 |         "uri": "socket:\/\/whois.aero",
 381 |         "available": "NOT FOUND"
 382 |     },
 383 |     {
 384 |         "extensions": ".by",
 385 |         "uri": "socket:\/\/whois.cctld.by",
 386 |         "available": "Object does not exist"
 387 |     },
 388 |     {
 389 |         "extensions": ".lv",
 390 |         "uri": "socket:\/\/whois.nic.lv",
 391 |         "available": "Status: free"
 392 |     },
 393 |     {
 394 |         "extensions": ".bz",
 395 |         "uri": "socket:\/\/whois.afilias-grs.info.",
 396 |         "available": "NOT FOUND"
 397 |     },
 398 |     {
 399 |         "extensions": ".jp",
 400 |         "uri": "socket:\/\/whois.jprs.jp",
 401 |         "available": "No match!!"
 402 |     },
 403 |     {
 404 |         "extensions": ".cl",
 405 |         "uri": "socket:\/\/whois.nic.cl",
 406 |         "available": "no entries found."
 407 |     },
 408 |     {
 409 |         "extensions": ".ag",
 410 |         "uri": "socket:\/\/whois.nic.ag",
 411 |         "available": "NOT FOUND"
 412 |     },
 413 |     {
 414 |         "extensions": ".mobi",
 415 |         "uri": "socket:\/\/whois.dotmobiregistry.net",
 416 |         "available": "Domain not found"
 417 |     },
 418 |     {
 419 |         "extensions": ".eu",
 420 |         "uri": "socket:\/\/whois.eu",
 421 |         "available": "Status: AVAILABLE"
 422 |     },
 423 |     {
 424 |         "extensions": ".co.nz,.org.nz,.net.nz,.maori.nz,.iwi.nz,.ac.nz,.kiwi.nz,.geek.nz,.gen.nz,.school.nz,.nz",
 425 |         "uri": "socket:\/\/whois.irs.net.nz",
 426 |         "available": "Not found"
 427 |     },
 428 |     {
 429 |         "extensions": ".io",
 430 |         "uri": "socket:\/\/whois.nic.io",
 431 |         "available": "---Domain not found"
 432 |     },
 433 |     {
 434 |         "extensions": ".la",
 435 |         "uri": "socket:\/\/whois.nic.la",
 436 |         "available": "NOT FOUND"
 437 |     },
 438 |     {
 439 |         "extensions": ".md",
 440 |         "uri": "socket:\/\/whois.nic.md",
 441 |         "available": "No match for"
 442 |     },
 443 |     {
 444 |         "extensions": ".sc",
 445 |         "uri": "socket:\/\/whois2.afilias-grs.net",
 446 |         "available": "NOT FOUND"
 447 |     },
 448 |     {
 449 |         "extensions": ".vc",
 450 |         "uri": "socket:\/\/whois2.afilias-grs.net",
 451 |         "available": "NOT FOUND"
 452 |     },
 453 |     {
 454 |         "extensions": ".vg",
 455 |         "uri": "socket:\/\/whois.nic.vg",
 456 |         "available": "DOMAIN NOT FOUND"
 457 |     },
 458 |     {
 459 |         "extensions": ".tc",
 460 |         "uri": "socket:\/\/whois.nic.tc",
 461 |         "available": "No Object Found"
 462 |     },
 463 |     {
 464 |         "extensions": ".tw",
 465 |         "uri": "socket:\/\/whois.twnic.net.tw",
 466 |         "available": "No Found"
 467 |     },
 468 |     {
 469 |         "extensions": ".travel",
 470 |         "uri": "socket:\/\/whois.nic.travel",
 471 |         "available": "Domain not found"
 472 |     },
 473 |     {
 474 |         "extensions": ".my,.com.my,.net.my,.org.my,.edu.my,.gov.my",
 475 |         "uri": "socket:\/\/whois.mynic.my",
 476 |         "available": "does not exist in database"
 477 |     },
 478 |     {
 479 |         "extensions": ".com.ph,.net.ph,.ph,.org.ph",
 480 |         "uri": "https:\/\/whois.dot.ph\/?search=",
 481 |         "available": "Domain is available"
 482 |     },
 483 |     {
 484 |         "extensions": ".tv",
 485 |         "uri": "socket:\/\/whois.nic.tv",
 486 |         "available": "No Data Found"
 487 |     },
 488 |     {
 489 |         "extensions": ".pt,.com.pt,.edu.pt",
 490 |         "uri": "socket:\/\/whois.dns.pt",
 491 |         "available": "No Match"
 492 |     },
 493 |     {
 494 |         "extensions": ".me",
 495 |         "uri": "socket:\/\/whois.nic.me",
 496 |         "available": "NOT FOUND"
 497 |     },
 498 |     {
 499 |         "extensions": ".asia",
 500 |         "uri": "socket:\/\/whois.nic.asia",
 501 |         "available": "NOT FOUND"
 502 |     },
 503 |     {
 504 |         "extensions": ".fi",
 505 |         "uri": "socket:\/\/whois.ficora.fi",
 506 |         "available": "Domain not found"
 507 |     },
 508 |     {
 509 |         "extensions": ".za.net,.za.org",
 510 |         "uri": "http:\/\/www.za.net\/cgi-bin\/whois.cgi?domain=",
 511 |         "available": "No such domain"
 512 |     },
 513 |     {
 514 |         "extensions": ".com.ve,.net.ve,.org.ve,.web.ve,.info.ve,.co.ve",
 515 |         "uri": "socket:\/\/whois.nic.ve",
 516 |         "available": "No entries found"
 517 |     },
 518 |     {
 519 |         "extensions": ".tel",
 520 |         "uri": "socket:\/\/whois.nic.tel",
 521 |         "available": "No Data Found"
 522 |     },
 523 |     {
 524 |         "extensions": ".im",
 525 |         "uri": "socket:\/\/whois.nic.im",
 526 |         "available": "was not found"
 527 |     },
 528 |     {
 529 |         "extensions": ".gr,.com.gr,.net.gr,.org.gr,.edu.gr,.gov.gr",
 530 |         "uri": "https:\/\/grwhois.ics.forth.gr:800\/plainwhois\/plainWhois?domainName=",
 531 |         "available": "not exist"
 532 |     },
 533 |     {
 534 |         "extensions": ".ir,.co.ir,.ac.ir,.sch.ir,.gov.ir,.org.ir,.edu.ir",
 535 |         "uri": "socket:\/\/whois.nic.ir",
 536 |         "premium": "under certain conditions",
 537 |         "available": "no entries found"
 538 |     },
 539 |     {
 540 |         "extensions": ".ru,.pp.ru,.net.ru,.org.ru,.su,.com.ru",
 541 |         "uri": "socket:\/\/whois.ripn.net",
 542 |         "available": "No entries found"
 543 |     },
 544 |     {
 545 |         "extensions": ".spb.ru,.msk.ru",
 546 |         "uri": "socket:\/\/whois.relcom.ru",
 547 |         "available": "No entries found"
 548 |     },
 549 |     {
 550 |         "extensions": ".com.ua,.dn.ua,.kh.ua,.lg.ua,.net.ua,.org.ua,.kiev.ua",
 551 |         "uri": "socket:\/\/whois.net.ua",
 552 |         "available": "No entries found"
 553 |     },
 554 |     {
 555 |         "extensions": ".lviv.ua",
 556 |         "uri": "socket:\/\/whois.lviv.ua",
 557 |         "available": "No Object Found"
 558 |     },
 559 |     {
 560 |         "extensions": ".co,.net.co,.com.co,.nom.co",
 561 |         "uri": "socket:\/\/whois.nic.co",
 562 |         "available": "No Data Found"
 563 |     },
 564 |     {
 565 |         "extensions": ".gt,.com.gt,.net.gt,.org.gt,.ind.gt,.edu.gt,.gob.gt,.mil.gt",
 566 |         "uri": "https:\/\/www.gt\/sitio\/whois.php?dn=",
 567 |         "available": "no est\u00e1 registrado"
 568 |     },
 569 |     {
 570 |         "extensions": ".re",
 571 |         "uri": "socket:\/\/whois.nic.re",
 572 |         "available": "NOT FOUND"
 573 |     },
 574 |     {
 575 |         "extensions": ".pm",
 576 |         "uri": "socket:\/\/whois.nic.pm",
 577 |         "available": "No entries found"
 578 |     },
 579 |     {
 580 |         "extensions": ".wf",
 581 |         "uri": "socket:\/\/whois.nic.wf",
 582 |         "available": "No entries found"
 583 |     },
 584 |     {
 585 |         "extensions": ".yt",
 586 |         "uri": "socket:\/\/whois.nic.yt",
 587 |         "available": "NOT FOUND"
 588 |     },
 589 |     {
 590 |         "extensions": ".xxx",
 591 |         "uri": "socket:\/\/whois.nic.xxx",
 592 |         "available": "No Data Found"
 593 |     },
 594 |     {
 595 |         "extensions": ".hu",
 596 |         "uri": "socket:\/\/whois.nic.hu",
 597 |         "available": "No match"
 598 |     },
 599 |     {
 600 |         "extensions": ".ac.ke,.co.ke,.or.ke,.ne.ke,.mobi.ke,.info.ke,.go.ke,.me.ke,.sc.ke",
 601 |         "uri": "socket:\/\/whois.kenic.or.ke",
 602 |         "available": "No Object Found"
 603 |     },
 604 |     {
 605 |         "extensions": ".gd",
 606 |         "uri": "socket:\/\/whois.nic.gd",
 607 |         "available": "not found..."
 608 |     },
 609 |     {
 610 |         "extensions": ".rs,.co.rs,.org.rs,.edu.rs,.in.rs",
 611 |         "uri": "socket:\/\/whois.rnids.rs",
 612 |         "available": "%ERROR:103"
 613 |     },
 614 |     {
 615 |         "extensions": ".ae",
 616 |         "uri": "socket:\/\/whois.aeda.net.ae",
 617 |         "available": "No Data Found"
 618 |     },
 619 |     {
 620 |         "extensions": ".pw",
 621 |         "uri": "socket:\/\/whois.nic.pw",
 622 |         "available": "DOMAIN NOT FOUND"
 623 |     },
 624 |     {
 625 |         "extensions": ".cat",
 626 |         "uri": "socket:\/\/whois.nic.cat",
 627 |         "available": "no matching objects found"
 628 |     },
 629 |     {
 630 |         "extensions": ".mil.id,.go.id",
 631 |         "uri": "socket:\/\/whois.id",
 632 |         "available": "DOMAIN NOT FOUND"
 633 |     },
 634 |     {
 635 |         "extensions": ".fm",
 636 |         "uri": "socket:\/\/whois.nic.fm",
 637 |         "available": "DOMAIN NOT FOUND"
 638 |     },
 639 |     {
 640 |         "extensions": ".mn",
 641 |         "uri": "socket:\/\/whois.afilias-grs.info",
 642 |         "available": "NOT FOUND"
 643 |     },
 644 |     {
 645 |         "extensions": ".sx",
 646 |         "uri": "socket:\/\/whois.sx",
 647 |         "available": "Not found:"
 648 |     },
 649 |     {
 650 |         "extensions": ".pa,.com.pa,.net.pa,.org.pa",
 651 |         "uri": "http:\/\/www.nic.pa\/en\/whois\/dominio\/",
 652 |         "available": "The domain doesn't exist"
 653 |     },
 654 |     {
 655 |         "extensions": ".equipment,.gallery,.graphics,.lighting,.photography,.directory,.technology,.today,.bike,.clothing,.guru,.plumbing,.singles,.camera,.estate,.construction,.contractors,.kitchen,.land,.enterprises,.holdings,.ventures,.diamonds,.voyage,.photos,.shoes,.careers,.recipes,.academy,.agency,.associates,.bargains,.boutique,.builders,.cab,.camp,.center,.cheap,.codes,.coffee,.company,.computer,.cool,.education,.email,.expert,.exposed,.farm,.flights,.florist,.glass,.holiday,.house,.institute,.international,.limo,.maison,.management,.marketing,.repair,.solar,.solutions,.supplies,.supply,.support,.systems,.tips,.training,.viajes,.zone,.world,.apartments,.bingo,.business,.cafe,.capital,.cards,.care,.cash,.casino,.catering,.chat,.church,.city,.claims,.cleaning,.clinic,.coach,.community,.condos,.coupons,.credit,.creditcard,.cruises,.dating,.deals,.delivery,.dental,.digital,.direct,.discount,.dog,.domains,.energy,.engineering,.events,.exchange,.express,.fail,.finance,.financial,.fish,.fitness,.football,.fund,.furniture,.fyi,.gifts,.gold,.golf,.gratis,.gripe,.guide,.healthcare,.hockey,.immo,.industries,.insure,.investments,.jewelry,.lease,.legal,.life,.limited,.loans,.mba,.media,.memorial,.money,.movie,.network,.partners,.parts,.pictures,.pizza,.place,.plus,.productions,.properties,.reisen,.rentals,.report,.restaurant,.run,.sarl,.school,.schule,.services,.show,.soccer,.style,.surgery,.tax,.taxi,.team,.tennis,.theater,.tienda,.tires,.tools,.tours,.town,.toys,.university,.vacations,.villas,.vision,.watch,.works,.wtf,.irish",
 656 |         "uri": "socket:\/\/whois.donuts.co",
 657 |         "available": "Domain not found"
 658 |     },
 659 |     {
 660 |         "extensions": ".foundation",
 661 |         "uri": "socket:\/\/whois.nic.foundation",
 662 |         "available": "Domain not found"
 663 |     },
 664 |     {
 665 |         "extensions": ".wiki",
 666 |         "uri": "socket:\/\/whois.nic.wiki",
 667 |         "available": "No Data Found"
 668 |     },
 669 |     {
 670 |         "extensions": ".cm",
 671 |         "uri": "socket:\/\/whois.netcom.cm",
 672 |         "available": "Not Registered"
 673 |     },
 674 |     {
 675 |         "extensions": ".gs",
 676 |         "uri": "socket:\/\/whois.nic.gs",
 677 |         "available": "No Object Found"
 678 |     },
 679 |     {
 680 |         "extensions": ".ms",
 681 |         "uri": "socket:\/\/whois.nic.ms",
 682 |         "available": "No Object Found"
 683 |     },
 684 |     {
 685 |         "extensions": ".sh",
 686 |         "uri": "socket:\/\/whois.nic.sh",
 687 |         "available": "Domain not found"
 688 |     },
 689 |     {
 690 |         "extensions": ".tm",
 691 |         "uri": "socket:\/\/whois.nic.tm",
 692 |         "available": "is available for purchase"
 693 |     },
 694 |     {
 695 |         "extensions": ".ee",
 696 |         "uri": "socket:\/\/whois.tld.ee",
 697 |         "available": "Domain not found"
 698 |     },
 699 |     {
 700 |         "extensions": ".airforce,.futbol,.social,.pub,.auction,.consulting,.dance,.democrat,.forsale,.haus,.immobilien,.kaufen,.reviews,.rocks",
 701 |         "uri": "socket:\/\/whois.donuts.co",
 702 |         "available": "Domain not found"
 703 |     },
 704 |     {
 705 |         "extensions": ".actor",
 706 |         "uri": "socket:\/\/whois.nic.actor",
 707 |         "available": "Domain not found"
 708 |     },
 709 |     {
 710 |         "extensions": ".desi",
 711 |         "uri": "socket:\/\/whois.nic.desi",
 712 |         "available": "DOMAIN NOT FOUND"
 713 |     },
 714 |     {
 715 |         "extensions": ".arpa",
 716 |         "uri": "socket:\/\/whois.iana.org",
 717 |         "available": "0 objects"
 718 |     },
 719 |     {
 720 |         "extensions": ".ax",
 721 |         "uri": "socket:\/\/whois.ax",
 722 |         "available": "Domain not found"
 723 |     },
 724 |     {
 725 |         "extensions": ".berlin",
 726 |         "uri": "socket:\/\/whois.nic.berlin",
 727 |         "available": "object does not exist"
 728 |     },
 729 |     {
 730 |         "extensions": ".build",
 731 |         "uri": "socket:\/\/whois.nic.build",
 732 |         "available": "DOMAIN NOT FOUND"
 733 |     },
 734 |     {
 735 |         "extensions": ".buzz",
 736 |         "uri": "socket:\/\/whois.nic.buzz",
 737 |         "available": "No Data Found"
 738 |     },
 739 |     {
 740 |         "extensions": ".capetown",
 741 |         "uri": "socket:\/\/whois.nic.capetown",
 742 |         "available": "Available"
 743 |     },
 744 |     {
 745 |         "extensions": ".club",
 746 |         "uri": "socket:\/\/whois.nic.club",
 747 |         "available": "No Data Found"
 748 |     },
 749 |     {
 750 |         "extensions": ".durban",
 751 |         "uri": "socket:\/\/whois.nic.durban",
 752 |         "available": "Available"
 753 |     },
 754 |     {
 755 |         "extensions": ".gift,.guitars,.link,.pics,.sexy,.audio,.blackfriday,.christmas,.click,.diet,.flowers,.help,.hosting,.juegos,.lol,.photo,.property,.tattoo",
 756 |         "uri": "socket:\/\/whois.uniregistry.net",
 757 |         "available": "is available for registration"
 758 |     },
 759 |     {
 760 |         "extensions": ".hiphop",
 761 |         "uri": "socket:\/\/whois.nic.hiphop",
 762 |         "available": "is available for registration"
 763 |     },
 764 |     {
 765 |         "extensions": ".joburg",
 766 |         "uri": "socket:\/\/whois.nic.joburg",
 767 |         "available": "Available"
 768 |     },
 769 |     {
 770 |         "extensions": ".luxury",
 771 |         "uri": "socket:\/\/whois.nic.luxury",
 772 |         "available": "DOMAIN NOT FOUND"
 773 |     },
 774 |     {
 775 |         "extensions": ".menu",
 776 |         "uri": "socket:\/\/whois.nic.menu",
 777 |         "available": "No Data Found"
 778 |     },
 779 |     {
 780 |         "extensions": ".moda",
 781 |         "uri": "socket:\/\/whois.nic.moda",
 782 |         "available": "Domain not found"
 783 |     },
 784 |     {
 785 |         "extensions": ".ninja",
 786 |         "uri": "socket:\/\/whois.nic.ninja",
 787 |         "available": "Domain not found"
 788 |     },
 789 |     {
 790 |         "extensions": ".shiksha",
 791 |         "uri": "socket:\/\/whois.nic.shiksha",
 792 |         "available": "Domain not found"
 793 |     },
 794 |     {
 795 |         "extensions": ".uno",
 796 |         "uri": "socket:\/\/whois.nic.uno",
 797 |         "available": "DOMAIN NOT FOUND"
 798 |     },
 799 |     {
 800 |         "extensions": ".work",
 801 |         "uri": "socket:\/\/whois.nic.work",
 802 |         "available": "No Data Found"
 803 |     },
 804 |     {
 805 |         "extensions": ".co.zw",
 806 |         "uri": "http:\/\/zispa.org.zw\/cgi-bin\/domain_lookup.pl?s=",
 807 |         "available": "is available for registration"
 808 |     },
 809 |     {
 810 |         "extensions": ".coop",
 811 |         "uri": "socket:\/\/whois.nic.coop",
 812 |         "available": "DOMAIN NOT FOUND"
 813 |     },
 814 |     {
 815 |         "extensions": ".co.id,.desa.id,.web.id,.ac.id,.or.id,.sch.id,.my.id,.biz.id",
 816 |         "uri": "socket:\/\/whois.pandi.or.id",
 817 |         "available": "DOMAIN NOT FOUND"
 818 |     },
 819 |     {
 820 |         "extensions": ".attorney",
 821 |         "uri": "socket:\/\/whois.nic.attorney",
 822 |         "available": "Domain not found."
 823 |     },
 824 |     {
 825 |         "extensions": ".lawyer",
 826 |         "uri": "socket:\/\/whois.nic.lawyer",
 827 |         "available": "Domain not found."
 828 |     },
 829 |     {
 830 |         "extensions": ".army",
 831 |         "uri": "socket:\/\/whois.nic.army",
 832 |         "available": "Domain not found."
 833 |     },
 834 |     {
 835 |         "extensions": ".band",
 836 |         "uri": "socket:\/\/whois.nic.band",
 837 |         "available": "Domain not found."
 838 |     },
 839 |     {
 840 |         "extensions": ".degree",
 841 |         "uri": "socket:\/\/whois.nic.degree",
 842 |         "available": "Domain not found."
 843 |     },
 844 |     {
 845 |         "extensions": ".dentist",
 846 |         "uri": "socket:\/\/whois.nic.dentist",
 847 |         "available": "Domain not found."
 848 |     },
 849 |     {
 850 |         "extensions": ".engineer",
 851 |         "uri": "socket:\/\/whois.nic.engineer",
 852 |         "available": "Domain not found."
 853 |     },
 854 |     {
 855 |         "extensions": ".family",
 856 |         "uri": "socket:\/\/whois.nic.family",
 857 |         "available": "Domain not found."
 858 |     },
 859 |     {
 860 |         "extensions": ".gives",
 861 |         "uri": "socket:\/\/whois.nic.gives",
 862 |         "available": "Domain not found."
 863 |     },
 864 |     {
 865 |         "extensions": ".live",
 866 |         "uri": "socket:\/\/whois.nic.live",
 867 |         "available": "Domain not found."
 868 |     },
 869 |     {
 870 |         "extensions": ".market",
 871 |         "uri": "socket:\/\/whois.nic.market",
 872 |         "available": "Domain not found."
 873 |     },
 874 |     {
 875 |         "extensions": ".mortgage",
 876 |         "uri": "socket:\/\/whois.nic.mortgage",
 877 |         "available": "Domain not found."
 878 |     },
 879 |     {
 880 |         "extensions": ".navy",
 881 |         "uri": "socket:\/\/whois.nic.navy",
 882 |         "available": "Domain not found."
 883 |     },
 884 |     {
 885 |         "extensions": ".news",
 886 |         "uri": "socket:\/\/whois.nic.news",
 887 |         "available": "Domain not found."
 888 |     },
 889 |     {
 890 |         "extensions": ".rehab",
 891 |         "uri": "socket:\/\/whois.nic.rehab",
 892 |         "available": "Domain not found."
 893 |     },
 894 |     {
 895 |         "extensions": ".republican",
 896 |         "uri": "socket:\/\/whois.nic.republican",
 897 |         "available": "Domain not found."
 898 |     },
 899 |     {
 900 |         "extensions": ".rip",
 901 |         "uri": "socket:\/\/whois.nic.rip",
 902 |         "available": "Domain not found."
 903 |     },
 904 |     {
 905 |         "extensions": ".sale",
 906 |         "uri": "socket:\/\/whois.nic.sale",
 907 |         "available": "Domain not found."
 908 |     },
 909 |     {
 910 |         "extensions": ".software",
 911 |         "uri": "socket:\/\/whois.nic.software",
 912 |         "available": "Domain not found."
 913 |     },
 914 |     {
 915 |         "extensions": ".studio",
 916 |         "uri": "socket:\/\/whois.nic.studio",
 917 |         "available": "Domain not found."
 918 |     },
 919 |     {
 920 |         "extensions": ".vet",
 921 |         "uri": "socket:\/\/whois.nic.vet",
 922 |         "available": "Domain not found."
 923 |     },
 924 |     {
 925 |         "extensions": ".video",
 926 |         "uri": "socket:\/\/whois.nic.video",
 927 |         "available": "Domain not found."
 928 |     },
 929 |     {
 930 |         "extensions": ".top",
 931 |         "uri": "socket:\/\/whois.nic.top",
 932 |         "available": "The queried object does not exist"
 933 |     },
 934 |     {
 935 |         "extensions": ".co.tz,.or.tz,.go.tz,.ne.tz,.me.tz,.tv.tz,.ac.tz,.sc.tz",
 936 |         "uri": "socket:\/\/whois.tznic.or.tz",
 937 |         "available": "No entries found"
 938 |     },
 939 |     {
 940 |         "extensions": ".ltda,.rich,.srl,.vegas,.onl",
 941 |         "uri": "socket:\/\/whois.afilias-srs.net",
 942 |         "available": "NOT FOUND"
 943 |     },
 944 |     {
 945 |         "extensions": ".sex",
 946 |         "uri": "socket:\/\/whois.nic.sex",
 947 |         "available": "No match for"
 948 |     },
 949 |     {
 950 |         "extensions": ".adult",
 951 |         "uri": "socket:\/\/whois.nic.adult",
 952 |         "available": "No Data Found"
 953 |     },
 954 |     {
 955 |         "extensions": ".porn",
 956 |         "uri": "socket:\/\/whois.nic.porn",
 957 |         "available": "No Data Found"
 958 |     },
 959 |     {
 960 |         "extensions": ".pe,.com.pe",
 961 |         "uri": "socket:\/\/kero.yachay.pe",
 962 |         "available": "No Object Found"
 963 |     },
 964 |     {
 965 |         "extensions": ".accountant",
 966 |         "uri": "socket:\/\/whois.nic.accountant",
 967 |         "available": "No Data Found"
 968 |     },
 969 |     {
 970 |         "extensions": ".accountants",
 971 |         "uri": "socket:\/\/whois.nic.accountants",
 972 |         "available": "Domain not found"
 973 |     },
 974 |     {
 975 |         "extensions": ".bar",
 976 |         "uri": "socket:\/\/whois.nic.bar",
 977 |         "available": "DOMAIN NOT FOUND"
 978 |     },
 979 |     {
 980 |         "extensions": ".best",
 981 |         "uri": "socket:\/\/whois.nic.best",
 982 |         "available": "DOMAIN NOT FOUND"
 983 |     },
 984 |     {
 985 |         "extensions": ".bid",
 986 |         "uri": "socket:\/\/whois.nic.bid",
 987 |         "available": "No Data Found"
 988 |     },
 989 |     {
 990 |         "extensions": ".ceo",
 991 |         "uri": "socket:\/\/whois.nic.ceo",
 992 |         "available": "DOMAIN NOT FOUND"
 993 |     },
 994 |     {
 995 |         "extensions": ".college",
 996 |         "uri": "socket:\/\/whois.nic.college",
 997 |         "available": "DOMAIN NOT FOUND"
 998 |     },
 999 |     {
1000 |         "extensions": ".courses",
1001 |         "uri": "socket:\/\/whois.nic.courses",
1002 |         "available": "No Data Found"
1003 |     },
1004 |     {
1005 |         "extensions": ".melbourne",
1006 |         "uri": "socket:\/\/whois.nic.melbourne",
1007 |         "available": "No Data Found"
1008 |     },
1009 |     {
1010 |         "extensions": ".cricket",
1011 |         "uri": "socket:\/\/whois.nic.cricket",
1012 |         "available": "No Data Found"
1013 |     },
1014 |     {
1015 |         "extensions": ".cymru",
1016 |         "uri": "socket:\/\/whois.nic.cymru",
1017 |         "available": "This domain name has not been registered"
1018 |     },
1019 |     {
1020 |         "extensions": ".date",
1021 |         "uri": "socket:\/\/whois.nic.date",
1022 |         "available": "No Data Found"
1023 |     },
1024 |     {
1025 |         "extensions": ".design",
1026 |         "uri": "socket:\/\/whois.nic.design",
1027 |         "available": "No Data Found"
1028 |     },
1029 |     {
1030 |         "extensions": ".download",
1031 |         "uri": "socket:\/\/whois.nic.download",
1032 |         "available": "No Data Found"
1033 |     },
1034 |     {
1035 |         "extensions": ".earth",
1036 |         "uri": "socket:\/\/whois.nic.earth",
1037 |         "available": "No Data Found"
1038 |     },
1039 |     {
1040 |         "extensions": ".eus",
1041 |         "uri": "socket:\/\/whois.nic.eus",
1042 |         "available": "no matching objects found"
1043 |     },
1044 |     {
1045 |         "extensions": ".faith",
1046 |         "uri": "socket:\/\/whois.nic.faith",
1047 |         "available": "No Data Found"
1048 |     },
1049 |     {
1050 |         "extensions": ".fans",
1051 |         "uri": "socket:\/\/whois.nic.fans",
1052 |         "available": "DOMAIN NOT FOUND"
1053 |     },
1054 |     {
1055 |         "extensions": ".film",
1056 |         "uri": "socket:\/\/whois.nic.film",
1057 |         "available": "No Data Found"
1058 |     },
1059 |     {
1060 |         "extensions": ".gal",
1061 |         "uri": "socket:\/\/whois.nic.gal",
1062 |         "available": "no matching objects found"
1063 |     },
1064 |     {
1065 |         "extensions": ".global",
1066 |         "uri": "socket:\/\/whois.nic.global",
1067 |         "available": "Domain not found"
1068 |     },
1069 |     {
1070 |         "extensions": ".host",
1071 |         "uri": "socket:\/\/whois.nic.host",
1072 |         "available": "DOMAIN NOT FOUND"
1073 |     },
1074 |     {
1075 |         "extensions": ".how,.soy",
1076 |         "uri": "socket:\/\/whois.nic.google",
1077 |         "available": "Domain not found"
1078 |     },
1079 |     {
1080 |         "extensions": ".loan",
1081 |         "uri": "socket:\/\/whois.nic.loan",
1082 |         "available": "No Data Found"
1083 |     },
1084 |     {
1085 |         "extensions": ".london",
1086 |         "uri": "socket:\/\/whois.nic.london",
1087 |         "available": "DOMAIN NOT FOUND"
1088 |     },
1089 |     {
1090 |         "extensions": ".love",
1091 |         "uri": "socket:\/\/whois.nic.love",
1092 |         "available": "available for registration"
1093 |     },
1094 |     {
1095 |         "extensions": ".men",
1096 |         "uri": "socket:\/\/whois.nic.men",
1097 |         "available": "No Data Found"
1098 |     },
1099 |     {
1100 |         "extensions": ".moe",
1101 |         "uri": "socket:\/\/whois.nic.moe",
1102 |         "available": "No Data Found"
1103 |     },
1104 |     {
1105 |         "extensions": ".one",
1106 |         "uri": "socket:\/\/whois.nic.one",
1107 |         "available": "No Data Found"
1108 |     },
1109 |     {
1110 |         "extensions": ".osaka",
1111 |         "uri": "socket:\/\/whois.nic.osaka",
1112 |         "available": "No Data Found"
1113 |     },
1114 |     {
1115 |         "extensions": ".paris",
1116 |         "uri": "socket:\/\/whois.nic.paris",
1117 |         "available": "NOT FOUND"
1118 |     },
1119 |     {
1120 |         "extensions": ".party",
1121 |         "uri": "socket:\/\/whois.nic.party",
1122 |         "available": "No Data Found"
1123 |     },
1124 |     {
1125 |         "extensions": ".press",
1126 |         "uri": "socket:\/\/whois.nic.press",
1127 |         "available": "DOMAIN NOT FOUND"
1128 |     },
1129 |     {
1130 |         "extensions": ".quebec",
1131 |         "uri": "socket:\/\/whois.nic.quebec",
1132 |         "available": "no matching objects found"
1133 |     },
1134 |     {
1135 |         "extensions": ".racing",
1136 |         "uri": "socket:\/\/whois.nic.racing",
1137 |         "available": "No Data Found"
1138 |     },
1139 |     {
1140 |         "extensions": ".reise",
1141 |         "uri": "socket:\/\/whois.nic.reise",
1142 |         "available": "Domain not found"
1143 |     },
1144 |     {
1145 |         "extensions": ".rent",
1146 |         "uri": "socket:\/\/whois.nic.rent",
1147 |         "available": "DOMAIN NOT FOUND"
1148 |     },
1149 |     {
1150 |         "extensions": ".rest",
1151 |         "uri": "socket:\/\/whois.nic.rest",
1152 |         "available": "DOMAIN NOT FOUND"
1153 |     },
1154 |     {
1155 |         "extensions": ".review",
1156 |         "uri": "socket:\/\/whois.nic.review",
1157 |         "available": "No Data Found"
1158 |     },
1159 |     {
1160 |         "extensions": ".science",
1161 |         "uri": "socket:\/\/whois.nic.science",
1162 |         "available": "No Data Found"
1163 |     },
1164 |     {
1165 |         "extensions": ".space",
1166 |         "uri": "socket:\/\/whois.nic.space",
1167 |         "available": "DOMAIN NOT FOUND"
1168 |     },
1169 |     {
1170 |         "extensions": ".study",
1171 |         "uri": "socket:\/\/whois.nic.study",
1172 |         "available": "No Data Found"
1173 |     },
1174 |     {
1175 |         "extensions": ".sucks",
1176 |         "uri": "socket:\/\/whois.nic.sucks",
1177 |         "available": "No Data Found"
1178 |     },
1179 |     {
1180 |         "extensions": ".sydney",
1181 |         "uri": "socket:\/\/whois.nic.sydney",
1182 |         "available": "No Data Found"
1183 |     },
1184 |     {
1185 |         "extensions": ".tech",
1186 |         "uri": "socket:\/\/whois.nic.tech",
1187 |         "available": "DOMAIN NOT FOUND"
1188 |     },
1189 |     {
1190 |         "extensions": ".trade",
1191 |         "uri": "socket:\/\/whois.nic.trade",
1192 |         "available": "No Data Found"
1193 |     },
1194 |     {
1195 |         "extensions": ".voting",
1196 |         "uri": "socket:\/\/whois.nic.voting",
1197 |         "available": "No Data Found"
1198 |     },
1199 |     {
1200 |         "extensions": ".wales",
1201 |         "uri": "socket:\/\/whois.nic.wales",
1202 |         "available": "This domain name has not been registered"
1203 |     },
1204 |     {
1205 |         "extensions": ".webcam",
1206 |         "uri": "socket:\/\/whois.nic.webcam",
1207 |         "available": "No Data Found"
1208 |     },
1209 |     {
1210 |         "extensions": ".website",
1211 |         "uri": "socket:\/\/whois.nic.website",
1212 |         "available": "DOMAIN NOT FOUND"
1213 |     },
1214 |     {
1215 |         "extensions": ".win",
1216 |         "uri": "socket:\/\/whois.nic.win",
1217 |         "available": "No Data Found"
1218 |     },
1219 |     {
1220 |         "extensions": ".xyz",
1221 |         "uri": "socket:\/\/whois.nic.xyz",
1222 |         "available": "DOMAIN NOT FOUND"
1223 |     },
1224 |     {
1225 |         "extensions": ".ru.com",
1226 |         "uri": "socket:\/\/whois.verisign-grs.com",
1227 |         "available": "No match for"
1228 |     },
1229 |     {
1230 |         "extensions": ".swiss",
1231 |         "uri": "socket:\/\/whois.nic.swiss",
1232 |         "available": "The queried object does not exist: no matching objects found"
1233 |     },
1234 |     {
1235 |         "extensions": ".mk,.com.mk,.org.mk,.net.mk,.inf.mk,.edu.mk",
1236 |         "uri": "socket:\/\/whois.marnet.mk",
1237 |         "available": "No entries found"
1238 |     },
1239 |     {
1240 |         "extensions": ".cloud",
1241 |         "uri": "socket:\/\/whois.nic.cloud",
1242 |         "available": "No Data Found"
1243 |     },
1244 |     {
1245 |         "extensions": ".ma,.net.ma,.org.ma,.co.ma,.gov.ma,.press.ma,.ac.ma",
1246 |         "uri": "socket:\/\/whois.registre.ma",
1247 |         "available": "No Object Found"
1248 |     },
1249 |     {
1250 |         "extensions": ".mg,.com.mg,.org.mg,.co.mg",
1251 |         "uri": "socket:\/\/whois.nic.mg",
1252 |         "available": "No Object Found"
1253 |     },
1254 |     {
1255 |         "extensions": ".qa",
1256 |         "uri": "socket:\/\/whois.registry.qa",
1257 |         "available": "No Data Found"
1258 |     },
1259 |     {
1260 |         "extensions": ".africa.com",
1261 |         "uri": "socket:\/\/srs-whois.dns.net.za",
1262 |         "available": "No information was found matching that query."
1263 |     },
1264 |     {
1265 |         "extensions": ".ltd",
1266 |         "uri": "socket:\/\/whois.donuts.co",
1267 |         "available": "Domain not found"
1268 |     },
1269 |     {
1270 |         "extensions": ".id,.co.id,.desa.id,.web.id,.ac.id,.or.id,.sch.id,.my.id,.biz.id",
1271 |         "uri": "socket:\/\/whois.pandi.or.id",
1272 |         "available": "DOMAIN NOT FOUND"
1273 |     },
1274 |     {
1275 |         "extensions": ".sa,.com.sa,.net.sa,.med.sa,.sch.sa,.org.sa,.edu.sa,.gov.sa,.pub.sa",
1276 |         "uri": "socket:\/\/whois.nic.net.sa",
1277 |         "available": "No Match for"
1278 |     },
1279 |     {
1280 |         "extensions": ".lat",
1281 |         "uri": "socket:\/\/whois.nic.lat",
1282 |         "available": "The queried object does not exist"
1283 |     },
1284 |     {
1285 |         "extensions": ".hospital",
1286 |         "uri": "socket:\/\/whois.nic.hospital",
1287 |         "available": "Domain not found"
1288 |     },
1289 |     {
1290 |         "extensions": ".cam",
1291 |         "uri": "socket:\/\/whois.nic.cam",
1292 |         "available": "The queried object does not exist"
1293 |     },
1294 |     {
1295 |         "extensions": ".eco",
1296 |         "uri": "socket:\/\/whois.nic.eco",
1297 |         "available": "Not found"
1298 |     },
1299 |     {
1300 |         "extensions": ".health",
1301 |         "uri": "socket:\/\/whois.nic.health",
1302 |         "available": "No Data Found"
1303 |     },
1304 |     {
1305 |         "extensions": ".icu",
1306 |         "uri": "socket:\/\/whois.nic.icu",
1307 |         "available": "DOMAIN NOT FOUND"
1308 |     },
1309 |     {
1310 |         "extensions": ".fun",
1311 |         "uri": "socket:\/\/whois.nic.fun",
1312 |         "available": "DOMAIN NOT FOUND"
1313 |     },
1314 |     {
1315 |         "extensions": ".art",
1316 |         "uri": "socket:\/\/whois.nic.art",
1317 |         "available": "DOMAIN NOT FOUND"
1318 |     },
1319 |     {
1320 |         "extensions": ".doctor",
1321 |         "uri": "socket:\/\/whois.nic.doctor",
1322 |         "available": "Domain not found"
1323 |     },
1324 |     {
1325 |         "extensions": ".mom",
1326 |         "uri": "socket:\/\/whois.uniregistry.net",
1327 |         "available": "is available for registration"
1328 |     },
1329 |     {
1330 |         "extensions": ".store",
1331 |         "uri": "socket:\/\/whois.nic.store",
1332 |         "available": "DOMAIN NOT FOUND"
1333 |     },
1334 |     {
1335 |         "extensions": ".vip",
1336 |         "uri": "socket:\/\/whois.nic.vip",
1337 |         "available": "No Data Found"
1338 |     },
1339 |     {
1340 |         "extensions": ".gdn",
1341 |         "uri": "socket:\/\/whois.nic.gdn",
1342 |         "available": "Domain Not Found"
1343 |     },
1344 |     {
1345 |         "extensions": ".tube",
1346 |         "uri": "socket:\/\/whois.nic.tube",
1347 |         "available": "No Data Found"
1348 |     },
1349 |     {
1350 |         "extensions": ".stream",
1351 |         "uri": "socket:\/\/whois.nic.stream",
1352 |         "available": "No Data Found"
1353 |     },
1354 |     {
1355 |         "extensions": ".miami",
1356 |         "uri": "socket:\/\/whois.nic.miami",
1357 |         "available": "No Data Found"
1358 |     },
1359 |     {
1360 |         "extensions": ".jetzt",
1361 |         "uri": "socket:\/\/whois.nic.jetzt",
1362 |         "available": "Domain not found."
1363 |     },
1364 |     {
1365 |         "extensions": ".shopping",
1366 |         "uri": "socket:\/\/whois.nic.shopping",
1367 |         "available": "Domain not found."
1368 |     },
1369 |     {
1370 |         "extensions": ".shop",
1371 |         "uri": "socket:\/\/whois.nic.shop",
1372 |         "available": "DOMAIN NOT FOUND"
1373 |     },
1374 |     {
1375 |         "extensions": ".games",
1376 |         "uri": "socket:\/\/whois.nic.games",
1377 |         "available": "Domain not found."
1378 |     },
1379 |     {
1380 |         "extensions": ".blog",
1381 |         "uri": "socket:\/\/whois.nic.blog",
1382 |         "available": "DOMAIN NOT FOUND"
1383 |     },
1384 |     {
1385 |         "extensions": ".security",
1386 |         "uri": "socket:\/\/whois.nic.security",
1387 |         "available": "DOMAIN NOT FOUND"
1388 |     },
1389 |     {
1390 |         "extensions": ".protection",
1391 |         "uri": "socket:\/\/whois.nic.protection",
1392 |         "available": "DOMAIN NOT FOUND"
1393 |     },
1394 |     {
1395 |         "extensions": ".feedback",
1396 |         "uri": "socket:\/\/whois.nic.feedback",
1397 |         "available": "DOMAIN NOT FOUND"
1398 |     },
1399 |     {
1400 |         "extensions": ".theatre",
1401 |         "uri": "socket:\/\/whois.nic.theatre",
1402 |         "available": "DOMAIN NOT FOUND"
1403 |     },
1404 |     {
1405 |         "extensions": ".game",
1406 |         "uri": "socket:\/\/whois.uniregistry.net",
1407 |         "available": "is available for registration"
1408 |     },
1409 |     {
1410 |         "extensions": ".ar,.com.ar,.org.ar,.gob.ar,.gov.ar,.tur.ar,.net.ar,.mil.ar,.musica.ar",
1411 |         "uri": "socket:\/\/whois.nic.ar",
1412 |         "available": "El dominio no se encuentra registrado en NIC Argentina"
1413 |     },
1414 |     {
1415 |         "extensions": ".dev",
1416 |         "uri": "socket:\/\/whois.nic.google",
1417 |         "available": "Domain not found"
1418 |     },
1419 |     {
1420 |         "extensions": ".nyc",
1421 |         "uri": "socket:\/\/whois.nic.nyc",
1422 |         "available": "No Data Found"
1423 |     },
1424 |     {
1425 |         "extensions": ".it.com",
1426 |         "uri": "socket:\/\/whois.it.com",
1427 |         "available": "No match for"
1428 |     }
1429 | ]
1430 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
   1 | {
   2 |     "_readme": [
   3 |         "This file locks the dependencies of your project to a known state",
   4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
   5 |         "This file is @generated automatically"
   6 |     ],
   7 |     "content-hash": "8cfe6e3d7e060da2e9a339db6cd8499e",
   8 |     "packages": [],
   9 |     "packages-dev": [
  10 |         {
  11 |             "name": "doctrine/instantiator",
  12 |             "version": "1.5.0",
  13 |             "source": {
  14 |                 "type": "git",
  15 |                 "url": "https://github.com/doctrine/instantiator.git",
  16 |                 "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b"
  17 |             },
  18 |             "dist": {
  19 |                 "type": "zip",
  20 |                 "url": "https://api.github.com/repos/doctrine/instantiator/zipball/0a0fa9780f5d4e507415a065172d26a98d02047b",
  21 |                 "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b",
  22 |                 "shasum": ""
  23 |             },
  24 |             "require": {
  25 |                 "php": "^7.1 || ^8.0"
  26 |             },
  27 |             "require-dev": {
  28 |                 "doctrine/coding-standard": "^9 || ^11",
  29 |                 "ext-pdo": "*",
  30 |                 "ext-phar": "*",
  31 |                 "phpbench/phpbench": "^0.16 || ^1",
  32 |                 "phpstan/phpstan": "^1.4",
  33 |                 "phpstan/phpstan-phpunit": "^1",
  34 |                 "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5",
  35 |                 "vimeo/psalm": "^4.30 || ^5.4"
  36 |             },
  37 |             "type": "library",
  38 |             "autoload": {
  39 |                 "psr-4": {
  40 |                     "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
  41 |                 }
  42 |             },
  43 |             "notification-url": "https://packagist.org/downloads/",
  44 |             "license": [
  45 |                 "MIT"
  46 |             ],
  47 |             "authors": [
  48 |                 {
  49 |                     "name": "Marco Pivetta",
  50 |                     "email": "ocramius@gmail.com",
  51 |                     "homepage": "https://ocramius.github.io/"
  52 |                 }
  53 |             ],
  54 |             "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
  55 |             "homepage": "https://www.doctrine-project.org/projects/instantiator.html",
  56 |             "keywords": [
  57 |                 "constructor",
  58 |                 "instantiate"
  59 |             ],
  60 |             "support": {
  61 |                 "issues": "https://github.com/doctrine/instantiator/issues",
  62 |                 "source": "https://github.com/doctrine/instantiator/tree/1.5.0"
  63 |             },
  64 |             "funding": [
  65 |                 {
  66 |                     "url": "https://www.doctrine-project.org/sponsorship.html",
  67 |                     "type": "custom"
  68 |                 },
  69 |                 {
  70 |                     "url": "https://www.patreon.com/phpdoctrine",
  71 |                     "type": "patreon"
  72 |                 },
  73 |                 {
  74 |                     "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator",
  75 |                     "type": "tidelift"
  76 |                 }
  77 |             ],
  78 |             "time": "2022-12-30T00:15:36+00:00"
  79 |         },
  80 |         {
  81 |             "name": "myclabs/deep-copy",
  82 |             "version": "1.11.0",
  83 |             "source": {
  84 |                 "type": "git",
  85 |                 "url": "https://github.com/myclabs/DeepCopy.git",
  86 |                 "reference": "14daed4296fae74d9e3201d2c4925d1acb7aa614"
  87 |             },
  88 |             "dist": {
  89 |                 "type": "zip",
  90 |                 "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/14daed4296fae74d9e3201d2c4925d1acb7aa614",
  91 |                 "reference": "14daed4296fae74d9e3201d2c4925d1acb7aa614",
  92 |                 "shasum": ""
  93 |             },
  94 |             "require": {
  95 |                 "php": "^7.1 || ^8.0"
  96 |             },
  97 |             "conflict": {
  98 |                 "doctrine/collections": "<1.6.8",
  99 |                 "doctrine/common": "<2.13.3 || >=3,<3.2.2"
 100 |             },
 101 |             "require-dev": {
 102 |                 "doctrine/collections": "^1.6.8",
 103 |                 "doctrine/common": "^2.13.3 || ^3.2.2",
 104 |                 "phpunit/phpunit": "^7.5.20 || ^8.5.23 || ^9.5.13"
 105 |             },
 106 |             "type": "library",
 107 |             "autoload": {
 108 |                 "files": [
 109 |                     "src/DeepCopy/deep_copy.php"
 110 |                 ],
 111 |                 "psr-4": {
 112 |                     "DeepCopy\\": "src/DeepCopy/"
 113 |                 }
 114 |             },
 115 |             "notification-url": "https://packagist.org/downloads/",
 116 |             "license": [
 117 |                 "MIT"
 118 |             ],
 119 |             "description": "Create deep copies (clones) of your objects",
 120 |             "keywords": [
 121 |                 "clone",
 122 |                 "copy",
 123 |                 "duplicate",
 124 |                 "object",
 125 |                 "object graph"
 126 |             ],
 127 |             "support": {
 128 |                 "issues": "https://github.com/myclabs/DeepCopy/issues",
 129 |                 "source": "https://github.com/myclabs/DeepCopy/tree/1.11.0"
 130 |             },
 131 |             "funding": [
 132 |                 {
 133 |                     "url": "https://tidelift.com/funding/github/packagist/myclabs/deep-copy",
 134 |                     "type": "tidelift"
 135 |                 }
 136 |             ],
 137 |             "time": "2022-03-03T13:19:32+00:00"
 138 |         },
 139 |         {
 140 |             "name": "nikic/php-parser",
 141 |             "version": "v4.15.3",
 142 |             "source": {
 143 |                 "type": "git",
 144 |                 "url": "https://github.com/nikic/PHP-Parser.git",
 145 |                 "reference": "570e980a201d8ed0236b0a62ddf2c9cbb2034039"
 146 |             },
 147 |             "dist": {
 148 |                 "type": "zip",
 149 |                 "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/570e980a201d8ed0236b0a62ddf2c9cbb2034039",
 150 |                 "reference": "570e980a201d8ed0236b0a62ddf2c9cbb2034039",
 151 |                 "shasum": ""
 152 |             },
 153 |             "require": {
 154 |                 "ext-tokenizer": "*",
 155 |                 "php": ">=7.0"
 156 |             },
 157 |             "require-dev": {
 158 |                 "ircmaxell/php-yacc": "^0.0.7",
 159 |                 "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0"
 160 |             },
 161 |             "bin": [
 162 |                 "bin/php-parse"
 163 |             ],
 164 |             "type": "library",
 165 |             "extra": {
 166 |                 "branch-alias": {
 167 |                     "dev-master": "4.9-dev"
 168 |                 }
 169 |             },
 170 |             "autoload": {
 171 |                 "psr-4": {
 172 |                     "PhpParser\\": "lib/PhpParser"
 173 |                 }
 174 |             },
 175 |             "notification-url": "https://packagist.org/downloads/",
 176 |             "license": [
 177 |                 "BSD-3-Clause"
 178 |             ],
 179 |             "authors": [
 180 |                 {
 181 |                     "name": "Nikita Popov"
 182 |                 }
 183 |             ],
 184 |             "description": "A PHP parser written in PHP",
 185 |             "keywords": [
 186 |                 "parser",
 187 |                 "php"
 188 |             ],
 189 |             "support": {
 190 |                 "issues": "https://github.com/nikic/PHP-Parser/issues",
 191 |                 "source": "https://github.com/nikic/PHP-Parser/tree/v4.15.3"
 192 |             },
 193 |             "time": "2023-01-16T22:05:37+00:00"
 194 |         },
 195 |         {
 196 |             "name": "phar-io/manifest",
 197 |             "version": "2.0.3",
 198 |             "source": {
 199 |                 "type": "git",
 200 |                 "url": "https://github.com/phar-io/manifest.git",
 201 |                 "reference": "97803eca37d319dfa7826cc2437fc020857acb53"
 202 |             },
 203 |             "dist": {
 204 |                 "type": "zip",
 205 |                 "url": "https://api.github.com/repos/phar-io/manifest/zipball/97803eca37d319dfa7826cc2437fc020857acb53",
 206 |                 "reference": "97803eca37d319dfa7826cc2437fc020857acb53",
 207 |                 "shasum": ""
 208 |             },
 209 |             "require": {
 210 |                 "ext-dom": "*",
 211 |                 "ext-phar": "*",
 212 |                 "ext-xmlwriter": "*",
 213 |                 "phar-io/version": "^3.0.1",
 214 |                 "php": "^7.2 || ^8.0"
 215 |             },
 216 |             "type": "library",
 217 |             "extra": {
 218 |                 "branch-alias": {
 219 |                     "dev-master": "2.0.x-dev"
 220 |                 }
 221 |             },
 222 |             "autoload": {
 223 |                 "classmap": [
 224 |                     "src/"
 225 |                 ]
 226 |             },
 227 |             "notification-url": "https://packagist.org/downloads/",
 228 |             "license": [
 229 |                 "BSD-3-Clause"
 230 |             ],
 231 |             "authors": [
 232 |                 {
 233 |                     "name": "Arne Blankerts",
 234 |                     "email": "arne@blankerts.de",
 235 |                     "role": "Developer"
 236 |                 },
 237 |                 {
 238 |                     "name": "Sebastian Heuer",
 239 |                     "email": "sebastian@phpeople.de",
 240 |                     "role": "Developer"
 241 |                 },
 242 |                 {
 243 |                     "name": "Sebastian Bergmann",
 244 |                     "email": "sebastian@phpunit.de",
 245 |                     "role": "Developer"
 246 |                 }
 247 |             ],
 248 |             "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
 249 |             "support": {
 250 |                 "issues": "https://github.com/phar-io/manifest/issues",
 251 |                 "source": "https://github.com/phar-io/manifest/tree/2.0.3"
 252 |             },
 253 |             "time": "2021-07-20T11:28:43+00:00"
 254 |         },
 255 |         {
 256 |             "name": "phar-io/version",
 257 |             "version": "3.2.1",
 258 |             "source": {
 259 |                 "type": "git",
 260 |                 "url": "https://github.com/phar-io/version.git",
 261 |                 "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74"
 262 |             },
 263 |             "dist": {
 264 |                 "type": "zip",
 265 |                 "url": "https://api.github.com/repos/phar-io/version/zipball/4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
 266 |                 "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74",
 267 |                 "shasum": ""
 268 |             },
 269 |             "require": {
 270 |                 "php": "^7.2 || ^8.0"
 271 |             },
 272 |             "type": "library",
 273 |             "autoload": {
 274 |                 "classmap": [
 275 |                     "src/"
 276 |                 ]
 277 |             },
 278 |             "notification-url": "https://packagist.org/downloads/",
 279 |             "license": [
 280 |                 "BSD-3-Clause"
 281 |             ],
 282 |             "authors": [
 283 |                 {
 284 |                     "name": "Arne Blankerts",
 285 |                     "email": "arne@blankerts.de",
 286 |                     "role": "Developer"
 287 |                 },
 288 |                 {
 289 |                     "name": "Sebastian Heuer",
 290 |                     "email": "sebastian@phpeople.de",
 291 |                     "role": "Developer"
 292 |                 },
 293 |                 {
 294 |                     "name": "Sebastian Bergmann",
 295 |                     "email": "sebastian@phpunit.de",
 296 |                     "role": "Developer"
 297 |                 }
 298 |             ],
 299 |             "description": "Library for handling version information and constraints",
 300 |             "support": {
 301 |                 "issues": "https://github.com/phar-io/version/issues",
 302 |                 "source": "https://github.com/phar-io/version/tree/3.2.1"
 303 |             },
 304 |             "time": "2022-02-21T01:04:05+00:00"
 305 |         },
 306 |         {
 307 |             "name": "phpunit/php-code-coverage",
 308 |             "version": "9.2.24",
 309 |             "source": {
 310 |                 "type": "git",
 311 |                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
 312 |                 "reference": "2cf940ebc6355a9d430462811b5aaa308b174bed"
 313 |             },
 314 |             "dist": {
 315 |                 "type": "zip",
 316 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/2cf940ebc6355a9d430462811b5aaa308b174bed",
 317 |                 "reference": "2cf940ebc6355a9d430462811b5aaa308b174bed",
 318 |                 "shasum": ""
 319 |             },
 320 |             "require": {
 321 |                 "ext-dom": "*",
 322 |                 "ext-libxml": "*",
 323 |                 "ext-xmlwriter": "*",
 324 |                 "nikic/php-parser": "^4.14",
 325 |                 "php": ">=7.3",
 326 |                 "phpunit/php-file-iterator": "^3.0.3",
 327 |                 "phpunit/php-text-template": "^2.0.2",
 328 |                 "sebastian/code-unit-reverse-lookup": "^2.0.2",
 329 |                 "sebastian/complexity": "^2.0",
 330 |                 "sebastian/environment": "^5.1.2",
 331 |                 "sebastian/lines-of-code": "^1.0.3",
 332 |                 "sebastian/version": "^3.0.1",
 333 |                 "theseer/tokenizer": "^1.2.0"
 334 |             },
 335 |             "require-dev": {
 336 |                 "phpunit/phpunit": "^9.3"
 337 |             },
 338 |             "suggest": {
 339 |                 "ext-pcov": "*",
 340 |                 "ext-xdebug": "*"
 341 |             },
 342 |             "type": "library",
 343 |             "extra": {
 344 |                 "branch-alias": {
 345 |                     "dev-master": "9.2-dev"
 346 |                 }
 347 |             },
 348 |             "autoload": {
 349 |                 "classmap": [
 350 |                     "src/"
 351 |                 ]
 352 |             },
 353 |             "notification-url": "https://packagist.org/downloads/",
 354 |             "license": [
 355 |                 "BSD-3-Clause"
 356 |             ],
 357 |             "authors": [
 358 |                 {
 359 |                     "name": "Sebastian Bergmann",
 360 |                     "email": "sebastian@phpunit.de",
 361 |                     "role": "lead"
 362 |                 }
 363 |             ],
 364 |             "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
 365 |             "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
 366 |             "keywords": [
 367 |                 "coverage",
 368 |                 "testing",
 369 |                 "xunit"
 370 |             ],
 371 |             "support": {
 372 |                 "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues",
 373 |                 "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/9.2.24"
 374 |             },
 375 |             "funding": [
 376 |                 {
 377 |                     "url": "https://github.com/sebastianbergmann",
 378 |                     "type": "github"
 379 |                 }
 380 |             ],
 381 |             "time": "2023-01-26T08:26:55+00:00"
 382 |         },
 383 |         {
 384 |             "name": "phpunit/php-file-iterator",
 385 |             "version": "3.0.6",
 386 |             "source": {
 387 |                 "type": "git",
 388 |                 "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
 389 |                 "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf"
 390 |             },
 391 |             "dist": {
 392 |                 "type": "zip",
 393 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
 394 |                 "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf",
 395 |                 "shasum": ""
 396 |             },
 397 |             "require": {
 398 |                 "php": ">=7.3"
 399 |             },
 400 |             "require-dev": {
 401 |                 "phpunit/phpunit": "^9.3"
 402 |             },
 403 |             "type": "library",
 404 |             "extra": {
 405 |                 "branch-alias": {
 406 |                     "dev-master": "3.0-dev"
 407 |                 }
 408 |             },
 409 |             "autoload": {
 410 |                 "classmap": [
 411 |                     "src/"
 412 |                 ]
 413 |             },
 414 |             "notification-url": "https://packagist.org/downloads/",
 415 |             "license": [
 416 |                 "BSD-3-Clause"
 417 |             ],
 418 |             "authors": [
 419 |                 {
 420 |                     "name": "Sebastian Bergmann",
 421 |                     "email": "sebastian@phpunit.de",
 422 |                     "role": "lead"
 423 |                 }
 424 |             ],
 425 |             "description": "FilterIterator implementation that filters files based on a list of suffixes.",
 426 |             "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
 427 |             "keywords": [
 428 |                 "filesystem",
 429 |                 "iterator"
 430 |             ],
 431 |             "support": {
 432 |                 "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues",
 433 |                 "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/3.0.6"
 434 |             },
 435 |             "funding": [
 436 |                 {
 437 |                     "url": "https://github.com/sebastianbergmann",
 438 |                     "type": "github"
 439 |                 }
 440 |             ],
 441 |             "time": "2021-12-02T12:48:52+00:00"
 442 |         },
 443 |         {
 444 |             "name": "phpunit/php-invoker",
 445 |             "version": "3.1.1",
 446 |             "source": {
 447 |                 "type": "git",
 448 |                 "url": "https://github.com/sebastianbergmann/php-invoker.git",
 449 |                 "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67"
 450 |             },
 451 |             "dist": {
 452 |                 "type": "zip",
 453 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
 454 |                 "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67",
 455 |                 "shasum": ""
 456 |             },
 457 |             "require": {
 458 |                 "php": ">=7.3"
 459 |             },
 460 |             "require-dev": {
 461 |                 "ext-pcntl": "*",
 462 |                 "phpunit/phpunit": "^9.3"
 463 |             },
 464 |             "suggest": {
 465 |                 "ext-pcntl": "*"
 466 |             },
 467 |             "type": "library",
 468 |             "extra": {
 469 |                 "branch-alias": {
 470 |                     "dev-master": "3.1-dev"
 471 |                 }
 472 |             },
 473 |             "autoload": {
 474 |                 "classmap": [
 475 |                     "src/"
 476 |                 ]
 477 |             },
 478 |             "notification-url": "https://packagist.org/downloads/",
 479 |             "license": [
 480 |                 "BSD-3-Clause"
 481 |             ],
 482 |             "authors": [
 483 |                 {
 484 |                     "name": "Sebastian Bergmann",
 485 |                     "email": "sebastian@phpunit.de",
 486 |                     "role": "lead"
 487 |                 }
 488 |             ],
 489 |             "description": "Invoke callables with a timeout",
 490 |             "homepage": "https://github.com/sebastianbergmann/php-invoker/",
 491 |             "keywords": [
 492 |                 "process"
 493 |             ],
 494 |             "support": {
 495 |                 "issues": "https://github.com/sebastianbergmann/php-invoker/issues",
 496 |                 "source": "https://github.com/sebastianbergmann/php-invoker/tree/3.1.1"
 497 |             },
 498 |             "funding": [
 499 |                 {
 500 |                     "url": "https://github.com/sebastianbergmann",
 501 |                     "type": "github"
 502 |                 }
 503 |             ],
 504 |             "time": "2020-09-28T05:58:55+00:00"
 505 |         },
 506 |         {
 507 |             "name": "phpunit/php-text-template",
 508 |             "version": "2.0.4",
 509 |             "source": {
 510 |                 "type": "git",
 511 |                 "url": "https://github.com/sebastianbergmann/php-text-template.git",
 512 |                 "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28"
 513 |             },
 514 |             "dist": {
 515 |                 "type": "zip",
 516 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
 517 |                 "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28",
 518 |                 "shasum": ""
 519 |             },
 520 |             "require": {
 521 |                 "php": ">=7.3"
 522 |             },
 523 |             "require-dev": {
 524 |                 "phpunit/phpunit": "^9.3"
 525 |             },
 526 |             "type": "library",
 527 |             "extra": {
 528 |                 "branch-alias": {
 529 |                     "dev-master": "2.0-dev"
 530 |                 }
 531 |             },
 532 |             "autoload": {
 533 |                 "classmap": [
 534 |                     "src/"
 535 |                 ]
 536 |             },
 537 |             "notification-url": "https://packagist.org/downloads/",
 538 |             "license": [
 539 |                 "BSD-3-Clause"
 540 |             ],
 541 |             "authors": [
 542 |                 {
 543 |                     "name": "Sebastian Bergmann",
 544 |                     "email": "sebastian@phpunit.de",
 545 |                     "role": "lead"
 546 |                 }
 547 |             ],
 548 |             "description": "Simple template engine.",
 549 |             "homepage": "https://github.com/sebastianbergmann/php-text-template/",
 550 |             "keywords": [
 551 |                 "template"
 552 |             ],
 553 |             "support": {
 554 |                 "issues": "https://github.com/sebastianbergmann/php-text-template/issues",
 555 |                 "source": "https://github.com/sebastianbergmann/php-text-template/tree/2.0.4"
 556 |             },
 557 |             "funding": [
 558 |                 {
 559 |                     "url": "https://github.com/sebastianbergmann",
 560 |                     "type": "github"
 561 |                 }
 562 |             ],
 563 |             "time": "2020-10-26T05:33:50+00:00"
 564 |         },
 565 |         {
 566 |             "name": "phpunit/php-timer",
 567 |             "version": "5.0.3",
 568 |             "source": {
 569 |                 "type": "git",
 570 |                 "url": "https://github.com/sebastianbergmann/php-timer.git",
 571 |                 "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2"
 572 |             },
 573 |             "dist": {
 574 |                 "type": "zip",
 575 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
 576 |                 "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2",
 577 |                 "shasum": ""
 578 |             },
 579 |             "require": {
 580 |                 "php": ">=7.3"
 581 |             },
 582 |             "require-dev": {
 583 |                 "phpunit/phpunit": "^9.3"
 584 |             },
 585 |             "type": "library",
 586 |             "extra": {
 587 |                 "branch-alias": {
 588 |                     "dev-master": "5.0-dev"
 589 |                 }
 590 |             },
 591 |             "autoload": {
 592 |                 "classmap": [
 593 |                     "src/"
 594 |                 ]
 595 |             },
 596 |             "notification-url": "https://packagist.org/downloads/",
 597 |             "license": [
 598 |                 "BSD-3-Clause"
 599 |             ],
 600 |             "authors": [
 601 |                 {
 602 |                     "name": "Sebastian Bergmann",
 603 |                     "email": "sebastian@phpunit.de",
 604 |                     "role": "lead"
 605 |                 }
 606 |             ],
 607 |             "description": "Utility class for timing",
 608 |             "homepage": "https://github.com/sebastianbergmann/php-timer/",
 609 |             "keywords": [
 610 |                 "timer"
 611 |             ],
 612 |             "support": {
 613 |                 "issues": "https://github.com/sebastianbergmann/php-timer/issues",
 614 |                 "source": "https://github.com/sebastianbergmann/php-timer/tree/5.0.3"
 615 |             },
 616 |             "funding": [
 617 |                 {
 618 |                     "url": "https://github.com/sebastianbergmann",
 619 |                     "type": "github"
 620 |                 }
 621 |             ],
 622 |             "time": "2020-10-26T13:16:10+00:00"
 623 |         },
 624 |         {
 625 |             "name": "phpunit/phpunit",
 626 |             "version": "9.6.3",
 627 |             "source": {
 628 |                 "type": "git",
 629 |                 "url": "https://github.com/sebastianbergmann/phpunit.git",
 630 |                 "reference": "e7b1615e3e887d6c719121c6d4a44b0ab9645555"
 631 |             },
 632 |             "dist": {
 633 |                 "type": "zip",
 634 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/e7b1615e3e887d6c719121c6d4a44b0ab9645555",
 635 |                 "reference": "e7b1615e3e887d6c719121c6d4a44b0ab9645555",
 636 |                 "shasum": ""
 637 |             },
 638 |             "require": {
 639 |                 "doctrine/instantiator": "^1.3.1 || ^2",
 640 |                 "ext-dom": "*",
 641 |                 "ext-json": "*",
 642 |                 "ext-libxml": "*",
 643 |                 "ext-mbstring": "*",
 644 |                 "ext-xml": "*",
 645 |                 "ext-xmlwriter": "*",
 646 |                 "myclabs/deep-copy": "^1.10.1",
 647 |                 "phar-io/manifest": "^2.0.3",
 648 |                 "phar-io/version": "^3.0.2",
 649 |                 "php": ">=7.3",
 650 |                 "phpunit/php-code-coverage": "^9.2.13",
 651 |                 "phpunit/php-file-iterator": "^3.0.5",
 652 |                 "phpunit/php-invoker": "^3.1.1",
 653 |                 "phpunit/php-text-template": "^2.0.3",
 654 |                 "phpunit/php-timer": "^5.0.2",
 655 |                 "sebastian/cli-parser": "^1.0.1",
 656 |                 "sebastian/code-unit": "^1.0.6",
 657 |                 "sebastian/comparator": "^4.0.8",
 658 |                 "sebastian/diff": "^4.0.3",
 659 |                 "sebastian/environment": "^5.1.3",
 660 |                 "sebastian/exporter": "^4.0.5",
 661 |                 "sebastian/global-state": "^5.0.1",
 662 |                 "sebastian/object-enumerator": "^4.0.3",
 663 |                 "sebastian/resource-operations": "^3.0.3",
 664 |                 "sebastian/type": "^3.2",
 665 |                 "sebastian/version": "^3.0.2"
 666 |             },
 667 |             "suggest": {
 668 |                 "ext-soap": "*",
 669 |                 "ext-xdebug": "*"
 670 |             },
 671 |             "bin": [
 672 |                 "phpunit"
 673 |             ],
 674 |             "type": "library",
 675 |             "extra": {
 676 |                 "branch-alias": {
 677 |                     "dev-master": "9.6-dev"
 678 |                 }
 679 |             },
 680 |             "autoload": {
 681 |                 "files": [
 682 |                     "src/Framework/Assert/Functions.php"
 683 |                 ],
 684 |                 "classmap": [
 685 |                     "src/"
 686 |                 ]
 687 |             },
 688 |             "notification-url": "https://packagist.org/downloads/",
 689 |             "license": [
 690 |                 "BSD-3-Clause"
 691 |             ],
 692 |             "authors": [
 693 |                 {
 694 |                     "name": "Sebastian Bergmann",
 695 |                     "email": "sebastian@phpunit.de",
 696 |                     "role": "lead"
 697 |                 }
 698 |             ],
 699 |             "description": "The PHP Unit Testing framework.",
 700 |             "homepage": "https://phpunit.de/",
 701 |             "keywords": [
 702 |                 "phpunit",
 703 |                 "testing",
 704 |                 "xunit"
 705 |             ],
 706 |             "support": {
 707 |                 "issues": "https://github.com/sebastianbergmann/phpunit/issues",
 708 |                 "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.3"
 709 |             },
 710 |             "funding": [
 711 |                 {
 712 |                     "url": "https://phpunit.de/sponsors.html",
 713 |                     "type": "custom"
 714 |                 },
 715 |                 {
 716 |                     "url": "https://github.com/sebastianbergmann",
 717 |                     "type": "github"
 718 |                 },
 719 |                 {
 720 |                     "url": "https://tidelift.com/funding/github/packagist/phpunit/phpunit",
 721 |                     "type": "tidelift"
 722 |                 }
 723 |             ],
 724 |             "time": "2023-02-04T13:37:15+00:00"
 725 |         },
 726 |         {
 727 |             "name": "sebastian/cli-parser",
 728 |             "version": "1.0.1",
 729 |             "source": {
 730 |                 "type": "git",
 731 |                 "url": "https://github.com/sebastianbergmann/cli-parser.git",
 732 |                 "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2"
 733 |             },
 734 |             "dist": {
 735 |                 "type": "zip",
 736 |                 "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/442e7c7e687e42adc03470c7b668bc4b2402c0b2",
 737 |                 "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2",
 738 |                 "shasum": ""
 739 |             },
 740 |             "require": {
 741 |                 "php": ">=7.3"
 742 |             },
 743 |             "require-dev": {
 744 |                 "phpunit/phpunit": "^9.3"
 745 |             },
 746 |             "type": "library",
 747 |             "extra": {
 748 |                 "branch-alias": {
 749 |                     "dev-master": "1.0-dev"
 750 |                 }
 751 |             },
 752 |             "autoload": {
 753 |                 "classmap": [
 754 |                     "src/"
 755 |                 ]
 756 |             },
 757 |             "notification-url": "https://packagist.org/downloads/",
 758 |             "license": [
 759 |                 "BSD-3-Clause"
 760 |             ],
 761 |             "authors": [
 762 |                 {
 763 |                     "name": "Sebastian Bergmann",
 764 |                     "email": "sebastian@phpunit.de",
 765 |                     "role": "lead"
 766 |                 }
 767 |             ],
 768 |             "description": "Library for parsing CLI options",
 769 |             "homepage": "https://github.com/sebastianbergmann/cli-parser",
 770 |             "support": {
 771 |                 "issues": "https://github.com/sebastianbergmann/cli-parser/issues",
 772 |                 "source": "https://github.com/sebastianbergmann/cli-parser/tree/1.0.1"
 773 |             },
 774 |             "funding": [
 775 |                 {
 776 |                     "url": "https://github.com/sebastianbergmann",
 777 |                     "type": "github"
 778 |                 }
 779 |             ],
 780 |             "time": "2020-09-28T06:08:49+00:00"
 781 |         },
 782 |         {
 783 |             "name": "sebastian/code-unit",
 784 |             "version": "1.0.8",
 785 |             "source": {
 786 |                 "type": "git",
 787 |                 "url": "https://github.com/sebastianbergmann/code-unit.git",
 788 |                 "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120"
 789 |             },
 790 |             "dist": {
 791 |                 "type": "zip",
 792 |                 "url": "https://api.github.com/repos/sebastianbergmann/code-unit/zipball/1fc9f64c0927627ef78ba436c9b17d967e68e120",
 793 |                 "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120",
 794 |                 "shasum": ""
 795 |             },
 796 |             "require": {
 797 |                 "php": ">=7.3"
 798 |             },
 799 |             "require-dev": {
 800 |                 "phpunit/phpunit": "^9.3"
 801 |             },
 802 |             "type": "library",
 803 |             "extra": {
 804 |                 "branch-alias": {
 805 |                     "dev-master": "1.0-dev"
 806 |                 }
 807 |             },
 808 |             "autoload": {
 809 |                 "classmap": [
 810 |                     "src/"
 811 |                 ]
 812 |             },
 813 |             "notification-url": "https://packagist.org/downloads/",
 814 |             "license": [
 815 |                 "BSD-3-Clause"
 816 |             ],
 817 |             "authors": [
 818 |                 {
 819 |                     "name": "Sebastian Bergmann",
 820 |                     "email": "sebastian@phpunit.de",
 821 |                     "role": "lead"
 822 |                 }
 823 |             ],
 824 |             "description": "Collection of value objects that represent the PHP code units",
 825 |             "homepage": "https://github.com/sebastianbergmann/code-unit",
 826 |             "support": {
 827 |                 "issues": "https://github.com/sebastianbergmann/code-unit/issues",
 828 |                 "source": "https://github.com/sebastianbergmann/code-unit/tree/1.0.8"
 829 |             },
 830 |             "funding": [
 831 |                 {
 832 |                     "url": "https://github.com/sebastianbergmann",
 833 |                     "type": "github"
 834 |                 }
 835 |             ],
 836 |             "time": "2020-10-26T13:08:54+00:00"
 837 |         },
 838 |         {
 839 |             "name": "sebastian/code-unit-reverse-lookup",
 840 |             "version": "2.0.3",
 841 |             "source": {
 842 |                 "type": "git",
 843 |                 "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
 844 |                 "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5"
 845 |             },
 846 |             "dist": {
 847 |                 "type": "zip",
 848 |                 "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
 849 |                 "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5",
 850 |                 "shasum": ""
 851 |             },
 852 |             "require": {
 853 |                 "php": ">=7.3"
 854 |             },
 855 |             "require-dev": {
 856 |                 "phpunit/phpunit": "^9.3"
 857 |             },
 858 |             "type": "library",
 859 |             "extra": {
 860 |                 "branch-alias": {
 861 |                     "dev-master": "2.0-dev"
 862 |                 }
 863 |             },
 864 |             "autoload": {
 865 |                 "classmap": [
 866 |                     "src/"
 867 |                 ]
 868 |             },
 869 |             "notification-url": "https://packagist.org/downloads/",
 870 |             "license": [
 871 |                 "BSD-3-Clause"
 872 |             ],
 873 |             "authors": [
 874 |                 {
 875 |                     "name": "Sebastian Bergmann",
 876 |                     "email": "sebastian@phpunit.de"
 877 |                 }
 878 |             ],
 879 |             "description": "Looks up which function or method a line of code belongs to",
 880 |             "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
 881 |             "support": {
 882 |                 "issues": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/issues",
 883 |                 "source": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/tree/2.0.3"
 884 |             },
 885 |             "funding": [
 886 |                 {
 887 |                     "url": "https://github.com/sebastianbergmann",
 888 |                     "type": "github"
 889 |                 }
 890 |             ],
 891 |             "time": "2020-09-28T05:30:19+00:00"
 892 |         },
 893 |         {
 894 |             "name": "sebastian/comparator",
 895 |             "version": "4.0.8",
 896 |             "source": {
 897 |                 "type": "git",
 898 |                 "url": "https://github.com/sebastianbergmann/comparator.git",
 899 |                 "reference": "fa0f136dd2334583309d32b62544682ee972b51a"
 900 |             },
 901 |             "dist": {
 902 |                 "type": "zip",
 903 |                 "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa0f136dd2334583309d32b62544682ee972b51a",
 904 |                 "reference": "fa0f136dd2334583309d32b62544682ee972b51a",
 905 |                 "shasum": ""
 906 |             },
 907 |             "require": {
 908 |                 "php": ">=7.3",
 909 |                 "sebastian/diff": "^4.0",
 910 |                 "sebastian/exporter": "^4.0"
 911 |             },
 912 |             "require-dev": {
 913 |                 "phpunit/phpunit": "^9.3"
 914 |             },
 915 |             "type": "library",
 916 |             "extra": {
 917 |                 "branch-alias": {
 918 |                     "dev-master": "4.0-dev"
 919 |                 }
 920 |             },
 921 |             "autoload": {
 922 |                 "classmap": [
 923 |                     "src/"
 924 |                 ]
 925 |             },
 926 |             "notification-url": "https://packagist.org/downloads/",
 927 |             "license": [
 928 |                 "BSD-3-Clause"
 929 |             ],
 930 |             "authors": [
 931 |                 {
 932 |                     "name": "Sebastian Bergmann",
 933 |                     "email": "sebastian@phpunit.de"
 934 |                 },
 935 |                 {
 936 |                     "name": "Jeff Welch",
 937 |                     "email": "whatthejeff@gmail.com"
 938 |                 },
 939 |                 {
 940 |                     "name": "Volker Dusch",
 941 |                     "email": "github@wallbash.com"
 942 |                 },
 943 |                 {
 944 |                     "name": "Bernhard Schussek",
 945 |                     "email": "bschussek@2bepublished.at"
 946 |                 }
 947 |             ],
 948 |             "description": "Provides the functionality to compare PHP values for equality",
 949 |             "homepage": "https://github.com/sebastianbergmann/comparator",
 950 |             "keywords": [
 951 |                 "comparator",
 952 |                 "compare",
 953 |                 "equality"
 954 |             ],
 955 |             "support": {
 956 |                 "issues": "https://github.com/sebastianbergmann/comparator/issues",
 957 |                 "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.8"
 958 |             },
 959 |             "funding": [
 960 |                 {
 961 |                     "url": "https://github.com/sebastianbergmann",
 962 |                     "type": "github"
 963 |                 }
 964 |             ],
 965 |             "time": "2022-09-14T12:41:17+00:00"
 966 |         },
 967 |         {
 968 |             "name": "sebastian/complexity",
 969 |             "version": "2.0.2",
 970 |             "source": {
 971 |                 "type": "git",
 972 |                 "url": "https://github.com/sebastianbergmann/complexity.git",
 973 |                 "reference": "739b35e53379900cc9ac327b2147867b8b6efd88"
 974 |             },
 975 |             "dist": {
 976 |                 "type": "zip",
 977 |                 "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/739b35e53379900cc9ac327b2147867b8b6efd88",
 978 |                 "reference": "739b35e53379900cc9ac327b2147867b8b6efd88",
 979 |                 "shasum": ""
 980 |             },
 981 |             "require": {
 982 |                 "nikic/php-parser": "^4.7",
 983 |                 "php": ">=7.3"
 984 |             },
 985 |             "require-dev": {
 986 |                 "phpunit/phpunit": "^9.3"
 987 |             },
 988 |             "type": "library",
 989 |             "extra": {
 990 |                 "branch-alias": {
 991 |                     "dev-master": "2.0-dev"
 992 |                 }
 993 |             },
 994 |             "autoload": {
 995 |                 "classmap": [
 996 |                     "src/"
 997 |                 ]
 998 |             },
 999 |             "notification-url": "https://packagist.org/downloads/",
1000 |             "license": [
1001 |                 "BSD-3-Clause"
1002 |             ],
1003 |             "authors": [
1004 |                 {
1005 |                     "name": "Sebastian Bergmann",
1006 |                     "email": "sebastian@phpunit.de",
1007 |                     "role": "lead"
1008 |                 }
1009 |             ],
1010 |             "description": "Library for calculating the complexity of PHP code units",
1011 |             "homepage": "https://github.com/sebastianbergmann/complexity",
1012 |             "support": {
1013 |                 "issues": "https://github.com/sebastianbergmann/complexity/issues",
1014 |                 "source": "https://github.com/sebastianbergmann/complexity/tree/2.0.2"
1015 |             },
1016 |             "funding": [
1017 |                 {
1018 |                     "url": "https://github.com/sebastianbergmann",
1019 |                     "type": "github"
1020 |                 }
1021 |             ],
1022 |             "time": "2020-10-26T15:52:27+00:00"
1023 |         },
1024 |         {
1025 |             "name": "sebastian/diff",
1026 |             "version": "4.0.4",
1027 |             "source": {
1028 |                 "type": "git",
1029 |                 "url": "https://github.com/sebastianbergmann/diff.git",
1030 |                 "reference": "3461e3fccc7cfdfc2720be910d3bd73c69be590d"
1031 |             },
1032 |             "dist": {
1033 |                 "type": "zip",
1034 |                 "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/3461e3fccc7cfdfc2720be910d3bd73c69be590d",
1035 |                 "reference": "3461e3fccc7cfdfc2720be910d3bd73c69be590d",
1036 |                 "shasum": ""
1037 |             },
1038 |             "require": {
1039 |                 "php": ">=7.3"
1040 |             },
1041 |             "require-dev": {
1042 |                 "phpunit/phpunit": "^9.3",
1043 |                 "symfony/process": "^4.2 || ^5"
1044 |             },
1045 |             "type": "library",
1046 |             "extra": {
1047 |                 "branch-alias": {
1048 |                     "dev-master": "4.0-dev"
1049 |                 }
1050 |             },
1051 |             "autoload": {
1052 |                 "classmap": [
1053 |                     "src/"
1054 |                 ]
1055 |             },
1056 |             "notification-url": "https://packagist.org/downloads/",
1057 |             "license": [
1058 |                 "BSD-3-Clause"
1059 |             ],
1060 |             "authors": [
1061 |                 {
1062 |                     "name": "Sebastian Bergmann",
1063 |                     "email": "sebastian@phpunit.de"
1064 |                 },
1065 |                 {
1066 |                     "name": "Kore Nordmann",
1067 |                     "email": "mail@kore-nordmann.de"
1068 |                 }
1069 |             ],
1070 |             "description": "Diff implementation",
1071 |             "homepage": "https://github.com/sebastianbergmann/diff",
1072 |             "keywords": [
1073 |                 "diff",
1074 |                 "udiff",
1075 |                 "unidiff",
1076 |                 "unified diff"
1077 |             ],
1078 |             "support": {
1079 |                 "issues": "https://github.com/sebastianbergmann/diff/issues",
1080 |                 "source": "https://github.com/sebastianbergmann/diff/tree/4.0.4"
1081 |             },
1082 |             "funding": [
1083 |                 {
1084 |                     "url": "https://github.com/sebastianbergmann",
1085 |                     "type": "github"
1086 |                 }
1087 |             ],
1088 |             "time": "2020-10-26T13:10:38+00:00"
1089 |         },
1090 |         {
1091 |             "name": "sebastian/environment",
1092 |             "version": "5.1.5",
1093 |             "source": {
1094 |                 "type": "git",
1095 |                 "url": "https://github.com/sebastianbergmann/environment.git",
1096 |                 "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed"
1097 |             },
1098 |             "dist": {
1099 |                 "type": "zip",
1100 |                 "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
1101 |                 "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed",
1102 |                 "shasum": ""
1103 |             },
1104 |             "require": {
1105 |                 "php": ">=7.3"
1106 |             },
1107 |             "require-dev": {
1108 |                 "phpunit/phpunit": "^9.3"
1109 |             },
1110 |             "suggest": {
1111 |                 "ext-posix": "*"
1112 |             },
1113 |             "type": "library",
1114 |             "extra": {
1115 |                 "branch-alias": {
1116 |                     "dev-master": "5.1-dev"
1117 |                 }
1118 |             },
1119 |             "autoload": {
1120 |                 "classmap": [
1121 |                     "src/"
1122 |                 ]
1123 |             },
1124 |             "notification-url": "https://packagist.org/downloads/",
1125 |             "license": [
1126 |                 "BSD-3-Clause"
1127 |             ],
1128 |             "authors": [
1129 |                 {
1130 |                     "name": "Sebastian Bergmann",
1131 |                     "email": "sebastian@phpunit.de"
1132 |                 }
1133 |             ],
1134 |             "description": "Provides functionality to handle HHVM/PHP environments",
1135 |             "homepage": "http://www.github.com/sebastianbergmann/environment",
1136 |             "keywords": [
1137 |                 "Xdebug",
1138 |                 "environment",
1139 |                 "hhvm"
1140 |             ],
1141 |             "support": {
1142 |                 "issues": "https://github.com/sebastianbergmann/environment/issues",
1143 |                 "source": "https://github.com/sebastianbergmann/environment/tree/5.1.5"
1144 |             },
1145 |             "funding": [
1146 |                 {
1147 |                     "url": "https://github.com/sebastianbergmann",
1148 |                     "type": "github"
1149 |                 }
1150 |             ],
1151 |             "time": "2023-02-03T06:03:51+00:00"
1152 |         },
1153 |         {
1154 |             "name": "sebastian/exporter",
1155 |             "version": "4.0.5",
1156 |             "source": {
1157 |                 "type": "git",
1158 |                 "url": "https://github.com/sebastianbergmann/exporter.git",
1159 |                 "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d"
1160 |             },
1161 |             "dist": {
1162 |                 "type": "zip",
1163 |                 "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
1164 |                 "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d",
1165 |                 "shasum": ""
1166 |             },
1167 |             "require": {
1168 |                 "php": ">=7.3",
1169 |                 "sebastian/recursion-context": "^4.0"
1170 |             },
1171 |             "require-dev": {
1172 |                 "ext-mbstring": "*",
1173 |                 "phpunit/phpunit": "^9.3"
1174 |             },
1175 |             "type": "library",
1176 |             "extra": {
1177 |                 "branch-alias": {
1178 |                     "dev-master": "4.0-dev"
1179 |                 }
1180 |             },
1181 |             "autoload": {
1182 |                 "classmap": [
1183 |                     "src/"
1184 |                 ]
1185 |             },
1186 |             "notification-url": "https://packagist.org/downloads/",
1187 |             "license": [
1188 |                 "BSD-3-Clause"
1189 |             ],
1190 |             "authors": [
1191 |                 {
1192 |                     "name": "Sebastian Bergmann",
1193 |                     "email": "sebastian@phpunit.de"
1194 |                 },
1195 |                 {
1196 |                     "name": "Jeff Welch",
1197 |                     "email": "whatthejeff@gmail.com"
1198 |                 },
1199 |                 {
1200 |                     "name": "Volker Dusch",
1201 |                     "email": "github@wallbash.com"
1202 |                 },
1203 |                 {
1204 |                     "name": "Adam Harvey",
1205 |                     "email": "aharvey@php.net"
1206 |                 },
1207 |                 {
1208 |                     "name": "Bernhard Schussek",
1209 |                     "email": "bschussek@gmail.com"
1210 |                 }
1211 |             ],
1212 |             "description": "Provides the functionality to export PHP variables for visualization",
1213 |             "homepage": "https://www.github.com/sebastianbergmann/exporter",
1214 |             "keywords": [
1215 |                 "export",
1216 |                 "exporter"
1217 |             ],
1218 |             "support": {
1219 |                 "issues": "https://github.com/sebastianbergmann/exporter/issues",
1220 |                 "source": "https://github.com/sebastianbergmann/exporter/tree/4.0.5"
1221 |             },
1222 |             "funding": [
1223 |                 {
1224 |                     "url": "https://github.com/sebastianbergmann",
1225 |                     "type": "github"
1226 |                 }
1227 |             ],
1228 |             "time": "2022-09-14T06:03:37+00:00"
1229 |         },
1230 |         {
1231 |             "name": "sebastian/global-state",
1232 |             "version": "5.0.5",
1233 |             "source": {
1234 |                 "type": "git",
1235 |                 "url": "https://github.com/sebastianbergmann/global-state.git",
1236 |                 "reference": "0ca8db5a5fc9c8646244e629625ac486fa286bf2"
1237 |             },
1238 |             "dist": {
1239 |                 "type": "zip",
1240 |                 "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/0ca8db5a5fc9c8646244e629625ac486fa286bf2",
1241 |                 "reference": "0ca8db5a5fc9c8646244e629625ac486fa286bf2",
1242 |                 "shasum": ""
1243 |             },
1244 |             "require": {
1245 |                 "php": ">=7.3",
1246 |                 "sebastian/object-reflector": "^2.0",
1247 |                 "sebastian/recursion-context": "^4.0"
1248 |             },
1249 |             "require-dev": {
1250 |                 "ext-dom": "*",
1251 |                 "phpunit/phpunit": "^9.3"
1252 |             },
1253 |             "suggest": {
1254 |                 "ext-uopz": "*"
1255 |             },
1256 |             "type": "library",
1257 |             "extra": {
1258 |                 "branch-alias": {
1259 |                     "dev-master": "5.0-dev"
1260 |                 }
1261 |             },
1262 |             "autoload": {
1263 |                 "classmap": [
1264 |                     "src/"
1265 |                 ]
1266 |             },
1267 |             "notification-url": "https://packagist.org/downloads/",
1268 |             "license": [
1269 |                 "BSD-3-Clause"
1270 |             ],
1271 |             "authors": [
1272 |                 {
1273 |                     "name": "Sebastian Bergmann",
1274 |                     "email": "sebastian@phpunit.de"
1275 |                 }
1276 |             ],
1277 |             "description": "Snapshotting of global state",
1278 |             "homepage": "http://www.github.com/sebastianbergmann/global-state",
1279 |             "keywords": [
1280 |                 "global state"
1281 |             ],
1282 |             "support": {
1283 |                 "issues": "https://github.com/sebastianbergmann/global-state/issues",
1284 |                 "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.5"
1285 |             },
1286 |             "funding": [
1287 |                 {
1288 |                     "url": "https://github.com/sebastianbergmann",
1289 |                     "type": "github"
1290 |                 }
1291 |             ],
1292 |             "time": "2022-02-14T08:28:10+00:00"
1293 |         },
1294 |         {
1295 |             "name": "sebastian/lines-of-code",
1296 |             "version": "1.0.3",
1297 |             "source": {
1298 |                 "type": "git",
1299 |                 "url": "https://github.com/sebastianbergmann/lines-of-code.git",
1300 |                 "reference": "c1c2e997aa3146983ed888ad08b15470a2e22ecc"
1301 |             },
1302 |             "dist": {
1303 |                 "type": "zip",
1304 |                 "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/c1c2e997aa3146983ed888ad08b15470a2e22ecc",
1305 |                 "reference": "c1c2e997aa3146983ed888ad08b15470a2e22ecc",
1306 |                 "shasum": ""
1307 |             },
1308 |             "require": {
1309 |                 "nikic/php-parser": "^4.6",
1310 |                 "php": ">=7.3"
1311 |             },
1312 |             "require-dev": {
1313 |                 "phpunit/phpunit": "^9.3"
1314 |             },
1315 |             "type": "library",
1316 |             "extra": {
1317 |                 "branch-alias": {
1318 |                     "dev-master": "1.0-dev"
1319 |                 }
1320 |             },
1321 |             "autoload": {
1322 |                 "classmap": [
1323 |                     "src/"
1324 |                 ]
1325 |             },
1326 |             "notification-url": "https://packagist.org/downloads/",
1327 |             "license": [
1328 |                 "BSD-3-Clause"
1329 |             ],
1330 |             "authors": [
1331 |                 {
1332 |                     "name": "Sebastian Bergmann",
1333 |                     "email": "sebastian@phpunit.de",
1334 |                     "role": "lead"
1335 |                 }
1336 |             ],
1337 |             "description": "Library for counting the lines of code in PHP source code",
1338 |             "homepage": "https://github.com/sebastianbergmann/lines-of-code",
1339 |             "support": {
1340 |                 "issues": "https://github.com/sebastianbergmann/lines-of-code/issues",
1341 |                 "source": "https://github.com/sebastianbergmann/lines-of-code/tree/1.0.3"
1342 |             },
1343 |             "funding": [
1344 |                 {
1345 |                     "url": "https://github.com/sebastianbergmann",
1346 |                     "type": "github"
1347 |                 }
1348 |             ],
1349 |             "time": "2020-11-28T06:42:11+00:00"
1350 |         },
1351 |         {
1352 |             "name": "sebastian/object-enumerator",
1353 |             "version": "4.0.4",
1354 |             "source": {
1355 |                 "type": "git",
1356 |                 "url": "https://github.com/sebastianbergmann/object-enumerator.git",
1357 |                 "reference": "5c9eeac41b290a3712d88851518825ad78f45c71"
1358 |             },
1359 |             "dist": {
1360 |                 "type": "zip",
1361 |                 "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/5c9eeac41b290a3712d88851518825ad78f45c71",
1362 |                 "reference": "5c9eeac41b290a3712d88851518825ad78f45c71",
1363 |                 "shasum": ""
1364 |             },
1365 |             "require": {
1366 |                 "php": ">=7.3",
1367 |                 "sebastian/object-reflector": "^2.0",
1368 |                 "sebastian/recursion-context": "^4.0"
1369 |             },
1370 |             "require-dev": {
1371 |                 "phpunit/phpunit": "^9.3"
1372 |             },
1373 |             "type": "library",
1374 |             "extra": {
1375 |                 "branch-alias": {
1376 |                     "dev-master": "4.0-dev"
1377 |                 }
1378 |             },
1379 |             "autoload": {
1380 |                 "classmap": [
1381 |                     "src/"
1382 |                 ]
1383 |             },
1384 |             "notification-url": "https://packagist.org/downloads/",
1385 |             "license": [
1386 |                 "BSD-3-Clause"
1387 |             ],
1388 |             "authors": [
1389 |                 {
1390 |                     "name": "Sebastian Bergmann",
1391 |                     "email": "sebastian@phpunit.de"
1392 |                 }
1393 |             ],
1394 |             "description": "Traverses array structures and object graphs to enumerate all referenced objects",
1395 |             "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
1396 |             "support": {
1397 |                 "issues": "https://github.com/sebastianbergmann/object-enumerator/issues",
1398 |                 "source": "https://github.com/sebastianbergmann/object-enumerator/tree/4.0.4"
1399 |             },
1400 |             "funding": [
1401 |                 {
1402 |                     "url": "https://github.com/sebastianbergmann",
1403 |                     "type": "github"
1404 |                 }
1405 |             ],
1406 |             "time": "2020-10-26T13:12:34+00:00"
1407 |         },
1408 |         {
1409 |             "name": "sebastian/object-reflector",
1410 |             "version": "2.0.4",
1411 |             "source": {
1412 |                 "type": "git",
1413 |                 "url": "https://github.com/sebastianbergmann/object-reflector.git",
1414 |                 "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7"
1415 |             },
1416 |             "dist": {
1417 |                 "type": "zip",
1418 |                 "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
1419 |                 "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7",
1420 |                 "shasum": ""
1421 |             },
1422 |             "require": {
1423 |                 "php": ">=7.3"
1424 |             },
1425 |             "require-dev": {
1426 |                 "phpunit/phpunit": "^9.3"
1427 |             },
1428 |             "type": "library",
1429 |             "extra": {
1430 |                 "branch-alias": {
1431 |                     "dev-master": "2.0-dev"
1432 |                 }
1433 |             },
1434 |             "autoload": {
1435 |                 "classmap": [
1436 |                     "src/"
1437 |                 ]
1438 |             },
1439 |             "notification-url": "https://packagist.org/downloads/",
1440 |             "license": [
1441 |                 "BSD-3-Clause"
1442 |             ],
1443 |             "authors": [
1444 |                 {
1445 |                     "name": "Sebastian Bergmann",
1446 |                     "email": "sebastian@phpunit.de"
1447 |                 }
1448 |             ],
1449 |             "description": "Allows reflection of object attributes, including inherited and non-public ones",
1450 |             "homepage": "https://github.com/sebastianbergmann/object-reflector/",
1451 |             "support": {
1452 |                 "issues": "https://github.com/sebastianbergmann/object-reflector/issues",
1453 |                 "source": "https://github.com/sebastianbergmann/object-reflector/tree/2.0.4"
1454 |             },
1455 |             "funding": [
1456 |                 {
1457 |                     "url": "https://github.com/sebastianbergmann",
1458 |                     "type": "github"
1459 |                 }
1460 |             ],
1461 |             "time": "2020-10-26T13:14:26+00:00"
1462 |         },
1463 |         {
1464 |             "name": "sebastian/recursion-context",
1465 |             "version": "4.0.5",
1466 |             "source": {
1467 |                 "type": "git",
1468 |                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
1469 |                 "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1"
1470 |             },
1471 |             "dist": {
1472 |                 "type": "zip",
1473 |                 "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
1474 |                 "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1",
1475 |                 "shasum": ""
1476 |             },
1477 |             "require": {
1478 |                 "php": ">=7.3"
1479 |             },
1480 |             "require-dev": {
1481 |                 "phpunit/phpunit": "^9.3"
1482 |             },
1483 |             "type": "library",
1484 |             "extra": {
1485 |                 "branch-alias": {
1486 |                     "dev-master": "4.0-dev"
1487 |                 }
1488 |             },
1489 |             "autoload": {
1490 |                 "classmap": [
1491 |                     "src/"
1492 |                 ]
1493 |             },
1494 |             "notification-url": "https://packagist.org/downloads/",
1495 |             "license": [
1496 |                 "BSD-3-Clause"
1497 |             ],
1498 |             "authors": [
1499 |                 {
1500 |                     "name": "Sebastian Bergmann",
1501 |                     "email": "sebastian@phpunit.de"
1502 |                 },
1503 |                 {
1504 |                     "name": "Jeff Welch",
1505 |                     "email": "whatthejeff@gmail.com"
1506 |                 },
1507 |                 {
1508 |                     "name": "Adam Harvey",
1509 |                     "email": "aharvey@php.net"
1510 |                 }
1511 |             ],
1512 |             "description": "Provides functionality to recursively process PHP variables",
1513 |             "homepage": "https://github.com/sebastianbergmann/recursion-context",
1514 |             "support": {
1515 |                 "issues": "https://github.com/sebastianbergmann/recursion-context/issues",
1516 |                 "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.5"
1517 |             },
1518 |             "funding": [
1519 |                 {
1520 |                     "url": "https://github.com/sebastianbergmann",
1521 |                     "type": "github"
1522 |                 }
1523 |             ],
1524 |             "time": "2023-02-03T06:07:39+00:00"
1525 |         },
1526 |         {
1527 |             "name": "sebastian/resource-operations",
1528 |             "version": "3.0.3",
1529 |             "source": {
1530 |                 "type": "git",
1531 |                 "url": "https://github.com/sebastianbergmann/resource-operations.git",
1532 |                 "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8"
1533 |             },
1534 |             "dist": {
1535 |                 "type": "zip",
1536 |                 "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
1537 |                 "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8",
1538 |                 "shasum": ""
1539 |             },
1540 |             "require": {
1541 |                 "php": ">=7.3"
1542 |             },
1543 |             "require-dev": {
1544 |                 "phpunit/phpunit": "^9.0"
1545 |             },
1546 |             "type": "library",
1547 |             "extra": {
1548 |                 "branch-alias": {
1549 |                     "dev-master": "3.0-dev"
1550 |                 }
1551 |             },
1552 |             "autoload": {
1553 |                 "classmap": [
1554 |                     "src/"
1555 |                 ]
1556 |             },
1557 |             "notification-url": "https://packagist.org/downloads/",
1558 |             "license": [
1559 |                 "BSD-3-Clause"
1560 |             ],
1561 |             "authors": [
1562 |                 {
1563 |                     "name": "Sebastian Bergmann",
1564 |                     "email": "sebastian@phpunit.de"
1565 |                 }
1566 |             ],
1567 |             "description": "Provides a list of PHP built-in functions that operate on resources",
1568 |             "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
1569 |             "support": {
1570 |                 "issues": "https://github.com/sebastianbergmann/resource-operations/issues",
1571 |                 "source": "https://github.com/sebastianbergmann/resource-operations/tree/3.0.3"
1572 |             },
1573 |             "funding": [
1574 |                 {
1575 |                     "url": "https://github.com/sebastianbergmann",
1576 |                     "type": "github"
1577 |                 }
1578 |             ],
1579 |             "time": "2020-09-28T06:45:17+00:00"
1580 |         },
1581 |         {
1582 |             "name": "sebastian/type",
1583 |             "version": "3.2.1",
1584 |             "source": {
1585 |                 "type": "git",
1586 |                 "url": "https://github.com/sebastianbergmann/type.git",
1587 |                 "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7"
1588 |             },
1589 |             "dist": {
1590 |                 "type": "zip",
1591 |                 "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
1592 |                 "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7",
1593 |                 "shasum": ""
1594 |             },
1595 |             "require": {
1596 |                 "php": ">=7.3"
1597 |             },
1598 |             "require-dev": {
1599 |                 "phpunit/phpunit": "^9.5"
1600 |             },
1601 |             "type": "library",
1602 |             "extra": {
1603 |                 "branch-alias": {
1604 |                     "dev-master": "3.2-dev"
1605 |                 }
1606 |             },
1607 |             "autoload": {
1608 |                 "classmap": [
1609 |                     "src/"
1610 |                 ]
1611 |             },
1612 |             "notification-url": "https://packagist.org/downloads/",
1613 |             "license": [
1614 |                 "BSD-3-Clause"
1615 |             ],
1616 |             "authors": [
1617 |                 {
1618 |                     "name": "Sebastian Bergmann",
1619 |                     "email": "sebastian@phpunit.de",
1620 |                     "role": "lead"
1621 |                 }
1622 |             ],
1623 |             "description": "Collection of value objects that represent the types of the PHP type system",
1624 |             "homepage": "https://github.com/sebastianbergmann/type",
1625 |             "support": {
1626 |                 "issues": "https://github.com/sebastianbergmann/type/issues",
1627 |                 "source": "https://github.com/sebastianbergmann/type/tree/3.2.1"
1628 |             },
1629 |             "funding": [
1630 |                 {
1631 |                     "url": "https://github.com/sebastianbergmann",
1632 |                     "type": "github"
1633 |                 }
1634 |             ],
1635 |             "time": "2023-02-03T06:13:03+00:00"
1636 |         },
1637 |         {
1638 |             "name": "sebastian/version",
1639 |             "version": "3.0.2",
1640 |             "source": {
1641 |                 "type": "git",
1642 |                 "url": "https://github.com/sebastianbergmann/version.git",
1643 |                 "reference": "c6c1022351a901512170118436c764e473f6de8c"
1644 |             },
1645 |             "dist": {
1646 |                 "type": "zip",
1647 |                 "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c6c1022351a901512170118436c764e473f6de8c",
1648 |                 "reference": "c6c1022351a901512170118436c764e473f6de8c",
1649 |                 "shasum": ""
1650 |             },
1651 |             "require": {
1652 |                 "php": ">=7.3"
1653 |             },
1654 |             "type": "library",
1655 |             "extra": {
1656 |                 "branch-alias": {
1657 |                     "dev-master": "3.0-dev"
1658 |                 }
1659 |             },
1660 |             "autoload": {
1661 |                 "classmap": [
1662 |                     "src/"
1663 |                 ]
1664 |             },
1665 |             "notification-url": "https://packagist.org/downloads/",
1666 |             "license": [
1667 |                 "BSD-3-Clause"
1668 |             ],
1669 |             "authors": [
1670 |                 {
1671 |                     "name": "Sebastian Bergmann",
1672 |                     "email": "sebastian@phpunit.de",
1673 |                     "role": "lead"
1674 |                 }
1675 |             ],
1676 |             "description": "Library that helps with managing the version number of Git-hosted PHP projects",
1677 |             "homepage": "https://github.com/sebastianbergmann/version",
1678 |             "support": {
1679 |                 "issues": "https://github.com/sebastianbergmann/version/issues",
1680 |                 "source": "https://github.com/sebastianbergmann/version/tree/3.0.2"
1681 |             },
1682 |             "funding": [
1683 |                 {
1684 |                     "url": "https://github.com/sebastianbergmann",
1685 |                     "type": "github"
1686 |                 }
1687 |             ],
1688 |             "time": "2020-09-28T06:39:44+00:00"
1689 |         },
1690 |         {
1691 |             "name": "squizlabs/php_codesniffer",
1692 |             "version": "3.7.1",
1693 |             "source": {
1694 |                 "type": "git",
1695 |                 "url": "https://github.com/squizlabs/PHP_CodeSniffer.git",
1696 |                 "reference": "1359e176e9307e906dc3d890bcc9603ff6d90619"
1697 |             },
1698 |             "dist": {
1699 |                 "type": "zip",
1700 |                 "url": "https://api.github.com/repos/squizlabs/PHP_CodeSniffer/zipball/1359e176e9307e906dc3d890bcc9603ff6d90619",
1701 |                 "reference": "1359e176e9307e906dc3d890bcc9603ff6d90619",
1702 |                 "shasum": ""
1703 |             },
1704 |             "require": {
1705 |                 "ext-simplexml": "*",
1706 |                 "ext-tokenizer": "*",
1707 |                 "ext-xmlwriter": "*",
1708 |                 "php": ">=5.4.0"
1709 |             },
1710 |             "require-dev": {
1711 |                 "phpunit/phpunit": "^4.0 || ^5.0 || ^6.0 || ^7.0"
1712 |             },
1713 |             "bin": [
1714 |                 "bin/phpcs",
1715 |                 "bin/phpcbf"
1716 |             ],
1717 |             "type": "library",
1718 |             "extra": {
1719 |                 "branch-alias": {
1720 |                     "dev-master": "3.x-dev"
1721 |                 }
1722 |             },
1723 |             "notification-url": "https://packagist.org/downloads/",
1724 |             "license": [
1725 |                 "BSD-3-Clause"
1726 |             ],
1727 |             "authors": [
1728 |                 {
1729 |                     "name": "Greg Sherwood",
1730 |                     "role": "lead"
1731 |                 }
1732 |             ],
1733 |             "description": "PHP_CodeSniffer tokenizes PHP, JavaScript and CSS files and detects violations of a defined set of coding standards.",
1734 |             "homepage": "https://github.com/squizlabs/PHP_CodeSniffer",
1735 |             "keywords": [
1736 |                 "phpcs",
1737 |                 "standards"
1738 |             ],
1739 |             "support": {
1740 |                 "issues": "https://github.com/squizlabs/PHP_CodeSniffer/issues",
1741 |                 "source": "https://github.com/squizlabs/PHP_CodeSniffer",
1742 |                 "wiki": "https://github.com/squizlabs/PHP_CodeSniffer/wiki"
1743 |             },
1744 |             "time": "2022-06-18T07:21:10+00:00"
1745 |         },
1746 |         {
1747 |             "name": "theseer/tokenizer",
1748 |             "version": "1.2.1",
1749 |             "source": {
1750 |                 "type": "git",
1751 |                 "url": "https://github.com/theseer/tokenizer.git",
1752 |                 "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e"
1753 |             },
1754 |             "dist": {
1755 |                 "type": "zip",
1756 |                 "url": "https://api.github.com/repos/theseer/tokenizer/zipball/34a41e998c2183e22995f158c581e7b5e755ab9e",
1757 |                 "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e",
1758 |                 "shasum": ""
1759 |             },
1760 |             "require": {
1761 |                 "ext-dom": "*",
1762 |                 "ext-tokenizer": "*",
1763 |                 "ext-xmlwriter": "*",
1764 |                 "php": "^7.2 || ^8.0"
1765 |             },
1766 |             "type": "library",
1767 |             "autoload": {
1768 |                 "classmap": [
1769 |                     "src/"
1770 |                 ]
1771 |             },
1772 |             "notification-url": "https://packagist.org/downloads/",
1773 |             "license": [
1774 |                 "BSD-3-Clause"
1775 |             ],
1776 |             "authors": [
1777 |                 {
1778 |                     "name": "Arne Blankerts",
1779 |                     "email": "arne@blankerts.de",
1780 |                     "role": "Developer"
1781 |                 }
1782 |             ],
1783 |             "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
1784 |             "support": {
1785 |                 "issues": "https://github.com/theseer/tokenizer/issues",
1786 |                 "source": "https://github.com/theseer/tokenizer/tree/1.2.1"
1787 |             },
1788 |             "funding": [
1789 |                 {
1790 |                     "url": "https://github.com/theseer",
1791 |                     "type": "github"
1792 |                 }
1793 |             ],
1794 |             "time": "2021-07-28T10:34:58+00:00"
1795 |         }
1796 |     ],
1797 |     "aliases": [],
1798 |     "minimum-stability": "stable",
1799 |     "stability-flags": [],
1800 |     "prefer-stable": false,
1801 |     "prefer-lowest": false,
1802 |     "platform": {
1803 |         "php": ">=7.4"
1804 |     },
1805 |     "platform-dev": [],
1806 |     "plugin-api-version": "2.3.0"
1807 | }
1808 | 


--------------------------------------------------------------------------------