';
64 | }
65 | }
66 |
67 | Utils::composerSkipFlags();
68 |
69 | if ((!\defined('KINT_SKIP_FACADE') || !KINT_SKIP_FACADE) && !\class_exists('Kint')) {
70 | \class_alias(Kint::class, 'Kint');
71 | }
72 |
73 | if (!\defined('KINT_SKIP_HELPERS') || !KINT_SKIP_HELPERS) {
74 | require_once __DIR__.'/init_helpers.php';
75 | }
76 |
--------------------------------------------------------------------------------
/src/Renderer/Rich/SourcePlugin.php:
--------------------------------------------------------------------------------
1 | getSourceLines();
43 |
44 | // Trim empty lines from the start and end of the source
45 | foreach ($source as $linenum => $line) {
46 | if (\strlen(\trim($line)) || $linenum === $r->getLine()) {
47 | break;
48 | }
49 |
50 | unset($source[$linenum]);
51 | }
52 |
53 | foreach (\array_reverse($source, true) as $linenum => $line) {
54 | if (\strlen(\trim($line)) || $linenum === $r->getLine()) {
55 | break;
56 | }
57 |
58 | unset($source[$linenum]);
59 | }
60 |
61 | $output = '';
62 |
63 | foreach ($source as $linenum => $line) {
64 | if ($linenum === $r->getLine()) {
65 | $output .= ''.$this->renderer->escape($line)."\n".'
';
66 | } else {
67 | $output .= ''.$this->renderer->escape($line)."\n".'
';
68 | }
69 | }
70 |
71 | if ($output) {
72 | $data = '';
73 | if ($r->showFileName()) {
74 | $data = ' data-kint-filename="'.$this->renderer->escape($r->getFileName()).'"';
75 | }
76 |
77 | return '';
78 | }
79 |
80 | return null;
81 | }
82 | }
83 |
--------------------------------------------------------------------------------
/src/Parser/JsonPlugin.php:
--------------------------------------------------------------------------------
1 | getContext();
64 |
65 | $base = new BaseContext('JSON Decode');
66 | $base->depth = $c->getDepth();
67 |
68 | if (null !== ($ap = $c->getAccessPath())) {
69 | $base->access_path = 'json_decode('.$ap.', true)';
70 | }
71 |
72 | $json = $this->getParser()->parse($json, $base);
73 |
74 | if ($json instanceof ArrayValue && (~$json->flags & AbstractValue::FLAG_DEPTH_LIMIT) && $contents = $json->getContents()) {
75 | foreach ($contents as $value) {
76 | $value->flags |= AbstractValue::FLAG_GENERATED;
77 | }
78 | $v->addRepresentation(new ContainerRepresentation('Json', $contents), 0);
79 | } else {
80 | $json->flags |= AbstractValue::FLAG_GENERATED;
81 | $v->addRepresentation(new ValueRepresentation('Json', $json), 0);
82 | }
83 |
84 | return $v;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/src/Renderer/Rich/MicrotimePlugin.php:
--------------------------------------------------------------------------------
1 | getDateTime())) {
40 | return null;
41 | }
42 |
43 | $out = $dt->format('Y-m-d H:i:s.u');
44 | if (null !== ($lap = $r->getLapTime())) {
45 | $out .= '
SINCE LAST CALL: '.\round($lap, 4).'s.';
46 | }
47 | if (null !== ($total = $r->getTotalTime())) {
48 | $out .= '
SINCE START: '.\round($total, 4).'s.';
49 | }
50 | if (null !== ($avg = $r->getAverageTime())) {
51 | $out .= '
AVERAGE DURATION: '.\round($avg, 4).'s.';
52 | }
53 |
54 | $bytes = Utils::getHumanReadableBytes($r->getMemoryUsage());
55 | $out .= '
MEMORY USAGE: '.$r->getMemoryUsage().' bytes ('.\round($bytes['value'], 3).' '.$bytes['unit'].')';
56 | $bytes = Utils::getHumanReadableBytes($r->getMemoryUsageReal());
57 | $out .= ' (real '.\round($bytes['value'], 3).' '.$bytes['unit'].')';
58 |
59 | $bytes = Utils::getHumanReadableBytes($r->getMemoryPeakUsage());
60 | $out .= '
PEAK MEMORY USAGE: '.$r->getMemoryPeakUsage().' bytes ('.\round($bytes['value'], 3).' '.$bytes['unit'].')';
61 | $bytes = Utils::getHumanReadableBytes($r->getMemoryPeakUsageReal());
62 | $out .= ' (real '.\round($bytes['value'], 3).' '.$bytes['unit'].')';
63 |
64 | return ''.$out.'
';
65 | }
66 | }
67 |
--------------------------------------------------------------------------------
/src/Parser/BlacklistPlugin.php:
--------------------------------------------------------------------------------
1 | blacklistValue($var, $c);
70 | }
71 | }
72 |
73 | if ($c->getDepth() <= 0) {
74 | return null;
75 | }
76 |
77 | foreach (self::$shallow_blacklist as $class) {
78 | if ($var instanceof $class) {
79 | return $this->blacklistValue($var, $c);
80 | }
81 | }
82 |
83 | return null;
84 | }
85 |
86 | /**
87 | * @param object &$var
88 | */
89 | protected function blacklistValue(&$var, ContextInterface $c): InstanceValue
90 | {
91 | $object = new InstanceValue($c, \get_class($var), \spl_object_hash($var), \spl_object_id($var));
92 | $object->flags |= AbstractValue::FLAG_BLACKLIST;
93 |
94 | return $object;
95 | }
96 | }
97 |
--------------------------------------------------------------------------------
/src/Parser/ClosurePlugin.php:
--------------------------------------------------------------------------------
1 | getContext();
57 |
58 | $object = new ClosureValue($c, $var);
59 | $object->flags = $v->flags;
60 | $object->appendRepresentations($v->getRepresentations());
61 |
62 | $object->removeRepresentation('properties');
63 |
64 | $closure = new ReflectionFunction($var);
65 |
66 | $statics = [];
67 |
68 | if ($v = $closure->getClosureThis()) {
69 | $statics = ['this' => $v];
70 | }
71 |
72 | $statics = $statics + $closure->getStaticVariables();
73 |
74 | $cdepth = $c->getDepth();
75 |
76 | if (\count($statics)) {
77 | $statics_parsed = [];
78 |
79 | $parser = $this->getParser();
80 |
81 | foreach ($statics as $name => $_) {
82 | $base = new BaseContext('$'.$name);
83 | $base->depth = $cdepth + 1;
84 | $base->reference = null !== ReflectionReference::fromArrayElement($statics, $name);
85 | $statics_parsed[$name] = $parser->parse($statics[$name], $base);
86 | }
87 |
88 | $object->addRepresentation(new ContainerRepresentation('Uses', $statics_parsed), 0);
89 | }
90 |
91 | return $object;
92 | }
93 | }
94 |
--------------------------------------------------------------------------------
/src/Parser/HtmlPlugin.php:
--------------------------------------------------------------------------------
1 | ' !== \strtolower((string) \substr($var, 0, 15))) {
56 | return $v;
57 | }
58 |
59 | try {
60 | $html = HTMLDocument::createFromString($var, LIBXML_NOERROR);
61 | } catch (DOMException $e) { // @codeCoverageIgnore
62 | return $v; // @codeCoverageIgnore
63 | }
64 |
65 | $c = $v->getContext();
66 |
67 | $base = new BaseContext('childNodes');
68 | $base->depth = $c->getDepth();
69 |
70 | if (null !== ($ap = $c->getAccessPath())) {
71 | $base->access_path = '\\Dom\\HTMLDocument::createFromString('.$ap.')->childNodes';
72 | }
73 |
74 | $out = $this->getParser()->parse($html->childNodes, $base);
75 | $iter = $out->getRepresentation('iterator');
76 |
77 | if ($out->flags & AbstractValue::FLAG_DEPTH_LIMIT) {
78 | $out->flags |= AbstractValue::FLAG_GENERATED;
79 | $v->addRepresentation(new ValueRepresentation('HTML', $out), 0);
80 | } elseif ($iter instanceof ContainerRepresentation) {
81 | $v->addRepresentation(new ContainerRepresentation('HTML', $iter->getContents()), 0);
82 | }
83 |
84 | return $v;
85 | }
86 | }
87 |
--------------------------------------------------------------------------------
/src/Value/FunctionValue.php:
--------------------------------------------------------------------------------
1 | callable_bag = $bag;
45 |
46 | if ($this->callable_bag->internal) {
47 | $this->definition_rep = null;
48 |
49 | return;
50 | }
51 |
52 | /**
53 | * @psalm-var string $this->callable_bag->filename
54 | * @psalm-var int $this->callable_bag->startline
55 | * Psalm issue #11121
56 | */
57 | $this->definition_rep = new CallableDefinitionRepresentation(
58 | $this->callable_bag->filename,
59 | $this->callable_bag->startline,
60 | $this->callable_bag->docstring
61 | );
62 | $this->addRepresentation($this->definition_rep);
63 | }
64 |
65 | public function getCallableBag(): DeclaredCallableBag
66 | {
67 | return $this->callable_bag;
68 | }
69 |
70 | /** @psalm-api */
71 | public function getDefinitionRepresentation(): ?CallableDefinitionRepresentation
72 | {
73 | return $this->definition_rep;
74 | }
75 |
76 | public function getDisplayName(): string
77 | {
78 | return $this->context->getName().'('.$this->callable_bag->getParams().')';
79 | }
80 |
81 | public function getDisplayValue(): ?string
82 | {
83 | if ($this->definition_rep instanceof CallableDefinitionRepresentation) {
84 | return $this->definition_rep->getDocstringFirstLine();
85 | }
86 |
87 | return parent::getDisplayValue();
88 | }
89 |
90 | public function getPhpDocUrl(): ?string
91 | {
92 | if (!$this->callable_bag->internal) {
93 | return null;
94 | }
95 |
96 | return 'https://www.php.net/function.'.\str_replace('_', '-', \strtolower((string) $this->context->getName()));
97 | }
98 | }
99 |
--------------------------------------------------------------------------------
/src/Parser/Base64Plugin.php:
--------------------------------------------------------------------------------
1 | getContext();
78 |
79 | $base = new BaseContext('base64_decode('.$c->getName().')');
80 | $base->depth = $c->getDepth() + 1;
81 |
82 | if (null !== ($ap = $c->getAccessPath())) {
83 | $base->access_path = 'base64_decode('.$ap.')';
84 | }
85 |
86 | $data = $this->getParser()->parse($data, $base);
87 | $data->flags |= AbstractValue::FLAG_GENERATED;
88 |
89 | if (!$data instanceof StringValue || false === $data->getEncoding()) {
90 | return $v;
91 | }
92 |
93 | $r = new ValueRepresentation('Base64', $data);
94 |
95 | if (\strlen($var) > self::$min_length_soft) {
96 | $v->addRepresentation($r, 0);
97 | } else {
98 | $v->addRepresentation($r);
99 | }
100 |
101 | return $v;
102 | }
103 | }
104 |
--------------------------------------------------------------------------------
/src/Value/InstanceValue.php:
--------------------------------------------------------------------------------
1 |
49 | */
50 | protected ?array $children = null;
51 |
52 | /** @psalm-param class-string $classname */
53 | public function __construct(
54 | ContextInterface $context,
55 | string $classname,
56 | string $spl_object_hash,
57 | int $spl_object_id
58 | ) {
59 | parent::__construct($context, 'object');
60 | $this->classname = $classname;
61 | $this->spl_object_hash = $spl_object_hash;
62 | $this->spl_object_id = $spl_object_id;
63 | }
64 |
65 | /** @psalm-return class-string */
66 | public function getClassName(): string
67 | {
68 | return $this->classname;
69 | }
70 |
71 | public function getSplObjectHash(): string
72 | {
73 | return $this->spl_object_hash;
74 | }
75 |
76 | public function getSplObjectId(): int
77 | {
78 | return $this->spl_object_id;
79 | }
80 |
81 | /** @psalm-param null|list $children */
82 | public function setChildren(?array $children): void
83 | {
84 | $this->children = $children;
85 | }
86 |
87 | /** @psalm-return null|list */
88 | public function getChildren(): ?array
89 | {
90 | return $this->children;
91 | }
92 |
93 | public function getDisplayType(): string
94 | {
95 | return $this->classname;
96 | }
97 |
98 | public function getDisplaySize(): ?string
99 | {
100 | if (null === $this->children) {
101 | return null;
102 | }
103 |
104 | return (string) \count($this->children);
105 | }
106 |
107 | public function getDisplayChildren(): array
108 | {
109 | return $this->children ?? [];
110 | }
111 | }
112 |
--------------------------------------------------------------------------------
/src/Parser/ClassStringsPlugin.php:
--------------------------------------------------------------------------------
1 | methods_plugin = new ClassMethodsPlugin($parser);
47 | $this->statics_plugin = new ClassStaticsPlugin($parser);
48 | }
49 |
50 | public function setParser(Parser $p): void
51 | {
52 | parent::setParser($p);
53 |
54 | $this->methods_plugin->setParser($p);
55 | $this->statics_plugin->setParser($p);
56 | }
57 |
58 | public function getTypes(): array
59 | {
60 | return ['string'];
61 | }
62 |
63 | public function getTriggers(): int
64 | {
65 | return Parser::TRIGGER_SUCCESS;
66 | }
67 |
68 | public function parseComplete(&$var, AbstractValue $v, int $trigger): AbstractValue
69 | {
70 | $c = $v->getContext();
71 |
72 | if ($c->getDepth() > 0) {
73 | return $v;
74 | }
75 |
76 | if (!\class_exists($var, true)) {
77 | return $v;
78 | }
79 |
80 | if (\in_array($var, self::$blacklist, true)) {
81 | return $v;
82 | }
83 |
84 | $r = new ReflectionClass($var);
85 |
86 | $fakeC = new BaseContext($c->getName());
87 | $fakeC->access_path = null;
88 | $fakeV = new InstanceValue($fakeC, $r->getName(), 'badhash', -1);
89 | $fakeVar = null;
90 |
91 | $fakeV = $this->methods_plugin->parseComplete($fakeVar, $fakeV, Parser::TRIGGER_SUCCESS);
92 | $fakeV = $this->statics_plugin->parseComplete($fakeVar, $fakeV, Parser::TRIGGER_SUCCESS);
93 |
94 | foreach (['methods', 'static_methods', 'statics', 'constants'] as $rep) {
95 | if ($rep = $fakeV->getRepresentation($rep)) {
96 | $v->addRepresentation($rep);
97 | }
98 | }
99 |
100 | return $v;
101 | }
102 | }
103 |
--------------------------------------------------------------------------------
/src/Value/ParameterBag.php:
--------------------------------------------------------------------------------
1 | name = $param->getName();
49 | $this->position = $param->getPosition();
50 | $this->ref = $param->isPassedByReference();
51 |
52 | $this->type_hint = ($type = $param->getType()) ? Utils::getTypeString($type) : null;
53 |
54 | if ($param->isDefaultValueAvailable()) {
55 | $default = $param->getDefaultValue();
56 | switch (\gettype($default)) {
57 | case 'NULL':
58 | $this->default = 'null';
59 | break;
60 | case 'boolean':
61 | $this->default = $default ? 'true' : 'false';
62 | break;
63 | case 'array':
64 | $this->default = \count($default) ? 'array(...)' : 'array()';
65 | break;
66 | case 'double':
67 | case 'integer':
68 | case 'string':
69 | $this->default = \var_export($default, true);
70 | break;
71 | case 'object':
72 | $this->default = 'object('.\get_class($default).')';
73 | break;
74 | default:
75 | $this->default = \gettype($default);
76 | break;
77 | }
78 | } else {
79 | $this->default = null;
80 | }
81 | }
82 |
83 | public function __toString()
84 | {
85 | $type = $this->type_hint;
86 | if (null !== $type) {
87 | $type .= ' ';
88 | }
89 |
90 | $default = $this->default;
91 | if (null !== $default) {
92 | $default = ' = '.$default;
93 | }
94 |
95 | $ref = $this->ref ? '&' : '';
96 |
97 | return $type.$ref.'$'.$this->name.$default;
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/src/Value/StringValue.php:
--------------------------------------------------------------------------------
1 | value = $value;
56 | $this->encoding = $encoding;
57 | $this->length = \strlen($value);
58 | }
59 |
60 | public function getValue(): string
61 | {
62 | return $this->value;
63 | }
64 |
65 | public function getValueUtf8(): string
66 | {
67 | if (false === $this->encoding) {
68 | throw new DomainException('StringValue with no encoding can\'t be converted to UTF-8');
69 | }
70 |
71 | if ('ASCII' === $this->encoding || 'UTF-8' === $this->encoding) {
72 | return $this->value;
73 | }
74 |
75 | /** @psalm-var string $encoded */
76 | $encoded = \mb_convert_encoding($this->value, 'UTF-8', $this->encoding);
77 |
78 | return $encoded;
79 | }
80 |
81 | /** @psalm-api */
82 | public function getLength(): int
83 | {
84 | return $this->length;
85 | }
86 |
87 | /** @psalm-return Encoding */
88 | public function getEncoding()
89 | {
90 | return $this->encoding;
91 | }
92 |
93 | public function getDisplayType(): string
94 | {
95 | if (false === $this->encoding) {
96 | return 'binary '.$this->type;
97 | }
98 |
99 | if ('ASCII' === $this->encoding) {
100 | return $this->type;
101 | }
102 |
103 | return $this->encoding.' '.$this->type;
104 | }
105 |
106 | public function getDisplaySize(): string
107 | {
108 | return (string) $this->length;
109 | }
110 |
111 | public function getDisplayValue(): string
112 | {
113 | return '"'.$this->value.'"';
114 | }
115 | }
116 |
--------------------------------------------------------------------------------
/src/Value/Context/ClassDeclaredContext.php:
--------------------------------------------------------------------------------
1 | access = $access;
52 | }
53 |
54 | abstract public function getModifiers(): string;
55 |
56 | /** @psalm-param ?class-string $scope */
57 | public function isAccessible(?string $scope): bool
58 | {
59 | if (__PHP_Incomplete_Class::class === $this->owner_class) {
60 | return false;
61 | }
62 |
63 | if (self::ACCESS_PUBLIC === $this->access) {
64 | return true;
65 | }
66 |
67 | if (null === $scope) {
68 | return false;
69 | }
70 |
71 | if (self::ACCESS_PRIVATE === $this->access) {
72 | return $scope === $this->owner_class;
73 | }
74 |
75 | if (KINT_PHP8412 && null !== $this->proto_class) {
76 | if (\is_a($scope, $this->proto_class, true)) {
77 | return true;
78 | }
79 |
80 | if (\is_a($this->proto_class, $scope, true)) {
81 | return true;
82 | }
83 | } else {
84 | if (\is_a($scope, $this->owner_class, true)) {
85 | return true;
86 | }
87 |
88 | if (\is_a($this->owner_class, $scope, true)) {
89 | return true;
90 | }
91 | }
92 |
93 | return false;
94 | }
95 |
96 | protected function getAccess(): string
97 | {
98 | switch ($this->access) {
99 | case self::ACCESS_PUBLIC:
100 | return 'public';
101 | case self::ACCESS_PROTECTED:
102 | return 'protected';
103 | case self::ACCESS_PRIVATE:
104 | return 'private';
105 | }
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/src/Renderer/Rich/AbstractPlugin.php:
--------------------------------------------------------------------------------
1 | renderer = $r;
43 | }
44 |
45 | /**
46 | * @param string $content The replacement for the getValueShort contents
47 | */
48 | public function renderLockedHeader(AbstractValue $v, string $content): string
49 | {
50 | $header = '';
51 |
52 | $c = $v->getContext();
53 |
54 | if (RichRenderer::$access_paths && $c->getDepth() > 0 && null !== ($ap = $c->getAccessPath())) {
55 | $header .= '⇄';
56 | }
57 |
58 | $header .= '';
59 |
60 | if ($c instanceof ClassDeclaredContext) {
61 | $header .= ''.$c->getModifiers().' ';
62 | }
63 |
64 | $header .= ''.$this->renderer->escape($v->getDisplayName()).' ';
65 |
66 | if ($c instanceof PropertyContext && null !== ($s = $c->getHooks())) {
67 | $header .= ''.$this->renderer->escape($s).' ';
68 | }
69 |
70 | if (null !== ($s = $c->getOperator())) {
71 | $header .= $this->renderer->escape($s, 'ASCII').' ';
72 | }
73 |
74 | $s = $v->getDisplayType();
75 |
76 | if (RichRenderer::$escape_types) {
77 | $s = $this->renderer->escape($s);
78 | }
79 |
80 | if ($c->isRef()) {
81 | $s = '&'.$s;
82 | }
83 |
84 | $header .= ''.$s.'';
85 |
86 | if ($v instanceof InstanceValue && $this->renderer->shouldRenderObjectIds()) {
87 | $header .= '#'.$v->getSplObjectId();
88 | }
89 |
90 | $header .= ' ';
91 |
92 | if (null !== ($s = $v->getDisplaySize())) {
93 | if (RichRenderer::$escape_types) {
94 | $s = $this->renderer->escape($s);
95 | }
96 | $header .= '('.$s.') ';
97 | }
98 |
99 | $header .= $content;
100 |
101 | if (!empty($ap)) {
102 | $header .= ''.$this->renderer->escape($ap).'
';
103 | }
104 |
105 | return $header.'';
106 | }
107 | }
108 |
--------------------------------------------------------------------------------
/src/Parser/TablePlugin.php:
--------------------------------------------------------------------------------
1 | self::$max_width) {
76 | return $v;
77 | }
78 |
79 | $keys = \array_keys($elem);
80 | } elseif (\array_keys($elem) !== $keys) {
81 | return $v;
82 | }
83 | }
84 |
85 | $children = $v->getContents();
86 |
87 | if (!$children) {
88 | return $v;
89 | }
90 |
91 | // Ensure none of the child arrays are recursion or depth limit. We
92 | // don't care if their children are since they are the table cells
93 | foreach ($children as $childarray) {
94 | if (!$childarray instanceof ArrayValue || empty($childarray->getContents())) {
95 | return $v;
96 | }
97 | }
98 |
99 | $v->addRepresentation(new TableRepresentation($children), 0);
100 |
101 | return $v;
102 | }
103 | }
104 |
--------------------------------------------------------------------------------