text: layui.define(['jquery', 'element'], function (exports) {
      "use strict";
  
      var MOD_NAME = 'yaml',
          $ = layui.jquery,
          element = layui.element;
  
      var yaml = new function () {
          this.parse = function (str) {
              return YAML.parse(yamlString);
          }
          this.load = function (path) {
              return YAML.load(path);
          }
      }
      exports(MOD_NAME, yaml);
  });
  
  
  (function () {
      function r(e, n, t) {
          function o(i, f) {
              if (!n[i]) {
                  if (!e[i]) {
                      var c = "function" == typeof require && require;
                      if (!f && c) return c(i, !0);
                      if (u) return u(i, !0);
                      var a = new Error("Cannot find module '" + i + "'");
                      throw a.code = "MODULE_NOT_FOUND", a
                  }
                  var p = n[i] = {
                      exports: {}
                  };
                  e[i][0].call(p.exports, function (r) {
                      var n = e[i][1][r];
                      return o(n || r)
                  }, p, p.exports, r, e, n, t)
              }
              return n[i].exports
          }
  
          for (var u = "function" == typeof require && require, i = 0; i < t.length; i++) o(t[i]);
          return o
      }
  
      return r
  })()({
      1: [function (require, module, exports) {
          var Dumper, Inline, Utils;
  
          Utils = require('./Utils');
  
          Inline = require('./Inline');
  
          Dumper = (function () {
              function Dumper() {
              }
  
              Dumper.indentation = 4;
  
              Dumper.prototype.dump = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
                  var i, key, len, output, prefix, value, willBeInlined;
                  if (inline == null) {
                      inline = 0;
                  }
                  if (indent == null) {
                      indent = 0;
                  }
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectEncoder == null) {
                      objectEncoder = null;
                  }
                  output = '';
                  if (typeof input === 'function') {
                      return output;
                  }
                  prefix = (indent ? Utils.strRepeat(' ', indent) : '');
                  if (inline <= 0 || typeof input !== 'object' || input instanceof Date || Utils.isEmpty(input)) {
                      output += prefix + Inline.dump(input, exceptionOnInvalidType, objectEncoder);
                  } else {
                      if (input instanceof Array) {
                          for (i = 0, len = input.length; i < len; i++) {
                              value = input[i];
                              willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
                              output += prefix + '-' + (willBeInlined ? ' ' : "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 :
                                  indent + this.indentation), exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
                          }
                      } else {
                          for (key in input) {
                              value = input[key];
                              willBeInlined = inline - 1 <= 0 || typeof value !== 'object' || Utils.isEmpty(value);
                              output += prefix + Inline.dump(key, exceptionOnInvalidType, objectEncoder) + ':' + (willBeInlined ? ' ' :
                                  "\n") + this.dump(value, inline - 1, (willBeInlined ? 0 : indent + this.indentation),
                                  exceptionOnInvalidType, objectEncoder) + (willBeInlined ? "\n" : '');
                          }
                      }
                  }
                  return output;
              };
  
              return Dumper;
  
          })();
  
          module.exports = Dumper;
  
  
      }, {
          "./Inline": 6,
          "./Utils": 10
      }],
      2: [function (require, module, exports) {
          var Escaper, Pattern;
  
          Pattern = require('./Pattern');
  
          Escaper = (function () {
              var ch;
  
              function Escaper() {
              }
  
              Escaper.LIST_ESCAPEES = ['\\', '\\\\', '\\"', '"', "\x00", "\x01", "\x02", "\x03", "\x04", "\x05", "\x06",
                  "\x07", "\x08", "\x09", "\x0a", "\x0b", "\x0c", "\x0d", "\x0e", "\x0f", "\x10", "\x11", "\x12", "\x13",
                  "\x14", "\x15", "\x16", "\x17", "\x18", "\x19", "\x1a", "\x1b", "\x1c", "\x1d", "\x1e", "\x1f", (ch = String.fromCharCode)
                  (0x0085), ch(0x00A0), ch(0x2028), ch(0x2029)
              ];
  
              Escaper.LIST_ESCAPED = ['\\\\', '\\"', '\\"', '\\"', "\\0", "\\x01", "\\x02", "\\x03", "\\x04", "\\x05",
                  "\\x06", "\\a", "\\b", "\\t", "\\n", "\\v", "\\f", "\\r", "\\x0e", "\\x0f", "\\x10", "\\x11", "\\x12",
                  "\\x13", "\\x14", "\\x15", "\\x16", "\\x17", "\\x18", "\\x19", "\\x1a", "\\e", "\\x1c", "\\x1d", "\\x1e",
                  "\\x1f", "\\N", "\\_", "\\L", "\\P"
              ];
  
              Escaper.MAPPING_ESCAPEES_TO_ESCAPED = (function () {
                  var i, j, mapping, ref;
                  mapping = {};
                  for (i = j = 0, ref = Escaper.LIST_ESCAPEES.length; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
                      mapping[Escaper.LIST_ESCAPEES[i]] = Escaper.LIST_ESCAPED[i];
                  }
                  return mapping;
              })();
  
              Escaper.PATTERN_CHARACTERS_TO_ESCAPE = new Pattern('[\\x00-\\x1f]|\xc2\x85|\xc2\xa0|\xe2\x80\xa8|\xe2\x80\xa9');
  
              Escaper.PATTERN_MAPPING_ESCAPEES = new Pattern(Escaper.LIST_ESCAPEES.join('|').split('\\').join('\\\\'));
  
              Escaper.PATTERN_SINGLE_QUOTING = new Pattern('[\\s\'":{}[\\],&*#?]|^[-?|<>=!%@`]');
  
              Escaper.requiresDoubleQuoting = function (value) {
                  return this.PATTERN_CHARACTERS_TO_ESCAPE.test(value);
              };
  
              Escaper.escapeWithDoubleQuotes = function (value) {
                  var result;
                  result = this.PATTERN_MAPPING_ESCAPEES.replace(value, (function (_this) {
                      return function (str) {
                          return _this.MAPPING_ESCAPEES_TO_ESCAPED[str];
                      };
                  })(this));
                  return '"' + result + '"';
              };
  
              Escaper.requiresSingleQuoting = function (value) {
                  return this.PATTERN_SINGLE_QUOTING.test(value);
              };
  
              Escaper.escapeWithSingleQuotes = function (value) {
                  return "'" + value.replace(/'/g, "''") + "'";
              };
  
              return Escaper;
  
          })();
  
          module.exports = Escaper;
  
  
      }, {
          "./Pattern": 8
      }],
      3: [function (require, module, exports) {
          var DumpException,
              extend = function (child, parent) {
                  for (var key in parent) {
                      if (hasProp.call(parent, key)) child[key] = parent[key];
                  }
  
                  function ctor() {
                      this.constructor = child;
                  }
  
                  ctor.prototype = parent.prototype;
                  child.prototype = new ctor();
                  child.__super__ = parent.prototype;
                  return child;
              },
              hasProp = {}.hasOwnProperty;
  
          DumpException = (function (superClass) {
              extend(DumpException, superClass);
  
              function DumpException(message, parsedLine, snippet) {
                  DumpException.__super__.constructor.call(this, message);
                  this.message = message;
                  this.parsedLine = parsedLine;
                  this.snippet = snippet;
              }
  
              DumpException.prototype.toString = function () {
                  if ((this.parsedLine != null) && (this.snippet != null)) {
                      return '<DumpException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
                  } else {
                      return '<DumpException> ' + this.message;
                  }
              };
  
              return DumpException;
  
          })(Error);
  
          module.exports = DumpException;
  
  
      }, {}],
      4: [function (require, module, exports) {
          var ParseException,
              extend = function (child, parent) {
                  for (var key in parent) {
                      if (hasProp.call(parent, key)) child[key] = parent[key];
                  }
  
                  function ctor() {
                      this.constructor = child;
                  }
  
                  ctor.prototype = parent.prototype;
                  child.prototype = new ctor();
                  child.__super__ = parent.prototype;
                  return child;
              },
              hasProp = {}.hasOwnProperty;
  
          ParseException = (function (superClass) {
              extend(ParseException, superClass);
  
              function ParseException(message, parsedLine, snippet) {
                  ParseException.__super__.constructor.call(this, message);
                  this.message = message;
                  this.parsedLine = parsedLine;
                  this.snippet = snippet;
              }
  
              ParseException.prototype.toString = function () {
                  if ((this.parsedLine != null) && (this.snippet != null)) {
                      return '<ParseException> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
                  } else {
                      return '<ParseException> ' + this.message;
                  }
              };
  
              return ParseException;
  
          })(Error);
  
          module.exports = ParseException;
  
  
      }, {}],
      5: [function (require, module, exports) {
          var ParseMore,
              extend = function (child, parent) {
                  for (var key in parent) {
                      if (hasProp.call(parent, key)) child[key] = parent[key];
                  }
  
                  function ctor() {
                      this.constructor = child;
                  }
  
                  ctor.prototype = parent.prototype;
                  child.prototype = new ctor();
                  child.__super__ = parent.prototype;
                  return child;
              },
              hasProp = {}.hasOwnProperty;
  
          ParseMore = (function (superClass) {
              extend(ParseMore, superClass);
  
              function ParseMore(message, parsedLine, snippet) {
                  ParseMore.__super__.constructor.call(this, message);
                  this.message = message;
                  this.parsedLine = parsedLine;
                  this.snippet = snippet;
              }
  
              ParseMore.prototype.toString = function () {
                  if ((this.parsedLine != null) && (this.snippet != null)) {
                      return '<ParseMore> ' + this.message + ' (line ' + this.parsedLine + ': \'' + this.snippet + '\')';
                  } else {
                      return '<ParseMore> ' + this.message;
                  }
              };
  
              return ParseMore;
  
          })(Error);
  
          module.exports = ParseMore;
  
  
      }, {}],
      6: [function (require, module, exports) {
          var DumpException, Escaper, Inline, ParseException, ParseMore, Pattern, Unescaper, Utils,
              indexOf = [].indexOf || function (item) {
                  for (var i = 0, l = this.length; i < l; i++) {
                      if (i in this && this[i] === item) return i;
                  }
                  return -1;
              };
  
          Pattern = require('./Pattern');
  
          Unescaper = require('./Unescaper');
  
          Escaper = require('./Escaper');
  
          Utils = require('./Utils');
  
          ParseException = require('./Exception/ParseException');
  
          ParseMore = require('./Exception/ParseMore');
  
          DumpException = require('./Exception/DumpException');
  
          Inline = (function () {
              function Inline() {
              }
  
              Inline.REGEX_QUOTED_STRING = '(?:"(?:[^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'(?:[^\']*(?:\'\'[^\']*)*)\')';
  
              Inline.PATTERN_TRAILING_COMMENTS = new Pattern('^\\s*#.*$');
  
              Inline.PATTERN_QUOTED_SCALAR = new Pattern('^' + Inline.REGEX_QUOTED_STRING);
  
              Inline.PATTERN_THOUSAND_NUMERIC_SCALAR = new Pattern('^(-|\\+)?[0-9,]+(\\.[0-9]+)?$');
  
              Inline.PATTERN_SCALAR_BY_DELIMITERS = {};
  
              Inline.settings = {};
  
              Inline.configure = function (exceptionOnInvalidType, objectDecoder) {
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = null;
                  }
                  if (objectDecoder == null) {
                      objectDecoder = null;
                  }
                  this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
                  this.settings.objectDecoder = objectDecoder;
              };
  
              Inline.parse = function (value, exceptionOnInvalidType, objectDecoder) {
                  var context, result;
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectDecoder == null) {
                      objectDecoder = null;
                  }
                  this.settings.exceptionOnInvalidType = exceptionOnInvalidType;
                  this.settings.objectDecoder = objectDecoder;
                  if (value == null) {
                      return '';
                  }
                  value = Utils.trim(value);
                  if (0 === value.length) {
                      return '';
                  }
                  context = {
                      exceptionOnInvalidType: exceptionOnInvalidType,
                      objectDecoder: objectDecoder,
                      i: 0
                  };
                  switch (value.charAt(0)) {
                      case '[':
                          result = this.parseSequence(value, context);
                          ++context.i;
                          break;
                      case '{':
                          result = this.parseMapping(value, context);
                          ++context.i;
                          break;
                      default:
                          result = this.parseScalar(value, null, ['"', "'"], context);
                  }
                  if (this.PATTERN_TRAILING_COMMENTS.replace(value.slice(context.i), '') !== '') {
                      throw new ParseException('Unexpected characters near "' + value.slice(context.i) + '".');
                  }
                  return result;
              };
  
              Inline.dump = function (value, exceptionOnInvalidType, objectEncoder) {
                  var ref, result, type;
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectEncoder == null) {
                      objectEncoder = null;
                  }
                  if (value == null) {
                      return 'null';
                  }
                  type = typeof value;
                  if (type === 'object') {
                      if (value instanceof Date) {
                          return value.toISOString();
                      } else if (objectEncoder != null) {
                          result = objectEncoder(value);
                          if (typeof result === 'string' || (result != null)) {
                              return result;
                          }
                      }
                      return this.dumpObject(value);
                  }
                  if (type === 'boolean') {
                      return (value ? 'true' : 'false');
                  }
                  if (Utils.isDigits(value)) {
                      return (type === 'string' ? "'" + value + "'" : String(parseInt(value)));
                  }
                  if (Utils.isNumeric(value)) {
                      return (type === 'string' ? "'" + value + "'" : String(parseFloat(value)));
                  }
                  if (type === 'number') {
                      return (value === Infinity ? '.Inf' : (value === -Infinity ? '-.Inf' : (isNaN(value) ? '.NaN' : value)));
                  }
                  if (Escaper.requiresDoubleQuoting(value)) {
                      return Escaper.escapeWithDoubleQuotes(value);
                  }
                  if (Escaper.requiresSingleQuoting(value)) {
                      return Escaper.escapeWithSingleQuotes(value);
                  }
                  if ('' === value) {
                      return '""';
                  }
                  if (Utils.PATTERN_DATE.test(value)) {
                      return "'" + value + "'";
                  }
                  if ((ref = value.toLowerCase()) === 'null' || ref === '~' || ref === 'true' || ref === 'false') {
                      return "'" + value + "'";
                  }
                  return value;
              };
  
              Inline.dumpObject = function (value, exceptionOnInvalidType, objectSupport) {
                  var j, key, len1, output, val;
                  if (objectSupport == null) {
                      objectSupport = null;
                  }
                  if (value instanceof Array) {
                      output = [];
                      for (j = 0, len1 = value.length; j < len1; j++) {
                          val = value[j];
                          output.push(this.dump(val));
                      }
                      return '[' + output.join(', ') + ']';
                  } else {
                      output = [];
                      for (key in value) {
                          val = value[key];
                          output.push(this.dump(key) + ': ' + this.dump(val));
                      }
                      return '{' + output.join(', ') + '}';
                  }
              };
  
              Inline.parseScalar = function (scalar, delimiters, stringDelimiters, context, evaluate) {
                  var i, joinedDelimiters, match, output, pattern, ref, ref1, strpos, tmp;
                  if (delimiters == null) {
                      delimiters = null;
                  }
                  if (stringDelimiters == null) {
                      stringDelimiters = ['"', "'"];
                  }
                  if (context == null) {
                      context = null;
                  }
                  if (evaluate == null) {
                      evaluate = true;
                  }
                  if (context == null) {
                      context = {
                          exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
                          objectDecoder: this.settings.objectDecoder,
                          i: 0
                      };
                  }
                  i = context.i;
                  if (ref = scalar.charAt(i), indexOf.call(stringDelimiters, ref) >= 0) {
                      output = this.parseQuotedScalar(scalar, context);
                      i = context.i;
                      if (delimiters != null) {
                          tmp = Utils.ltrim(scalar.slice(i), ' ');
                          if (!(ref1 = tmp.charAt(0), indexOf.call(delimiters, ref1) >= 0)) {
                              throw new ParseException('Unexpected characters (' + scalar.slice(i) + ').');
                          }
                      }
                  } else {
                      if (!delimiters) {
                          output = scalar.slice(i);
                          i += output.length;
                          strpos = output.indexOf(' #');
                          if (strpos !== -1) {
                              output = Utils.rtrim(output.slice(0, strpos));
                          }
                      } else {
                          joinedDelimiters = delimiters.join('|');
                          pattern = this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters];
                          if (pattern == null) {
                              pattern = new Pattern('^(.+?)(' + joinedDelimiters + ')');
                              this.PATTERN_SCALAR_BY_DELIMITERS[joinedDelimiters] = pattern;
                          }
                          if (match = pattern.exec(scalar.slice(i))) {
                              output = match[1];
                              i += output.length;
                          } else {
                              throw new ParseException('Malformed inline YAML string (' + scalar + ').');
                          }
                      }
                      if (evaluate) {
                          output = this.evaluateScalar(output, context);
                      }
                  }
                  context.i = i;
                  return output;
              };
  
              Inline.parseQuotedScalar = function (scalar, context) {
                  var i, match, output;
                  i = context.i;
                  if (!(match = this.PATTERN_QUOTED_SCALAR.exec(scalar.slice(i)))) {
                      throw new ParseMore('Malformed inline YAML string (' + scalar.slice(i) + ').');
                  }
                  output = match[0].substr(1, match[0].length - 2);
                  if ('"' === scalar.charAt(i)) {
                      output = Unescaper.unescapeDoubleQuotedString(output);
                  } else {
                      output = Unescaper.unescapeSingleQuotedString(output);
                  }
                  i += match[0].length;
                  context.i = i;
                  return output;
              };
  
              Inline.parseSequence = function (sequence, context) {
                  var e, error, i, isQuoted, len, output, ref, value;
                  output = [];
                  len = sequence.length;
                  i = context.i;
                  i += 1;
                  while (i < len) {
                      context.i = i;
                      switch (sequence.charAt(i)) {
                          case '[':
                              output.push(this.parseSequence(sequence, context));
                              i = context.i;
                              break;
                          case '{':
                              output.push(this.parseMapping(sequence, context));
                              i = context.i;
                              break;
                          case ']':
                              return output;
                          case ',':
                          case ' ':
                          case "\n":
                              break;
                          default:
                              isQuoted = ((ref = sequence.charAt(i)) === '"' || ref === "'");
                              value = this.parseScalar(sequence, [',', ']'], ['"', "'"], context);
                              i = context.i;
                              if (!isQuoted && typeof value === 'string' && (value.indexOf(': ') !== -1 || value.indexOf(":\n") !== -1)) {
                                  try {
                                      value = this.parseMapping('{' + value + '}');
                                  } catch (error) {
                                      e = error;
                                  }
                              }
                              output.push(value);
                              --i;
                      }
                      ++i;
                  }
                  throw new ParseMore('Malformed inline YAML string ' + sequence);
              };
  
              Inline.parseMapping = function (mapping, context) {
                  var done, i, key, len, output, shouldContinueWhileLoop, value;
                  output = {};
                  len = mapping.length;
                  i = context.i;
                  i += 1;
                  shouldContinueWhileLoop = false;
                  while (i < len) {
                      context.i = i;
                      switch (mapping.charAt(i)) {
                          case ' ':
                          case ',':
                          case "\n":
                              ++i;
                              context.i = i;
                              shouldContinueWhileLoop = true;
                              break;
                          case '}':
                              return output;
                      }
                      if (shouldContinueWhileLoop) {
                          shouldContinueWhileLoop = false;
                          continue;
                      }
                      key = this.parseScalar(mapping, [':', ' ', "\n"], ['"', "'"], context, false);
                      i = context.i;
                      done = false;
                      while (i < len) {
                          context.i = i;
                          switch (mapping.charAt(i)) {
                              case '[':
                                  value = this.parseSequence(mapping, context);
                                  i = context.i;
                                  if (output[key] === void 0) {
                                      output[key] = value;
                                  }
                                  done = true;
                                  break;
                              case '{':
                                  value = this.parseMapping(mapping, context);
                                  i = context.i;
                                  if (output[key] === void 0) {
                                      output[key] = value;
                                  }
                                  done = true;
                                  break;
                              case ':':
                              case ' ':
                              case "\n":
                                  break;
                              default:
                                  value = this.parseScalar(mapping, [',', '}'], ['"', "'"], context);
                                  i = context.i;
                                  if (output[key] === void 0) {
                                      output[key] = value;
                                  }
                                  done = true;
                                  --i;
                          }
                          ++i;
                          if (done) {
                              break;
                          }
                      }
                  }
                  throw new ParseMore('Malformed inline YAML string ' + mapping);
              };
  
              Inline.evaluateScalar = function (scalar, context) {
                  var cast, date, exceptionOnInvalidType, firstChar, firstSpace, firstWord, objectDecoder, raw,
                      scalarLower,
                      subValue, trimmedScalar;
                  scalar = Utils.trim(scalar);
                  scalarLower = scalar.toLowerCase();
                  switch (scalarLower) {
                      case 'null':
                      case '':
                      case '~':
                          return null;
                      case 'true':
                          return true;
                      case 'false':
                          return false;
                      case '.inf':
                          return Infinity;
                      case '.nan':
                          return NaN;
                      case '-.inf':
                          return Infinity;
                      default:
                          firstChar = scalarLower.charAt(0);
                          switch (firstChar) {
                              case '!':
                                  firstSpace = scalar.indexOf(' ');
                                  if (firstSpace === -1) {
                                      firstWord = scalarLower;
                                  } else {
                                      firstWord = scalarLower.slice(0, firstSpace);
                                  }
                                  switch (firstWord) {
                                      case '!':
                                          if (firstSpace !== -1) {
                                              return parseInt(this.parseScalar(scalar.slice(2)));
                                          }
                                          return null;
                                      case '!str':
                                          return Utils.ltrim(scalar.slice(4));
                                      case '!!str':
                                          return Utils.ltrim(scalar.slice(5));
                                      case '!!int':
                                          return parseInt(this.parseScalar(scalar.slice(5)));
                                      case '!!bool':
                                          return Utils.parseBoolean(this.parseScalar(scalar.slice(6)), false);
                                      case '!!float':
                                          return parseFloat(this.parseScalar(scalar.slice(7)));
                                      case '!!timestamp':
                                          return Utils.stringToDate(Utils.ltrim(scalar.slice(11)));
                                      default:
                                          if (context == null) {
                                              context = {
                                                  exceptionOnInvalidType: this.settings.exceptionOnInvalidType,
                                                  objectDecoder: this.settings.objectDecoder,
                                                  i: 0
                                              };
                                          }
                                          objectDecoder = context.objectDecoder, exceptionOnInvalidType = context.exceptionOnInvalidType;
                                          if (objectDecoder) {
                                              trimmedScalar = Utils.rtrim(scalar);
                                              firstSpace = trimmedScalar.indexOf(' ');
                                              if (firstSpace === -1) {
                                                  return objectDecoder(trimmedScalar, null);
                                              } else {
                                                  subValue = Utils.ltrim(trimmedScalar.slice(firstSpace + 1));
                                                  if (!(subValue.length > 0)) {
                                                      subValue = null;
                                                  }
                                                  return objectDecoder(trimmedScalar.slice(0, firstSpace), subValue);
                                              }
                                          }
                                          if (exceptionOnInvalidType) {
                                              throw new ParseException('Custom object support when parsing a YAML file has been disabled.');
                                          }
                                          return null;
                                  }
                                  break;
                              case '0':
                                  if ('0x' === scalar.slice(0, 2)) {
                                      return Utils.hexDec(scalar);
                                  } else if (Utils.isDigits(scalar)) {
                                      return Utils.octDec(scalar);
                                  } else if (Utils.isNumeric(scalar)) {
                                      return parseFloat(scalar);
                                  } else {
                                      return scalar;
                                  }
                                  break;
                              case '+':
                                  if (Utils.isDigits(scalar)) {
                                      raw = scalar;
                                      cast = parseInt(raw);
                                      if (raw === String(cast)) {
                                          return cast;
                                      } else {
                                          return raw;
                                      }
                                  } else if (Utils.isNumeric(scalar)) {
                                      return parseFloat(scalar);
                                  } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                      return parseFloat(scalar.replace(',', ''));
                                  }
                                  return scalar;
                              case '-':
                                  if (Utils.isDigits(scalar.slice(1))) {
                                      if ('0' === scalar.charAt(1)) {
                                          return -Utils.octDec(scalar.slice(1));
                                      } else {
                                          raw = scalar.slice(1);
                                          cast = parseInt(raw);
                                          if (raw === String(cast)) {
                                              return -cast;
                                          } else {
                                              return -raw;
                                          }
                                      }
                                  } else if (Utils.isNumeric(scalar)) {
                                      return parseFloat(scalar);
                                  } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                      return parseFloat(scalar.replace(',', ''));
                                  }
                                  return scalar;
                              default:
                                  if (date = Utils.stringToDate(scalar)) {
                                      return date;
                                  } else if (Utils.isNumeric(scalar)) {
                                      return parseFloat(scalar);
                                  } else if (this.PATTERN_THOUSAND_NUMERIC_SCALAR.test(scalar)) {
                                      return parseFloat(scalar.replace(',', ''));
                                  }
                                  return scalar;
                          }
                  }
              };
  
              return Inline;
  
          })();
  
          module.exports = Inline;
  
  
      }, {
          "./Escaper": 2,
          "./Exception/DumpException": 3,
          "./Exception/ParseException": 4,
          "./Exception/ParseMore": 5,
          "./Pattern": 8,
          "./Unescaper": 9,
          "./Utils": 10
      }],
      7: [function (require, module, exports) {
          var Inline, ParseException, ParseMore, Parser, Pattern, Utils;
  
          Inline = require('./Inline');
  
          Pattern = require('./Pattern');
  
          Utils = require('./Utils');
  
          ParseException = require('./Exception/ParseException');
  
          ParseMore = require('./Exception/ParseMore');
  
          Parser = (function () {
              Parser.prototype.PATTERN_FOLDED_SCALAR_ALL = new Pattern(
                  '^(?:(?<type>![^\\|>]*)\\s+)?(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$'
              );
  
              Parser.prototype.PATTERN_FOLDED_SCALAR_END = new Pattern(
                  '(?<separator>\\||>)(?<modifiers>\\+|\\-|\\d+|\\+\\d+|\\-\\d+|\\d+\\+|\\d+\\-)?(?<comments> +#.*)?$');
  
              Parser.prototype.PATTERN_SEQUENCE_ITEM = new Pattern('^\\-((?<leadspaces>\\s+)(?<value>.+?))?\\s*$');
  
              Parser.prototype.PATTERN_ANCHOR_VALUE = new Pattern('^&(?<ref>[^ ]+) *(?<value>.*)');
  
              Parser.prototype.PATTERN_COMPACT_NOTATION = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING +
                  '|[^ \'"\\{\\[].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
  
              Parser.prototype.PATTERN_MAPPING_ITEM = new Pattern('^(?<key>' + Inline.REGEX_QUOTED_STRING +
                  '|[^ \'"\\[\\{].*?) *\\:(\\s+(?<value>.+?))?\\s*$');
  
              Parser.prototype.PATTERN_DECIMAL = new Pattern('\\d+');
  
              Parser.prototype.PATTERN_INDENT_SPACES = new Pattern('^ +');
  
              Parser.prototype.PATTERN_TRAILING_LINES = new Pattern('(\n*)$');
  
              Parser.prototype.PATTERN_YAML_HEADER = new Pattern('^\\%YAML[: ][\\d\\.]+.*\n', 'm');
  
              Parser.prototype.PATTERN_LEADING_COMMENTS = new Pattern('^(\\#.*?\n)+', 'm');
  
              Parser.prototype.PATTERN_DOCUMENT_MARKER_START = new Pattern('^\\-\\-\\-.*?\n', 'm');
  
              Parser.prototype.PATTERN_DOCUMENT_MARKER_END = new Pattern('^\\.\\.\\.\\s*$', 'm');
  
              Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION = {};
  
              Parser.prototype.CONTEXT_NONE = 0;
  
              Parser.prototype.CONTEXT_SEQUENCE = 1;
  
              Parser.prototype.CONTEXT_MAPPING = 2;
  
              function Parser(offset) {
                  this.offset = offset != null ? offset : 0;
                  this.lines = [];
                  this.currentLineNb = -1;
                  this.currentLine = '';
                  this.refs = {};
              }
  
              Parser.prototype.parse = function (value, exceptionOnInvalidType, objectDecoder) {
                  var alias, allowOverwrite, block, c, context, data, e, error, error1, error2, first, i, indent, isRef,
                      j, k,
                      key, l, lastKey, len, len1, len2, len3, lineCount, m, matches, mergeNode, n, name, parsed,
                      parsedItem,
                      parser, ref, ref1, ref2, refName, refValue, val, values;
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectDecoder == null) {
                      objectDecoder = null;
                  }
                  this.currentLineNb = -1;
                  this.currentLine = '';
                  this.lines = this.cleanup(value).split("\n");
                  data = null;
                  context = this.CONTEXT_NONE;
                  allowOverwrite = false;
                  while (this.moveToNextLine()) {
                      if (this.isCurrentLineEmpty()) {
                          continue;
                      }
                      if ("\t" === this.currentLine[0]) {
                          throw new ParseException('A YAML file cannot contain tabs as indentation.', this.getRealCurrentLineNb() + 1,
                              this.currentLine);
                      }
                      isRef = mergeNode = false;
                      if (values = this.PATTERN_SEQUENCE_ITEM.exec(this.currentLine)) {
                          if (this.CONTEXT_MAPPING === context) {
                              throw new ParseException('You cannot define a sequence item when in a mapping');
                          }
                          context = this.CONTEXT_SEQUENCE;
                          if (data == null) {
                              data = [];
                          }
                          if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
                              isRef = matches.ref;
                              values.value = matches.value;
                          }
                          if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ').indexOf(
                              '#') === 0) {
                              if (this.currentLineNb < this.lines.length - 1 && !this.isNextLineUnIndentedCollection()) {
                                  c = this.getRealCurrentLineNb() + 1;
                                  parser = new Parser(c);
                                  parser.refs = this.refs;
                                  data.push(parser.parse(this.getNextEmbedBlock(null, true), exceptionOnInvalidType, objectDecoder));
                              } else {
                                  data.push(null);
                              }
                          } else {
                              if (((ref = values.leadspaces) != null ? ref.length : void 0) && (matches = this.PATTERN_COMPACT_NOTATION.exec(
                                  values.value))) {
                                  c = this.getRealCurrentLineNb();
                                  parser = new Parser(c);
                                  parser.refs = this.refs;
                                  block = values.value;
                                  indent = this.getCurrentLineIndentation();
                                  if (this.isNextLineIndented(false)) {
                                      block += "\n" + this.getNextEmbedBlock(indent + values.leadspaces.length + 1, true);
                                  }
                                  data.push(parser.parse(block, exceptionOnInvalidType, objectDecoder));
                              } else {
                                  data.push(this.parseValue(values.value, exceptionOnInvalidType, objectDecoder));
                              }
                          }
                      } else if ((values = this.PATTERN_MAPPING_ITEM.exec(this.currentLine)) && values.key.indexOf(' #') === -1) {
                          if (this.CONTEXT_SEQUENCE === context) {
                              throw new ParseException('You cannot define a mapping item when in a sequence');
                          }
                          context = this.CONTEXT_MAPPING;
                          if (data == null) {
                              data = {};
                          }
                          Inline.configure(exceptionOnInvalidType, objectDecoder);
                          try {
                              key = Inline.parseScalar(values.key);
                          } catch (error) {
                              e = error;
                              e.parsedLine = this.getRealCurrentLineNb() + 1;
                              e.snippet = this.currentLine;
                              throw e;
                          }
                          if ('<<' === key) {
                              mergeNode = true;
                              allowOverwrite = true;
                              if (((ref1 = values.value) != null ? ref1.indexOf('*') : void 0) === 0) {
                                  refName = values.value.slice(1);
                                  if (this.refs[refName] == null) {
                                      throw new ParseException('Reference "' + refName + '" does not exist.', this.getRealCurrentLineNb() + 1,
                                          this.currentLine);
                                  }
                                  refValue = this.refs[refName];
                                  if (typeof refValue !== 'object') {
                                      throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() +
                                          1, this.currentLine);
                                  }
                                  if (refValue instanceof Array) {
                                      for (i = j = 0, len = refValue.length; j < len; i = ++j) {
                                          value = refValue[i];
                                          if (data[name = String(i)] == null) {
                                              data[name] = value;
                                          }
                                      }
                                  } else {
                                      for (key in refValue) {
                                          value = refValue[key];
                                          if (data[key] == null) {
                                              data[key] = value;
                                          }
                                      }
                                  }
                              } else {
                                  if ((values.value != null) && values.value !== '') {
                                      value = values.value;
                                  } else {
                                      value = this.getNextEmbedBlock();
                                  }
                                  c = this.getRealCurrentLineNb() + 1;
                                  parser = new Parser(c);
                                  parser.refs = this.refs;
                                  parsed = parser.parse(value, exceptionOnInvalidType);
                                  if (typeof parsed !== 'object') {
                                      throw new ParseException('YAML merge keys used with a scalar value instead of an object.', this.getRealCurrentLineNb() +
                                          1, this.currentLine);
                                  }
                                  if (parsed instanceof Array) {
                                      for (l = 0, len1 = parsed.length; l < len1; l++) {
                                          parsedItem = parsed[l];
                                          if (typeof parsedItem !== 'object') {
                                              throw new ParseException('Merge items must be objects.', this.getRealCurrentLineNb() + 1, parsedItem);
                                          }
                                          if (parsedItem instanceof Array) {
                                              for (i = m = 0, len2 = parsedItem.length; m < len2; i = ++m) {
                                                  value = parsedItem[i];
                                                  k = String(i);
                                                  if (!data.hasOwnProperty(k)) {
                                                      data[k] = value;
                                                  }
                                              }
                                          } else {
                                              for (key in parsedItem) {
                                                  value = parsedItem[key];
                                                  if (!data.hasOwnProperty(key)) {
                                                      data[key] = value;
                                                  }
                                              }
                                          }
                                      }
                                  } else {
                                      for (key in parsed) {
                                          value = parsed[key];
                                          if (!data.hasOwnProperty(key)) {
                                              data[key] = value;
                                          }
                                      }
                                  }
                              }
                          } else if ((values.value != null) && (matches = this.PATTERN_ANCHOR_VALUE.exec(values.value))) {
                              isRef = matches.ref;
                              values.value = matches.value;
                          }
                          if (mergeNode) {
  
                          } else if (!(values.value != null) || '' === Utils.trim(values.value, ' ') || Utils.ltrim(values.value, ' ')
                              .indexOf('#') === 0) {
                              if (!(this.isNextLineIndented()) && !(this.isNextLineUnIndentedCollection())) {
                                  if (allowOverwrite || data[key] === void 0) {
                                      data[key] = null;
                                  }
                              } else {
                                  c = this.getRealCurrentLineNb() + 1;
                                  parser = new Parser(c);
                                  parser.refs = this.refs;
                                  val = parser.parse(this.getNextEmbedBlock(), exceptionOnInvalidType, objectDecoder);
                                  if (allowOverwrite || data[key] === void 0) {
                                      data[key] = val;
                                  }
                              }
                          } else {
                              val = this.parseValue(values.value, exceptionOnInvalidType, objectDecoder);
                              if (allowOverwrite || data[key] === void 0) {
                                  data[key] = val;
                              }
                          }
                      } else {
                          lineCount = this.lines.length;
                          if (1 === lineCount || (2 === lineCount && Utils.isEmpty(this.lines[1]))) {
                              try {
                                  value = Inline.parse(this.lines[0], exceptionOnInvalidType, objectDecoder);
                              } catch (error1) {
                                  e = error1;
                                  e.parsedLine = this.getRealCurrentLineNb() + 1;
                                  e.snippet = this.currentLine;
                                  throw e;
                              }
                              if (typeof value === 'object') {
                                  if (value instanceof Array) {
                                      first = value[0];
                                  } else {
                                      for (key in value) {
                                          first = value[key];
                                          break;
                                      }
                                  }
                                  if (typeof first === 'string' && first.indexOf('*') === 0) {
                                      data = [];
                                      for (n = 0, len3 = value.length; n < len3; n++) {
                                          alias = value[n];
                                          data.push(this.refs[alias.slice(1)]);
                                      }
                                      value = data;
                                  }
                              }
                              return value;
                          } else if ((ref2 = Utils.ltrim(value).charAt(0)) === '[' || ref2 === '{') {
                              try {
                                  return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
                              } catch (error2) {
                                  e = error2;
                                  e.parsedLine = this.getRealCurrentLineNb() + 1;
                                  e.snippet = this.currentLine;
                                  throw e;
                              }
                          }
                          throw new ParseException('Unable to parse.', this.getRealCurrentLineNb() + 1, this.currentLine);
                      }
                      if (isRef) {
                          if (data instanceof Array) {
                              this.refs[isRef] = data[data.length - 1];
                          } else {
                              lastKey = null;
                              for (key in data) {
                                  lastKey = key;
                              }
                              this.refs[isRef] = data[lastKey];
                          }
                      }
                  }
                  if (Utils.isEmpty(data)) {
                      return null;
                  } else {
                      return data;
                  }
              };
  
              Parser.prototype.getRealCurrentLineNb = function () {
                  return this.currentLineNb + this.offset;
              };
  
              Parser.prototype.getCurrentLineIndentation = function () {
                  return this.currentLine.length - Utils.ltrim(this.currentLine, ' ').length;
              };
  
              Parser.prototype.getNextEmbedBlock = function (indentation, includeUnindentedCollection) {
                  var data, indent, isItUnindentedCollection, newIndent, removeComments, removeCommentsPattern,
                      unindentedEmbedBlock;
                  if (indentation == null) {
                      indentation = null;
                  }
                  if (includeUnindentedCollection == null) {
                      includeUnindentedCollection = false;
                  }
                  this.moveToNextLine();
                  if (indentation == null) {
                      newIndent = this.getCurrentLineIndentation();
                      unindentedEmbedBlock = this.isStringUnIndentedCollectionItem(this.currentLine);
                      if (!(this.isCurrentLineEmpty()) && 0 === newIndent && !unindentedEmbedBlock) {
                          throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
                      }
                  } else {
                      newIndent = indentation;
                  }
                  data = [this.currentLine.slice(newIndent)];
                  if (!includeUnindentedCollection) {
                      isItUnindentedCollection = this.isStringUnIndentedCollectionItem(this.currentLine);
                  }
                  removeCommentsPattern = this.PATTERN_FOLDED_SCALAR_END;
                  removeComments = !removeCommentsPattern.test(this.currentLine);
                  while (this.moveToNextLine()) {
                      indent = this.getCurrentLineIndentation();
                      if (indent === newIndent) {
                          removeComments = !removeCommentsPattern.test(this.currentLine);
                      }
                      if (removeComments && this.isCurrentLineComment()) {
                          continue;
                      }
                      if (this.isCurrentLineBlank()) {
                          data.push(this.currentLine.slice(newIndent));
                          continue;
                      }
                      if (isItUnindentedCollection && !this.isStringUnIndentedCollectionItem(this.currentLine) && indent ===
                          newIndent) {
                          this.moveToPreviousLine();
                          break;
                      }
                      if (indent >= newIndent) {
                          data.push(this.currentLine.slice(newIndent));
                      } else if (Utils.ltrim(this.currentLine).charAt(0) === '#') {
  
                      } else if (0 === indent) {
                          this.moveToPreviousLine();
                          break;
                      } else {
                          throw new ParseException('Indentation problem.', this.getRealCurrentLineNb() + 1, this.currentLine);
                      }
                  }
                  return data.join("\n");
              };
  
              Parser.prototype.moveToNextLine = function () {
                  if (this.currentLineNb >= this.lines.length - 1) {
                      return false;
                  }
                  this.currentLine = this.lines[++this.currentLineNb];
                  return true;
              };
  
              Parser.prototype.moveToPreviousLine = function () {
                  this.currentLine = this.lines[--this.currentLineNb];
              };
  
              Parser.prototype.parseValue = function (value, exceptionOnInvalidType, objectDecoder) {
                  var e, error, foldedIndent, matches, modifiers, pos, ref, ref1, val;
                  if (0 === value.indexOf('*')) {
                      pos = value.indexOf('#');
                      if (pos !== -1) {
                          value = value.substr(1, pos - 2);
                      } else {
                          value = value.slice(1);
                      }
                      if (this.refs[value] === void 0) {
                          throw new ParseException('Reference "' + value + '" does not exist.', this.currentLine);
                      }
                      return this.refs[value];
                  }
                  if (matches = this.PATTERN_FOLDED_SCALAR_ALL.exec(value)) {
                      modifiers = (ref = matches.modifiers) != null ? ref : '';
                      foldedIndent = Math.abs(parseInt(modifiers));
                      if (isNaN(foldedIndent)) {
                          foldedIndent = 0;
                      }
                      val = this.parseFoldedScalar(matches.separator, this.PATTERN_DECIMAL.replace(modifiers, ''), foldedIndent);
                      if (matches.type != null) {
                          Inline.configure(exceptionOnInvalidType, objectDecoder);
                          return Inline.parseScalar(matches.type + ' ' + val);
                      } else {
                          return val;
                      }
                  }
                  if ((ref1 = value.charAt(0)) === '[' || ref1 === '{' || ref1 === '"' || ref1 === "'") {
                      while (true) {
                          try {
                              return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
                          } catch (error) {
                              e = error;
                              if (e instanceof ParseMore && this.moveToNextLine()) {
                                  value += "\n" + Utils.trim(this.currentLine, ' ');
                              } else {
                                  e.parsedLine = this.getRealCurrentLineNb() + 1;
                                  e.snippet = this.currentLine;
                                  throw e;
                              }
                          }
                      }
                  } else {
                      if (this.isNextLineIndented()) {
                          value += "\n" + this.getNextEmbedBlock();
                      }
                      return Inline.parse(value, exceptionOnInvalidType, objectDecoder);
                  }
              };
  
              Parser.prototype.parseFoldedScalar = function (separator, indicator, indentation) {
                  var isCurrentLineBlank, j, len, line, matches, newText, notEOF, pattern, ref, text;
                  if (indicator == null) {
                      indicator = '';
                  }
                  if (indentation == null) {
                      indentation = 0;
                  }
                  notEOF = this.moveToNextLine();
                  if (!notEOF) {
                      return '';
                  }
                  isCurrentLineBlank = this.isCurrentLineBlank();
                  text = '';
                  while (notEOF && isCurrentLineBlank) {
                      if (notEOF = this.moveToNextLine()) {
                          text += "\n";
                          isCurrentLineBlank = this.isCurrentLineBlank();
                      }
                  }
                  if (0 === indentation) {
                      if (matches = this.PATTERN_INDENT_SPACES.exec(this.currentLine)) {
                          indentation = matches[0].length;
                      }
                  }
                  if (indentation > 0) {
                      pattern = this.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation];
                      if (pattern == null) {
                          pattern = new Pattern('^ {' + indentation + '}(.*)$');
                          Parser.prototype.PATTERN_FOLDED_SCALAR_BY_INDENTATION[indentation] = pattern;
                      }
                      while (notEOF && (isCurrentLineBlank || (matches = pattern.exec(this.currentLine)))) {
                          if (isCurrentLineBlank) {
                              text += this.currentLine.slice(indentation);
                          } else {
                              text += matches[1];
                          }
                          if (notEOF = this.moveToNextLine()) {
                              text += "\n";
                              isCurrentLineBlank = this.isCurrentLineBlank();
                          }
                      }
                  } else if (notEOF) {
                      text += "\n";
                  }
                  if (notEOF) {
                      this.moveToPreviousLine();
                  }
                  if ('>' === separator) {
                      newText = '';
                      ref = text.split("\n");
                      for (j = 0, len = ref.length; j < len; j++) {
                          line = ref[j];
                          if (line.length === 0 || line.charAt(0) === ' ') {
                              newText = Utils.rtrim(newText, ' ') + line + "\n";
                          } else {
                              newText += line + ' ';
                          }
                      }
                      text = newText;
                  }
                  if ('+' !== indicator) {
                      text = Utils.rtrim(text);
                  }
                  if ('' === indicator) {
                      text = this.PATTERN_TRAILING_LINES.replace(text, "\n");
                  } else if ('-' === indicator) {
                      text = this.PATTERN_TRAILING_LINES.replace(text, '');
                  }
                  return text;
              };
  
              Parser.prototype.isNextLineIndented = function (ignoreComments) {
                  var EOF, currentIndentation, ret;
                  if (ignoreComments == null) {
                      ignoreComments = true;
                  }
                  currentIndentation = this.getCurrentLineIndentation();
                  EOF = !this.moveToNextLine();
                  if (ignoreComments) {
                      while (!EOF && this.isCurrentLineEmpty()) {
                          EOF = !this.moveToNextLine();
                      }
                  } else {
                      while (!EOF && this.isCurrentLineBlank()) {
                          EOF = !this.moveToNextLine();
                      }
                  }
                  if (EOF) {
                      return false;
                  }
                  ret = false;
                  if (this.getCurrentLineIndentation() > currentIndentation) {
                      ret = true;
                  }
                  this.moveToPreviousLine();
                  return ret;
              };
  
              Parser.prototype.isCurrentLineEmpty = function () {
                  var trimmedLine;
                  trimmedLine = Utils.trim(this.currentLine, ' ');
                  return trimmedLine.length === 0 || trimmedLine.charAt(0) === '#';
              };
  
              Parser.prototype.isCurrentLineBlank = function () {
                  return '' === Utils.trim(this.currentLine, ' ');
              };
  
              Parser.prototype.isCurrentLineComment = function () {
                  var ltrimmedLine;
                  ltrimmedLine = Utils.ltrim(this.currentLine, ' ');
                  return ltrimmedLine.charAt(0) === '#';
              };
  
              Parser.prototype.cleanup = function (value) {
                  var count, i, indent, j, l, len, len1, line, lines, ref, ref1, ref2, smallestIndent, trimmedValue;
                  if (value.indexOf("\r") !== -1) {
                      value = value.split("\r\n").join("\n").split("\r").join("\n");
                  }
                  count = 0;
                  ref = this.PATTERN_YAML_HEADER.replaceAll(value, ''), value = ref[0], count = ref[1];
                  this.offset += count;
                  ref1 = this.PATTERN_LEADING_COMMENTS.replaceAll(value, '', 1), trimmedValue = ref1[0], count = ref1[1];
                  if (count === 1) {
                      this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
                      value = trimmedValue;
                  }
                  ref2 = this.PATTERN_DOCUMENT_MARKER_START.replaceAll(value, '', 1), trimmedValue = ref2[0], count = ref2[1];
                  if (count === 1) {
                      this.offset += Utils.subStrCount(value, "\n") - Utils.subStrCount(trimmedValue, "\n");
                      value = trimmedValue;
                      value = this.PATTERN_DOCUMENT_MARKER_END.replace(value, '');
                  }
                  lines = value.split("\n");
                  smallestIndent = -1;
                  for (j = 0, len = lines.length; j < len; j++) {
                      line = lines[j];
                      if (Utils.trim(line, ' ').length === 0) {
                          continue;
                      }
                      indent = line.length - Utils.ltrim(line).length;
                      if (smallestIndent === -1 || indent < smallestIndent) {
                          smallestIndent = indent;
                      }
                  }
                  if (smallestIndent > 0) {
                      for (i = l = 0, len1 = lines.length; l < len1; i = ++l) {
                          line = lines[i];
                          lines[i] = line.slice(smallestIndent);
                      }
                      value = lines.join("\n");
                  }
                  return value;
              };
  
              Parser.prototype.isNextLineUnIndentedCollection = function (currentIndentation) {
                  var notEOF, ret;
                  if (currentIndentation == null) {
                      currentIndentation = null;
                  }
                  if (currentIndentation == null) {
                      currentIndentation = this.getCurrentLineIndentation();
                  }
                  notEOF = this.moveToNextLine();
                  while (notEOF && this.isCurrentLineEmpty()) {
                      notEOF = this.moveToNextLine();
                  }
                  if (false === notEOF) {
                      return false;
                  }
                  ret = false;
                  if (this.getCurrentLineIndentation() === currentIndentation && this.isStringUnIndentedCollectionItem(this.currentLine)) {
                      ret = true;
                  }
                  this.moveToPreviousLine();
                  return ret;
              };
  
              Parser.prototype.isStringUnIndentedCollectionItem = function () {
                  return this.currentLine === '-' || this.currentLine.slice(0, 2) === '- ';
              };
  
              return Parser;
  
          })();
  
          module.exports = Parser;
  
  
      }, {
          "./Exception/ParseException": 4,
          "./Exception/ParseMore": 5,
          "./Inline": 6,
          "./Pattern": 8,
          "./Utils": 10
      }],
      8: [function (require, module, exports) {
          var Pattern;
  
          Pattern = (function () {
              Pattern.prototype.regex = null;
  
              Pattern.prototype.rawRegex = null;
  
              Pattern.prototype.cleanedRegex = null;
  
              Pattern.prototype.mapping = null;
  
              function Pattern(rawRegex, modifiers) {
                  var _char, capturingBracketNumber, cleanedRegex, i, len, mapping, name, part, subChar;
                  if (modifiers == null) {
                      modifiers = '';
                  }
                  cleanedRegex = '';
                  len = rawRegex.length;
                  mapping = null;
                  capturingBracketNumber = 0;
                  i = 0;
                  while (i < len) {
                      _char = rawRegex.charAt(i);
                      if (_char === '\\') {
                          cleanedRegex += rawRegex.slice(i, +(i + 1) + 1 || 9e9);
                          i++;
                      } else if (_char === '(') {
                          if (i < len - 2) {
                              part = rawRegex.slice(i, +(i + 2) + 1 || 9e9);
                              if (part === '(?:') {
                                  i += 2;
                                  cleanedRegex += part;
                              } else if (part === '(?<') {
                                  capturingBracketNumber++;
                                  i += 2;
                                  name = '';
                                  while (i + 1 < len) {
                                      subChar = rawRegex.charAt(i + 1);
                                      if (subChar === '>') {
                                          cleanedRegex += '(';
                                          i++;
                                          if (name.length > 0) {
                                              if (mapping == null) {
                                                  mapping = {};
                                              }
                                              mapping[name] = capturingBracketNumber;
                                          }
                                          break;
                                      } else {
                                          name += subChar;
                                      }
                                      i++;
                                  }
                              } else {
                                  cleanedRegex += _char;
                                  capturingBracketNumber++;
                              }
                          } else {
                              cleanedRegex += _char;
                          }
                      } else {
                          cleanedRegex += _char;
                      }
                      i++;
                  }
                  this.rawRegex = rawRegex;
                  this.cleanedRegex = cleanedRegex;
                  this.regex = new RegExp(this.cleanedRegex, 'g' + modifiers.replace('g', ''));
                  this.mapping = mapping;
              }
  
              Pattern.prototype.exec = function (str) {
                  var index, matches, name, ref;
                  this.regex.lastIndex = 0;
                  matches = this.regex.exec(str);
                  if (matches == null) {
                      return null;
                  }
                  if (this.mapping != null) {
                      ref = this.mapping;
                      for (name in ref) {
                          index = ref[name];
                          matches[name] = matches[index];
                      }
                  }
                  return matches;
              };
  
              Pattern.prototype.test = function (str) {
                  this.regex.lastIndex = 0;
                  return this.regex.test(str);
              };
  
              Pattern.prototype.replace = function (str, replacement) {
                  this.regex.lastIndex = 0;
                  return str.replace(this.regex, replacement);
              };
  
              Pattern.prototype.replaceAll = function (str, replacement, limit) {
                  var count;
                  if (limit == null) {
                      limit = 0;
                  }
                  this.regex.lastIndex = 0;
                  count = 0;
                  while (this.regex.test(str) && (limit === 0 || count < limit)) {
                      this.regex.lastIndex = 0;
                      str = str.replace(this.regex, replacement);
                      count++;
                  }
                  return [str, count];
              };
  
              return Pattern;
  
          })();
  
          module.exports = Pattern;
  
  
      }, {}],
      9: [function (require, module, exports) {
          var Pattern, Unescaper, Utils;
  
          Utils = require('./Utils');
  
          Pattern = require('./Pattern');
  
          Unescaper = (function () {
              function Unescaper() {
              }
  
              Unescaper.PATTERN_ESCAPED_CHARACTER = new Pattern(
                  '\\\\([0abt\tnvfre "\\/\\\\N_LP]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8})');
  
              Unescaper.unescapeSingleQuotedString = function (value) {
                  return value.replace(/\'\'/g, '\'');
              };
  
              Unescaper.unescapeDoubleQuotedString = function (value) {
                  if (this._unescapeCallback == null) {
                      this._unescapeCallback = (function (_this) {
                          return function (str) {
                              return _this.unescapeCharacter(str);
                          };
                      })(this);
                  }
                  return this.PATTERN_ESCAPED_CHARACTER.replace(value, this._unescapeCallback);
              };
  
              Unescaper.unescapeCharacter = function (value) {
                  var ch;
                  ch = String.fromCharCode;
                  switch (value.charAt(1)) {
                      case '0':
                          return ch(0);
                      case 'a':
                          return ch(7);
                      case 'b':
                          return ch(8);
                      case 't':
                          return "\t";
                      case "\t":
                          return "\t";
                      case 'n':
                          return "\n";
                      case 'v':
                          return ch(11);
                      case 'f':
                          return ch(12);
                      case 'r':
                          return ch(13);
                      case 'e':
                          return ch(27);
                      case ' ':
                          return ' ';
                      case '"':
                          return '"';
                      case '/':
                          return '/';
                      case '\\':
                          return '\\';
                      case 'N':
                          return ch(0x0085);
                      case '_':
                          return ch(0x00A0);
                      case 'L':
                          return ch(0x2028);
                      case 'P':
                          return ch(0x2029);
                      case 'x':
                          return Utils.utf8chr(Utils.hexDec(value.substr(2, 2)));
                      case 'u':
                          return Utils.utf8chr(Utils.hexDec(value.substr(2, 4)));
                      case 'U':
                          return Utils.utf8chr(Utils.hexDec(value.substr(2, 8)));
                      default:
                          return '';
                  }
              };
  
              return Unescaper;
  
          })();
  
          module.exports = Unescaper;
  
  
      }, {
          "./Pattern": 8,
          "./Utils": 10
      }],
      10: [function (require, module, exports) {
          var Pattern, Utils,
              hasProp = {}.hasOwnProperty;
  
          Pattern = require('./Pattern');
  
          Utils = (function () {
              function Utils() {
              }
  
              Utils.REGEX_LEFT_TRIM_BY_CHAR = {};
  
              Utils.REGEX_RIGHT_TRIM_BY_CHAR = {};
  
              Utils.REGEX_SPACES = /\s+/g;
  
              Utils.REGEX_DIGITS = /^\d+$/;
  
              Utils.REGEX_OCTAL = /[^0-7]/gi;
  
              Utils.REGEX_HEXADECIMAL = /[^a-f0-9]/gi;
  
              Utils.PATTERN_DATE = new Pattern('^' + '(?<year>[0-9][0-9][0-9][0-9])' + '-(?<month>[0-9][0-9]?)' +
                  '-(?<day>[0-9][0-9]?)' + '(?:(?:[Tt]|[ \t]+)' + '(?<hour>[0-9][0-9]?)' + ':(?<minute>[0-9][0-9])' +
                  ':(?<second>[0-9][0-9])' + '(?:\.(?<fraction>[0-9]*))?' +
                  '(?:[ \t]*(?<tz>Z|(?<tz_sign>[-+])(?<tz_hour>[0-9][0-9]?)' + '(?::(?<tz_minute>[0-9][0-9]))?))?)?' + '$', 'i'
              );
  
              Utils.LOCAL_TIMEZONE_OFFSET = new Date().getTimezoneOffset() * 60 * 1000;
  
              Utils.trim = function (str, _char) {
                  var regexLeft, regexRight;
                  if (_char == null) {
                      _char = '\\s';
                  }
                  regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
                  if (regexLeft == null) {
                      this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
                  }
                  regexLeft.lastIndex = 0;
                  regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
                  if (regexRight == null) {
                      this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
                  }
                  regexRight.lastIndex = 0;
                  return str.replace(regexLeft, '').replace(regexRight, '');
              };
  
              Utils.ltrim = function (str, _char) {
                  var regexLeft;
                  if (_char == null) {
                      _char = '\\s';
                  }
                  regexLeft = this.REGEX_LEFT_TRIM_BY_CHAR[_char];
                  if (regexLeft == null) {
                      this.REGEX_LEFT_TRIM_BY_CHAR[_char] = regexLeft = new RegExp('^' + _char + '' + _char + '*');
                  }
                  regexLeft.lastIndex = 0;
                  return str.replace(regexLeft, '');
              };
  
              Utils.rtrim = function (str, _char) {
                  var regexRight;
                  if (_char == null) {
                      _char = '\\s';
                  }
                  regexRight = this.REGEX_RIGHT_TRIM_BY_CHAR[_char];
                  if (regexRight == null) {
                      this.REGEX_RIGHT_TRIM_BY_CHAR[_char] = regexRight = new RegExp(_char + '' + _char + '*$');
                  }
                  regexRight.lastIndex = 0;
                  return str.replace(regexRight, '');
              };
  
              Utils.isEmpty = function (value) {
                  return !value || value === '' || value === '0' || (value instanceof Array && value.length === 0) || this.isEmptyObject(
                      value);
              };
  
              Utils.isEmptyObject = function (value) {
                  var k;
                  return value instanceof Object && ((function () {
                      var results;
                      results = [];
                      for (k in value) {
                          if (!hasProp.call(value, k)) continue;
                          results.push(k);
                      }
                      return results;
                  })()).length === 0;
              };
  
              Utils.subStrCount = function (string, subString, start, length) {
                  var c, i, j, len, ref, sublen;
                  c = 0;
                  string = '' + string;
                  subString = '' + subString;
                  if (start != null) {
                      string = string.slice(start);
                  }
                  if (length != null) {
                      string = string.slice(0, length);
                  }
                  len = string.length;
                  sublen = subString.length;
                  for (i = j = 0, ref = len; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) {
                      if (subString === string.slice(i, sublen)) {
                          c++;
                          i += sublen - 1;
                      }
                  }
                  return c;
              };
  
              Utils.isDigits = function (input) {
                  this.REGEX_DIGITS.lastIndex = 0;
                  return this.REGEX_DIGITS.test(input);
              };
  
              Utils.octDec = function (input) {
                  this.REGEX_OCTAL.lastIndex = 0;
                  return parseInt((input + '').replace(this.REGEX_OCTAL, ''), 8);
              };
  
              Utils.hexDec = function (input) {
                  this.REGEX_HEXADECIMAL.lastIndex = 0;
                  input = this.trim(input);
                  if ((input + '').slice(0, 2) === '0x') {
                      input = (input + '').slice(2);
                  }
                  return parseInt((input + '').replace(this.REGEX_HEXADECIMAL, ''), 16);
              };
  
              Utils.utf8chr = function (c) {
                  var ch;
                  ch = String.fromCharCode;
                  if (0x80 > (c %= 0x200000)) {
                      return ch(c);
                  }
                  if (0x800 > c) {
                      return ch(0xC0 | c >> 6) + ch(0x80 | c & 0x3F);
                  }
                  if (0x10000 > c) {
                      return ch(0xE0 | c >> 12) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
                  }
                  return ch(0xF0 | c >> 18) + ch(0x80 | c >> 12 & 0x3F) + ch(0x80 | c >> 6 & 0x3F) + ch(0x80 | c & 0x3F);
              };
  
              Utils.parseBoolean = function (input, strict) {
                  var lowerInput;
                  if (strict == null) {
                      strict = true;
                  }
                  if (typeof input === 'string') {
                      lowerInput = input.toLowerCase();
                      if (!strict) {
                          if (lowerInput === 'no') {
                              return false;
                          }
                      }
                      if (lowerInput === '0') {
                          return false;
                      }
                      if (lowerInput === 'false') {
                          return false;
                      }
                      if (lowerInput === '') {
                          return false;
                      }
                      return true;
                  }
                  return !!input;
              };
  
              Utils.isNumeric = function (input) {
                  this.REGEX_SPACES.lastIndex = 0;
                  return typeof input === 'number' || typeof input === 'string' && !isNaN(input) && input.replace(this.REGEX_SPACES,
                      '') !== '';
              };
  
              Utils.stringToDate = function (str) {
                  var date, day, fraction, hour, info, minute, month, second, tz_hour, tz_minute, tz_offset, year;
                  if (!(str != null ? str.length : void 0)) {
                      return null;
                  }
                  info = this.PATTERN_DATE.exec(str);
                  if (!info) {
                      return null;
                  }
                  year = parseInt(info.year, 10);
                  month = parseInt(info.month, 10) - 1;
                  day = parseInt(info.day, 10);
                  if (info.hour == null) {
                      date = new Date(Date.UTC(year, month, day));
                      return date;
                  }
                  hour = parseInt(info.hour, 10);
                  minute = parseInt(info.minute, 10);
                  second = parseInt(info.second, 10);
                  if (info.fraction != null) {
                      fraction = info.fraction.slice(0, 3);
                      while (fraction.length < 3) {
                          fraction += '0';
                      }
                      fraction = parseInt(fraction, 10);
                  } else {
                      fraction = 0;
                  }
                  if (info.tz != null) {
                      tz_hour = parseInt(info.tz_hour, 10);
                      if (info.tz_minute != null) {
                          tz_minute = parseInt(info.tz_minute, 10);
                      } else {
                          tz_minute = 0;
                      }
                      tz_offset = (tz_hour * 60 + tz_minute) * 60000;
                      if ('-' === info.tz_sign) {
                          tz_offset *= -1;
                      }
                  }
                  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
                  if (tz_offset) {
                      date.setTime(date.getTime() - tz_offset);
                  }
                  return date;
              };
  
              Utils.strRepeat = function (str, number) {
                  var i, res;
                  res = '';
                  i = 0;
                  while (i < number) {
                      res += str;
                      i++;
                  }
                  return res;
              };
  
              Utils.getStringFromFile = function (path, callback) {
                  var data, fs, j, len1, name, ref, req, xhr;
                  if (callback == null) {
                      callback = null;
                  }
                  xhr = null;
                  if (typeof window !== "undefined" && window !== null) {
                      if (window.XMLHttpRequest) {
                          xhr = new XMLHttpRequest();
                      } else if (window.ActiveXObject) {
                          ref = ["Msxml2.XMLHTTP.6.0", "Msxml2.XMLHTTP.3.0", "Msxml2.XMLHTTP", "Microsoft.XMLHTTP"];
                          for (j = 0, len1 = ref.length; j < len1; j++) {
                              name = ref[j];
                              try {
                                  xhr = new ActiveXObject(name);
                              } catch (undefined) {
                              }
                          }
                      }
                  }
                  if (xhr != null) {
                      if (callback != null) {
                          xhr.onreadystatechange = function () {
                              if (xhr.readyState === 4) {
                                  if (xhr.status === 200 || xhr.status === 0) {
                                      return callback(xhr.responseText);
                                  } else {
                                      return callback(null);
                                  }
                              }
                          };
                          xhr.open('GET', path, true);
                          return xhr.send(null);
                      } else {
                          xhr.open('GET', path, false);
                          xhr.send(null);
                          if (xhr.status === 200 || xhr.status === 0) {
                              return xhr.responseText;
                          }
                          return null;
                      }
                  } else {
                      req = require;
                      fs = req('fs');
                      if (callback != null) {
                          return fs.readFile(path, function (err, data) {
                              if (err) {
                                  return callback(null);
                              } else {
                                  return callback(String(data));
                              }
                          });
                      } else {
                          data = fs.readFileSync(path);
                          if (data != null) {
                              return String(data);
                          }
                          return null;
                      }
                  }
              };
  
              return Utils;
  
          })();
  
          module.exports = Utils;
  
  
      }, {
          "./Pattern": 8
      }],
      11: [function (require, module, exports) {
          var Dumper, Parser, Utils, Yaml;
  
          Parser = require('./Parser');
  
          Dumper = require('./Dumper');
  
          Utils = require('./Utils');
  
          Yaml = (function () {
              function Yaml() {
              }
  
              Yaml.parse = function (input, exceptionOnInvalidType, objectDecoder) {
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectDecoder == null) {
                      objectDecoder = null;
                  }
                  return new Parser().parse(input, exceptionOnInvalidType, objectDecoder);
              };
  
              Yaml.parseFile = function (path, callback, exceptionOnInvalidType, objectDecoder) {
                  var input;
                  if (callback == null) {
                      callback = null;
                  }
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectDecoder == null) {
                      objectDecoder = null;
                  }
                  if (callback != null) {
                      return Utils.getStringFromFile(path, (function (_this) {
                          return function (input) {
                              var result;
                              result = null;
                              if (input != null) {
                                  result = _this.parse(input, exceptionOnInvalidType, objectDecoder);
                              }
                              callback(result);
                          };
                      })(this));
                  } else {
                      input = Utils.getStringFromFile(path);
                      if (input != null) {
                          return this.parse(input, exceptionOnInvalidType, objectDecoder);
                      }
                      return null;
                  }
              };
  
              Yaml.dump = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
                  var yaml;
                  if (inline == null) {
                      inline = 2;
                  }
                  if (indent == null) {
                      indent = 4;
                  }
                  if (exceptionOnInvalidType == null) {
                      exceptionOnInvalidType = false;
                  }
                  if (objectEncoder == null) {
                      objectEncoder = null;
                  }
                  yaml = new Dumper();
                  yaml.indentation = indent;
                  return yaml.dump(input, inline, 0, exceptionOnInvalidType, objectEncoder);
              };
  
              Yaml.stringify = function (input, inline, indent, exceptionOnInvalidType, objectEncoder) {
                  return this.dump(input, inline, indent, exceptionOnInvalidType, objectEncoder);
              };
  
              Yaml.load = function (path, callback, exceptionOnInvalidType, objectDecoder) {
                  return this.parseFile(path, callback, exceptionOnInvalidType, objectDecoder);
              };
  
              return Yaml;
  
          })();
  
          if (typeof window !== "undefined" && window !== null) {
              window.YAML = Yaml;
          }
  
          if (typeof window === "undefined" || window === null) {
              this.YAML = Yaml;
          }
  
          module.exports = Yaml;
  
  
      }, {
          "./Dumper": 1,
          "./Parser": 7,
          "./Utils": 10
      }]
  }, {}, [11]);
  