1. (function (console) {
    3.     // vars
    5.     var el, head, input,
    6.         glob = this,
    7.         rows = 1,
    8.         ctrlon = false,
    9.         shifton = false,
    10.         history = new History(100),
    11.         api = new API();
    13.     // colors
    15.     var GRAY = '#777',
    16.         RED  = 'red',
    17.         BLUE = 'blue';
    19.     // shortcuts
    21.     var body     = document.body,
    22.         slice    = Array.prototype.slice,
    23.         toString = Object.prototype.toString;
    25.     // hooks
    27.     var evaluateHook = evaluate,
    28.         stringifyHook = stringify;
    30.     // dom
    32.     document.write(''
    33.     + '<pre id="miniconsole">'
    34.     +     '<div id="miniconsole-prompt">'
    35.     +         '<span>> </span>'
    36.     +         '<span><textarea '
    37.     +             'id="miniconsole-input" rows="1"'
    38.     +         '></textarea><span>'
    39.     +     '</div>'
    40.     +     '<style>'
    41.     +         '#miniconsole {'
    42.     +             'margin: 0;'
    43.     +             'padding-bottom: 2em;'
    44.     +         '}'
    45.     +         '#miniconsole * {'
    46.     +             'font-size: 1em;'
    47.     +         '}'
    48.     +         '#miniconsole-prompt span {'
    49.     +             'display: table-cell;'
    50.     +             'vertical-align: top;'
    51.     +         '}'
    52.     +         '#miniconsole-prompt span + span {'
    53.     +             'width: 100%;'
    54.     +         '}'
    55.     +         '#miniconsole-input {'
    56.     +             'font-family: inherit;'
    57.     +             'overflow: hidden;'
    58.     +             'outline: none;'
    59.     +             'resize: none;'
    60.     +             'display: block;'
    61.     +             'width: 100%;'
    62.     +             'border: 0;'
    63.     +             'margin: 0;'
    64.     +             'padding: 0;'
    65.     +         '}'
    66.     +         '#miniconsole div {'
    67.     +             'padding: .5em;'
    68.     +             'border-top: 1px solid #ddd;'
    69.     +         '}'
    70.     +     '</style>'
    71.     + '</pre>'
    72.     );
    74.     el = document.getElementById('miniconsole');
    75.     head = document.getElementsByTagName('head')[0];
    76.     input = document.getElementById('miniconsole-input');
    77.     head.appendChild(el.lastChild);
    79.     onKeydown(input, {
    80.         13 /* ENTER */: function () {
    81.             if (shifton) {
    82.                 rows += 1;
    83.             } else {
    84.                 rows = 1;
    85.                 this.focus();
    86.                 send(this.value);
    87.                 setTimeout(function () {
    88.                     input.value = '';
    89.                 }, 0);
    90.             }
    91.             refreshRows();
    92.         },
    93.         38 /* UP */: function () {
    94.             if (ctrlon) {
    95.                 this.value = history.up();
    96.             }
    97.         },
    98.         40 /* DOWN */: function () {
    99.             if (ctrlon) {
    100.                 this.value = history.down();
    101.             }
    102.         }
    103.     });
    105.     on(input, 'keyup', function (ev) {
    106.         var i, s, c;
    107.         if (which(ev) != 13) {
    108.             rows = 1;
    109.             c = '\n';
    110.             s = this.value;
    111.             i = s.length;
    112.             while (i-- > 0) if (s[i] == c) rows++;
    113.             refreshRows();
    114.         }
    115.     });
    117.     onKeydown(document, {
    118.         16 /* SHIFT */: function () {
    119.             shifton = true;
    120.         },
    121.         17 /* CTRL */: function () {
    122.             ctrlon = true;
    123.         },
    124.         76 /* L */: function (ev) {
    125.             if (ctrlon) {
    126.                 ev.preventDefault();
    127.                 clear();
    128.                 input.focus();
    129.             }
    130.         }
    131.     });
    133.     onKeyup(document, {
    134.         16 /* SHIFT */: function () {
    135.             shifton = false;
    136.         },
    137.         17 /* CTRL */: function () {
    138.             ctrlon = false;
    139.         }
    140.     });
    142.     on(document, 'click', function (ev) {
    143.         var doFocus = ev.target == el;
    144.         if (!doFocus) doFocus = ev.target == input.parentNode.parentNode;
    145.         if (!doFocus) doFocus = ev.target == body;
    146.         if (!doFocus) doFocus = ev.target == body.parentNode;
    147.         if (!doFocus) doFocus = ev.target == document;
    148.         if (doFocus) input.focus();
    149.     });
    151.     // init
    153.     input.focus();
    154.     glob.mini = api;
    156.     // functions
    158.     function noop () {}
    160.     function clear () {        
    161.         while (last()) el.removeChild(last());
    162.     }
    164.     function last () {
    165.         return el.lastChild.previousSibling;
    166.     }
    168.     function color (el, color) {
    169.         el.style.color = color;
    170.     }
    172.     function which (ev) {
    173.         return ev.which || ev.keyCode;
    174.     }
    176.     function onKeyup (o, handlers) {
    177.         onKeystroke(o, 'keyup', handlers);
    178.     }
    180.     function onKeydown (o, handlers) {
    181.         onKeystroke(o, 'keydown', handlers);
    182.     }
    184.     function refreshRows () {
    185.         input.setAttribute('rows', rows);
    186.         scrollToBottom();        
    187.     }
    189.     function scrollToBottom () {
    190.         var value = body.scrollHeight;
    191.         if (body.scrollTop) body.scrollTop = value;
    192.         else document.documentElement.scrollTop = value;
    193.     }
    195.     function map (l, f) {
    196.         var i, n = l.length;
    197.         var r = new Array(n);
    198.         while (n--) r[n] = f(l[n]);
    199.         return r;
    200.     }
    202.     function onKeystroke (o, ev, handlers) {
    203.         var handler;
    204.         on(o, ev, function (ev) {
    205.             if (handler = handlers[which(ev)]) {
    206.                 return handler.apply(this, arguments);
    207.             }
    208.         });
    209.     }
    211.     function on (o, ev, fn) {
    212.         if (o.addEventListener) {
    213.             o.addEventListener(ev, fn, false);
    214.         } else if (o.attachEvent) {
    215.             o.attachEvent('on' + ev, fn);
    216.         }
    217.     }
    219.     function un (o, ev, fn) {
    220.         if (o.removeEventListener) {
    221.             o.removeEventListener(ev, fn, false);
    222.         } else if (o.detachEvent) {
    223.             o.detachEvent('on' + ev, fn);
    224.         }
    225.     }
    227.     function stringify (o) {
    228.         switch (toString.call(o).slice(8, -1)) {
    229.             case 'Object': return stringifyObject(o);
    230.             case 'Array': return stringifyArray(o);
    231.             case 'Function': return o + '';
    232.             default: return stringifyItem(o);
    233.         }
    234.     }
    236.     function stringifyArray (o) {
    237.         var i, l = o.length, temp = [];
    238.         for (i = 0; i < l; i++) {
    239.             temp.push(stringifyItem(o[i]));
    240.         }
    241.         return '[' + temp.join(',') + ']';
    242.     }
    244.     function stringifyObject (o) {
    245.         var k, temp = [];
    246.         for (k in o) {
    247.             if (o.hasOwnProperty(k)) {
    248.                 temp.push(k + ':' + stringifyItem(o[k]));
    249.             }
    250.         }
    251.         return '{' + temp.join(',') + '}';
    252.     }
    254.     function stringifyItem (o) {
    255.         var string = toString.call(o);
    256.         switch (string.slice(8, -1)) {
    257.             case 'Array': case 'Function': return string;
    258.             case 'String': return '"' + o + '"';
    259.             default: return o + '';
    260.         }
    261.     }
    263.     function stringifyButString (o) {
    264.         if (typeof o != 'string') {
    265.             return stringifyHook(o);
    266.         } else {
    267.             return o;
    268.         }
    269.     }
    271.     function entitify (str) {
    272.         return String(str)
    273.         .replace(/&/g, '&amp;')
    274.         .replace(/</g, '&lt;')
    275.         .replace(/>/g, '&gt;')
    276.         .replace(/"/g, '&quot;')
    277.         .replace(/ /g, '&nbsp;');
    278.     }
    280.     function evaluate (code) {
    281.         var script = document.createElement('script');
    282.         code = code.replace(/('|\\|\n)/g, '\\$1');
    283.         script.text = ''
    284.         + 'try { mini = [eval(\'' + code + '\'), true]; }'
    285.         + 'catch (error) { mini = [error, false]; }';
    286.         head.appendChild(script);
    287.         head.removeChild(script);
    288.         code = glob.mini;
    289.         glob.mini = api;
    290.         if (code.pop()) {
    291.             return code.pop();
    292.         } else {
    293.             code = code.pop();
    294.             consoleDotError(code);
    295.             throw code;
    296.         }
    297.     }
    299.     // io
    301.     function info (msg) {
    302.         print('<i>' + msg + '</i>');
    303.         color(last(), GRAY);
    304.     }
    306.     function consoleDotError (error) {
    307.         if (console && console.error)
    308.         if (typeof console.error == 'function')
    309.         console.error(error);
    310.     }
    312.     function print (msg) {
    313.         var div = document.createElement('div');
    314.         el.insertBefore(div, el.lastChild);
    315.         div.innerHTML = msg === '' ? '&nbsp;' : msg + '';
    316.     }
    318.     function hook (dflt, hook) {
    319.         return function () {
    320.             var args = slice.call(arguments);
    321.             return hook.apply(api, args.concat(dflt));
    322.         };
    323.     }
    325.     function log (msg) {
    326.         msg = slice.call(arguments);
    327.         msg = map(msg, stringifyButString);
    328.         print(entitify(msg.join(' ')));
    329.         scrollToBottom();
    330.     }
    332.     function send (code) {
    333.         history.save(code);
    334.         print(entitify('> ' + code.replace(/\n/g, '\n  ')));
    335.         color(last(), BLUE);
    336.         evalPrint(code);
    337.     }
    339.     function evalPrint (code) {
    340.         try {
    341.             var r = evaluateHook(code);
    342.             print(entitify(stringifyHook(r)));
    343.             if (r === undefined) color(last(), GRAY);
    344.         } catch (error) {
    345.             print(entitify(error));
    346.             color(last(), RED);
    347.         }
    348.     }
    350.     function set (opt, val) {
    351.         switch (opt) {
    352.             case 'evalHook': 
    353.                 evaluateHook = hook(evaluate, val);
    354.                 info('"evalHook" set.');
    355.                 break;
    356.             case 'printHook': 
    357.                 stringifyHook = hook(stringify, val);
    358.                 info('"printHook" set.');
    359.                 break;
    360.             default:
    361.                 info('Unknown option "' + opt + '".');
    362.                 break;
    363.         }
    364.     }
    366.     // constructors
    368.     function API () {
    369.         this.set = set;
    370.         this.log = log;
    371.         this.send = send;
    372.         this.clear = function () {
    373.             clear(), info('Console was cleared.');
    374.         };
    375.     }
    377.     function History (size) {
    378.         var i = 0, items = [''];
    379.         this.up = function () {
    380.             return items[++i < items.length ? i : --i];
    381.         };
    382.         this.down = function () {
    383.             return items[--i > -1 ? i : ++i];
    384.         };
    385.         this.save = function (input) {
    386.             i = 0;
    387.             if (input) items[0] = input;
    388.             if (items[0] === items[1]) {
    389.                 items[0] = '';
    390.             } else {
    391.                 items.unshift('');
    392.                 if (items.length > size) {
    393.                     items.pop();
    394.                 }
    395.             }
    396.         };
    397.     }
    398. })(console);