docs: function(JSON) {
  	
  	  var rx_one = /^[\],:{}\s]*$/;
  	  var rx_two = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g;
  	  var rx_three = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g;
  	  var rx_four = /(?:^|:|,)(?:\s*\[)+/g;
  	  var rx_escapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
  	  var rx_dangerous = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g;
  	
  	  function f(n) {
  	    // Format integers to have at least two digits.
  	    return n < 10
  	      ? "0" + n
  	      : n;
  	  }
  	
  	  function this_value() {
  	    return this.valueOf();
  	  }
  	
  	  if (typeof Date.prototype.toJSON !== "function") {
  	
  	    Date.prototype.toJSON = function () {
  	
  	      return isFinite(this.valueOf())
  	        ? this.getUTCFullYear() + "-" +
  	        f(this.getUTCMonth() + 1) + "-" +
  	        f(this.getUTCDate()) + "T" +
  	        f(this.getUTCHours()) + ":" +
  	        f(this.getUTCMinutes()) + ":" +
  	        f(this.getUTCSeconds()) + "Z"
  	        : null;
  	    };
  	
  	    Boolean.prototype.toJSON = this_value;
  	    Number.prototype.toJSON = this_value;
  	    String.prototype.toJSON = this_value;
  	  }
  	
  	  var gap;
  	  var indent;
  	  var meta;
  	  var rep;
  	
  	
  	  function quote(string) {
  	
  	    // If the string contains no control characters, no quote characters, and no
  	    // backslash characters, then we can safely slap some quotes around it.
  	    // Otherwise we must also replace the offending characters with safe escape
  	    // sequences.
  	
  	    rx_escapable.lastIndex = 0;
  	    return rx_escapable.test(string)
  	      ? "\"" + string.replace(rx_escapable, function (a) {
  	        var c = meta[a];
  	        return typeof c === "string"
  	          ? c
  	          : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
  	      }) + "\""
  	    : "\"" + string + "\"";
  	  }
  	
  	
  	  function str(key, holder) {
  	
  	    // Produce a string from holder[key].
  	
  	    var i;          // The loop counter.
  	    var k;          // The member key.
  	    var v;          // The member value.
  	    var length;
  	    var mind = gap;
  	    var partial;
  	    var value = holder[key];
  	
  	    // If the value has a toJSON method, call it to obtain a replacement value.
  	
  	    if (value && typeof value === "object" &&
  	        typeof value.toJSON === "function") {
  	      value = value.toJSON(key);
  	    }
  	
  	    // If we were called with a replacer function, then call the replacer to
  	    // obtain a replacement value.
  	
  	    if (typeof rep === "function") {
  	      value = rep.call(holder, key, value);
  	    }
  	
  	    // What happens next depends on the value's type.
  	
  	    switch (typeof value) {
  	      case "string":
  	        return quote(value);
  	
  	      case "number":
  	
  	        // JSON numbers must be finite. Encode non-finite numbers as null.
  	
  	        return isFinite(value)
  	          ? String(value)
  	          : "null";
  	
  	      case "boolean":
  	      case "null":
  	
  	        // If the value is a boolean or null, convert it to a string. Note:
  	        // typeof null does not produce "null". The case is included here in
  	        // the remote chance that this gets fixed someday.
  	
  	        return String(value);
  	
  	        // If the type is "object", we might be dealing with an object or an array or
  	        // null.
  	
  	      case "object":
  	
  	        // Due to a specification blunder in ECMAScript, typeof null is "object",
  	        // so watch out for that case.
  	
  	        if (!value) {
  	          return "null";
  	        }
  	
  	        // Make an array to hold the partial results of stringifying this object value.
  	
  	        gap += indent;
  	        partial = [];
  	
  	        // Is the value an array?
  	
  	        if (Object.prototype.toString.apply(value) === "[object Array]") {
  	
  	          // The value is an array. Stringify every element. Use null as a placeholder
  	          // for non-JSON values.
  	
  	          length = value.length;
  	          for (i = 0; i < length; i += 1) {
  	            partial[i] = str(i, value) || "null";
  	          }
  	
  	          // Join all of the elements together, separated with commas, and wrap them in
  	          // brackets.
  	
  	          v = partial.length === 0
  	            ? "[]"
  	            : gap
  	            ? "[\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "]"
  	            : "[" + partial.join(",") + "]";
  	          gap = mind;
  	          return v;
  	        }
  	
  	        // If the replacer is an array, use it to select the members to be stringified.
  	
  	        if (rep && typeof rep === "object") {
  	          length = rep.length;
  	          for (i = 0; i < length; i += 1) {
  	            if (typeof rep[i] === "string") {
  	              k = rep[i];
  	              v = str(k, value);
  	              if (v) {
  	                partial.push(quote(k) + (
  	                      gap
  	                      ? ": "
  	                      : ":"
  	                      ) + v);
  	              }
  	            }
  	          }
  	        } else {
  	
  	          // Otherwise, iterate through all of the keys in the object.
  	
  	          for (k in value) {
  	            if (Object.prototype.hasOwnProperty.call(value, k)) {
  	              v = str(k, value);
  	              if (v) {
  	                partial.push(quote(k) + (
  	                      gap
  	                      ? ": "
  	                      : ":"
  	                      ) + v);
  	              }
  	            }
  	          }
  	        }
  	
  	        // Join all of the member texts together, separated with commas,
  	        // and wrap them in braces.
  	
  	        v = partial.length === 0
  	          ? "{}"
  	          : gap
  	          ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}"
  	          : "{" + partial.join(",") + "}";
  	        gap = mind;
  	        return v;
  	    }
  	  }
  	
  	  // If the JSON object does not yet have a stringify method, give it one.
  	
  	  if (typeof JSON.stringify !== "function") {
  	    meta = {    // table of character substitutions
  	      "\b": "\\b",
  	      "\t": "\\t",
  	      "\n": "\\n",
  	      "\f": "\\f",
  	      "\r": "\\r",
  	      "\"": "\\\"",
  	      "\\": "\\\\"
  	    };
  	    JSON.stringify = function (value, replacer, space) {
  	
  	      // The stringify method takes a value and an optional replacer, and an optional
  	      // space parameter, and returns a JSON text. The replacer can be a function
  	      // that can replace values, or an array of strings that will select the keys.
  	      // A default replacer method can be provided. Use of the space parameter can
  	      // produce text that is more easily readable.
  	
  	      var i;
  	      gap = "";
  	      indent = "";
  	
  	      // If the space parameter is a number, make an indent string containing that
  	      // many spaces.
  	
  	      if (typeof space === "number") {
  	        for (i = 0; i < space; i += 1) {
  	          indent += " ";
  	        }
  	
  	        // If the space parameter is a string, it will be used as the indent string.
  	
  	      } else if (typeof space === "string") {
  	        indent = space;
  	      }
  	
  	      // If there is a replacer, it must be a function or an array.
  	      // Otherwise, throw an error.
  	
  	      rep = replacer;
  	      if (replacer && typeof replacer !== "function" &&
  	          (typeof replacer !== "object" ||
  	           typeof replacer.length !== "number")) {
  	        throw new Error("JSON.stringify");
  	      }
  	
  	      // Make a fake root object containing our value under the key of "".
  	      // Return the result of stringifying the value.
  	
  	      return str("", {"": value});
  	    };
  	  }
  	
  	
  	  // If the JSON object does not yet have a parse method, give it one.
  	
  	  if (typeof JSON.parse !== "function") {
  	    JSON.parse = (function () {
  	
  	      // This function creates a JSON parse function that uses a state machine rather
  	      // than the dangerous eval function to parse a JSON text.
  	
  	      var state;      // The state of the parser, one of
  	      // 'go'         The starting state
  	      // 'ok'         The final, accepting state
  	      // 'firstokey'  Ready for the first key of the object or
  	      //              the closing of an empty object
  	      // 'okey'       Ready for the next key of the object
  	      // 'colon'      Ready for the colon
  	      // 'ovalue'     Ready for the value half of a key/value pair
  	      // 'ocomma'     Ready for a comma or closing }
  	      // 'firstavalue' Ready for the first value of an array or
  	      //              an empty array
  	      // 'avalue'     Ready for the next value of an array
  	      // 'acomma'     Ready for a comma or closing ]
  	      var stack;      // The stack, for controlling nesting.
  	      var container;  // The current container object or array
  	      var key;        // The current key
  	      var value;      // The current value
  	      var escapes = { // Escapement translation table
  	        "\\": "\\",
  	        "\"": "\"",
  	        "/": "/",
  	        "t": "\t",
  	        "n": "\n",
  	        "r": "\r",
  	        "f": "\f",
  	        "b": "\b"
  	      };
  	      var string = {   // The actions for string tokens
  	        go: function () {
  	          state = "ok";
  	        },
  	        firstokey: function () {
  	          key = value;
  	          state = "colon";
  	        },
  	        okey: function () {
  	          key = value;
  	          state = "colon";
  	        },
  	        ovalue: function () {
  	          state = "ocomma";
  	        },
  	        firstavalue: function () {
  	          state = "acomma";
  	        },
  	        avalue: function () {
  	          state = "acomma";
  	        }
  	      };
  	      var number = {   // The actions for number tokens
  	        go: function () {
  	          state = "ok";
  	        },
  	        ovalue: function () {
  	          state = "ocomma";
  	        },
  	        firstavalue: function () {
  	          state = "acomma";
  	        },
  	        avalue: function () {
  	          state = "acomma";
  	        }
  	      };
  	      var action = {
  	
  	        // The action table describes the behavior of the machine. It contains an
  	        // object for each token. Each object contains a method that is called when
  	        // a token is matched in a state. An object will lack a method for illegal
  	        // states.
  	
  	        "{": {
  	          go: function () {
  	            stack.push({state: "ok"});
  	            container = {};
  	            state = "firstokey";
  	          },
  	          ovalue: function () {
  	            stack.push({container: container, state: "ocomma", key: key});
  	            container = {};
  	            state = "firstokey";
  	          },
  	          firstavalue: function () {
  	            stack.push({container: container, state: "acomma"});
  	            container = {};
  	            state = "firstokey";
  	          },
  	          avalue: function () {
  	            stack.push({container: container, state: "acomma"});
  	            container = {};
  	            state = "firstokey";
  	          }
  	        },
  	        "}": {
  	          firstokey: function () {
  	            var pop = stack.pop();
  	            value = container;
  	            container = pop.container;
  	            key = pop.key;
  	            state = pop.state;
  	          },
  	          ocomma: function () {
  	            var pop = stack.pop();
  	            container[key] = value;
  	            value = container;
  	            container = pop.container;
  	            key = pop.key;
  	            state = pop.state;
  	          }
  	        },
  	        "[": {
  	          go: function () {
  	            stack.push({state: "ok"});
  	            container = [];
  	            state = "firstavalue";
  	          },
  	          ovalue: function () {
  	            stack.push({container: container, state: "ocomma", key: key});
  	            container = [];
  	            state = "firstavalue";
  	          },
  	          firstavalue: function () {
  	            stack.push({container: container, state: "acomma"});
  	            container = [];
  	            state = "firstavalue";
  	          },
  	          avalue: function () {
  	            stack.push({container: container, state: "acomma"});
  	            container = [];
  	            state = "firstavalue";
  	          }
  	        },
  	        "]": {
  	          firstavalue: function () {
  	            var pop = stack.pop();
  	            value = container;
  	            container = pop.container;
  	            key = pop.key;
  	            state = pop.state;
  	          },
  	          acomma: function () {
  	            var pop = stack.pop();
  	            container.push(value);
  	            value = container;
  	            container = pop.container;
  	            key = pop.key;
  	            state = pop.state;
  	          }
  	        },
  	        ":": {
  	          colon: function () {
  	            if (Object.hasOwnProperty.call(container, key)) {
  	              throw new SyntaxError("Duplicate key '" + key + "\"");
  	            }
  	            state = "ovalue";
  	          }
  	        },
  	        ",": {
  	          ocomma: function () {
  	            container[key] = value;
  	            state = "okey";
  	          },
  	          acomma: function () {
  	            container.push(value);
  	            state = "avalue";
  	          }
  	        },
  	        "true": {
  	          go: function () {
  	            value = true;
  	            state = "ok";
  	          },
  	          ovalue: function () {
  	            value = true;
  	            state = "ocomma";
  	          },
  	          firstavalue: function () {
  	            value = true;
  	            state = "acomma";
  	          },
  	          avalue: function () {
  	            value = true;
  	            state = "acomma";
  	          }
  	        },
  	        "false": {
  	          go: function () {
  	            value = false;
  	            state = "ok";
  	          },
  	          ovalue: function () {
  	            value = false;
  	            state = "ocomma";
  	          },
  	          firstavalue: function () {
  	            value = false;
  	            state = "acomma";
  	          },
  	          avalue: function () {
  	            value = false;
  	            state = "acomma";
  	          }
  	        },
  	        "null": {
  	          go: function () {
  	            value = null;
  	            state = "ok";
  	          },
  	          ovalue: function () {
  	            value = null;
  	            state = "ocomma";
  	          },
  	          firstavalue: function () {
  	            value = null;
  	            state = "acomma";
  	          },
  	          avalue: function () {
  	            value = null;
  	            state = "acomma";
  	          }
  	        }
  	      };
  	
  	      function debackslashify(text) {
  	
  	        // Remove and replace any backslash escapement.
  	
  	        return text.replace(/\\(?:u(.{4})|([^u]))/g, function (ignore, b, c) {
  	          return b
  	            ? String.fromCharCode(parseInt(b, 16))
  	            : escapes[c];
  	        });
  	      }
  	
  	      return function (source, reviver) {
  	
  	        // A regular expression is used to extract tokens from the JSON text.
  	        // The extraction process is cautious.
  	
  	        var result;
  	        var tx = /^[\u0020\t\n\r]*(?:([,:\[\]{}]|true|false|null)|(-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)|"((?:[^\r\n\t\\\"]|\\(?:["\\\/trnfb]|u[0-9a-fA-F]{4}))*)")/;
  	
  	        // Set the starting state.
  	
  	        state = "go";
  	
  	        // The stack records the container, key, and state for each object or array
  	        // that contains another object or array while processing nested structures.
  	
  	        stack = [];
  	
  	        // If any error occurs, we will catch it and ultimately throw a syntax error.
  	
  	        try {
  	
  	          // For each token...
  	
  	          while (true) {
  	            result = tx.exec(source);
  	            if (!result) {
  	              break;
  	            }
  	
  	            // result is the result array from matching the tokenizing regular expression.
  	            //  result[0] contains everything that matched, including any initial whitespace.
  	            //  result[1] contains any punctuation that was matched, or true, false, or null.
  	            //  result[2] contains a matched number, still in string form.
  	            //  result[3] contains a matched string, without quotes but with escapement.
  	
  	            if (result[1]) {
  	
  	              // Token: Execute the action for this state and token.
  	
  	              action[result[1]][state]();
  	
  	            } else if (result[2]) {
  	
  	              // Number token: Convert the number string into a number value and execute
  	              // the action for this state and number.
  	
  	              value = +result[2];
  	              number[state]();
  	            } else {
  	
  	              // String token: Replace the escapement sequences and execute the action for
  	              // this state and string.
  	
  	              value = debackslashify(result[3]);
  	              string[state]();
  	            }
  	
  	            // Remove the token from the string. The loop will continue as long as there
  	            // are tokens. This is a slow process, but it allows the use of ^ matching,
  	            // which assures that no illegal tokens slip through.
  	
  	            source = source.slice(result[0].length);
  	          }
  	
  	          // If we find a state/token combination that is illegal, then the action will
  	          // cause an error. We handle the error by simply changing the state.
  	
  	        } catch (e) {
  	          state = e;
  	        }
  	
  	        // The parsing is finished. If we are not in the final "ok" state, or if the
  	        // remaining source contains anything except whitespace, then we did not have
  	        //a well-formed JSON text.
  	
  	        if (state !== "ok" || (/[^\u0020\t\n\r]/.test(source))) {
  	          throw (state instanceof SyntaxError)
  	            ? state
  	            : new SyntaxError("JSON");
  	        }
  	
  	        // If there is a reviver function, we recursively walk the new structure,
  	        // passing each name/value pair to the reviver function for possible
  	        // transformation, starting with a temporary root object that holds the current
  	        // value in an empty key. If there is not a reviver function, we simply return
  	        // that value.
  	
  	        return (typeof reviver === "function")
  	          ? (function walk(holder, key) {
  	            var k;
  	            var v;
  	            var val = holder[key];
  	            if (val && typeof val === "object") {
  	              for (k in value) {
  	                if (Object.prototype.hasOwnProperty.call(val, k)) {
  	                  v = walk(val, k);
  	                  if (v !== undefined) {
  	                    val[k] = v;
  	                  } else {
  	                    delete val[k];
  	                  }
  	                }
  	              }
  	            }
  	            return reviver.call(holder, key, val);
  	          }({"": value}, ""))
  	        : value;
  	      };
  	    }());
  	  }
  	}