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]);
