From 06146828eb90657dec117280055cfe8d3a54f528 Mon Sep 17 00:00:00 2001
From: Tom Wright <tom@inflatablecookie.com>
Date: Tue, 3 Sep 2019 18:18:09 +0100
Subject: [PATCH 1/3] Split shared renderer functions into trait

Signed-off-by: Tom Wright <tom@inflatablecookie.com>
---
 src/Glitch/Renderer/Base.php       | 1126 ++++++++++++++++++++++++++++
 src/Glitch/Renderer/Html.php       |  997 ++++++++----------------
 src/Glitch/Renderer/assets/dump.js |    2 +-
 3 files changed, 1458 insertions(+), 667 deletions(-)
 create mode 100644 src/Glitch/Renderer/Base.php

diff --git a/src/Glitch/Renderer/Base.php b/src/Glitch/Renderer/Base.php
new file mode 100644
index 0000000..7868aa6
--- /dev/null
+++ b/src/Glitch/Renderer/Base.php
@@ -0,0 +1,1126 @@
+<?php
+/**
+ * This file is part of the Glitch package
+ * @license http://opensource.org/licenses/MIT
+ */
+declare(strict_types=1);
+namespace DecodeLabs\Glitch\Renderer;
+
+use DecodeLabs\Glitch\Context;
+use DecodeLabs\Glitch\Renderer;
+use DecodeLabs\Glitch\Stack\Trace;
+use DecodeLabs\Glitch\Stack\Frame;
+use DecodeLabs\Glitch\Dumper\Dump;
+use DecodeLabs\Glitch\Dumper\Entity;
+
+trait Base
+{
+    protected $context;
+
+    /**
+     * Construct with Context
+     */
+    public function __construct(Context $context)
+    {
+        $this->context = $context;
+    }
+
+
+    /**
+     * Convert Dump object to HTML string
+     */
+    public function renderDump(Dump $dump, bool $isFinal=false): string
+    {
+        $output = [];
+
+        if (!empty($header = $this->renderHeader())) {
+            $output[] = $header;
+        }
+
+        $output[] = $this->renderStats($dump->getStats());
+        $output[] = $this->renderDumpEntities($dump);
+
+        if ($trace = $dump->getTrace()) {
+            $output[] = $this->renderTrace($trace);
+        }
+
+        if (!empty($footer = $this->renderFooter())) {
+            $output[] = $footer;
+        }
+
+        return $this->exportBuffer($output);
+    }
+
+    /**
+     * Render dump header
+     */
+    protected function renderHeader(): string
+    {
+        return '';
+    }
+
+    /**
+     * Render basic stat list
+     */
+    protected function renderStats(array $stats): string
+    {
+        return implode(' | ', $stats);
+    }
+
+    abstract protected function renderDumpEntities(Dump $dump): string;
+    abstract protected function renderTrace(Trace $trace): string;
+
+    /**
+     * Render dump footer
+     */
+    protected function renderFooter(): string
+    {
+        return '';
+    }
+
+    /**
+     * Flatten buffer for final render
+     */
+    protected function exportBuffer(array $buffer): string
+    {
+        return implode("\n", $buffer);
+    }
+
+
+
+    /**
+     * Render a scalar value
+     */
+    protected function renderScalar($value, ?string $class=null): string
+    {
+        switch (true) {
+            case $value === null:
+                $output = $this->renderNull($class);
+                break;
+
+            case is_bool($value):
+                $output = $this->renderBool($value, $class);
+                break;
+
+            case is_int($value):
+                $output = $this->renderInt($value, $class);
+                break;
+
+            case is_float($value):
+                $output = $this->renderFloat($value, $class);
+                break;
+
+            case is_string($value):
+                $output = $this->renderString($value, $class);
+                break;
+
+            default:
+                $output = '';
+                break;
+        }
+
+        return $output;
+    }
+
+
+    /**
+     * Passthrough null
+     */
+    protected function renderNull(?string $class=null): string
+    {
+        return 'null';
+    }
+
+    /**
+     * Passthrough boolean
+     */
+    protected function renderBool(bool $value, ?string $class=null): string
+    {
+        return $value ? 'true' : 'false';
+    }
+
+    /**
+     * Passthrough integer
+     */
+    protected function renderInt(int $value, ?string $class=null): string
+    {
+        return (string)$value;
+    }
+
+    /**
+     * Passthrough float
+     */
+    protected function renderFloat(float $value, ?string $class=null): string
+    {
+        return $this->normalizeFloat($value);
+    }
+
+
+    /**
+     * Convert a float value to string ensuring decimals
+     */
+    protected function normalizeFloat(float $number): string
+    {
+        $output = (string)$number;
+
+        if (false === strpos($output, '.')) {
+            $output .= '.0';
+        }
+
+        return $output;
+    }
+
+    /**
+     * Render standard string
+     */
+    protected function renderString(string $string, ?string $class=null, int $forceSingleLineMax=null): string
+    {
+        $isMultiLine = $forceSingleLineMax === null && false !== strpos($string, "\n");
+
+        if ($class !== null) {
+            return $this->renderIdentifierString($string, $class, $forceSingleLineMax);
+        } elseif ($isMultiLine) {
+            return $this->renderMultiLineString($string);
+        } else {
+            return $this->renderSingleLineString($string, $forceSingleLineMax);
+        }
+    }
+
+    /**
+     * Passthrough string
+     */
+    protected function renderIdentifierString(string $string, string $class, int $forceSingleLineMax=null): string
+    {
+        return $string;
+    }
+
+    /**
+     * Passthrough string
+     */
+    protected function renderMultiLineString(string $string): string
+    {
+        return $string;
+    }
+
+    /**
+     * Passthrough string
+     */
+    protected function renderSingleLineString(string $string, int $forceSingleLineMax=null): string
+    {
+        return $string;
+    }
+
+
+    /**
+     * render string for rendering
+     */
+    protected function renderStringLine(string $line, int $maxLength=null): string
+    {
+        $shorten = false;
+
+        if ($maxLength !== null && strlen($line) > $maxLength) {
+            $shorten = true;
+            $line = substr($line, 0, $maxLength);
+        }
+
+        $output = $this->esc($line);
+
+        $output = preg_replace_callback('/[[:cntrl:]]/', function ($matches) {
+            $hex = implode(unpack("H*", $matches[0]));
+            $output = $this->normalizeHex($hex);
+            return $this->wrapControlCharacter($output);
+        }, $output);
+
+        if ($shorten) {
+            $output .= $this->renderGrammar('…');
+        }
+
+        return $output;
+    }
+
+    /**
+     * render binary string chunk
+     */
+    protected function renderBinaryStringChunk(string $chunk): string
+    {
+        return $chunk;
+    }
+
+
+    /**
+     * Normalize a hex value for output
+     */
+    protected function normalizeHex(string $hex): string
+    {
+        switch ($hex) {
+            case '07':
+                $output = '\\a';
+                break;
+
+            case '1B':
+                $output = '\\e';
+                break;
+
+            case '0C':
+                $output = '\\f';
+                break;
+
+            case '0A':
+                $output = '\\n';
+                break;
+
+            case '0D':
+                $output = '\\r';
+                break;
+
+            case '09':
+                $output = '\\t';
+                break;
+
+            default:
+                $output = '\\x'.$hex;
+                break;
+        }
+
+        return $output;
+    }
+
+
+    /**
+     * Render character
+     */
+    protected function wrapControlCharacter(string $control): string
+    {
+        return $control;
+    }
+
+    /**
+     * Render grammar
+     */
+    protected function renderGrammar(string $grammar): string
+    {
+        return $grammar;
+    }
+
+    /**
+     * Render pointer
+     */
+    protected function renderPointer(string $pointer): string
+    {
+        return $pointer;
+    }
+
+    /**
+     * Render line number
+     */
+    protected function renderLineNumber(int $number): string
+    {
+        return (string)$number;
+    }
+
+    /**
+     * Render file path
+     */
+    protected function renderSourceFile(string $path): string
+    {
+        return $path;
+    }
+
+    /**
+     * Render source line
+     */
+    protected function renderSourceLine(int $number): string
+    {
+        return (string)$number;
+    }
+
+
+
+
+
+    /**
+     * Split const name for rendering
+     */
+    protected function renderConstName(string $const): string
+    {
+        $parts = explode('::', $const, 2);
+        $const = array_pop($parts);
+
+        if (empty($parts)) {
+            $class = null;
+            $parts = explode('\\', $const);
+            $const = array_pop($parts);
+        } else {
+            $parts = explode('\\', array_shift($parts));
+            $class = array_pop($parts);
+        }
+
+        $namespace = implode('\\', $parts);
+
+        if (empty($namespace)) {
+            $namespace = '\\';
+        }
+
+        $output = [];
+
+        $output[] = $this->renderSignatureNamespace($namespace);
+
+        if ($class !== null) {
+            $output[] = $this->renderSignatureClass($class);
+            $output[] = $this->renderSignatureCallType('::');
+        }
+
+        $output[] = $this->renderSignatureConstant($const);
+
+        return $this->wrapSignature(implode('', $output), 'const');
+    }
+
+
+    /**
+     * Render stack frame signature
+     */
+    protected function renderStackFrameSignature(Frame $frame): string
+    {
+        $output = [];
+
+        // Namespace
+        if (null !== ($class = $frame->getClassName())) {
+            $output[] = $this->renderSignatureNamespace($frame->getNamespace().'\\');
+            $output[] = $this->renderSignatureClass($frame::normalizeClassName($class));
+        }
+
+        // Type
+        if ($frame->getInvokeType() !== null) {
+            $output[] = $this->renderSignatureCallType($frame->getInvokeType());
+        }
+
+        // Function
+        if (false !== strpos($function = $frame->getFunctionName(), '{closure}')) {
+            $output[] = $this->wrapSignatureFunction($this->renderSignatureClosure(), 'closure');
+        } else {
+            if (false !== strpos($function, ',')) {
+                $parts = explode(',', $function);
+                $parts = array_map('trim', $parts);
+                $function = [];
+                $fArgs = [];
+
+                $function[] = $this->renderSignatureBracket('{');
+
+                foreach ($parts as $part) {
+                    $fArgs[] = $this->renderString($part, 'identifier');
+                }
+
+                $function[] = implode(', ', $fArgs);
+                $function[] = $this->renderSignatureBracket('}');
+                $function = implode($function);
+            } else {
+                $function = $this->esc($function);
+            }
+
+            $output[] = $this->wrapSignatureFunction($function);
+        }
+
+        // Args
+        $output[] = $this->renderSignatureBracket('(');
+        $args = [];
+
+        foreach ($frame->getArgs() as $arg) {
+            if (is_object($arg)) {
+                $args[] = $this->renderSignatureObject($frame::normalizeClassName(get_class($arg)));
+            } elseif (is_array($arg)) {
+                $args[] = $this->wrapSignatureArray(
+                    $this->renderSignatureBracket('[').count($arg).$this->renderSignatureBracket(']')
+                );
+            } else {
+                switch (true) {
+                    case $arg === null:
+                        $args[] = $this->renderNull();
+                        break;
+
+                    case is_bool($arg):
+                        $args[] = $this->renderBool($arg);
+                        break;
+
+                    case is_int($arg):
+                        $args[] = $this->renderInt($arg);
+                        break;
+
+                    case is_float($arg):
+                        $args[] = $this->renderFloat($arg);
+                        break;
+
+                    case is_string($arg):
+                        $args[] = $this->renderString($arg, null, 16);
+                        break;
+
+                    default:
+                        $args[] = '';
+                        break;
+                }
+            }
+        }
+
+        $output[] = implode($this->renderSignatureComma().' ', $args);
+        $output[] = $this->renderSignatureBracket(')');
+
+        return implode('', $output);
+    }
+
+
+    /**
+     * Passthrough signature
+     */
+    protected function wrapSignature(string $signature, ?string $class=null): string
+    {
+        return $signature;
+    }
+
+    /**
+     * Passthrough namespace
+     */
+    protected function renderSignatureNamespace(string $namespace): string
+    {
+        return $namespace;
+    }
+
+    /**
+     * Passthrough class
+     */
+    protected function renderSignatureClass(string $class): string
+    {
+        return $class;
+    }
+
+    /**
+     * Passthrough call type
+     */
+    protected function renderSignatureCallType(string $type): string
+    {
+        return $type;
+    }
+
+    /**
+     * Passthrough constant
+     */
+    protected function renderSignatureConstant(string $constant): string
+    {
+        return $constant;
+    }
+
+    /**
+     * Passthrough function
+     */
+    protected function wrapSignatureFunction(string $function, ?string $class=null): string
+    {
+        return $function;
+    }
+
+    /**
+     * Passthrough closure
+     */
+    protected function renderSignatureClosure(): string
+    {
+        return 'closure';
+    }
+
+    /**
+     * Passthrough bracket
+     */
+    protected function renderSignatureBracket(string $bracket): string
+    {
+        return $bracket;
+    }
+
+    /**
+     * Passthrough comma
+     */
+    protected function renderSignatureComma(): string
+    {
+        return ',';
+    }
+
+    /**
+     * Passthrough
+     */
+    protected function wrapSignatureArray(string $array, ?string $class=null): string
+    {
+        return $array;
+    }
+
+    /**
+     * Passthrough
+     */
+    protected function renderSignatureObject(string $object): string
+    {
+        return $object;
+    }
+
+
+
+
+
+    /**
+     * Render an individual entity
+     */
+    protected function renderEntity(Entity $entity): string
+    {
+        $id = $linkId = $entity->getId();
+        $name = $this->esc($entity->getName() ?? $entity->getType());
+        $showInfo = true;
+        $isRef = $showClass = false;
+        $hasText = $entity->getText() !== null;
+        $hasProperties = (bool)$entity->getProperties();
+        $hasValues = (bool)$entity->getValues();
+        $hasStack = (bool)$entity->getStackTrace();
+        $open = $entity->isOpen();
+
+        switch ($type = $entity->getType()) {
+            case 'arrayReference':
+                $name = 'array';
+
+                // no break
+            case 'objectReference':
+                $linkId = 'ref-'.$id.'-'.spl_object_id($entity);
+                $name = $this->wrapReferenceName($name);
+                $isRef = true;
+                break;
+
+            case 'resource':
+                $showInfo = false;
+                break;
+
+            case 'class':
+            case 'interface':
+            case 'trait':
+                $showClass = true;
+                $showInfo = false;
+                break;
+
+            case 'stack':
+                $showInfo = false;
+                $showStack = false;
+                break;
+
+            case 'flags':
+                $showInfo = false;
+                break;
+
+            case 'const':
+                $showInfo = false;
+                $const = $entity->getName();
+                $name = $this->renderConstName($const);
+                break;
+        }
+
+        $header = [];
+
+        // Name
+        if ($isRef) {
+            $header[] = $this->wrapEntityNameReference($name, $open, $id);
+        } else {
+            $header[] = $this->wrapEntityName($name, $open, $linkId);
+        }
+
+        // Length
+        if (null !== ($length = $entity->getLength())) {
+            $header[] = $this->renderEntityLength($length);
+        }
+
+        // Class
+        if ($showClass) {
+            $header[] = $this->renderPointer(':');
+            $header[] = $this->renderEntityClassName($entity->getClass());
+        }
+
+        // Info
+        if ($showInfo) {
+            $header[] = $this->renderEntityInfoButton($linkId);
+        }
+
+        // Meta
+        if ($showMeta = (bool)$entity->getAllMeta()) {
+            $header[] = $this->renderEntityMetaButton($linkId);
+        }
+
+        // Text
+        if ($hasText) {
+            $header[] = $this->renderEntityTextButton($linkId);
+        }
+
+        // Properties
+        if ($hasProperties) {
+            $header[] = $this->renderEntityPropertiesButton($linkId);
+        }
+
+        // Values
+        if ($hasValues) {
+            $header[] = $this->renderEntityValuesButton($linkId);
+        }
+
+        // Stack
+        if ($hasStack) {
+            $header[] = $this->renderEntityStackButton($type, $open, $linkId);
+        }
+
+        // Bracket
+        if ($hasBody = ($showInfo || $showMeta || $hasText || $hasProperties || $hasValues || $hasStack)) {
+            $header[] = $this->renderGrammar('{');
+        }
+
+        // Object id
+        if (null !== ($objectId = $entity->getObjectId())) {
+            $header[] = $this->renderEntityOid($objectId, $isRef, $id);
+        }
+
+
+        $output = [];
+        $output[] = $this->wrapEntityHeader(implode($header), $type, $linkId);
+
+
+
+        // Body
+        if ($hasText || $hasProperties || $hasValues || $hasStack) {
+            $body = [];
+
+            // Info
+            if ($showInfo) {
+                $body[] = $this->renderInfoBlock($entity);
+            }
+
+            // Meta
+            if ($showMeta) {
+                $body[] = $this->renderMetaBlock($entity);
+            }
+
+            // Text
+            if ($hasText) {
+                $body[] = $this->renderTextBlock($entity);
+            }
+
+            // Properties
+            if ($hasProperties) {
+                $body[] = $this->renderPropertiesBlock($entity);
+            }
+
+            // Values
+            if ($hasValues) {
+                $body[] = $this->renderValuesBlock($entity);
+            }
+
+            // Stack
+            if ($hasStack) {
+                $body[] = $this->renderStackBlock($entity);
+            }
+
+            $output[] = $this->wrapEntityBody(implode("\n", $body), $open, $linkId);
+        }
+
+        // Footer
+        if ($hasBody) {
+            $output[] = $this->wrapEntityFooter($this->renderGrammar('}'));
+        }
+
+        return implode("\n", $output);
+    }
+
+
+    /**
+     * Passthrough header
+     */
+    protected function wrapEntityHeader(string $header, string $type, string $linkId): string
+    {
+        return $header;
+    }
+
+    /**
+     * Passthrough reference name
+     */
+    protected function wrapReferenceName(string $name): string
+    {
+        return $name;
+    }
+
+    /**
+     * Passthrough entity name
+     */
+    protected function wrapEntityName(string $name, bool $open, string $linkId): string
+    {
+        return $name;
+    }
+
+
+    /**
+     * Passthrough entity name reference
+     */
+    protected function wrapEntityNameReference(string $name, bool $open, string $id): string
+    {
+        return $name;
+    }
+
+
+    /**
+     * render entity length
+     */
+    protected function renderEntityLength(int $length): string
+    {
+        return $length;
+    }
+
+    /**
+     * render entity class name
+     */
+    protected function renderEntityClassName(string $class): string
+    {
+        return $class;
+    }
+
+
+    /**
+     * Empty info button stub
+     */
+    protected function renderEntityInfoButton(string $linkId): string
+    {
+        return '';
+    }
+
+    /**
+     * Empty meta button stub
+     */
+    protected function renderEntityMetaButton(string $linkId): string
+    {
+        return '';
+    }
+
+    /**
+     * Empty text button stub
+     */
+    protected function renderEntityTextButton(string $linkId): string
+    {
+        return '';
+    }
+
+    /**
+     * Empty properties button stub
+     */
+    protected function renderEntityPropertiesButton(string $linkId): string
+    {
+        return '';
+    }
+
+    /**
+     * Empty values button stub
+     */
+    protected function renderEntityValuesButton(string $linkId): string
+    {
+        return '';
+    }
+
+    /**
+     * Empty stack button stub
+     */
+    protected function renderEntityStackButton(string $type, bool $open, string $linkId): string
+    {
+        return '';
+    }
+
+
+    /**
+     * render entity object id
+     */
+    protected function renderEntityOid(int $objectId, bool $isRef, string $id): string
+    {
+        return $objectId;
+    }
+
+
+
+
+    /**
+     * Render entity info block
+     */
+    protected function renderInfoBlock(Entity $entity): string
+    {
+        $id = $linkId = $entity->getId();
+
+        switch ($entity->getType()) {
+            case 'arrayReference':
+            case 'objectReference':
+                $linkId = 'ref-'.$id.'-'.spl_object_id($entity);
+                break;
+        }
+
+        $type = $entity->getType();
+        $info = [];
+        $showClass = false;
+
+        // Type
+        switch ($type) {
+            case 'object':
+            case 'objectReference':
+            case 'const':
+                $showClass = true;
+                break;
+
+            case 'array':
+            case 'arrayReference':
+            case 'class':
+            case 'interface':
+            case 'trait':
+                break;
+
+            default:
+                $info['type'] = $type;
+                break;
+        }
+
+        // Class
+        if ($showClass && null !== ($class = $entity->getClass())) {
+            $info['class'] = $class;
+        }
+
+        // Location
+        if ($file = $entity->getFile()) {
+            $info['location'] = $this->context->normalizePath($file).' : '.$entity->getStartLine();
+        }
+
+        // Parents
+        if ($parents = $entity->getParentClasses()) {
+            $info['parentClasses'] = $parents;
+        }
+
+        // Interfaces
+        if ($interfaces = $entity->getInterfaces()) {
+            $info['interfaces'] = $interfaces;
+        }
+
+        // Traits
+        if ($traits = $entity->getTraits()) {
+            $info['traits'] = $traits;
+        }
+
+        // Hash
+        if (($hash = $entity->getHash()) || $type == 'array') {
+            $info['hash'] = $hash;
+        }
+
+        $output = $this->renderList($info, 'info');
+        return $this->wrapEntityBodyBlock($output, 'info', false, $linkId);
+    }
+
+    /**
+     * Render entity meta block
+     */
+    protected function renderMetaBlock(Entity $entity): string
+    {
+        $id = $entity->getId();
+        $output = $this->renderList($entity->getAllMeta(), 'meta');
+        return $this->wrapEntityBodyBlock($output, 'meta', false, $id);
+    }
+
+    /**
+     * Render entity text block
+     */
+    protected function renderTextBlock(Entity $entity): string
+    {
+        $id = $entity->getId();
+        $type = $entity->getType();
+
+        if ($type === 'binary') {
+            $chunks = explode("\n", trim(chunk_split($entity->getText(), 2, "\n")));
+            $output = [];
+
+            foreach ($chunks as $chunk) {
+                $output[] = $this->renderBinaryStringChunk($chunk);
+            }
+
+            $output = implode($output);
+        } else {
+            $output = $this->renderScalar($entity->getText());
+        }
+
+        return $this->wrapEntityBodyBlock($output, 'text', true, $id);
+    }
+
+    /**
+     * Render entity properties block
+     */
+    protected function renderPropertiesBlock(Entity $entity): string
+    {
+        $id = $entity->getId();
+        $output = $this->renderList($entity->getProperties(), 'properties');
+        return $this->wrapEntityBodyBlock($output, 'properties', true, $id);
+    }
+
+    /**
+     * Render entity values block
+     */
+    protected function renderValuesBlock(Entity $entity): string
+    {
+        $id = $entity->getId();
+        $output = $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys());
+        return $this->wrapEntityBodyBlock($output, 'values', true, $id);
+    }
+
+
+    /**
+     * Render entity stack trace block
+     */
+    protected function renderStackBlock(Entity $entity): string
+    {
+        $id = $entity->getId();
+        $type = $entity->getType();
+        $trace = $entity->getStackTrace();
+
+        if ($type == 'stack') {
+            $count = count($trace);
+            $lines = [];
+
+            foreach ($trace as $i => $frame) {
+                $line = [];
+                $line[] = $this->renderLineNumber($count - $i);
+                $line[] = $this->wrapSignature($this->renderStackFrameSignature($frame));
+                $line[] = $this->renderSourceFile($this->context->normalizePath($frame->getCallingFile()));
+                $line[] = $this->renderSourceLine($frame->getCallingLine());
+                $lines[] = implode("\n", $line);
+            }
+
+            $output = $this->renderBasicList($lines, 'stack');
+        } else {
+            $newEntity = (new Entity('stack'))
+                ->setName('stack')
+                ->setStackTrace($trace)
+                ->setLength($trace->count());
+
+            $output = $this->renderEntity($newEntity);
+        }
+
+        return $this->wrapEntityBodyBlock($output, 'stack', true, $id);
+    }
+
+
+    /**
+     * Wrap entity body
+     */
+    protected function wrapEntityBody(string $body, bool $open, string $linkId): string
+    {
+        return $body;
+    }
+
+
+    /**
+     * Wrap entity body block
+     */
+    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId): string
+    {
+        return $block;
+    }
+
+
+    /**
+     * Wrap entity footer
+     */
+    protected function wrapEntityFooter(string $footer): string
+    {
+        return $footer;
+    }
+
+
+    /**
+     * Render list
+     */
+    protected function renderList(array $items, string $style, bool $includeKeys=true, string $class=null): string
+    {
+        $output[] = '<ul class="list '.$style.' '.$class.'">';
+        $lines = [];
+        $pointer = '=>';
+        $asIdentifier = $access = false;
+
+        switch ($style) {
+            case 'info':
+            case 'meta':
+                $pointer = ':';
+                $asIdentifier = true;
+                break;
+
+            case 'properties':
+                $access = true;
+                break;
+        }
+
+        foreach ($items as $key => $value) {
+            $line = [];
+
+            if ($includeKeys) {
+                $mod = 'public';
+
+                if ($access) {
+                    $first = substr($key, 0, 1);
+
+                    if ($first == '*') {
+                        $key = substr($key, 1);
+                        $mod = 'protected';
+                    } elseif ($first == '!') {
+                        $key = substr($key, 1);
+                        $mod = 'private';
+                    } elseif ($first == '%') {
+                        $key = substr($key, 1);
+                        $mod = 'virtual';
+                    }
+                }
+
+                $line[] = $this->renderScalar($key, 'identifier key '.$mod);
+                $line[] = $this->renderPointer($pointer);
+            }
+
+            if ($value instanceof Entity) {
+                $line[] = $this->renderEntity($value);
+            } elseif (is_array($value)) {
+                $isAssoc = $this->arrayIsAssoc($value);
+                $line[] = implode("\n", [
+                    $this->renderGrammar('{'),
+                    $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline'),
+                    $this->renderGrammar('}')
+                ]);
+            } else {
+                $line[] = $this->renderScalar($value, $asIdentifier ? 'identifier' : null);
+            }
+
+            $lines[] = implode(' ', $line);
+        }
+
+
+        return $this->renderBasicList($lines);
+    }
+
+
+    /**
+     * Render basic list
+     */
+    protected function renderBasicList(array $lines, ?string $class=null): string
+    {
+        return implode("\n", $lines);
+    }
+
+
+
+    /**
+     * Test if array is associative
+     */
+    protected function arrayIsAssoc(array $arr): bool
+    {
+        if (empty($arr)) {
+            return false;
+        }
+
+        return array_keys($arr) !== range(0, count($arr) - 1);
+    }
+
+
+    /**
+     * Escape a value for output
+     */
+    protected function esc(?string $value): string
+    {
+        return $value ?? '';
+    }
+}
diff --git a/src/Glitch/Renderer/Html.php b/src/Glitch/Renderer/Html.php
index f1ccdf0..dfba9b2 100644
--- a/src/Glitch/Renderer/Html.php
+++ b/src/Glitch/Renderer/Html.php
@@ -15,110 +15,17 @@
 
 class Html implements Renderer
 {
-    const SPACES = 2;
-
-    protected $output = [];
-    protected $context;
-
-
-    /**
-     * Construct with Context
-     */
-    public function __construct(Context $context)
-    {
-        $this->context = $context;
-    }
-
-
-    /**
-     * Convert Dump object to HTML string
-     */
-    public function renderDump(Dump $dump, bool $isFinal=false): string
-    {
-        $this->output = [];
-        $space = str_repeat(' ', self::SPACES);
-
-        // Header
-        $this->renderHeader();
-
-
-        // Stats
-        $this->output[] = '<header class="stats container-fluid">';
-
-        foreach ($dump->getStats() as $key => $stat) {
-            $this->output[] = $space.'<span class="stat stat-'.$key.' badge badge-'.$stat->getClass().'" title="'.$this->esc($stat->getName()).'">'.$stat->render('html').'</span>';
-        }
-
-        $this->output[] = '</header>';
-
-
-        // Entities
-        $this->output[] = '<div class="container-fluid">';
-
-        foreach ($dump->getEntities() as $value) {
-            $this->output[] = '<samp class="dump">';
-
-            if ($value instanceof Entity) {
-                $this->renderEntity($value);
-            } else {
-                $this->renderScalar($value);
-            }
-
-            $this->output[] = '</samp>';
-        }
-
-
-        // Trace
-        if ($trace = $dump->getTrace()) {
-            $this->output[] = '<samp class="dump trace">';
-            $this->renderEntity(
-                (new Entity('stack'))
-                    ->setName('stack')
-                    ->setStackTrace($trace)
-                    ->setOpen(false)
-                    ->setLength($trace->count())
-            );
-
-            $this->output[] = '</samp>';
-        }
-
-        $this->output[] = '</div>';
-
-
-        // Footer
-        $this->output[] = '</body>';
-        $this->output[] = '</html>';
-
-        $html = implode("\n", $this->output);
-        $this->output = [];
-
-
-        // Wrap in iframe
-        $id = uniqid('glitch-dump');
-
-        $output = [];
-        $output[] = '<iframe id="'.$id.'" frameborder="0" class="glitch-dump"></iframe>';
-        $output[] = '<style>';
-        $output[] = '.glitch-dump { width: 100%; height: 30rem; border: 1px solid #EEE; }';
-        $output[] = '.glitch-dump:only-of-type { height: calc(100% - 8px); border: none; }';
-        $output[] = '</style>';
-        $output[] = '<script>';
-        $output[] = 'var doc = document.getElementById(\''.$id.'\').contentWindow.document;';
-        $output[] = 'doc.open();doc.write('.json_encode($html).');doc.close();';
-        $output[] = '</script>';
-
-        return implode("\n", $output);
-    }
-
+    use Base;
 
     /**
      * Render scripts and styles
      */
-    protected function renderHeader(): void
+    protected function renderHeader(): string
     {
-        $this->output[] = '<!doctype html>';
-        $this->output[] = '<html lang="en">';
-        $this->output[] = '<head>';
+        $output = [];
+        $output[] = '<!doctype html>';
+        $output[] = '<html lang="en">';
+        $output[] = '<head>';
 
         $vendor = $this->context->getVendorPath();
 
@@ -136,63 +43,128 @@ protected function renderHeader(): void
 
 
         // Meta
-        $this->output[] = '<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">';
+        $output[] = '<meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">';
 
 
         // Css
         foreach ($css as $name => $path) {
-            $this->output[] = '<style id="style-'.$name.'">';
-            $this->output[] = file_get_contents($path);
-            $this->output[] = '</style>';
+            $output[] = '<style id="style-'.$name.'">';
+            $output[] = file_get_contents($path);
+            $output[] = '</style>';
         }
 
         // Js
         foreach ($js as $name => $path) {
-            $this->output[] = '<script id="script-'.$name.'">';
-            $this->output[] = file_get_contents($path);
-            $this->output[] = '</script>';
+            $output[] = '<script id="script-'.$name.'">';
+            $output[] = file_get_contents($path);
+            $output[] = '</script>';
         }
 
 
         $output[] = '</head>';
         $output[] = '<body>';
+
+        return implode("\n", $output);
     }
 
 
     /**
-     * Render a scalar value
+     * Build a stat list header bar
      */
-    protected function renderScalar($value, ?string $class=null): void
+    protected function renderStats(array $stats): string
     {
-        switch (true) {
-            case $value === null:
-                $output = $this->renderNull($class);
-                break;
+        $output = [];
+        $output[] = '<header class="stats container-fluid">';
 
-            case is_bool($value):
-                $output = $this->renderBool($value, $class);
-                break;
+        foreach ($stats as $key => $stat) {
+            $output[] = '<span class="stat stat-'.$key.' badge badge-'.$stat->getClass().'" title="'.$this->esc($stat->getName()).'">'.$stat->render('html').'</span>';
+        }
 
-            case is_int($value):
-                $output = $this->renderInt($value, $class);
-                break;
+        $output[] = '</header>';
+        return implode("\n", $output);
+    }
 
-            case is_float($value):
-                $output = $this->renderFloat($value, $class);
-                break;
+    /**
+     * Render dump entity list
+     */
+    protected function renderDumpEntities(Dump $dump): string
+    {
+        $output = [];
+        $output[] = '<div class="container-fluid">';
 
-            case is_string($value):
-                $output = $this->renderString($value, $class);
-                break;
+        foreach ($dump->getEntities() as $value) {
+            $output[] = '<samp class="dump">';
 
-            default:
-                $output = '';
-                break;
+            if ($value instanceof Entity) {
+                $output[] = $this->renderEntity($value);
+            } else {
+                $output[] = $this->renderScalar($value);
+            }
+
+            $output[] = '</samp>';
         }
 
-        $this->output[] = $output;
+        $output[] = '</div>';
+        return implode("\n", $output);
     }
 
+    /**
+     * Render final stack trace
+     */
+    protected function renderTrace(Trace $trace): string
+    {
+        $output = [];
+        $output[] = '<div class="container-fluid">';
+        $output[] = '<samp class="dump trace">';
+
+        $output[] = $this->renderEntity(
+            (new Entity('stack'))
+                ->setName('stack')
+                ->setStackTrace($trace)
+                ->setOpen(false)
+                ->setLength($trace->count())
+        );
+
+        $output[] = '</samp>';
+        $output[] = '</div>';
+        return implode("\n", $output);
+    }
+
+    /**
+     * Render final tags
+     */
+    protected function renderFooter(): string
+    {
+        $output = [];
+        $output[] = '</body>';
+        $output[] = '</html>';
+
+        return implode("\n", $output);
+    }
+
+    /**
+     * Implode buffer and wrap it in JS iframe injector
+     */
+    protected function exportBuffer(array $buffer): string
+    {
+        $html = implode("\n", $buffer);
+        $id = uniqid('glitch-dump');
+
+        $output = [];
+        $output[] = '<iframe id="'.$id.'" frameborder="0" class="glitch-dump"></iframe>';
+        $output[] = '<style>';
+        $output[] = '.glitch-dump { width: 100%; height: 30rem; border: 1px solid #EEE; }';
+        $output[] = '.glitch-dump:only-of-type { height: calc(100% - 8px); border: none; }';
+        $output[] = '</style>';
+        $output[] = '<script>';
+        $output[] = 'var doc = document.getElementById(\''.$id.'\').contentWindow.document;';
+        $output[] = 'doc.open();doc.write('.json_encode($html).');doc.close();';
+        $output[] = '</script>';
+
+        return implode("\n", $output);
+    }
+
+
 
 
     /**
@@ -224,668 +196,361 @@ protected function renderInt(int $value, ?string $class=null): string
      */
     protected function renderFloat(float $value, ?string $class=null): string
     {
-        return '<span class="float'.($class !== null ? ' '.$class : null).'">'.$this->formatFloat($value).'</span>';
+        return '<span class="float'.($class !== null ? ' '.$class : null).'">'.$this->normalizeFloat($value).'</span>';
     }
 
-    protected function formatFloat(float $number): string
-    {
-        $output = (string)$number;
 
-        if (false === strpos($output, '.')) {
-            $output .= '.0';
-        }
 
-        return $output;
+    /**
+     * render a single identifier string
+     */
+    protected function renderIdentifierString(string $string, string $class, int $forceSingleLineMax=null): string
+    {
+        return '<span class="string '.$class.'">'.$this->renderStringLine($string, $forceSingleLineMax).'</span>';
     }
 
-
     /**
-     * Render standard string
+     * render a standard multi line string
      */
-    protected function renderString(string $string, ?string $class=null, int $forceSingleLineMax=null): string
+    protected function renderMultiLineString(string $string): string
     {
-        $isMultiLine = $forceSingleLineMax === null && false !== strpos($string, "\n");
-
-        if ($class !== null) {
-            return '<span class="string '.$class.'">'.$this->prepareStringLine($string, $forceSingleLineMax).'</span>';
-        } elseif ($isMultiLine) {
-            $string = str_replace("\r", '', $string);
-            $parts = explode("\n", $string);
-            $count = count($parts);
+        $string = str_replace("\r", '', $string);
+        $parts = explode("\n", $string);
+        $count = count($parts);
 
-            $output = [];
-            $output[] = '<div class="string m'.($count > 10 ? ' large' : null).'"><span class="length">'.mb_strlen($string).'</span>';
-
-            foreach ($parts as $part) {
-                $output[] = '<div class="line">'.$this->prepareStringLine($part).'</div>';
-            }
-
-            $output[] = '</div>';
-            return implode('', $output);
-        } else {
-            $output = '<span class="string s"><span class="line">'.$this->prepareStringLine($string, $forceSingleLineMax).'</span>';
-
-            if ($forceSingleLineMax === null) {
-                $output .= '<span class="length">'.mb_strlen($string).'</span>';
-            }
-
-            $output .= '</span>';
+        $output = [];
+        $output[] = '<div class="string m'.($count > 10 ? ' large' : null).'"><span class="length">'.mb_strlen($string).'</span>';
 
-            return $output;
+        foreach ($parts as $part) {
+            $output[] = '<div class="line">'.$this->renderStringLine($part).'</div>';
         }
+
+        $output[] = '</div>';
+        return implode('', $output);
     }
 
     /**
-     * Prepare string for rendering
+     * render a standard single line string
      */
-    protected function prepareStringLine(string $line, int $maxLength=null): string
+    protected function renderSingleLineString(string $string, int $forceSingleLineMax=null): string
     {
-        $shorten = false;
+        $output = '<span class="string s"><span class="line">'.$this->renderStringLine($string, $forceSingleLineMax).'</span>';
 
-        if ($maxLength !== null && strlen($line) > $maxLength) {
-            $shorten = true;
-            $line = substr($line, 0, $maxLength);
+        if ($forceSingleLineMax === null) {
+            $output .= '<span class="length">'.mb_strlen($string).'</span>';
         }
 
-        $output = $this->esc($line);
-
-        $output = preg_replace_callback('/[[:cntrl:]]/', function ($matches) {
-            $hex = implode(unpack("H*", $matches[0]));
-
-            switch ($hex) {
-                case '07':
-                    $output = '\\a';
-                    break;
-
-                case '1B':
-                    $output = '\\e';
-                    break;
-
-                case '0C':
-                    $output = '\\f';
-                    break;
-
-                case '0A':
-                    $output = '\\n';
-                    break;
-
-                case '0D':
-                    $output = '\\r';
-                    break;
-
-                case '09':
-                    $output = '\\t';
-                    break;
-
-                default:
-                    $output = '\\x'.$hex;
-                    break;
-            }
-
-            return '<span class="control">'.$output.'</span>';
-        }, $output);
-
-        if ($shorten) {
-            $output .= '<span class="g">…</span>';
-        }
+        $output .= '</span>';
 
         return $output;
     }
 
-
-
     /**
-     * Render an individual entity
+     * render binary string chunk
      */
-    protected function renderEntity(Entity $entity): void
+    protected function renderBinaryStringChunk(string $chunk): string
     {
-        $id = $linkId = $entity->getId();
-        $name = $this->esc($entity->getName() ?? $entity->getType());
-        $showInfo = true;
-        $isRef = $showClass = false;
-        $hasText = $entity->getText() !== null;
-        $hasProperties = (bool)$entity->getProperties();
-        $hasValues = (bool)$entity->getValues();
-        $hasStack = (bool)$entity->getStackTrace();
-        $open = $entity->isOpen();
-
-        switch ($type = $entity->getType()) {
-            case 'arrayReference':
-                $name = 'array';
-
-                // no break
-            case 'objectReference':
-                $linkId = 'ref-'.$id.'-'.spl_object_id($entity);
-                $name = '<span class="ref">'.$name.'</span>';
-                $isRef = true;
-                break;
-
-            case 'resource':
-                $showInfo = false;
-                break;
-
-            case 'class':
-            case 'interface':
-            case 'trait':
-                $showClass = true;
-                $showInfo = false;
-                break;
-
-            case 'stack':
-                $showInfo = false;
-                $showStack = false;
-                break;
-
-            case 'flags':
-                $showInfo = false;
-                break;
-
-            case 'const':
-                $showInfo = false;
-                $const = $entity->getName();
-                $name = $this->renderConstName($const);
-                break;
-        }
-
-        $this->output[] = '<div class="entity title type-'.$type.'" id="'.$linkId.'">';
-
-        // Name
-        if ($isRef) {
-            $this->output[] = '<a class="name code'.($open ? null : ' collapsed').' ref" href="#'.$id.'">'.$name.'</a>';
-        } else {
-            $this->output[] = '<a class="name code'.($open ? null : ' collapsed').'" data-target="#body-'.$linkId.'">'.$name.'</a>';
-        }
-
-        // Length
-        if (null !== ($length = $entity->getLength())) {
-            $this->output[] = '<span class="length">'.$length.'</span>';
-        }
-
-        // Class
-        if ($showClass) {
-            $this->output[] = '<span class="pointer">:</span>';
-            $this->output[] = '<span class="class">'.$this->esc($entity->getClass()).'</span>';
-        }
-
-        // Info
-        if ($showInfo) {
-            $this->output[] = '<a data-target="#info-'.$linkId.'" class="info badge badge-info collapsed"><i>i</i></a>';
-        }
-
-        // Meta
-        if ($showMeta = (bool)$entity->getAllMeta()) {
-            $this->output[] = '<a data-target="#meta-'.$linkId.'" class="meta badge badge-secondary collapsed"><i>m</i></a>';
-        }
-
-        // Text
-        if ($hasText) {
-            $this->output[] = '<a data-target="#text-'.$linkId.'" class="text body badge badge-danger"><i>t</i></a>';
-        }
-
-        // Properties
-        if ($hasProperties) {
-            $this->output[] = '<a data-target="#properties-'.$linkId.'" class="properties body badge badge-primary"><i>p</i></a>';
-        }
-
-        // Values
-        if ($hasValues) {
-            $this->output[] = '<a data-target="#values-'.$linkId.'" class="values body badge badge-warning"><i>v</i></a>';
-        }
-
-        // Stack
-        if ($hasStack) {
-            if ($type === 'stack') {
-                $this->output[] = '<a data-target="#body-'.$linkId.'" class="stack badge badge-dark'.($open ? null : ' collapsed').'"><i>s</i></a>';
-            } else {
-                $this->output[] = '<a data-target="#stack-'.$linkId.'" class="stack body badge badge-dark"><i>s</i></a>';
-            }
-        }
-
-        // Bracket
-        if ($hasBody = ($showInfo || $showMeta || $hasText || $hasProperties || $hasValues || $hasStack)) {
-            $this->output[] = '<span class="g">{</span>';
-        }
-
-        // Object id
-        if (null !== ($objectId = $entity->getObjectId())) {
-            if ($isRef) {
-                $this->output[] = '<a href="#'.$id.'" class="ref oid">'.$this->esc((string)$objectId).'</a>';
-            } else {
-                $this->output[] = '<span class="oid">'.$this->esc((string)$objectId).'</span>';
-            }
-        }
-
-
-
-        $this->output[] = '</div>';
-
+        return '<i>'.$chunk.'</i>';
+    }
 
-        // Info
-        if ($showInfo) {
-            $this->renderInfoBlock($entity);
-        }
 
-        // Meta
-        if ($showMeta) {
-            $this->renderMetaBlock($entity);
-        }
+    /**
+     * render a detected ascii control character
+     */
+    protected function wrapControlCharacter(string $control): string
+    {
+        return '<span class="control">'.$control.'</span>';
+    }
 
+    /**
+     * render structure grammer
+     */
+    protected function renderGrammar(string $grammar): string
+    {
+        return '<span class="g">'.$this->esc($grammar).'</span>';
+    }
 
-        // Body
-        if ($hasText || $hasProperties || $hasValues || $hasStack) {
-            $this->output[] = '<div id="body-'.$linkId.'" class="collapse'.($open ? ' show' : null).' inner body">';
+    /**
+     * render structure pointer
+     */
+    protected function renderPointer(string $pointer): string
+    {
+        return '<span class="pointer">'.$this->esc($pointer).'</span>';
+    }
 
-            // Text
-            if ($hasText) {
-                $this->renderTextBlock($entity);
-            }
+    /**
+     * Render line number
+     */
+    protected function renderLineNumber(int $number): string
+    {
+        return '<span class="number">'.$number.'</span>';
+    }
 
-            // Properties
-            if ($hasProperties) {
-                $this->renderPropertiesBlock($entity);
-            }
+    /**
+     * Render file path
+     */
+    protected function renderSourceFile(string $path): string
+    {
+        return '<span class="file">'.$path.'</span>';
+    }
 
-            // Values
-            if ($hasValues) {
-                $this->renderValuesBlock($entity);
-            }
+    /**
+     * Render source line
+     */
+    protected function renderSourceLine(int $number): string
+    {
+        return '<span class="line">'.$number.'</span>';
+    }
 
-            // Stack
-            if ($hasStack) {
-                $this->renderStackBlock($entity);
-            }
 
-            $this->output[] = '</div>';
-        }
 
-        // Footer
-        if ($hasBody) {
-            $this->output[] = '<div class="entity footer">';
-            $this->output[] = '<span class="g">}</span>';
-            $this->output[] = '</div>';
-        }
+    /**
+     * render a signature block
+     */
+    protected function wrapSignature(string $signature, ?string $class=null): string
+    {
+        return '<span class="signature'.($class ? ' '.$class : null).'">'.$signature.'</span>';
     }
 
-
     /**
-     * Split const name for rendering
+     * render signature namespace part
      */
-    protected function renderConstName(string $const): string
+    protected function renderSignatureNamespace(string $namespace): string
     {
-        $parts = explode('::', $const, 2);
-        $const = array_pop($parts);
-
-        if (empty($parts)) {
-            $class = null;
-            $parts = explode('\\', $const);
-            $const = array_pop($parts);
-        } else {
-            $parts = explode('\\', array_shift($parts));
-            $class = array_pop($parts);
-        }
-
-        $namespace = implode('\\', $parts);
+        return '<i class="ns">'.$this->esc($namespace).'</i>';
+    }
 
-        if (empty($namespace)) {
-            $namespace = '\\';
-        }
+    /**
+     * render signature class part
+     */
+    protected function renderSignatureClass(string $class): string
+    {
+        return '<i class="cl">'.$this->esc($class).'</i>';
+    }
 
-        $output = [];
-        $output[] = '<span class="const signature">';
+    /**
+     * render signature call type part (:: or ->)
+     */
+    protected function renderSignatureCallType(string $type): string
+    {
+        return '<i class="ty">'.$this->esc($type).'</i>';
+    }
 
-        $output[] = '<i class="ns">'.$this->esc($namespace).'</i>';
+    /**
+     * render signature constant part
+     */
+    protected function renderSignatureConstant(string $constant): string
+    {
+        return '<i class="co">'.$this->esc($constant).'</i>';
+    }
 
-        if ($class !== null) {
-            $output[] = '<i class="cl">'.$this->esc($class).'</i>';
-            $output[] = '<i class="ty">::</i>';
-        }
+    /**
+     * Wrap signature function block
+     */
+    protected function wrapSignatureFunction(string $function, ?string $class=null): string
+    {
+        return '<i class="fn'.($class ? ' '.$class : null).'">'.$function.'</i>';
+    }
 
-        $output[] = '<i class="co">'.$this->esc($const).'</i>';
+    /**
+     * render signature bracket string
+     */
+    protected function renderSignatureBracket(string $bracket): string
+    {
+        return '<i class="br">'.$this->esc($bracket).'</i>';
+    }
 
-        $output[] = '</span>';
-        return implode('', $output);
+    /**
+     * render signature arg comma
+     */
+    protected function renderSignatureComma(): string
+    {
+        return '<i class="cm">,</i>';
     }
 
     /**
-     * Render entity info block
+     * Wrap signature array
      */
-    protected function renderInfoBlock(Entity $entity): void
+    protected function wrapSignatureArray(string $array, ?string $class=null): string
     {
-        $id = $linkId = $entity->getId();
+        return '<span class="ar'.($class ? ' '.$class : null).'">'.$array.'</span>';
+    }
 
-        switch ($entity->getType()) {
-            case 'arrayReference':
-            case 'objectReference':
-                $linkId = 'ref-'.$id.'-'.spl_object_id($entity);
-                break;
-        }
+    /**
+     * render signature object name
+     */
+    protected function renderSignatureObject(string $object): string
+    {
+        return '<i class="ob">'.$this->esc($object).'</i>';
+    }
 
-        $this->output[] = '<div id="info-'.$linkId.'" class="collapse inner"><div class="info">';
-
-        $type = $entity->getType();
-        $info = [];
-        $showClass = false;
-
-        // Type
-        switch ($type) {
-            case 'object':
-            case 'objectReference':
-            case 'const':
-                $showClass = true;
-                break;
-
-            case 'array':
-            case 'arrayReference':
-            case 'class':
-            case 'interface':
-            case 'trait':
-                break;
-
-            default:
-                $info['type'] = $type;
-                break;
-        }
 
-        // Class
-        if ($showClass && null !== ($class = $entity->getClass())) {
-            $info['class'] = $class;
-        }
 
-        // Location
-        if ($file = $entity->getFile()) {
-            $info['location'] = $this->context->normalizePath($file).' : '.$entity->getStartLine();
-        }
 
-        // Parents
-        if ($parents = $entity->getParentClasses()) {
-            $info['parentClasses'] = $parents;
-        }
+    /**
+     * Begin entity block
+     */
+    protected function wrapEntityHeader(string $header, string $type, string $linkId): string
+    {
+        return '<div class="entity title type-'.$type.'" id="'.$linkId.'">'.$header.'</div>';
+    }
 
-        // Interfaces
-        if ($interfaces = $entity->getInterfaces()) {
-            $info['interfaces'] = $interfaces;
-        }
+    /**
+     * Wrap entity name if reference
+     */
+    protected function wrapReferenceName(string $name): string
+    {
+        return '<span class="ref">'.$name.'</span>';
+    }
 
-        // Traits
-        if ($traits = $entity->getTraits()) {
-            $info['traits'] = $traits;
-        }
 
-        // Hash
-        if (($hash = $entity->getHash()) || $type == 'array') {
-            $info['hash'] = $hash;
-        }
 
-        $this->renderList($info, 'info');
+    /**
+     * Wrap entity name link
+     */
+    protected function wrapEntityName(string $name, bool $open, string $linkId): string
+    {
+        return '<a class="name code'.($open ? null : ' collapsed').'" data-target="#body-'.$linkId.'">'.$name.'</a>';
+    }
 
-        $this->output[] = '</div></div>';
+    /**
+     * Wrap entity name link reference
+     */
+    protected function wrapEntityNameReference(string $name, bool $open, string $id): string
+    {
+        return '<a class="name code'.($open ? null : ' collapsed').' ref" href="#'.$id.'">'.$name.'</a>';
     }
 
     /**
-     * Render entity meta block
+     * render entity length tag
      */
-    protected function renderMetaBlock(Entity $entity): void
+    protected function renderEntityLength(int $length): string
     {
-        $id = $entity->getId();
-        $this->output[] = '<div id="meta-'.$id.'" class="collapse inner"><div class="meta">';
-        $this->renderList($entity->getAllMeta(), 'meta');
-        $this->output[] = '</div></div>';
+        return '<span class="length">'.$length.'</span>';
     }
 
     /**
-     * Render entity text block
+     * render entity class name
      */
-    protected function renderTextBlock(Entity $entity): void
+    protected function renderEntityClassName(string $class): string
     {
-        $id = $entity->getId();
-        $type = $entity->getType();
+        return '<span class="class">'.$this->esc($class).'</span>';
+    }
 
-        $this->output[] = '<div id="text-'.$id.'" class="collapse show inner"><div class="text '.$type.'">';
 
-        if ($type === 'binary') {
-            $chunks = trim(chunk_split($entity->getText(), 2, "\n"));
-            $this->output[] = '<i>'.str_replace("\n", '</i><i>', $chunks).'</i>';
-        } else {
-            $this->renderScalar($entity->getText());
-        }
 
-        $this->output[] = '</div></div>';
+    /**
+     * render info toggle button
+     */
+    protected function renderEntityInfoButton(string $linkId): string
+    {
+        return '<a data-target="#info-'.$linkId.'" class="info body badge badge-info collapsed"><i>i</i></a>';
     }
 
     /**
-     * Render entity properties block
+     * render meta toggle button
      */
-    protected function renderPropertiesBlock(Entity $entity): void
+    protected function renderEntityMetaButton(string $linkId): string
     {
-        $id = $entity->getId();
-        $this->output[] = '<div id="properties-'.$id.'" class="collapse show inner"><div class="properties">';
-        $this->renderList($entity->getProperties(), 'properties');
-        $this->output[] = '</div></div>';
+        return '<a data-target="#meta-'.$linkId.'" class="meta body badge badge-secondary collapsed"><i>m</i></a>';
     }
 
     /**
-     * Render entity values block
+     * render text toggle button
      */
-    protected function renderValuesBlock(Entity $entity): void
+    protected function renderEntityTextButton(string $linkId): string
     {
-        $id = $entity->getId();
-        $this->output[] = '<div id="values-'.$id.'" class="collapse show inner"><div class="values">';
-        $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys());
-        $this->output[] = '</div></div>';
+        return '<a data-target="#text-'.$linkId.'" class="text body primary badge badge-danger"><i>t</i></a>';
     }
 
     /**
-     * Render entity stack trace block
+     * render properties toggle button
      */
-    protected function renderStackBlock(Entity $entity): void
+    protected function renderEntityPropertiesButton(string $linkId): string
     {
-        $id = $entity->getId();
-        $type = $entity->getType();
-        $trace = $entity->getStackTrace();
-        $this->output[] = '<div id="stack-'.$id.'" class="collapse show inner type-'.$type.'"><div class="stack">';
-
-        if ($type == 'stack') {
-            $this->renderStackList($trace);
-        } else {
-            $newEntity = (new Entity('stack'))
-                ->setName('stack')
-                ->setStackTrace($trace)
-                ->setLength($trace->count());
-
-            $this->renderEntity($newEntity);
-        }
-
-        $this->output[] = '</div></div>';
+        return '<a data-target="#properties-'.$linkId.'" class="properties body primary badge badge-primary"><i>p</i></a>';
     }
 
     /**
-     * Render entity stack list
+     * render values toggle button
      */
-    protected function renderStackList(Trace $trace): void
+    protected function renderEntityValuesButton(string $linkId): string
     {
-        $this->output[] = '<ul class="stack">';
-        $count = count($trace);
-
-        foreach ($trace as $i => $frame) {
-            $this->output[] = '<li>';
-            $this->output[] = '<span class="number">'.($count - $i).'</span>';
-            $this->output[] = '<span class="signature">';
-            $this->renderStackFrameSignature($frame);
-            $this->output[] = '</span>';
-            $this->output[] = '<span class="file">'.$this->context->normalizePath($frame->getCallingFile()).'</span>';
-            $this->output[] = '<span class="line">'.$frame->getCallingLine().'</span>';
-            $this->output[] = '</li>';
-        }
-
-        $this->output[] = '</ul>';
+        return '<a data-target="#values-'.$linkId.'" class="values body badge primary badge-warning"><i>v</i></a>';
     }
 
     /**
-     * Render stack frame signature
+     * render stack toggle button
      */
-    protected function renderStackFrameSignature(Frame $frame): void
+    protected function renderEntityStackButton(string $type, bool $open, string $linkId): string
     {
-        $output = [];
-
-        // Namespace
-        if (null !== ($class = $frame->getClassName())) {
-            $output[] = '<i class="ns">'.$this->esc($frame->getNamespace().'\\').'</i>';
-            $output[] = '<i class="cl">'.$this->esc($frame::normalizeClassName($class)).'</i>';
-        }
-
-        // Type
-        if ($frame->getType() !== null) {
-            $output[] = '<i class="ty">'.$this->esc($frame->getInvokeType()).'</i>';
-        }
-
-        // Function
-        if (false !== strpos($function = $frame->getFunctionName(), '{closure}')) {
-            $output[] = '<i class="fn closure">closure</i>';
+        if ($type === 'stack') {
+            return '<a data-target="#body-'.$linkId.'" class="stack badge badge-dark'.($open ? null : ' collapsed').'"><i>s</i></a>';
         } else {
-            if (false !== strpos($function, ',')) {
-                $parts = explode(',', $function);
-                $parts = array_map('trim', $parts);
-                $function = [];
-                $fArgs = [];
-
-                $function[] = '<i class="br">{</i> ';
-
-                foreach ($parts as $part) {
-                    $fArgs[] = $this->renderString($part, 'identifier');
-                }
-
-                $function[] = implode(', ', $fArgs);
-                $function[] = ' <i class="br">}</i>';
-                $function = implode($function);
-            } else {
-                $function = $this->esc($function);
-            }
-
-            $output[] = '<i class="fn">'.$function.'</i>';
-        }
-
-        // Args
-        $output[] = '<i class="br">(</i>';
-        $args = [];
-
-        foreach ($frame->getArgs() as $arg) {
-            if (is_object($arg)) {
-                $args[] = '<i class="ob">'.$frame::normalizeClassName(get_class($arg)).'</i>';
-            } elseif (is_array($arg)) {
-                $args[] = '<span class="ar"><i class="br">[</i>'.count($arg).'<i class="br">]</i></span>';
-            } else {
-                switch (true) {
-                    case $arg === null:
-                        $args[] = $this->renderNull();
-                        break;
-
-                    case is_bool($arg):
-                        $args[] = $this->renderBool($arg);
-                        break;
-
-                    case is_int($arg):
-                        $args[] = $this->renderInt($arg);
-                        break;
-
-                    case is_float($arg):
-                        $args[] = $this->renderFloat($arg);
-                        break;
-
-                    case is_string($arg):
-                        $args[] = $this->renderString($arg, null, 16);
-                        break;
-
-                    default:
-                        $args[] = '';
-                        break;
-                }
-            }
+            return '<a data-target="#stack-'.$linkId.'" class="stack body primary badge badge-dark"><i>s</i></a>';
         }
-
-        $output[] = implode('<i class="cm">,</i> ', $args);
-        $output[] = '<i class="br">)</i>';
-
-        $this->output[] = implode('', $output);
     }
 
 
     /**
-     * Render list
+     * render object id tag
      */
-    protected function renderList(array $items, string $style, bool $includeKeys=true, string $class=null): void
+    protected function renderEntityOid(int $objectId, bool $isRef, string $id): string
     {
-        $this->output[] = '<ul class="list '.$style.' '.$class.'">';
-        $pointer = '=&gt;';
-        $asIdentifier = $access = false;
-
-        switch ($style) {
-            case 'info':
-            case 'meta':
-                $pointer = ':';
-                $asIdentifier = true;
-                break;
-
-            case 'properties':
-                $access = true;
-                break;
+        if ($isRef) {
+            return '<a href="#'.$id.'" class="ref oid">'.$this->esc((string)$objectId).'</a>';
+        } else {
+            return '<span class="oid">'.$this->esc((string)$objectId).'</span>';
         }
+    }
 
-        foreach ($items as $key => $value) {
-            $this->output[] = '<li>';
-
-            if ($includeKeys) {
-                $mod = 'public';
-
-                if ($access) {
-                    $first = substr($key, 0, 1);
-
-                    if ($first == '*') {
-                        $key = substr($key, 1);
-                        $mod = 'protected';
-                    } elseif ($first == '!') {
-                        $key = substr($key, 1);
-                        $mod = 'private';
-                    } elseif ($first == '%') {
-                        $key = substr($key, 1);
-                        $mod = 'virtual';
-                    }
-                }
-
-                $this->renderScalar($key, 'identifier key '.$mod);
-                $this->output[] = '<span class="pointer">'.$pointer.'</span> ';
-            }
-
-            if ($value instanceof Entity) {
-                $this->renderEntity($value);
-            } elseif (is_array($value)) {
-                $isAssoc = $this->arrayIsAssoc($value);
-                $this->output[] = '<span class="g">{</span>';
-                $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline');
-                $this->output[] = '<span class="g">}</span>';
-            } else {
-                $this->renderScalar($value, $asIdentifier ? 'identifier' : null);
-            }
+    /**
+     * Wrap entity body
+     */
+    protected function wrapEntityBody(string $body, bool $open, string $linkId): string
+    {
+        return '<div id="body-'.$linkId.'" class="collapse'.($open ? ' show' : null).' inner body">'.$body.'</div>';
+    }
 
-            $this->output[] = '</li>';
-        }
+    /**
+     * Wrap entity body block
+     */
+    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId): string
+    {
+        return '<div id="'.$type.'-'.$linkId.'" class="collapse'.($open ? ' show': null).' inner type-'.$type.'"><div class="'.$type.'">'."\n".
+            $block."\n".
+        '</div></div>';
+    }
 
-        $this->output[] = '</ul>';
+    /**
+     * Wrap entity footer
+     */
+    protected function wrapEntityFooter(string $footer): string
+    {
+        return '<div class="entity footer">'.$footer.'</div>';
     }
 
-    protected function arrayIsAssoc(array $arr): bool
+
+    /**
+     * Render basic list
+     */
+    protected function renderBasicList(array $lines, ?string $class=null): string
     {
-        if (array() === $arr) {
-            return false;
+        $output = [];
+        $output[] = '<ul class="'.$class.'">';
+
+        foreach ($lines as $line) {
+            $output[] = '<li>'.$line.'</li>';
         }
 
-        return array_keys($arr) !== range(0, count($arr) - 1);
+        return implode("\n", $output);
     }
 
 
     /**
      * Escape a value for HTML
      */
-    public function esc(?string $value): string
+    protected function esc(?string $value): string
     {
         if ($value === null) {
             return '';
diff --git a/src/Glitch/Renderer/assets/dump.js b/src/Glitch/Renderer/assets/dump.js
index d40efb7..df7a3cb 100644
--- a/src/Glitch/Renderer/assets/dump.js
+++ b/src/Glitch/Renderer/assets/dump.js
@@ -45,7 +45,7 @@ $(function() {
             $badge.toggleClass('collapsed', !isCollapsed);
 
             if(isName && isCollapsed && !otherChildren) {
-                var $first = $entity.find('a.body:first');
+                var $first = $entity.find('a.primary:first');
 
                 if(!$first.length) {
                     $first = $entity.find('a.badge:first');

From 83067fb6215f6a3ae65fee29f8ec6daf53e8844f Mon Sep 17 00:00:00 2001
From: Tom Wright <tom@inflatablecookie.com>
Date: Tue, 3 Sep 2019 18:51:53 +0100
Subject: [PATCH 2/3] Added Text renderer

Signed-off-by: Tom Wright <tom@inflatablecookie.com>
---
 src/Glitch/Renderer/Base.php | 123 +++++++++++++++++++++++++++--------
 src/Glitch/Renderer/Html.php |   4 +-
 src/Glitch/Renderer/Text.php |  31 +++++++++
 3 files changed, 130 insertions(+), 28 deletions(-)
 create mode 100644 src/Glitch/Renderer/Text.php

diff --git a/src/Glitch/Renderer/Base.php b/src/Glitch/Renderer/Base.php
index 7868aa6..4f40d15 100644
--- a/src/Glitch/Renderer/Base.php
+++ b/src/Glitch/Renderer/Base.php
@@ -15,6 +15,8 @@
 
 trait Base
 {
+    //const SPACES = 2;
+
     protected $context;
 
     /**
@@ -64,11 +66,46 @@ protected function renderHeader(): string
      */
     protected function renderStats(array $stats): string
     {
-        return implode(' | ', $stats);
+        $output = [];
+
+        foreach ($stats as $stat) {
+            $output[] = $stat->render('text');
+        }
+
+        return implode(' | ', $output);
     }
 
-    abstract protected function renderDumpEntities(Dump $dump): string;
-    abstract protected function renderTrace(Trace $trace): string;
+    /**
+     * Render main list of entities
+     */
+    protected function renderDumpEntities(Dump $dump): string
+    {
+        $output = [];
+
+        foreach ($dump->getEntities() as $value) {
+            if ($value instanceof Entity) {
+                $output[] = $this->renderEntity($value);
+            } else {
+                $output[] = $this->renderScalar($value);
+            }
+        }
+
+        return implode("\n", $output);
+    }
+
+    /**
+     * Render final trace
+     */
+    protected function renderTrace(Trace $trace): string
+    {
+        return $this->renderEntity(
+            (new Entity('stack'))
+                ->setName('stack')
+                ->setStackTrace($trace)
+                ->setOpen(false)
+                ->setLength($trace->count())
+        );
+    }
 
     /**
      * Render dump footer
@@ -83,7 +120,7 @@ protected function renderFooter(): string
      */
     protected function exportBuffer(array $buffer): string
     {
-        return implode("\n", $buffer);
+        return implode("\n\n", $buffer);
     }
 
 
@@ -315,7 +352,7 @@ protected function renderPointer(string $pointer): string
      */
     protected function renderLineNumber(int $number): string
     {
-        return (string)$number;
+        return str_pad((string)$number, 2);
     }
 
     /**
@@ -674,12 +711,12 @@ protected function renderEntity(Entity $entity): string
 
 
         $output = [];
-        $output[] = $this->wrapEntityHeader(implode($header), $type, $linkId);
+        $output[] = $this->wrapEntityHeader(implode(' ', array_filter($header)), $type, $linkId);
 
 
 
         // Body
-        if ($hasText || $hasProperties || $hasValues || $hasStack) {
+        if ($hasBodyContent = $hasText || $hasProperties || $hasValues || $hasStack) {
             $body = [];
 
             // Info
@@ -712,7 +749,7 @@ protected function renderEntity(Entity $entity): string
                 $body[] = $this->renderStackBlock($entity);
             }
 
-            $output[] = $this->wrapEntityBody(implode("\n", $body), $open, $linkId);
+            $output[] = $this->wrapEntityBody(implode("\n", array_filter($body)), $open, $linkId);
         }
 
         // Footer
@@ -720,7 +757,7 @@ protected function renderEntity(Entity $entity): string
             $output[] = $this->wrapEntityFooter($this->renderGrammar('}'));
         }
 
-        return implode("\n", $output);
+        return implode($hasBodyContent ? "\n" : ' ', $output);
     }
 
 
@@ -737,7 +774,7 @@ protected function wrapEntityHeader(string $header, string $type, string $linkId
      */
     protected function wrapReferenceName(string $name): string
     {
-        return $name;
+        return '&'.$name;
     }
 
     /**
@@ -763,7 +800,7 @@ protected function wrapEntityNameReference(string $name, bool $open, string $id)
      */
     protected function renderEntityLength(int $length): string
     {
-        return $length;
+        return (string)$length;
     }
 
     /**
@@ -829,7 +866,7 @@ protected function renderEntityStackButton(string $type, bool $open, string $lin
      */
     protected function renderEntityOid(int $objectId, bool $isRef, string $id): string
     {
-        return $objectId;
+        return '#'.$objectId;
     }
 
 
@@ -903,7 +940,10 @@ protected function renderInfoBlock(Entity $entity): string
             $info['hash'] = $hash;
         }
 
-        $output = $this->renderList($info, 'info');
+        $output = $this->indent(
+            $this->renderList($info, 'info')
+        );
+
         return $this->wrapEntityBodyBlock($output, 'info', false, $linkId);
     }
 
@@ -913,7 +953,11 @@ protected function renderInfoBlock(Entity $entity): string
     protected function renderMetaBlock(Entity $entity): string
     {
         $id = $entity->getId();
-        $output = $this->renderList($entity->getAllMeta(), 'meta');
+
+        $output = $this->indent(
+            $this->renderList($entity->getAllMeta(), 'meta')
+        );
+
         return $this->wrapEntityBodyBlock($output, 'meta', false, $id);
     }
 
@@ -933,9 +977,13 @@ protected function renderTextBlock(Entity $entity): string
                 $output[] = $this->renderBinaryStringChunk($chunk);
             }
 
-            $output = implode($output);
+            $output = $this->indent(
+                implode($output)
+            );
         } else {
-            $output = $this->renderScalar($entity->getText());
+            $output = $this->indent(
+                $this->renderScalar($entity->getText())
+            );
         }
 
         return $this->wrapEntityBodyBlock($output, 'text', true, $id);
@@ -947,7 +995,11 @@ protected function renderTextBlock(Entity $entity): string
     protected function renderPropertiesBlock(Entity $entity): string
     {
         $id = $entity->getId();
-        $output = $this->renderList($entity->getProperties(), 'properties');
+
+        $output = $this->indent(
+            $this->renderList($entity->getProperties(), 'properties')
+        );
+
         return $this->wrapEntityBodyBlock($output, 'properties', true, $id);
     }
 
@@ -957,7 +1009,11 @@ protected function renderPropertiesBlock(Entity $entity): string
     protected function renderValuesBlock(Entity $entity): string
     {
         $id = $entity->getId();
-        $output = $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys());
+
+        $output = $this->indent(
+            $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys())
+        );
+
         return $this->wrapEntityBodyBlock($output, 'values', true, $id);
     }
 
@@ -979,12 +1035,15 @@ protected function renderStackBlock(Entity $entity): string
                 $line = [];
                 $line[] = $this->renderLineNumber($count - $i);
                 $line[] = $this->wrapSignature($this->renderStackFrameSignature($frame));
+                $line[] = "\n   ";
                 $line[] = $this->renderSourceFile($this->context->normalizePath($frame->getCallingFile()));
                 $line[] = $this->renderSourceLine($frame->getCallingLine());
-                $lines[] = implode("\n", $line);
+                $lines[] = implode(' ', $line);
             }
 
-            $output = $this->renderBasicList($lines, 'stack');
+            $output = $this->indent(
+                $this->renderBasicList($lines, 'stack')
+            );
         } else {
             $newEntity = (new Entity('stack'))
                 ->setName('stack')
@@ -1030,7 +1089,6 @@ protected function wrapEntityFooter(string $footer): string
      */
     protected function renderList(array $items, string $style, bool $includeKeys=true, string $class=null): string
     {
-        $output[] = '<ul class="list '.$style.' '.$class.'">';
         $lines = [];
         $pointer = '=>';
         $asIdentifier = $access = false;
@@ -1076,11 +1134,9 @@ protected function renderList(array $items, string $style, bool $includeKeys=tru
                 $line[] = $this->renderEntity($value);
             } elseif (is_array($value)) {
                 $isAssoc = $this->arrayIsAssoc($value);
-                $line[] = implode("\n", [
-                    $this->renderGrammar('{'),
-                    $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline'),
-                    $this->renderGrammar('}')
-                ]);
+                $line[] = $this->renderGrammar('{');
+                $line[] = $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline');
+                $line[] = $this->renderGrammar('}');
             } else {
                 $line[] = $this->renderScalar($value, $asIdentifier ? 'identifier' : null);
             }
@@ -1089,7 +1145,7 @@ protected function renderList(array $items, string $style, bool $includeKeys=tru
         }
 
 
-        return $this->renderBasicList($lines);
+        return $this->renderBasicList($lines, 'list '.$style.' '.$class);
     }
 
 
@@ -1102,6 +1158,19 @@ protected function renderBasicList(array $lines, ?string $class=null): string
     }
 
 
+    /**
+     * Apply indents
+     */
+    protected function indent(string $lines): string
+    {
+        if (static::SPACES) {
+            $space = str_repeat(' ', static::SPACES);
+            $lines = $space.str_replace("\n", "\n".$space, $lines);
+        }
+
+        return $lines;
+    }
+
 
     /**
      * Test if array is associative
diff --git a/src/Glitch/Renderer/Html.php b/src/Glitch/Renderer/Html.php
index dfba9b2..01ebe03 100644
--- a/src/Glitch/Renderer/Html.php
+++ b/src/Glitch/Renderer/Html.php
@@ -15,6 +15,8 @@
 
 class Html implements Renderer
 {
+    const SPACES = 0;
+
     use Base;
 
     /**
@@ -540,7 +542,7 @@ protected function renderBasicList(array $lines, ?string $class=null): string
         $output[] = '<ul class="'.$class.'">';
 
         foreach ($lines as $line) {
-            $output[] = '<li>'.$line.'</li>';
+            $output[] = '<li>'."\n".$line."\n".'</li>';
         }
 
         return implode("\n", $output);
diff --git a/src/Glitch/Renderer/Text.php b/src/Glitch/Renderer/Text.php
new file mode 100644
index 0000000..93e71de
--- /dev/null
+++ b/src/Glitch/Renderer/Text.php
@@ -0,0 +1,31 @@
+<?php
+/**
+ * This file is part of the Glitch package
+ * @license http://opensource.org/licenses/MIT
+ */
+declare(strict_types=1);
+namespace DecodeLabs\Glitch\Renderer;
+
+use DecodeLabs\Glitch\Context;
+use DecodeLabs\Glitch\Stack\Trace;
+use DecodeLabs\Glitch\Stack\Frame;
+use DecodeLabs\Glitch\Renderer;
+use DecodeLabs\Glitch\Dumper\Dump;
+use DecodeLabs\Glitch\Dumper\Entity;
+
+class Text implements Renderer
+{
+    const SPACES = 2;
+
+    use Base;
+
+
+    /**
+     * Render entity info block
+     * Not used for Text rendering
+     */
+    protected function renderInfoBlock(Entity $entity): string
+    {
+        return '';
+    }
+}

From 519a2f412c115dbb5ee9ec067c93426b79815e70 Mon Sep 17 00:00:00 2001
From: Tom Wright <tom@inflatablecookie.com>
Date: Tue, 3 Sep 2019 23:34:00 +0100
Subject: [PATCH 3/3] Added CLI renderer

Signed-off-by: Tom Wright <tom@inflatablecookie.com>
---
 src/Glitch.php               |  11 +-
 src/Glitch/Context.php       |   6 +-
 src/Glitch/Dumper/Entity.php |  11 +-
 src/Glitch/Renderer/Base.php | 132 ++++++----
 src/Glitch/Renderer/Cli.php  | 471 +++++++++++++++++++++++++++++++++++
 src/Glitch/Renderer/Html.php |  38 ++-
 src/Glitch/Renderer/Text.php |  14 +-
 src/Glitch/Stack/Trace.php   |   5 +-
 8 files changed, 629 insertions(+), 59 deletions(-)
 create mode 100644 src/Glitch/Renderer/Cli.php

diff --git a/src/Glitch.php b/src/Glitch.php
index 5ed69e3..96baf48 100644
--- a/src/Glitch.php
+++ b/src/Glitch.php
@@ -7,6 +7,7 @@
 
 use DecodeLabs\Glitch\Factory;
 use DecodeLabs\Glitch\Context;
+use DecodeLabs\Glitch\Stack\Trace;
 
 /**
  * This is just a facade.
@@ -54,11 +55,19 @@ public static function normalizePath(string $path): string
     /**
      * Shortcut to logException context method
      */
-    public function logException(\Throwable $e): void
+    public static function logException(\Throwable $e): void
     {
         Context::getDefault()->logException($e);
     }
 
+    /**
+     * Create a stack trace
+     */
+    public static function stackTrace(): Trace
+    {
+        return Trace::create();
+    }
+
     /**
      * Private instanciation
      */
diff --git a/src/Glitch/Context.php b/src/Glitch/Context.php
index d0bcadb..d297a30 100644
--- a/src/Glitch/Context.php
+++ b/src/Glitch/Context.php
@@ -428,7 +428,11 @@ public function setRenderer(Renderer $renderer): Context
     public function getRenderer(): Renderer
     {
         if (!$this->dumpRenderer) {
-            $this->dumpRenderer = new Renderer\Html($this);
+            if (in_array(\PHP_SAPI, ['cli', 'phpdbg'])) {
+                $this->dumpRenderer = new Renderer\Cli($this);
+            } else {
+                $this->dumpRenderer = new Renderer\Html($this);
+            }
         }
 
         return $this->dumpRenderer;
diff --git a/src/Glitch/Dumper/Entity.php b/src/Glitch/Dumper/Entity.php
index 3d43cc6..8f04dc0 100644
--- a/src/Glitch/Dumper/Entity.php
+++ b/src/Glitch/Dumper/Entity.php
@@ -41,9 +41,18 @@ class Entity
      * Construct with required info
      */
     public function __construct(string $type)
+    {
+        $this->setType($type);
+    }
+
+    /**
+     * Override type
+     */
+    public function setType(string $type): Entity
     {
         $this->type = $type;
         $this->id = str_replace('.', '-', uniqid($type.'-', true));
+        return $this;
     }
 
     /**
@@ -378,7 +387,7 @@ public function hasMeta(string $key): bool
         if ($this->meta === null) {
             return false;
         }
-        
+
         return array_key_exists($key, $this->meta);
     }
 
diff --git a/src/Glitch/Renderer/Base.php b/src/Glitch/Renderer/Base.php
index 4f40d15..218a88f 100644
--- a/src/Glitch/Renderer/Base.php
+++ b/src/Glitch/Renderer/Base.php
@@ -16,6 +16,18 @@
 trait Base
 {
     //const SPACES = 2;
+    //const RENDER_CLOSED = true;
+    /*
+    const RENDER_SECTIONS = [
+        'info' => true,
+        'meta' => true,
+        'text' => true,
+        'properties' => true,
+        'values' => true,
+        'stack' => true
+    ];
+    */
+    //const RENDER_STACK = true;
 
     protected $context;
 
@@ -42,7 +54,7 @@ public function renderDump(Dump $dump, bool $isFinal=false): string
         $output[] = $this->renderStats($dump->getStats());
         $output[] = $this->renderDumpEntities($dump);
 
-        if ($trace = $dump->getTrace()) {
+        if ((static::RENDER_STACK ?? true) && $trace = $dump->getTrace()) {
             $output[] = $this->renderTrace($trace);
         }
 
@@ -90,7 +102,7 @@ protected function renderDumpEntities(Dump $dump): string
             }
         }
 
-        return implode("\n", $output);
+        return implode("\n\n", $output);
     }
 
     /**
@@ -103,7 +115,8 @@ protected function renderTrace(Trace $trace): string
                 ->setName('stack')
                 ->setStackTrace($trace)
                 ->setOpen(false)
-                ->setLength($trace->count())
+                ->setLength($trace->count()),
+            true
         );
     }
 
@@ -599,16 +612,16 @@ protected function renderSignatureObject(string $object): string
     /**
      * Render an individual entity
      */
-    protected function renderEntity(Entity $entity): string
+    protected function renderEntity(Entity $entity, bool $forceOpen=false, int $level=0): string
     {
         $id = $linkId = $entity->getId();
         $name = $this->esc($entity->getName() ?? $entity->getType());
         $showInfo = true;
         $isRef = $showClass = false;
-        $hasText = $entity->getText() !== null;
-        $hasProperties = (bool)$entity->getProperties();
-        $hasValues = (bool)$entity->getValues();
-        $hasStack = (bool)$entity->getStackTrace();
+        $showText = $entity->getText() !== null;
+        $showProperties = (bool)$entity->getProperties();
+        $showValues = (bool)$entity->getValues();
+        $showStack = (bool)$entity->getStackTrace();
         $open = $entity->isOpen();
 
         switch ($type = $entity->getType()) {
@@ -634,8 +647,9 @@ protected function renderEntity(Entity $entity): string
                 break;
 
             case 'stack':
-                $showInfo = false;
-                $showStack = false;
+                if (!$entity->getClass()) {
+                    $showInfo = false;
+                }
                 break;
 
             case 'flags':
@@ -649,6 +663,27 @@ protected function renderEntity(Entity $entity): string
                 break;
         }
 
+        if (!static::RENDER_SECTIONS['info'] ?? true) {
+            $showInfo = false;
+        }
+        if (!static::RENDER_SECTIONS['meta'] ?? true) {
+            $showMeta = false;
+        }
+        if (!static::RENDER_SECTIONS['text'] ?? true) {
+            $showText = false;
+        }
+        if (!static::RENDER_SECTIONS['properties'] ?? true) {
+            $showProperties = false;
+        }
+        if (!static::RENDER_SECTIONS['values'] ?? true) {
+            $showValues = false;
+        }
+        if (!static::RENDER_SECTIONS['stack'] ?? true && $type !== 'stack') {
+            $showStack = false;
+        }
+
+
+
         $header = [];
 
         // Name
@@ -680,27 +715,27 @@ protected function renderEntity(Entity $entity): string
         }
 
         // Text
-        if ($hasText) {
+        if ($showText) {
             $header[] = $this->renderEntityTextButton($linkId);
         }
 
         // Properties
-        if ($hasProperties) {
+        if ($showProperties) {
             $header[] = $this->renderEntityPropertiesButton($linkId);
         }
 
         // Values
-        if ($hasValues) {
+        if ($showValues) {
             $header[] = $this->renderEntityValuesButton($linkId);
         }
 
         // Stack
-        if ($hasStack) {
+        if ($showStack) {
             $header[] = $this->renderEntityStackButton($type, $open, $linkId);
         }
 
         // Bracket
-        if ($hasBody = ($showInfo || $showMeta || $hasText || $hasProperties || $hasValues || $hasStack)) {
+        if ($hasBody = ($showInfo || $showMeta || $showText || $showProperties || $showValues || $showStack)) {
             $header[] = $this->renderGrammar('{');
         }
 
@@ -714,39 +749,45 @@ protected function renderEntity(Entity $entity): string
         $output[] = $this->wrapEntityHeader(implode(' ', array_filter($header)), $type, $linkId);
 
 
+        $hasBodyContent = $showText || $showProperties || $showValues || $showStack;
+        $renderClosed = static::RENDER_CLOSED ?? true;
+
+        if (!$open && !$renderClosed && !$forceOpen && $level > 4) {
+            $hasBodyContent = false;
+        }
 
         // Body
-        if ($hasBodyContent = $hasText || $hasProperties || $hasValues || $hasStack) {
+        if ($hasBodyContent) {
             $body = [];
 
             // Info
             if ($showInfo) {
-                $body[] = $this->renderInfoBlock($entity);
+                $body[] = $this->renderInfoBlock($entity, $level);
             }
 
             // Meta
             if ($showMeta) {
-                $body[] = $this->renderMetaBlock($entity);
+                $body[] = $this->renderMetaBlock($entity, $level);
             }
 
             // Text
-            if ($hasText) {
-                $body[] = $this->renderTextBlock($entity);
+            if ($showText) {
+                $body[] = $this->renderTextBlock($entity, $level);
             }
 
             // Properties
-            if ($hasProperties) {
-                $body[] = $this->renderPropertiesBlock($entity);
+            if ($showProperties) {
+                $body[] = $this->renderPropertiesBlock($entity, $level);
             }
 
             // Values
-            if ($hasValues) {
-                $body[] = $this->renderValuesBlock($entity);
+            if ($showValues) {
+                $body[] = $this->renderValuesBlock($entity, $level);
             }
 
             // Stack
-            if ($hasStack) {
-                $body[] = $this->renderStackBlock($entity);
+            if ($showStack) {
+                $body[] = $this->renderStackBlock($entity, $level);
             }
 
             $output[] = $this->wrapEntityBody(implode("\n", array_filter($body)), $open, $linkId);
@@ -875,7 +916,7 @@ protected function renderEntityOid(int $objectId, bool $isRef, string $id): stri
     /**
      * Render entity info block
      */
-    protected function renderInfoBlock(Entity $entity): string
+    protected function renderInfoBlock(Entity $entity, int $level=0): string
     {
         $id = $linkId = $entity->getId();
 
@@ -941,7 +982,7 @@ protected function renderInfoBlock(Entity $entity): string
         }
 
         $output = $this->indent(
-            $this->renderList($info, 'info')
+            $this->renderList($info, 'info', true, null, $level + 1)
         );
 
         return $this->wrapEntityBodyBlock($output, 'info', false, $linkId);
@@ -950,12 +991,12 @@ protected function renderInfoBlock(Entity $entity): string
     /**
      * Render entity meta block
      */
-    protected function renderMetaBlock(Entity $entity): string
+    protected function renderMetaBlock(Entity $entity, int $level=0): string
     {
         $id = $entity->getId();
 
         $output = $this->indent(
-            $this->renderList($entity->getAllMeta(), 'meta')
+            $this->renderList($entity->getAllMeta(), 'meta', true, null, $level + 1)
         );
 
         return $this->wrapEntityBodyBlock($output, 'meta', false, $id);
@@ -964,7 +1005,7 @@ protected function renderMetaBlock(Entity $entity): string
     /**
      * Render entity text block
      */
-    protected function renderTextBlock(Entity $entity): string
+    protected function renderTextBlock(Entity $entity, int $level=0): string
     {
         $id = $entity->getId();
         $type = $entity->getType();
@@ -986,18 +1027,18 @@ protected function renderTextBlock(Entity $entity): string
             );
         }
 
-        return $this->wrapEntityBodyBlock($output, 'text', true, $id);
+        return $this->wrapEntityBodyBlock($output, 'text', true, $id, $type);
     }
 
     /**
      * Render entity properties block
      */
-    protected function renderPropertiesBlock(Entity $entity): string
+    protected function renderPropertiesBlock(Entity $entity, int $level=0): string
     {
         $id = $entity->getId();
 
         $output = $this->indent(
-            $this->renderList($entity->getProperties(), 'properties')
+            $this->renderList($entity->getProperties(), 'properties', true, null, $level + 1)
         );
 
         return $this->wrapEntityBodyBlock($output, 'properties', true, $id);
@@ -1006,12 +1047,12 @@ protected function renderPropertiesBlock(Entity $entity): string
     /**
      * Render entity values block
      */
-    protected function renderValuesBlock(Entity $entity): string
+    protected function renderValuesBlock(Entity $entity, int $level=0): string
     {
         $id = $entity->getId();
 
         $output = $this->indent(
-            $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys())
+            $this->renderList($entity->getValues(), 'values', $entity->shouldShowKeys(), null, $level + 1)
         );
 
         return $this->wrapEntityBodyBlock($output, 'values', true, $id);
@@ -1021,7 +1062,7 @@ protected function renderValuesBlock(Entity $entity): string
     /**
      * Render entity stack trace block
      */
-    protected function renderStackBlock(Entity $entity): string
+    protected function renderStackBlock(Entity $entity, int $level=0): string
     {
         $id = $entity->getId();
         $type = $entity->getType();
@@ -1045,12 +1086,13 @@ protected function renderStackBlock(Entity $entity): string
                 $this->renderBasicList($lines, 'stack')
             );
         } else {
+            //die('oi2');
             $newEntity = (new Entity('stack'))
                 ->setName('stack')
                 ->setStackTrace($trace)
                 ->setLength($trace->count());
 
-            $output = $this->renderEntity($newEntity);
+            $output = $this->renderEntity($newEntity, false, $level + 1);
         }
 
         return $this->wrapEntityBodyBlock($output, 'stack', true, $id);
@@ -1069,7 +1111,7 @@ protected function wrapEntityBody(string $body, bool $open, string $linkId): str
     /**
      * Wrap entity body block
      */
-    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId): string
+    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId, ?string $class=null): string
     {
         return $block;
     }
@@ -1087,7 +1129,7 @@ protected function wrapEntityFooter(string $footer): string
     /**
      * Render list
      */
-    protected function renderList(array $items, string $style, bool $includeKeys=true, string $class=null): string
+    protected function renderList(array $items, string $style, bool $includeKeys=true, string $class=null, int $level=0): string
     {
         $lines = [];
         $pointer = '=>';
@@ -1126,16 +1168,16 @@ protected function renderList(array $items, string $style, bool $includeKeys=tru
                     }
                 }
 
-                $line[] = $this->renderScalar($key, 'identifier key '.$mod);
+                $line[] = $this->renderScalar($key, 'identifier key '.$style.' '.$mod);
                 $line[] = $this->renderPointer($pointer);
             }
 
             if ($value instanceof Entity) {
-                $line[] = $this->renderEntity($value);
+                $line[] = $this->renderEntity($value, false, $level + 1);
             } elseif (is_array($value)) {
                 $isAssoc = $this->arrayIsAssoc($value);
                 $line[] = $this->renderGrammar('{');
-                $line[] = $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline');
+                $line[] = $this->renderList($value, $style, $isAssoc, $isAssoc ? 'map' : 'inline', $level + 1);
                 $line[] = $this->renderGrammar('}');
             } else {
                 $line[] = $this->renderScalar($value, $asIdentifier ? 'identifier' : null);
@@ -1163,8 +1205,8 @@ protected function renderBasicList(array $lines, ?string $class=null): string
      */
     protected function indent(string $lines): string
     {
-        if (static::SPACES) {
-            $space = str_repeat(' ', static::SPACES);
+        if ($spaces = static::SPACES ?? 2) {
+            $space = str_repeat(' ', $spaces);
             $lines = $space.str_replace("\n", "\n".$space, $lines);
         }
 
diff --git a/src/Glitch/Renderer/Cli.php b/src/Glitch/Renderer/Cli.php
new file mode 100644
index 0000000..52268ba
--- /dev/null
+++ b/src/Glitch/Renderer/Cli.php
@@ -0,0 +1,471 @@
+<?php
+/**
+ * This file is part of the Glitch package
+ * @license http://opensource.org/licenses/MIT
+ */
+declare(strict_types=1);
+namespace DecodeLabs\Glitch\Renderer;
+
+use DecodeLabs\Glitch\Context;
+use DecodeLabs\Glitch\Stack\Trace;
+use DecodeLabs\Glitch\Stack\Frame;
+use DecodeLabs\Glitch\Renderer;
+use DecodeLabs\Glitch\Dumper\Dump;
+use DecodeLabs\Glitch\Dumper\Entity;
+
+class Cli implements Renderer
+{
+    const SPACES = 2;
+    const RENDER_CLOSED = false;
+
+    const RENDER_SECTIONS = [
+        'info' => false,
+        'meta' => false,
+        'text' => true,
+        'properties' => true,
+        'values' => true,
+        'stack' => true
+    ];
+
+    const RENDER_STACK = false;
+
+    const FG_COLORS = [
+        'black' => 30,
+        'red' => 31,
+        'green' => 32,
+        'yellow' => 33,
+        'blue' => 34,
+        'magenta' => 35,
+        'cyan' => 36,
+        'white' => 37,
+        'default' => 38,
+        'reset' => 39
+    ];
+
+    const BG_COLORS = [
+        'black' => 40,
+        'red' => 41,
+        'green' => 42,
+        'yellow' => 43,
+        'blue' => 44,
+        'magenta' => 45,
+        'cyan' => 46,
+        'white' => 47,
+        'default' => 48,
+        'reset' => 49
+    ];
+
+    const OPTIONS = [
+        'bold' => [1, 22],
+        'dim' => [2, 22],
+        'underline' => [4, 24],
+        'blink' => [5, 25],
+        'reverse' => [7, 27],
+        'private' => [8, 28]
+    ];
+
+    use Base;
+
+    protected $formatStack = [];
+
+
+    /**
+     * Build a stat list header bar
+     */
+    protected function renderStats(array $stats): string
+    {
+        $output = [];
+
+        foreach ($stats as $key => $stat) {
+            $output[] = $this->format($stat->render('text'), 'cyan');
+        }
+
+        return implode(' | ', $output);
+    }
+
+    /**
+     * Flatten buffer for final render
+     */
+    protected function exportBuffer(array $buffer): string
+    {
+        return "\n".implode("\n\n", $buffer)."\n\n";
+    }
+
+    /**
+     * Render a null scalar
+     */
+    protected function renderNull(?string $class=null): string
+    {
+        return $this->format('null', 'magenta', null, 'bold');
+    }
+
+    /**
+     * Render a boolean scalar
+     */
+    protected function renderBool(bool $value, ?string $class=null): string
+    {
+        return $this->format($value ? 'true' : 'false', 'magenta', null, 'bold');
+    }
+
+    /**
+     * Render a integer scalar
+     */
+    protected function renderInt(int $value, ?string $class=null): string
+    {
+        return $this->format((string)$value, 'blue', null, 'bold');
+    }
+
+    /**
+     * Render a float scalar
+     */
+    protected function renderFloat(float $value, ?string $class=null): string
+    {
+        return $this->format($this->normalizeFloat($value), 'blue', null, 'bold');
+    }
+
+    /**
+     * Render a single identifier string
+     */
+    protected function renderIdentifierString(string $string, string $class, int $forceSingleLineMax=null): string
+    {
+        $options = [];
+        $parts = explode(' ', $class);
+        $mod = array_pop($parts);
+        $style = array_pop($parts);
+        $color = 'yellow';
+        $output = '';
+
+        switch ($style) {
+            case 'info':
+                $color = 'cyan';
+                break;
+
+            case 'meta':
+                $color = 'white';
+                break;
+
+            case 'properties':
+                $color = 'white';
+                $options[] = 'bold';
+
+                switch ($mod) {
+                    case 'public':
+                        break;
+
+                    case 'protected':
+                        $output .= $this->format('*', 'blue', null, 'bold');
+                        break;
+
+                    case 'private':
+                        $output .= $this->format('!', 'red', null, 'bold');
+                        break;
+                }
+                break;
+
+            case 'values':
+                $color = 'yellow';
+                break;
+        }
+
+        return $output.$this->format($this->renderStringLine($string, $forceSingleLineMax), $color, null, ...$options);
+    }
+
+    /**
+     * Render a standard multi line string
+     */
+    protected function renderMultiLineString(string $string): string
+    {
+        $string = str_replace("\r", '', $string);
+        $parts = explode("\n", $string);
+        $count = count($parts);
+
+        $output = [];
+        $output[] = $this->format('""" '.mb_strlen($string), 'white', null, 'dim');
+
+        foreach ($parts as $part) {
+            $output[] = $this->format($this->renderStringLine($part), 'red', null, 'bold').
+                $this->format('⏎', 'white', null, 'dim');
+        }
+
+        $output[] = $this->format('"""', 'white', null, 'dim');
+
+        return implode("\n", $output);
+    }
+
+    /**
+     * Render a standard single line string
+     */
+    protected function renderSingleLineString(string $string, int $forceSingleLineMax=null): string
+    {
+        $output = $this->format('"', 'white', null, 'dim');
+        $output .= $this->stackFormat('red', null, 'bold');
+        $output .= $this->renderStringLine($string, $forceSingleLineMax);
+        $output .= $this->popFormat();
+        $output .= $this->format('"', 'white', null, 'dim');
+
+        return $output;
+    }
+
+    /**
+     * Render binary string chunk
+     */
+    protected function renderBinaryStringChunk(string $chunk): string
+    {
+        return $this->format($chunk, 'magenta').' ';
+    }
+
+    /**
+     * Render a detected ascii control character
+     */
+    protected function wrapControlCharacter(string $control): string
+    {
+        return $this->format($control, 'white', 'red', null, 'bold');
+    }
+
+
+    /**
+     * Render structure grammer
+     */
+    protected function renderGrammar(string $grammar): string
+    {
+        return $this->format($grammar, 'white', null, 'dim');
+    }
+
+    /**
+     * Render structure pointer
+     */
+    protected function renderPointer(string $pointer): string
+    {
+        return $this->format($pointer, 'white', null, 'dim');
+    }
+
+    /**
+     * Render line number
+     */
+    protected function renderLineNumber(int $number): string
+    {
+        return $this->format(str_pad((string)$number, 2), 'blue', null, 'bold');
+    }
+
+    /**
+     * Render file path
+     */
+    protected function renderSourceFile(string $path): string
+    {
+        return $this->format($path, 'yellow');
+    }
+
+    /**
+     * Render source line
+     */
+    protected function renderSourceLine(int $number): string
+    {
+        return $this->format((string)$number, 'magenta', null, 'bold');
+    }
+
+
+    /**
+     * render signature namespace part
+     */
+    protected function renderSignatureNamespace(string $namespace): string
+    {
+        return $this->format($namespace, 'cyan');
+    }
+
+    /**
+     * render signature class part
+     */
+    protected function renderSignatureClass(string $class): string
+    {
+        return $this->format($class, 'cyan', null, 'bold');
+    }
+
+    /**
+     * render signature call type part (:: or ->)
+     */
+    protected function renderSignatureCallType(string $type): string
+    {
+        return $this->format($type, 'white', null, 'dim');
+    }
+
+    /**
+     * render signature constant part
+     */
+    protected function renderSignatureConstant(string $constant): string
+    {
+        return $this->format($constant, 'magenta');
+    }
+
+    /**
+     * Wrap signature function block
+     */
+    protected function wrapSignatureFunction(string $function, ?string $class=null): string
+    {
+        $output = '';
+
+        if ($class == 'closure') {
+            $output .= $this->format('{', 'white', null, 'dim');
+        }
+
+        $output .= $this->format($function, 'blue');
+
+        if ($class == 'closure') {
+            $output .= $this->format('}', 'white', null, 'dim');
+        }
+
+        return $output;
+    }
+
+    /**
+     * render signature bracket string
+     */
+    protected function renderSignatureBracket(string $bracket): string
+    {
+        return $this->format($bracket, 'white', null, 'dim');
+    }
+
+    /**
+     * render signature arg comma
+     */
+    protected function renderSignatureComma(): string
+    {
+        return $this->format(',', 'white', null, 'dim');
+    }
+
+    /**
+     * render signature object name
+     */
+    protected function renderSignatureObject(string $object): string
+    {
+        return $this->format($object, 'green');
+    }
+
+    /**
+     * Wrap entity name if reference
+     */
+    protected function wrapReferenceName(string $name): string
+    {
+        return
+            $this->format('&', 'white', null, 'dim').
+            $this->format($name, 'green', null, 'bold');
+    }
+
+    /**
+     * Wrap entity name link
+     */
+    protected function wrapEntityName(string $name, bool $open, string $linkId): string
+    {
+        return $this->format($name, 'green', null, 'bold');
+    }
+
+    /**
+     * render entity length tag
+     */
+    protected function renderEntityLength(int $length): string
+    {
+        return $this->format((string)$length, 'cyan', null, 'bold');
+    }
+
+    /**
+     * render entity class name
+     */
+    protected function renderEntityClassName(string $class): string
+    {
+        return $this->format($class, 'white');
+    }
+
+    /**
+     * render object id tag
+     */
+    protected function renderEntityOid(int $objectId, bool $isRef, string $id): string
+    {
+        return
+            $this->format('#', 'white', null, 'dim').
+            $this->format((string)$objectId, 'white');
+    }
+
+
+
+    /**
+     * Format output for colours
+     */
+    protected function format(string $message, ?string $fgColor, ?string $bgColor=null, string ...$options): string
+    {
+        $output = $this->setFormat(...($args = array_slice(func_get_args(), 1)));
+        $output .= $message;
+        $output .= $this->applyStackedFormat($args);
+
+        return $output;
+    }
+
+    /**
+     * Stack a format
+     */
+    protected function stackFormat(?string $fgColor, ?string $bgColor=null, string ...$options): string
+    {
+        array_unshift($this->formatStack, $args = func_get_args());
+        return $this->setFormat(...$args);
+    }
+
+    protected function setFormat(?string $fgColor, ?string $bgColor=null, string ...$options): string
+    {
+        if ($fgColor !== null) {
+            $setCodes[] = static::FG_COLORS[$fgColor];
+        }
+
+        if ($bgColor !== null) {
+            $setCodes[] = static::BG_COLORS[$bgColor];
+        }
+
+        foreach ($options as $option) {
+            $setCodes[] = static::OPTIONS[$option][0];
+        }
+
+        return sprintf("\033[%sm", implode(';', $setCodes));
+    }
+
+    protected function resetFormat(?string $fgColor, ?string $bgColor=null, string ...$options): string
+    {
+        $setCodes[] = static::FG_COLORS['reset'];
+        $setCodes[] = static::BG_COLORS['reset'];
+
+        foreach ($options as $option) {
+            $setCodes[] = static::OPTIONS[$option][1];
+        }
+
+        return sprintf("\033[%sm", implode(';', $setCodes));
+    }
+
+    /**
+     * Pop formats
+     */
+    protected function popFormat(): string
+    {
+        $args = array_shift($this->formatStack);
+        return $this->applyStackedFormat($args);
+    }
+
+    /**
+     * Apply stacked args
+     */
+    protected function applyStackedFormat(array $args): string
+    {
+        $output = $this->resetFormat(...$args);
+
+        if (isset($this->formatStack[0])) {
+            $args = $this->formatStack[0];
+
+            if (!isset($args[0])) {
+                $args[0] = 'reset';
+            }
+
+            if (!isset($args[1])) {
+                $args[1] = 'reset';
+            }
+
+            $output .= $this->setFormat(...$args);
+        }
+
+        return $output;
+    }
+}
diff --git a/src/Glitch/Renderer/Html.php b/src/Glitch/Renderer/Html.php
index 01ebe03..db48bb9 100644
--- a/src/Glitch/Renderer/Html.php
+++ b/src/Glitch/Renderer/Html.php
@@ -16,6 +16,18 @@
 class Html implements Renderer
 {
     const SPACES = 0;
+    const RENDER_CLOSED = true;
+
+    const RENDER_SECTIONS = [
+        'info' => true,
+        'meta' => true,
+        'text' => true,
+        'properties' => true,
+        'values' => true,
+        'stack' => true
+    ];
+
+    const RENDER_STACK = true;
 
     use Base;
 
@@ -204,7 +216,7 @@ protected function renderFloat(float $value, ?string $class=null): string
 
 
     /**
-     * render a single identifier string
+     * Render a single identifier string
      */
     protected function renderIdentifierString(string $string, string $class, int $forceSingleLineMax=null): string
     {
@@ -212,7 +224,7 @@ protected function renderIdentifierString(string $string, string $class, int $fo
     }
 
     /**
-     * render a standard multi line string
+     * Render a standard multi line string
      */
     protected function renderMultiLineString(string $string): string
     {
@@ -232,7 +244,7 @@ protected function renderMultiLineString(string $string): string
     }
 
     /**
-     * render a standard single line string
+     * Render a standard single line string
      */
     protected function renderSingleLineString(string $string, int $forceSingleLineMax=null): string
     {
@@ -248,7 +260,7 @@ protected function renderSingleLineString(string $string, int $forceSingleLineMa
     }
 
     /**
-     * render binary string chunk
+     * Render binary string chunk
      */
     protected function renderBinaryStringChunk(string $chunk): string
     {
@@ -257,7 +269,7 @@ protected function renderBinaryStringChunk(string $chunk): string
 
 
     /**
-     * render a detected ascii control character
+     * Render a detected ascii control character
      */
     protected function wrapControlCharacter(string $control): string
     {
@@ -265,7 +277,7 @@ protected function wrapControlCharacter(string $control): string
     }
 
     /**
-     * render structure grammer
+     * Render structure grammer
      */
     protected function renderGrammar(string $grammar): string
     {
@@ -273,7 +285,7 @@ protected function renderGrammar(string $grammar): string
     }
 
     /**
-     * render structure pointer
+     * Render structure pointer
      */
     protected function renderPointer(string $pointer): string
     {
@@ -517,9 +529,15 @@ protected function wrapEntityBody(string $body, bool $open, string $linkId): str
     /**
      * Wrap entity body block
      */
-    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId): string
+    protected function wrapEntityBodyBlock(string $block, string $type, bool $open, string $linkId, ?string $class=null): string
     {
-        return '<div id="'.$type.'-'.$linkId.'" class="collapse'.($open ? ' show': null).' inner type-'.$type.'"><div class="'.$type.'">'."\n".
+        if ($class && $class !== $type) {
+            $class = $class.' '.$type;
+        } else {
+            $class = $type;
+        }
+
+        return '<div id="'.$type.'-'.$linkId.'" class="collapse'.($open ? ' show': null).' inner type-'.$type.'"><div class="'.$class.'">'."\n".
             $block."\n".
         '</div></div>';
     }
@@ -545,6 +563,8 @@ protected function renderBasicList(array $lines, ?string $class=null): string
             $output[] = '<li>'."\n".$line."\n".'</li>';
         }
 
+        $output[] = '</ul>';
+
         return implode("\n", $output);
     }
 
diff --git a/src/Glitch/Renderer/Text.php b/src/Glitch/Renderer/Text.php
index 93e71de..cc1abad 100644
--- a/src/Glitch/Renderer/Text.php
+++ b/src/Glitch/Renderer/Text.php
@@ -15,7 +15,19 @@
 
 class Text implements Renderer
 {
-    const SPACES = 2;
+    const SPACES = 0;
+    const RENDER_CLOSED = false;
+
+    const RENDER_SECTIONS = [
+        'info' => true,
+        'meta' => true,
+        'text' => true,
+        'properties' => true,
+        'values' => true,
+        'stack' => true
+    ];
+
+    const RENDER_STACK = true;
 
     use Base;
 
diff --git a/src/Glitch/Stack/Trace.php b/src/Glitch/Stack/Trace.php
index 5ea1bb6..7d9c7dc 100644
--- a/src/Glitch/Stack/Trace.php
+++ b/src/Glitch/Stack/Trace.php
@@ -212,6 +212,9 @@ public function __debugInfo(): array
      */
     public function glitchInspect(Entity $entity, Inspector $inspector): void
     {
-        $entity->setStackTrace($this);
+        $entity
+            ->setType('stack')
+            ->setLength(count($this->frames))
+            ->setStackTrace($this);
     }
 }