docs: function shim () {
      if (!Function.prototype.bind) {
        Function.prototype.bind = function (oThis) {
          if (typeof this !== 'function') {
            // closest thing possible to the ECMAScript 5 internal IsCallable function
            throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
          }
  
          var aArgs = Array.prototype.slice.call(arguments, 1),
              fToBind = this,
              FNOP = function () {},
              fBound = function () {
                return fToBind.apply(this instanceof FNOP && oThis ?
                              this : oThis, aArgs.concat(Array.prototype.slice.call(arguments)));
              };
  
          FNOP.prototype = this.prototype;
          fBound.prototype = new FNOP();
  
          return fBound;
        };
      }
  
      if(!Array.isArray) {
        Array.isArray = function (vArg) {
          return Object.prototype.toString.call(vArg) === '[object Array]';
        };
      }
  
      if (!Array.prototype.indexOf) {
        Array.prototype.indexOf = function (searchElement, fromIndex) {
          var i,
              pivot = (fromIndex) ? fromIndex : 0,
              length;
  
          if (!this) {
            throw new TypeError();
          }
  
          length = this.length;
  
          if (length === 0 || pivot >= length) {
            return -1;
          }
  
          if (pivot < 0) {
            pivot = length - Math.abs(pivot);
          }
  
          for (i = pivot; i < length; i++) {
            if (this[i] === searchElement) {
              return i;
            }
          }
          return -1;
        };
      }
  
      if (!Array.prototype.map)
      {
        Array.prototype.map = function(fun /*, thisArg */)
        {
          'use strict';
  
          if (this === void 0 || this === null)
            throw new TypeError();
  
          var t = Object(this);
          var len = t.length >>> 0;
          if (typeof fun !== 'function') {
            throw new TypeError();
          }
  
          var res = new Array(len);
          var thisArg = arguments.length >= 2 ? arguments[1] : void 0;
          for (var i = 0; i < len; i++)
          {
            // NOTE: Absolute correctness would demand Object.defineProperty
            //       be used.  But this method is fairly new, and failure is
            //       possible only if Object.prototype or Array.prototype
            //       has a property |i| (very unlikely), so use a less-correct
            //       but more portable alternative.
            if (i in t)
              res[i] = fun.call(thisArg, t[i], i, t);
          }
  
          return res;
        };
      }
    }