text: //
  //  Adapted by Michel Mariani:
  //  - Used module.exports to allow Node.js require ().
  //  json2.stringify ():
  //  - Used Array.isArray () to test if the value is an array.
  //  - Improved indenting so that pairs of brackets { } and [ ]
  //    are always aligned on the same vertical position.
  //  - Inserted single spaces systematically for better
  //    readability when indenting is off.
  //  - Removed all ranges from rx_escapable, except first one,
  //    to be consistent with JSON.stringify ().
  //  json2.parse ():
  //  - Not used.
  //
  //  json2.js
  //  2016-10-28
  //  Public Domain.
  //  NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
  //  See http://www.JSON.org/js.html
  //  This code should be minified before deployment.
  //  See http://javascript.crockford.com/jsmin.html
  
  //  USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
  //  NOT CONTROL.
  
  //  This file creates a global json2 object containing two methods: stringify
  //  and parse. This file provides the ES5 JSON capability to ES3 systems.
  //  If a project might run on IE8 or earlier, then this file should be included.
  //  This file does nothing on ES5 systems.
  
  //      json2.stringify(value, replacer, space)
  //          value       any JavaScript value, usually an object or array.
  //          replacer    an optional parameter that determines how object
  //                      values are stringified for objects. It can be a
  //                      function or an array of strings.
  //          space       an optional parameter that specifies the indentation
  //                      of nested structures. If it is omitted, the text will
  //                      be packed without extra whitespace. If it is a number,
  //                      it will specify the number of spaces to indent at each
  //                      level. If it is a string (such as "\t" or "&nbsp;"),
  //                      it contains the characters used to indent at each level.
  //          This method produces a JSON text from a JavaScript value.
  //          When an object value is found, if the object contains a toJSON
  //          method, its toJSON method will be called and the result will be
  //          stringified. A toJSON method does not serialize: it returns the
  //          value represented by the name/value pair that should be serialized,
  //          or undefined if nothing should be serialized. The toJSON method
  //          will be passed the key associated with the value, and this will be
  //          bound to the value.
  
  //          For example, this would serialize Dates as ISO strings.
  
  //              Date.prototype.toJSON = function (key) {
  //                  function f(n) {
  //                      // Format integers to have at least two digits.
  //                      return (n < 10)
  //                          ? "0" + n
  //                          : n;
  //                  }
  //                  return this.getUTCFullYear()   + "-" +
  //                       f(this.getUTCMonth() + 1) + "-" +
  //                       f(this.getUTCDate())      + "T" +
  //                       f(this.getUTCHours())     + ":" +
  //                       f(this.getUTCMinutes())   + ":" +
  //                       f(this.getUTCSeconds())   + "Z";
  //              };
  
  //          You can provide an optional replacer method. It will be passed the
  //          key and value of each member, with this bound to the containing
  //          object. The value that is returned from your method will be
  //          serialized. If your method returns undefined, then the member will
  //          be excluded from the serialization.
  
  //          If the replacer parameter is an array of strings, then it will be
  //          used to select the members to be serialized. It filters the results
  //          such that only members with keys listed in the replacer array are
  //          stringified.
  
  //          Values that do not have JSON representations, such as undefined or
  //          functions, will not be serialized. Such values in objects will be
  //          dropped; in arrays they will be replaced with null. You can use
  //          a replacer function to replace those with JSON values.
  
  //          json2.stringify(undefined) returns undefined.
  
  //          The optional space parameter produces a stringification of the
  //          value that is filled with line breaks and indentation to make it
  //          easier to read.
  
  //          If the space parameter is a non-empty string, then that string will
  //          be used for indentation. If the space parameter is a number, then
  //          the indentation will be that many spaces.
  
  //          Example:
  
  //          text = json2.stringify(["e", {pluribus: "unum"}]);
  //          // text is '["e",{"pluribus":"unum"}]'
  
  //          text = json2.stringify(["e", {pluribus: "unum"}], null, "\t");
  //          // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
  
  //          text = json2.stringify([new Date()], function (key, value) {
  //              return this[key] instanceof Date
  //                  ? "Date(" + this[key] + ")"
  //                  : value;
  //          });
  //          // text is '["Date(---current time---)"]'
  
  //      json2.parse(text, reviver)
  //          This method parses a JSON text to produce an object or array.
  //          It can throw a SyntaxError exception.
  
  //          The optional reviver parameter is a function that can filter and
  //          transform the results. It receives each of the keys and values,
  //          and its return value is used instead of the original value.
  //          If it returns what it received, then the structure is not modified.
  //          If it returns undefined then the member is deleted.
  
  //          Example:
  
  //          // Parse the text. Values that look like ISO date strings will
  //          // be converted to Date objects.
  
  //          myData = json2.parse(text, function (key, value) {
  //              var a;
  //              if (typeof value === "string") {
  //                  a =
  //   /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
  //                  if (a) {
  //                      return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
  //                          +a[5], +a[6]));
  //                  }
  //              }
  //              return value;
  //          });
  
  //          myData = json2.parse('["Date(09/09/2001)"]', function (key, value) {
  //              var d;
  //              if (typeof value === "string" &&
  //                      value.slice(0, 5) === "Date(" &&
  //                      value.slice(-1) === ")") {
  //                  d = new Date(value.slice(5, -1));
  //                  if (d) {
  //                      return d;
  //                  }
  //              }
  //              return value;
  //          });
  
  //  This is a reference implementation. You are free to copy, modify, or
  //  redistribute.
  
  /*jslint
      eval, for, this
  */
  
  /*property
      json2, apply, call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
      getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
      lastIndex, length, parse, prototype, push, replace, slice, stringify,
      test, toJSON, toString, valueOf
  */
  
  
  (function () {
      "use strict";
  
      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]/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 (Array.isArray (value)) {
  
  // 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" + mind + "]" : "[ ]")
                      : (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[0] === "{") || (v[0] === "["))
                                      ? ":\n" + 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[0] === "{") || (v[0] === "["))
                                      ? ":\n" + gap
                                      : ": ")
                              ) + v);
                          }
                      }
                  }
              }
  
  // Join all of the member texts together, separated with commas,
  // and wrap them in braces.
  
              v = (partial.length === 0)
                  ? (gap ? "{\n" + mind + "}" : "{ }")
                  : (gap
                      ? "{\n" + gap + partial.join(",\n" + gap) + "\n" + mind + "}"
                      : "{ " + partial.join(", ") + " }");
              gap = mind;
              return v;
          }
      }
  
      meta = {    // table of character substitutions
          "\b": "\\b",
          "\t": "\\t",
          "\n": "\\n",
          "\f": "\\f",
          "\r": "\\r",
          "\"": "\\\"",
          "\\": "\\\\"
      };
      module.exports.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] replacer must be a function or an array.");
          }
  
  // Make a fake root object containing our value under the key of "".
  // Return the result of stringifying the value.
  
          return str("", {"": value});
      };
  
  
      module.exports.parse = function (text, reviver) {
  
  // The parse method takes a text and an optional reviver function, and returns
  // a JavaScript value if the text is a valid JSON text.
  
          var j;
  
          function walk(holder, key) {
  
  // The walk method is used to recursively walk the resulting structure so
  // that modifications can be made.
  
              var k;
              var v;
              var value = holder[key];
              if (value && typeof value === "object") {
                  for (k in value) {
                      if (Object.prototype.hasOwnProperty.call(value, k)) {
                          v = walk(value, k);
                          if (v !== undefined) {
                              value[k] = v;
                          } else {
                              delete value[k];
                          }
                      }
                  }
              }
              return reviver.call(holder, key, value);
          }
  
  
  // Parsing happens in four stages. In the first stage, we replace certain
  // Unicode characters with escape sequences. JavaScript handles many characters
  // incorrectly, either silently deleting them, or treating them as line endings.
  
          text = String(text);
          rx_dangerous.lastIndex = 0;
          if (rx_dangerous.test(text)) {
              text = text.replace(rx_dangerous, function (a) {
                  return "\\u" +
                          ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
              });
          }
  
  // In the second stage, we run the text against regular expressions that look
  // for non-JSON patterns. We are especially concerned with "()" and "new"
  // because they can cause invocation, and "=" because it can cause mutation.
  // But just to be safe, we want to reject all unexpected forms.
  
  // We split the second stage into 4 regexp operations in order to work around
  // crippling inefficiencies in IE's and Safari's regexp engines. First we
  // replace the JSON backslash pairs with "@" (a non-JSON character). Second, we
  // replace all simple value tokens with "]" characters. Third, we delete all
  // open brackets that follow a colon or comma or that begin the text. Finally,
  // we look to see that the remaining characters are only whitespace or "]" or
  // "," or ":" or "{" or "}". If that is so, then the text is safe for eval.
  
          if (
              rx_one.test(
                  text
                      .replace(rx_two, "@")
                      .replace(rx_three, "]")
                      .replace(rx_four, "")
              )
          ) {
  
  // In the third stage we use the eval function to compile the text into a
  // JavaScript structure. The "{" operator is subject to a syntactic ambiguity
  // in JavaScript: it can begin a block or an object literal. We wrap the text
  // in parens to eliminate the ambiguity.
  
              j = eval("(" + text + ")");
  
  // In the optional fourth stage, we recursively walk the new structure, passing
  // each name/value pair to a reviver function for possible transformation.
  
              return (typeof reviver === "function")
                  ? walk({"": j}, "")
                  : j;
          }
  
  // If the text is not JSON parseable, then a SyntaxError is thrown.
  
          throw new SyntaxError("[JSON.parse] text is not JSON parseable.");
      };
  }());
  //
  