Files F120648200

parse-cst.js
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Sat, Jul 5, 22:58

parse-cst.js
View Options

	import { j as _inherits, k as _createSuper, c as _classCallCheck, T as Type, b as _createClass, R as Range, N as Node, g as YAMLSemanticError, l as _get, m as _getPrototypeOf, Y as YAMLSyntaxError, C as Char, e as _defineProperty, P as PlainValue } from './PlainValue-b8036b75.js';

	var BlankLine = /#__PURE__/function (_Node) {
	_inherits(BlankLine, _Node);

	var _super = _createSuper(BlankLine);

	function BlankLine() {
	_classCallCheck(this, BlankLine);

	return _super.call(this, Type.BLANK_LINE);
	}
	/* istanbul ignore next */


	_createClass(BlankLine, [{
	key: "includesTrailingLines",
	get: function get() {
	// This is never called from anywhere, but if it were,
	// this is the value it should return.
	return true;
	}
	/**
	* Parses a blank line from the source
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first \n character
	* @returns {number} - Index of the character after this
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	this.range = new Range(start, start + 1);
	return start + 1;
	}
	}]);

	return BlankLine;
	}(Node);

	var CollectionItem = /#__PURE__/function (_Node) {
	_inherits(CollectionItem, _Node);

	var _super = _createSuper(CollectionItem);

	function CollectionItem(type, props) {
	var _this;

	_classCallCheck(this, CollectionItem);

	_this = _super.call(this, type, props);
	_this.node = null;
	return _this;
	}

	_createClass(CollectionItem, [{
	key: "includesTrailingLines",
	get: function get() {
	return !!this.node && this.node.includesTrailingLines;
	}
	/**
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var parseNode = context.parseNode,
	src = context.src;
	var atLineStart = context.atLineStart,
	lineStart = context.lineStart;
	if (!atLineStart && this.type === Type.SEQ_ITEM) this.error = new YAMLSemanticError(this, 'Sequence items must not have preceding content on the same line');
	var indent = atLineStart ? start - lineStart : context.indent;
	var offset = Node.endOfWhiteSpace(src, start + 1);
	var ch = src[offset];
	var inlineComment = ch === '#';
	var comments = [];
	var blankLine = null;

	while (ch === '\n' \|\| ch === '#') {
	if (ch === '#') {
	var _end = Node.endOfLine(src, offset + 1);

	comments.push(new Range(offset, _end));
	offset = _end;
	} else {
	atLineStart = true;
	lineStart = offset + 1;
	var wsEnd = Node.endOfWhiteSpace(src, lineStart);

	if (src[wsEnd] === '\n' && comments.length === 0) {
	blankLine = new BlankLine();
	lineStart = blankLine.parse({
	src: src
	}, lineStart);
	}

	offset = Node.endOfIndent(src, lineStart);
	}

	ch = src[offset];
	}

	if (Node.nextNodeIsIndented(ch, offset - (lineStart + indent), this.type !== Type.SEQ_ITEM)) {
	this.node = parseNode({
	atLineStart: atLineStart,
	inCollection: false,
	indent: indent,
	lineStart: lineStart,
	parent: this
	}, offset);
	} else if (ch && lineStart > start + 1) {
	offset = lineStart - 1;
	}

	if (this.node) {
	if (blankLine) {
	// Only blank lines preceding non-empty nodes are captured. Note that
	// this means that collection item range start indices do not always
	// increase monotonically. -- eemeli/yaml#126
	var items = context.parent.items \|\| context.parent.contents;
	if (items) items.push(blankLine);
	}

	if (comments.length) Array.prototype.push.apply(this.props, comments);
	offset = this.node.range.end;
	} else {
	if (inlineComment) {
	var c = comments[0];
	this.props.push(c);
	offset = c.end;
	} else {
	offset = Node.endOfLine(src, start + 1);
	}
	}

	var end = this.node ? this.node.valueRange.end : offset;
	this.valueRange = new Range(start, end);
	return offset;
	}
	}, {
	key: "setOrigRanges",
	value: function setOrigRanges(cr, offset) {
	offset = _get(_getPrototypeOf(CollectionItem.prototype), "setOrigRanges", this).call(this, cr, offset);
	return this.node ? this.node.setOrigRanges(cr, offset) : offset;
	}
	}, {
	key: "toString",
	value: function toString() {
	var src = this.context.src,
	node = this.node,
	range = this.range,
	value = this.value;
	if (value != null) return value;
	var str = node ? src.slice(range.start, node.range.start) + String(node) : src.slice(range.start, range.end);
	return Node.addStringTerminator(src, range.end, str);
	}
	}]);

	return CollectionItem;
	}(Node);

	var Comment = /#__PURE__/function (_Node) {
	_inherits(Comment, _Node);

	var _super = _createSuper(Comment);

	function Comment() {
	_classCallCheck(this, Comment);

	return _super.call(this, Type.COMMENT);
	}
	/**
	* Parses a comment line from the source
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this scalar
	*/


	_createClass(Comment, [{
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var offset = this.parseComment(start);
	this.range = new Range(start, offset);
	return offset;
	}
	}]);

	return Comment;
	}(Node);

	function grabCollectionEndComments(node) {
	var cnode = node;

	while (cnode instanceof CollectionItem) {
	cnode = cnode.node;
	}

	if (!(cnode instanceof Collection)) return null;
	var len = cnode.items.length;
	var ci = -1;

	for (var i = len - 1; i >= 0; --i) {
	var n = cnode.items[i];

	if (n.type === Type.COMMENT) {
	// Keep sufficiently indented comments with preceding node
	var _n$context = n.context,
	indent = _n$context.indent,
	lineStart = _n$context.lineStart;
	if (indent > 0 && n.range.start >= lineStart + indent) break;
	ci = i;
	} else if (n.type === Type.BLANK_LINE) ci = i;else break;
	}

	if (ci === -1) return null;
	var ca = cnode.items.splice(ci, len - ci);
	var prevEnd = ca[0].range.start;

	while (true) {
	cnode.range.end = prevEnd;
	if (cnode.valueRange && cnode.valueRange.end > prevEnd) cnode.valueRange.end = prevEnd;
	if (cnode === node) break;
	cnode = cnode.context.parent;
	}

	return ca;
	}
	var Collection = /#__PURE__/function (_Node) {
	_inherits(Collection, _Node);

	var _super = _createSuper(Collection);

	function Collection(firstItem) {
	var _this;

	_classCallCheck(this, Collection);

	_this = _super.call(this, firstItem.type === Type.SEQ_ITEM ? Type.SEQ : Type.MAP);

	for (var i = firstItem.props.length - 1; i >= 0; --i) {
	if (firstItem.props[i].start < firstItem.context.lineStart) {
	// props on previous line are assumed by the collection
	_this.props = firstItem.props.slice(0, i + 1);
	firstItem.props = firstItem.props.slice(i + 1);
	var itemRange = firstItem.props[0] \|\| firstItem.valueRange;
	firstItem.range.start = itemRange.start;
	break;
	}
	}

	_this.items = [firstItem];
	var ec = grabCollectionEndComments(firstItem);
	if (ec) Array.prototype.push.apply(_this.items, ec);
	return _this;
	}

	_createClass(Collection, [{
	key: "includesTrailingLines",
	get: function get() {
	return this.items.length > 0;
	}
	/**
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var parseNode = context.parseNode,
	src = context.src; // It's easier to recalculate lineStart here rather than tracking down the
	// last context from which to read it -- eemeli/yaml#2

	var lineStart = Node.startOfLine(src, start);
	var firstItem = this.items[0]; // First-item context needs to be correct for later comment handling
	// -- eemeli/yaml#17

	firstItem.context.parent = this;
	this.valueRange = Range.copy(firstItem.valueRange);
	var indent = firstItem.range.start - firstItem.context.lineStart;
	var offset = start;
	offset = Node.normalizeOffset(src, offset);
	var ch = src[offset];
	var atLineStart = Node.endOfWhiteSpace(src, lineStart) === offset;
	var prevIncludesTrailingLines = false;

	while (ch) {
	while (ch === '\n' \|\| ch === '#') {
	if (atLineStart && ch === '\n' && !prevIncludesTrailingLines) {
	var blankLine = new BlankLine();
	offset = blankLine.parse({
	src: src
	}, offset);
	this.valueRange.end = offset;

	if (offset >= src.length) {
	ch = null;
	break;
	}

	this.items.push(blankLine);
	offset -= 1; // blankLine.parse() consumes terminal newline
	} else if (ch === '#') {
	if (offset < lineStart + indent && !Collection.nextContentHasIndent(src, offset, indent)) {
	return offset;
	}

	var comment = new Comment();
	offset = comment.parse({
	indent: indent,
	lineStart: lineStart,
	src: src
	}, offset);
	this.items.push(comment);
	this.valueRange.end = offset;

	if (offset >= src.length) {
	ch = null;
	break;
	}
	}

	lineStart = offset + 1;
	offset = Node.endOfIndent(src, lineStart);

	if (Node.atBlank(src, offset)) {
	var wsEnd = Node.endOfWhiteSpace(src, offset);
	var next = src[wsEnd];

	if (!next \|\| next === '\n' \|\| next === '#') {
	offset = wsEnd;
	}
	}

	ch = src[offset];
	atLineStart = true;
	}

	if (!ch) {
	break;
	}

	if (offset !== lineStart + indent && (atLineStart \|\| ch !== ':')) {
	if (offset < lineStart + indent) {
	if (lineStart > start) offset = lineStart;
	break;
	} else if (!this.error) {
	var msg = 'All collection items must start at the same column';
	this.error = new YAMLSyntaxError(this, msg);
	}
	}

	if (firstItem.type === Type.SEQ_ITEM) {
	if (ch !== '-') {
	if (lineStart > start) offset = lineStart;
	break;
	}
	} else if (ch === '-' && !this.error) {
	// map key may start with -, as long as it's followed by a non-whitespace char
	var _next = src[offset + 1];

	if (!_next \|\| _next === '\n' \|\| _next === '\t' \|\| _next === ' ') {
	var _msg = 'A collection cannot be both a mapping and a sequence';
	this.error = new YAMLSyntaxError(this, _msg);
	}
	}

	var node = parseNode({
	atLineStart: atLineStart,
	inCollection: true,
	indent: indent,
	lineStart: lineStart,
	parent: this
	}, offset);
	if (!node) return offset; // at next document start

	this.items.push(node);
	this.valueRange.end = node.valueRange.end;
	offset = Node.normalizeOffset(src, node.range.end);
	ch = src[offset];
	atLineStart = false;
	prevIncludesTrailingLines = node.includesTrailingLines; // Need to reset lineStart and atLineStart here if preceding node's range
	// has advanced to check the current line's indentation level
	// -- eemeli/yaml#10 & eemeli/yaml#38

	if (ch) {
	var ls = offset - 1;
	var prev = src[ls];

	while (prev === ' ' \|\| prev === '\t') {
	prev = src[--ls];
	}

	if (prev === '\n') {
	lineStart = ls + 1;
	atLineStart = true;
	}
	}

	var ec = grabCollectionEndComments(node);
	if (ec) Array.prototype.push.apply(this.items, ec);
	}

	return offset;
	}
	}, {
	key: "setOrigRanges",
	value: function setOrigRanges(cr, offset) {
	offset = _get(_getPrototypeOf(Collection.prototype), "setOrigRanges", this).call(this, cr, offset);
	this.items.forEach(function (node) {
	offset = node.setOrigRanges(cr, offset);
	});
	return offset;
	}
	}, {
	key: "toString",
	value: function toString() {
	var src = this.context.src,
	items = this.items,
	range = this.range,
	value = this.value;
	if (value != null) return value;
	var str = src.slice(range.start, items[0].range.start) + String(items[0]);

	for (var i = 1; i < items.length; ++i) {
	var item = items[i];
	var _item$context = item.context,
	atLineStart = _item$context.atLineStart,
	indent = _item$context.indent;
	if (atLineStart) for (var _i = 0; _i < indent; ++_i) {
	str += ' ';
	}
	str += String(item);
	}

	return Node.addStringTerminator(src, range.end, str);
	}
	}], [{
	key: "nextContentHasIndent",
	value: function nextContentHasIndent(src, offset, indent) {
	var lineStart = Node.endOfLine(src, offset) + 1;
	offset = Node.endOfWhiteSpace(src, lineStart);
	var ch = src[offset];
	if (!ch) return false;
	if (offset >= lineStart + indent) return true;
	if (ch !== '#' && ch !== '\n') return false;
	return Collection.nextContentHasIndent(src, offset, indent);
	}
	}]);

	return Collection;
	}(Node);

	var Directive = /#__PURE__/function (_Node) {
	_inherits(Directive, _Node);

	var _super = _createSuper(Directive);

	function Directive() {
	var _this;

	_classCallCheck(this, Directive);

	_this = _super.call(this, Type.DIRECTIVE);
	_this.name = null;
	return _this;
	}

	_createClass(Directive, [{
	key: "parameters",
	get: function get() {
	var raw = this.rawValue;
	return raw ? raw.trim().split(/[ \t]+/) : [];
	}
	}, {
	key: "parseName",
	value: function parseName(start) {
	var src = this.context.src;
	var offset = start;
	var ch = src[offset];

	while (ch && ch !== '\n' && ch !== '\t' && ch !== ' ') {
	ch = src[offset += 1];
	}

	this.name = src.slice(start, offset);
	return offset;
	}
	}, {
	key: "parseParameters",
	value: function parseParameters(start) {
	var src = this.context.src;
	var offset = start;
	var ch = src[offset];

	while (ch && ch !== '\n' && ch !== '#') {
	ch = src[offset += 1];
	}

	this.valueRange = new Range(start, offset);
	return offset;
	}
	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var offset = this.parseName(start + 1);
	offset = this.parseParameters(offset);
	offset = this.parseComment(offset);
	this.range = new Range(start, offset);
	return offset;
	}
	}]);

	return Directive;
	}(Node);

	var Document = /#__PURE__/function (_Node) {
	_inherits(Document, _Node);

	var _super = _createSuper(Document);

	function Document() {
	var _this;

	_classCallCheck(this, Document);

	_this = _super.call(this, Type.DOCUMENT);
	_this.directives = null;
	_this.contents = null;
	_this.directivesEndMarker = null;
	_this.documentEndMarker = null;
	return _this;
	}

	_createClass(Document, [{
	key: "parseDirectives",
	value: function parseDirectives(start) {
	var src = this.context.src;
	this.directives = [];
	var atLineStart = true;
	var hasDirectives = false;
	var offset = start;

	while (!Node.atDocumentBoundary(src, offset, Char.DIRECTIVES_END)) {
	offset = Document.startCommentOrEndBlankLine(src, offset);

	switch (src[offset]) {
	case '\n':
	if (atLineStart) {
	var blankLine = new BlankLine();
	offset = blankLine.parse({
	src: src
	}, offset);

	if (offset < src.length) {
	this.directives.push(blankLine);
	}
	} else {
	offset += 1;
	atLineStart = true;
	}

	break;

	case '#':
	{
	var comment = new Comment();
	offset = comment.parse({
	src: src
	}, offset);
	this.directives.push(comment);
	atLineStart = false;
	}
	break;

	case '%':
	{
	var directive = new Directive();
	offset = directive.parse({
	parent: this,
	src: src
	}, offset);
	this.directives.push(directive);
	hasDirectives = true;
	atLineStart = false;
	}
	break;

	default:
	if (hasDirectives) {
	this.error = new YAMLSemanticError(this, 'Missing directives-end indicator line');
	} else if (this.directives.length > 0) {
	this.contents = this.directives;
	this.directives = [];
	}

	return offset;
	}
	}

	if (src[offset]) {
	this.directivesEndMarker = new Range(offset, offset + 3);
	return offset + 3;
	}

	if (hasDirectives) {
	this.error = new YAMLSemanticError(this, 'Missing directives-end indicator line');
	} else if (this.directives.length > 0) {
	this.contents = this.directives;
	this.directives = [];
	}

	return offset;
	}
	}, {
	key: "parseContents",
	value: function parseContents(start) {
	var _this$context = this.context,
	parseNode = _this$context.parseNode,
	src = _this$context.src;
	if (!this.contents) this.contents = [];
	var lineStart = start;

	while (src[lineStart - 1] === '-') {
	lineStart -= 1;
	}

	var offset = Node.endOfWhiteSpace(src, start);
	var atLineStart = lineStart === start;
	this.valueRange = new Range(offset);

	while (!Node.atDocumentBoundary(src, offset, Char.DOCUMENT_END)) {
	switch (src[offset]) {
	case '\n':
	if (atLineStart) {
	var blankLine = new BlankLine();
	offset = blankLine.parse({
	src: src
	}, offset);

	if (offset < src.length) {
	this.contents.push(blankLine);
	}
	} else {
	offset += 1;
	atLineStart = true;
	}

	lineStart = offset;
	break;

	case '#':
	{
	var comment = new Comment();
	offset = comment.parse({
	src: src
	}, offset);
	this.contents.push(comment);
	atLineStart = false;
	}
	break;

	default:
	{
	var iEnd = Node.endOfIndent(src, offset);
	var context = {
	atLineStart: atLineStart,
	indent: -1,
	inFlow: false,
	inCollection: false,
	lineStart: lineStart,
	parent: this
	};
	var node = parseNode(context, iEnd);
	if (!node) return this.valueRange.end = iEnd; // at next document start

	this.contents.push(node);
	offset = node.range.end;
	atLineStart = false;
	var ec = grabCollectionEndComments(node);
	if (ec) Array.prototype.push.apply(this.contents, ec);
	}
	}

	offset = Document.startCommentOrEndBlankLine(src, offset);
	}

	this.valueRange.end = offset;

	if (src[offset]) {
	this.documentEndMarker = new Range(offset, offset + 3);
	offset += 3;

	if (src[offset]) {
	offset = Node.endOfWhiteSpace(src, offset);

	if (src[offset] === '#') {
	var _comment = new Comment();

	offset = _comment.parse({
	src: src
	}, offset);
	this.contents.push(_comment);
	}

	switch (src[offset]) {
	case '\n':
	offset += 1;
	break;

	case undefined:
	break;

	default:
	this.error = new YAMLSyntaxError(this, 'Document end marker line cannot have a non-comment suffix');
	}
	}
	}

	return offset;
	}
	/**
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	context.root = this;
	this.context = context;
	var src = context.src;
	var offset = src.charCodeAt(start) === 0xfeff ? start + 1 : start; // skip BOM

	offset = this.parseDirectives(offset);
	offset = this.parseContents(offset);
	return offset;
	}
	}, {
	key: "setOrigRanges",
	value: function setOrigRanges(cr, offset) {
	offset = _get(_getPrototypeOf(Document.prototype), "setOrigRanges", this).call(this, cr, offset);
	this.directives.forEach(function (node) {
	offset = node.setOrigRanges(cr, offset);
	});
	if (this.directivesEndMarker) offset = this.directivesEndMarker.setOrigRange(cr, offset);
	this.contents.forEach(function (node) {
	offset = node.setOrigRanges(cr, offset);
	});
	if (this.documentEndMarker) offset = this.documentEndMarker.setOrigRange(cr, offset);
	return offset;
	}
	}, {
	key: "toString",
	value: function toString() {
	var contents = this.contents,
	directives = this.directives,
	value = this.value;
	if (value != null) return value;
	var str = directives.join('');

	if (contents.length > 0) {
	if (directives.length > 0 \|\| contents[0].type === Type.COMMENT) str += '---\n';
	str += contents.join('');
	}

	if (str[str.length - 1] !== '\n') str += '\n';
	return str;
	}
	}], [{
	key: "startCommentOrEndBlankLine",
	value: function startCommentOrEndBlankLine(src, start) {
	var offset = Node.endOfWhiteSpace(src, start);
	var ch = src[offset];
	return ch === '#' \|\| ch === '\n' ? offset : start;
	}
	}]);

	return Document;
	}(Node);

	var Alias = /#__PURE__/function (_Node) {
	_inherits(Alias, _Node);

	var _super = _createSuper(Alias);

	function Alias() {
	_classCallCheck(this, Alias);

	return _super.apply(this, arguments);
	}

	_createClass(Alias, [{
	key: "parse",
	value:
	/**
	* Parses an *alias from the source
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this scalar
	*/
	function parse(context, start) {
	this.context = context;
	var src = context.src;
	var offset = Node.endOfIdentifier(src, start + 1);
	this.valueRange = new Range(start + 1, offset);
	offset = Node.endOfWhiteSpace(src, offset);
	offset = this.parseComment(offset);
	return offset;
	}
	}]);

	return Alias;
	}(Node);

	var Chomp = {
	CLIP: 'CLIP',
	KEEP: 'KEEP',
	STRIP: 'STRIP'
	};
	var BlockValue = /#__PURE__/function (_Node) {
	_inherits(BlockValue, _Node);

	var _super = _createSuper(BlockValue);

	function BlockValue(type, props) {
	var _this;

	_classCallCheck(this, BlockValue);

	_this = _super.call(this, type, props);
	_this.blockIndent = null;
	_this.chomping = Chomp.CLIP;
	_this.header = null;
	return _this;
	}

	_createClass(BlockValue, [{
	key: "includesTrailingLines",
	get: function get() {
	return this.chomping === Chomp.KEEP;
	}
	}, {
	key: "strValue",
	get: function get() {
	if (!this.valueRange \|\| !this.context) return null;
	var _this$valueRange = this.valueRange,
	start = _this$valueRange.start,
	end = _this$valueRange.end;
	var _this$context = this.context,
	indent = _this$context.indent,
	src = _this$context.src;
	if (this.valueRange.isEmpty()) return '';
	var lastNewLine = null;
	var ch = src[end - 1];

	while (ch === '\n' \|\| ch === '\t' \|\| ch === ' ') {
	end -= 1;

	if (end <= start) {
	if (this.chomping === Chomp.KEEP) break;else return ''; // probably never happens
	}

	if (ch === '\n') lastNewLine = end;
	ch = src[end - 1];
	}

	var keepStart = end + 1;

	if (lastNewLine) {
	if (this.chomping === Chomp.KEEP) {
	keepStart = lastNewLine;
	end = this.valueRange.end;
	} else {
	end = lastNewLine;
	}
	}

	var bi = indent + this.blockIndent;
	var folded = this.type === Type.BLOCK_FOLDED;
	var atStart = true;
	var str = '';
	var sep = '';
	var prevMoreIndented = false;

	for (var i = start; i < end; ++i) {
	for (var j = 0; j < bi; ++j) {
	if (src[i] !== ' ') break;
	i += 1;
	}

	var _ch = src[i];

	if (_ch === '\n') {
	if (sep === '\n') str += '\n';else sep = '\n';
	} else {
	var lineEnd = Node.endOfLine(src, i);
	var line = src.slice(i, lineEnd);
	i = lineEnd;

	if (folded && (_ch === ' ' \|\| _ch === '\t') && i < keepStart) {
	if (sep === ' ') sep = '\n';else if (!prevMoreIndented && !atStart && sep === '\n') sep = '\n\n';
	str += sep + line; //+ ((lineEnd < end && src[lineEnd]) \|\| '')

	sep = lineEnd < end && src[lineEnd] \|\| '';
	prevMoreIndented = true;
	} else {
	str += sep + line;
	sep = folded && i < keepStart ? ' ' : '\n';
	prevMoreIndented = false;
	}

	if (atStart && line !== '') atStart = false;
	}
	}

	return this.chomping === Chomp.STRIP ? str : str + '\n';
	}
	}, {
	key: "parseBlockHeader",
	value: function parseBlockHeader(start) {
	var src = this.context.src;
	var offset = start + 1;
	var bi = '';

	while (true) {
	var ch = src[offset];

	switch (ch) {
	case '-':
	this.chomping = Chomp.STRIP;
	break;

	case '+':
	this.chomping = Chomp.KEEP;
	break;

	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	bi += ch;
	break;

	default:
	this.blockIndent = Number(bi) \|\| null;
	this.header = new Range(start, offset);
	return offset;
	}

	offset += 1;
	}
	}
	}, {
	key: "parseBlockValue",
	value: function parseBlockValue(start) {
	var _this$context2 = this.context,
	indent = _this$context2.indent,
	src = _this$context2.src;
	var explicit = !!this.blockIndent;
	var offset = start;
	var valueEnd = start;
	var minBlockIndent = 1;

	for (var ch = src[offset]; ch === '\n'; ch = src[offset]) {
	offset += 1;
	if (Node.atDocumentBoundary(src, offset)) break;
	var end = Node.endOfBlockIndent(src, indent, offset); // should not include tab?

	if (end === null) break;
	var _ch2 = src[end];
	var lineIndent = end - (offset + indent);

	if (!this.blockIndent) {
	// no explicit block indent, none yet detected
	if (src[end] !== '\n') {
	// first line with non-whitespace content
	if (lineIndent < minBlockIndent) {
	var msg = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
	this.error = new YAMLSemanticError(this, msg);
	}

	this.blockIndent = lineIndent;
	} else if (lineIndent > minBlockIndent) {
	// empty line with more whitespace
	minBlockIndent = lineIndent;
	}
	} else if (_ch2 && _ch2 !== '\n' && lineIndent < this.blockIndent) {
	if (src[end] === '#') break;

	if (!this.error) {
	var _src = explicit ? 'explicit indentation indicator' : 'first line';

	var _msg = "Block scalars must not be less indented than their ".concat(_src);

	this.error = new YAMLSemanticError(this, _msg);
	}
	}

	if (src[end] === '\n') {
	offset = end;
	} else {
	offset = valueEnd = Node.endOfLine(src, end);
	}
	}

	if (this.chomping !== Chomp.KEEP) {
	offset = src[valueEnd] ? valueEnd + 1 : valueEnd;
	}

	this.valueRange = new Range(start + 1, offset);
	return offset;
	}
	/**
	* Parses a block value from the source
	*
	* Accepted forms are:
	* ```
	* BS
	* block
	* lines
	*
	* BS #comment
	* block
	* lines
	* ```
	* where the block style BS matches the regexp `[\|>][-+1-9]*` and block lines
	* are empty or have an indent level greater than `indent`.
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this block
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var src = context.src;
	var offset = this.parseBlockHeader(start);
	offset = Node.endOfWhiteSpace(src, offset);
	offset = this.parseComment(offset);
	offset = this.parseBlockValue(offset);
	return offset;
	}
	}, {
	key: "setOrigRanges",
	value: function setOrigRanges(cr, offset) {
	offset = _get(_getPrototypeOf(BlockValue.prototype), "setOrigRanges", this).call(this, cr, offset);
	return this.header ? this.header.setOrigRange(cr, offset) : offset;
	}
	}]);

	return BlockValue;
	}(Node);

	var FlowCollection = /#__PURE__/function (_Node) {
	_inherits(FlowCollection, _Node);

	var _super = _createSuper(FlowCollection);

	function FlowCollection(type, props) {
	var _this;

	_classCallCheck(this, FlowCollection);

	_this = _super.call(this, type, props);
	_this.items = null;
	return _this;
	}

	_createClass(FlowCollection, [{
	key: "prevNodeIsJsonLike",
	value: function prevNodeIsJsonLike() {
	var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.items.length;
	var node = this.items[idx - 1];
	return !!node && (node.jsonLike \|\| node.type === Type.COMMENT && this.prevNodeIsJsonLike(idx - 1));
	}
	/**
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var parseNode = context.parseNode,
	src = context.src;
	var indent = context.indent,
	lineStart = context.lineStart;
	var char = src[start]; // { or [

	this.items = [{
	char: char,
	offset: start
	}];
	var offset = Node.endOfWhiteSpace(src, start + 1);
	char = src[offset];

	while (char && char !== ']' && char !== '}') {
	switch (char) {
	case '\n':
	{
	lineStart = offset + 1;
	var wsEnd = Node.endOfWhiteSpace(src, lineStart);

	if (src[wsEnd] === '\n') {
	var blankLine = new BlankLine();
	lineStart = blankLine.parse({
	src: src
	}, lineStart);
	this.items.push(blankLine);
	}

	offset = Node.endOfIndent(src, lineStart);

	if (offset <= lineStart + indent) {
	char = src[offset];

	if (offset < lineStart + indent \|\| char !== ']' && char !== '}') {
	var msg = 'Insufficient indentation in flow collection';
	this.error = new YAMLSemanticError(this, msg);
	}
	}
	}
	break;

	case ',':
	{
	this.items.push({
	char: char,
	offset: offset
	});
	offset += 1;
	}
	break;

	case '#':
	{
	var comment = new Comment();
	offset = comment.parse({
	src: src
	}, offset);
	this.items.push(comment);
	}
	break;

	case '?':
	case ':':
	{
	var next = src[offset + 1];

	if (next === '\n' \|\| next === '\t' \|\| next === ' ' \|\| next === ',' \|\| // in-flow : after JSON-like key does not need to be followed by whitespace
	char === ':' && this.prevNodeIsJsonLike()) {
	this.items.push({
	char: char,
	offset: offset
	});
	offset += 1;
	break;
	}
	}
	// fallthrough

	default:
	{
	var node = parseNode({
	atLineStart: false,
	inCollection: false,
	inFlow: true,
	indent: -1,
	lineStart: lineStart,
	parent: this
	}, offset);

	if (!node) {
	// at next document start
	this.valueRange = new Range(start, offset);
	return offset;
	}

	this.items.push(node);
	offset = Node.normalizeOffset(src, node.range.end);
	}
	}

	offset = Node.endOfWhiteSpace(src, offset);
	char = src[offset];
	}

	this.valueRange = new Range(start, offset + 1);

	if (char) {
	this.items.push({
	char: char,
	offset: offset
	});
	offset = Node.endOfWhiteSpace(src, offset + 1);
	offset = this.parseComment(offset);
	}

	return offset;
	}
	}, {
	key: "setOrigRanges",
	value: function setOrigRanges(cr, offset) {
	offset = _get(_getPrototypeOf(FlowCollection.prototype), "setOrigRanges", this).call(this, cr, offset);
	this.items.forEach(function (node) {
	if (node instanceof Node) {
	offset = node.setOrigRanges(cr, offset);
	} else if (cr.length === 0) {
	node.origOffset = node.offset;
	} else {
	var i = offset;

	while (i < cr.length) {
	if (cr[i] > node.offset) break;else ++i;
	}

	node.origOffset = node.offset + i;
	offset = i;
	}
	});
	return offset;
	}
	}, {
	key: "toString",
	value: function toString() {
	var src = this.context.src,
	items = this.items,
	range = this.range,
	value = this.value;
	if (value != null) return value;
	var nodes = items.filter(function (item) {
	return item instanceof Node;
	});
	var str = '';
	var prevEnd = range.start;
	nodes.forEach(function (node) {
	var prefix = src.slice(prevEnd, node.range.start);
	prevEnd = node.range.end;
	str += prefix + String(node);

	if (str[str.length - 1] === '\n' && src[prevEnd - 1] !== '\n' && src[prevEnd] === '\n') {
	// Comment range does not include the terminal newline, but its
	// stringified value does. Without this fix, newlines at comment ends
	// get duplicated.
	prevEnd += 1;
	}
	});
	str += src.slice(prevEnd, range.end);
	return Node.addStringTerminator(src, range.end, str);
	}
	}]);

	return FlowCollection;
	}(Node);

	var QuoteDouble = /#__PURE__/function (_Node) {
	_inherits(QuoteDouble, _Node);

	var _super = _createSuper(QuoteDouble);

	function QuoteDouble() {
	_classCallCheck(this, QuoteDouble);

	return _super.apply(this, arguments);
	}

	_createClass(QuoteDouble, [{
	key: "strValue",
	get:
	/**
	* @returns {string \| { str: string, errors: YAMLSyntaxError[] }}
	*/
	function get() {
	if (!this.valueRange \|\| !this.context) return null;
	var errors = [];
	var _this$valueRange = this.valueRange,
	start = _this$valueRange.start,
	end = _this$valueRange.end;
	var _this$context = this.context,
	indent = _this$context.indent,
	src = _this$context.src;
	if (src[end - 1] !== '"') errors.push(new YAMLSyntaxError(this, 'Missing closing "quote')); // Using String#replace is too painful with escaped newlines preceded by
	// escaped backslashes; also, this should be faster.

	var str = '';

	for (var i = start + 1; i < end - 1; ++i) {
	var ch = src[i];

	if (ch === '\n') {
	if (Node.atDocumentBoundary(src, i + 1)) errors.push(new YAMLSemanticError(this, 'Document boundary indicators are not allowed within string values'));

	var _Node$foldNewline = Node.foldNewline(src, i, indent),
	fold = _Node$foldNewline.fold,
	offset = _Node$foldNewline.offset,
	error = _Node$foldNewline.error;

	str += fold;
	i = offset;
	if (error) errors.push(new YAMLSemanticError(this, 'Multi-line double-quoted string needs to be sufficiently indented'));
	} else if (ch === '\\') {
	i += 1;

	switch (src[i]) {
	case '0':
	str += '\0';
	break;
	// null character

	case 'a':
	str += '\x07';
	break;
	// bell character

	case 'b':
	str += '\b';
	break;
	// backspace

	case 'e':
	str += '\x1b';
	break;
	// escape character

	case 'f':
	str += '\f';
	break;
	// form feed

	case 'n':
	str += '\n';
	break;
	// line feed

	case 'r':
	str += '\r';
	break;
	// carriage return

	case 't':
	str += '\t';
	break;
	// horizontal tab

	case 'v':
	str += '\v';
	break;
	// vertical tab

	case 'N':
	str += "\x85";
	break;
	// Unicode next line

	case '_':
	str += "\xA0";
	break;
	// Unicode non-breaking space

	case 'L':
	str += "\u2028";
	break;
	// Unicode line separator

	case 'P':
	str += "\u2029";
	break;
	// Unicode paragraph separator

	case ' ':
	str += ' ';
	break;

	case '"':
	str += '"';
	break;

	case '/':
	str += '/';
	break;

	case '\\':
	str += '\\';
	break;

	case '\t':
	str += '\t';
	break;

	case 'x':
	str += this.parseCharCode(i + 1, 2, errors);
	i += 2;
	break;

	case 'u':
	str += this.parseCharCode(i + 1, 4, errors);
	i += 4;
	break;

	case 'U':
	str += this.parseCharCode(i + 1, 8, errors);
	i += 8;
	break;

	case '\n':
	// skip escaped newlines, but still trim the following line
	while (src[i + 1] === ' ' \|\| src[i + 1] === '\t') {
	i += 1;
	}

	break;

	default:
	errors.push(new YAMLSyntaxError(this, "Invalid escape sequence ".concat(src.substr(i - 1, 2))));
	str += '\\' + src[i];
	}
	} else if (ch === ' ' \|\| ch === '\t') {
	// trim trailing whitespace
	var wsStart = i;
	var next = src[i + 1];

	while (next === ' ' \|\| next === '\t') {
	i += 1;
	next = src[i + 1];
	}

	if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch;
	} else {
	str += ch;
	}
	}

	return errors.length > 0 ? {
	errors: errors,
	str: str
	} : str;
	}
	}, {
	key: "parseCharCode",
	value: function parseCharCode(offset, length, errors) {
	var src = this.context.src;
	var cc = src.substr(offset, length);
	var ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
	var code = ok ? parseInt(cc, 16) : NaN;

	if (isNaN(code)) {
	errors.push(new YAMLSyntaxError(this, "Invalid escape sequence ".concat(src.substr(offset - 2, length + 2))));
	return src.substr(offset - 2, length + 2);
	}

	return String.fromCodePoint(code);
	}
	/**
	* Parses a "double quoted" value from the source
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this scalar
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var src = context.src;
	var offset = QuoteDouble.endOfQuote(src, start + 1);
	this.valueRange = new Range(start, offset);
	offset = Node.endOfWhiteSpace(src, offset);
	offset = this.parseComment(offset);
	return offset;
	}
	}], [{
	key: "endOfQuote",
	value: function endOfQuote(src, offset) {
	var ch = src[offset];

	while (ch && ch !== '"') {
	offset += ch === '\\' ? 2 : 1;
	ch = src[offset];
	}

	return offset + 1;
	}
	}]);

	return QuoteDouble;
	}(Node);

	var QuoteSingle = /#__PURE__/function (_Node) {
	_inherits(QuoteSingle, _Node);

	var _super = _createSuper(QuoteSingle);

	function QuoteSingle() {
	_classCallCheck(this, QuoteSingle);

	return _super.apply(this, arguments);
	}

	_createClass(QuoteSingle, [{
	key: "strValue",
	get:
	/**
	* @returns {string \| { str: string, errors: YAMLSyntaxError[] }}
	*/
	function get() {
	if (!this.valueRange \|\| !this.context) return null;
	var errors = [];
	var _this$valueRange = this.valueRange,
	start = _this$valueRange.start,
	end = _this$valueRange.end;
	var _this$context = this.context,
	indent = _this$context.indent,
	src = _this$context.src;
	if (src[end - 1] !== "'") errors.push(new YAMLSyntaxError(this, "Missing closing 'quote"));
	var str = '';

	for (var i = start + 1; i < end - 1; ++i) {
	var ch = src[i];

	if (ch === '\n') {
	if (Node.atDocumentBoundary(src, i + 1)) errors.push(new YAMLSemanticError(this, 'Document boundary indicators are not allowed within string values'));

	var _Node$foldNewline = Node.foldNewline(src, i, indent),
	fold = _Node$foldNewline.fold,
	offset = _Node$foldNewline.offset,
	error = _Node$foldNewline.error;

	str += fold;
	i = offset;
	if (error) errors.push(new YAMLSemanticError(this, 'Multi-line single-quoted string needs to be sufficiently indented'));
	} else if (ch === "'") {
	str += ch;
	i += 1;
	if (src[i] !== "'") errors.push(new YAMLSyntaxError(this, 'Unescaped single quote? This should not happen.'));
	} else if (ch === ' ' \|\| ch === '\t') {
	// trim trailing whitespace
	var wsStart = i;
	var next = src[i + 1];

	while (next === ' ' \|\| next === '\t') {
	i += 1;
	next = src[i + 1];
	}

	if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch;
	} else {
	str += ch;
	}
	}

	return errors.length > 0 ? {
	errors: errors,
	str: str
	} : str;
	}
	/**
	* Parses a 'single quoted' value from the source
	*
	* @param {ParseContext} context
	* @param {number} start - Index of first character
	* @returns {number} - Index of the character after this scalar
	*/

	}, {
	key: "parse",
	value: function parse(context, start) {
	this.context = context;
	var src = context.src;
	var offset = QuoteSingle.endOfQuote(src, start + 1);
	this.valueRange = new Range(start, offset);
	offset = Node.endOfWhiteSpace(src, offset);
	offset = this.parseComment(offset);
	return offset;
	}
	}], [{
	key: "endOfQuote",
	value: function endOfQuote(src, offset) {
	var ch = src[offset];

	while (ch) {
	if (ch === "'") {
	if (src[offset + 1] !== "'") break;
	ch = src[offset += 2];
	} else {
	ch = src[offset += 1];
	}
	}

	return offset + 1;
	}
	}]);

	return QuoteSingle;
	}(Node);

	function createNewNode(type, props) {
	switch (type) {
	case Type.ALIAS:
	return new Alias(type, props);

	case Type.BLOCK_FOLDED:
	case Type.BLOCK_LITERAL:
	return new BlockValue(type, props);

	case Type.FLOW_MAP:
	case Type.FLOW_SEQ:
	return new FlowCollection(type, props);

	case Type.MAP_KEY:
	case Type.MAP_VALUE:
	case Type.SEQ_ITEM:
	return new CollectionItem(type, props);

	case Type.COMMENT:
	case Type.PLAIN:
	return new PlainValue(type, props);

	case Type.QUOTE_DOUBLE:
	return new QuoteDouble(type, props);

	case Type.QUOTE_SINGLE:
	return new QuoteSingle(type, props);

	/* istanbul ignore next */

	default:
	return null;
	// should never happen
	}
	}
	/**
	* @param {boolean} atLineStart - Node starts at beginning of line
	* @param {boolean} inFlow - true if currently in a flow context
	* @param {boolean} inCollection - true if currently in a collection context
	* @param {number} indent - Current level of indentation
	* @param {number} lineStart - Start of the current line
	* @param {Node} parent - The parent of the node
	* @param {string} src - Source of the YAML document
	*/


	var ParseContext = /#__PURE__/function () {
	function ParseContext() {
	var _this = this;

	var orig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

	var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
	atLineStart = _ref.atLineStart,
	inCollection = _ref.inCollection,
	inFlow = _ref.inFlow,
	indent = _ref.indent,
	lineStart = _ref.lineStart,
	parent = _ref.parent;

	_classCallCheck(this, ParseContext);

	_defineProperty(this, "parseNode", function (overlay, start) {
	if (Node.atDocumentBoundary(_this.src, start)) return null;
	var context = new ParseContext(_this, overlay);

	var _context$parseProps = context.parseProps(start),
	props = _context$parseProps.props,
	type = _context$parseProps.type,
	valueStart = _context$parseProps.valueStart;

	var node = createNewNode(type, props);
	var offset = node.parse(context, valueStart);
	node.range = new Range(start, offset);
	/* istanbul ignore if */

	if (offset <= start) {
	// This should never happen, but if it does, let's make sure to at least
	// step one character forward to avoid a busy loop.
	node.error = new Error("Node#parse consumed no characters");
	node.error.parseEnd = offset;
	node.error.source = node;
	node.range.end = start + 1;
	}

	if (context.nodeStartsCollection(node)) {
	if (!node.error && !context.atLineStart && context.parent.type === Type.DOCUMENT) {
	node.error = new YAMLSyntaxError(node, 'Block collection must not have preceding content here (e.g. directives-end indicator)');
	}

	var collection = new Collection(node);
	offset = collection.parse(new ParseContext(context), offset);
	collection.range = new Range(start, offset);
	return collection;
	}

	return node;
	});

	this.atLineStart = atLineStart != null ? atLineStart : orig.atLineStart \|\| false;
	this.inCollection = inCollection != null ? inCollection : orig.inCollection \|\| false;
	this.inFlow = inFlow != null ? inFlow : orig.inFlow \|\| false;
	this.indent = indent != null ? indent : orig.indent;
	this.lineStart = lineStart != null ? lineStart : orig.lineStart;
	this.parent = parent != null ? parent : orig.parent \|\| {};
	this.root = orig.root;
	this.src = orig.src;
	}

	_createClass(ParseContext, [{
	key: "nodeStartsCollection",
	value: function nodeStartsCollection(node) {
	var inCollection = this.inCollection,
	inFlow = this.inFlow,
	src = this.src;
	if (inCollection \|\| inFlow) return false;
	if (node instanceof CollectionItem) return true; // check for implicit key

	var offset = node.range.end;
	if (src[offset] === '\n' \|\| src[offset - 1] === '\n') return false;
	offset = Node.endOfWhiteSpace(src, offset);
	return src[offset] === ':';
	} // Anchor and tag are before type, which determines the node implementation
	// class; hence this intermediate step.

	}, {
	key: "parseProps",
	value: function parseProps(offset) {
	var inFlow = this.inFlow,
	parent = this.parent,
	src = this.src;
	var props = [];
	var lineHasProps = false;
	offset = this.atLineStart ? Node.endOfIndent(src, offset) : Node.endOfWhiteSpace(src, offset);
	var ch = src[offset];

	while (ch === Char.ANCHOR \|\| ch === Char.COMMENT \|\| ch === Char.TAG \|\| ch === '\n') {
	if (ch === '\n') {
	var inEnd = offset;
	var lineStart = void 0;

	do {
	lineStart = inEnd + 1;
	inEnd = Node.endOfIndent(src, lineStart);
	} while (src[inEnd] === '\n');

	var indentDiff = inEnd - (lineStart + this.indent);
	var noIndicatorAsIndent = parent.type === Type.SEQ_ITEM && parent.context.atLineStart;
	if (src[inEnd] !== '#' && !Node.nextNodeIsIndented(src[inEnd], indentDiff, !noIndicatorAsIndent)) break;
	this.atLineStart = true;
	this.lineStart = lineStart;
	lineHasProps = false;
	offset = inEnd;
	} else if (ch === Char.COMMENT) {
	var end = Node.endOfLine(src, offset + 1);
	props.push(new Range(offset, end));
	offset = end;
	} else {
	var _end = Node.endOfIdentifier(src, offset + 1);

	if (ch === Char.TAG && src[_end] === ',' && /^[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+,\d\d\d\d(-\d\d){0,2}\/\S/.test(src.slice(offset + 1, _end + 13))) {
	// Let's presume we're dealing with a YAML 1.0 domain tag here, rather
	// than an empty but 'foo.bar' private-tagged node in a flow collection
	// followed without whitespace by a plain string starting with a year
	// or date divided by something.
	_end = Node.endOfIdentifier(src, _end + 5);
	}

	props.push(new Range(offset, _end));
	lineHasProps = true;
	offset = Node.endOfWhiteSpace(src, _end);
	}

	ch = src[offset];
	} // '- &a : b' has an anchor on an empty node


	if (lineHasProps && ch === ':' && Node.atBlank(src, offset + 1, true)) offset -= 1;
	var type = ParseContext.parseType(src, offset, inFlow);
	return {
	props: props,
	type: type,
	valueStart: offset
	};
	}
	/**
	* Parses a node from the source
	* @param {ParseContext} overlay
	* @param {number} start - Index of first non-whitespace character for the node
	* @returns {?Node} - null if at a document boundary
	*/

	}], [{
	key: "parseType",
	value: function parseType(src, offset, inFlow) {
	switch (src[offset]) {
	case '*':
	return Type.ALIAS;

	case '>':
	return Type.BLOCK_FOLDED;

	case '\|':
	return Type.BLOCK_LITERAL;

	case '{':
	return Type.FLOW_MAP;

	case '[':
	return Type.FLOW_SEQ;

	case '?':
	return !inFlow && Node.atBlank(src, offset + 1, true) ? Type.MAP_KEY : Type.PLAIN;

	case ':':
	return !inFlow && Node.atBlank(src, offset + 1, true) ? Type.MAP_VALUE : Type.PLAIN;

	case '-':
	return !inFlow && Node.atBlank(src, offset + 1, true) ? Type.SEQ_ITEM : Type.PLAIN;

	case '"':
	return Type.QUOTE_DOUBLE;

	case "'":
	return Type.QUOTE_SINGLE;

	default:
	return Type.PLAIN;
	}
	}
	}]);

	return ParseContext;
	}();

	// Published as 'yaml/parse-cst'
	function parse(src) {
	var cr = [];

	if (src.indexOf('\r') !== -1) {
	src = src.replace(/\r\n?/g, function (match, offset) {
	if (match.length > 1) cr.push(offset);
	return '\n';
	});
	}

	var documents = [];
	var offset = 0;

	do {
	var doc = new Document();
	var context = new ParseContext({
	src: src
	});
	offset = doc.parse(context, offset);
	documents.push(doc);
	} while (offset < src.length);

	documents.setOrigRanges = function () {
	if (cr.length === 0) return false;

	for (var i = 1; i < cr.length; ++i) {
	cr[i] -= i;
	}

	var crOffset = 0;

	for (var _i = 0; _i < documents.length; ++_i) {
	crOffset = documents[_i].setOrigRanges(cr, crOffset);
	}

	cr.splice(0, cr.length);
	return true;
	};

	documents.toString = function () {
	return documents.join('...\n');
	};

	return documents;
	}

	export { parse };

Event Timeline