Diffusion Open Access Compliance Check Tool (OACCT) (paginated-inlines) Browse

rOACCT/node_modules/yaml/browser/dist/PlainValue-b8036b75.js
f646e1f695a7paginated-inlines

PlainValue-b8036b75.js
View Options

			function _typeof(obj) {
			"@babel/helpers - typeof";

			if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
			_typeof = function (obj) {
			return typeof obj;
			};
			} else {
			_typeof = function (obj) {
			return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
			};
			}

			return _typeof(obj);
			}

			function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
			throw new TypeError("Cannot call a class as a function");
			}
			}

			function _defineProperties(target, props) {
			for (var i = 0; i < props.length; i++) {
			var descriptor = props[i];
			descriptor.enumerable = descriptor.enumerable \|\| false;
			descriptor.configurable = true;
			if ("value" in descriptor) descriptor.writable = true;
			Object.defineProperty(target, descriptor.key, descriptor);
			}
			}

			function _createClass(Constructor, protoProps, staticProps) {
			if (protoProps) _defineProperties(Constructor.prototype, protoProps);
			if (staticProps) _defineProperties(Constructor, staticProps);
			return Constructor;
			}

			function _defineProperty(obj, key, value) {
			if (key in obj) {
			Object.defineProperty(obj, key, {
			value: value,
			enumerable: true,
			configurable: true,
			writable: true
			});
			} else {
			obj[key] = value;
			}

			return obj;
			}

			function _inherits(subClass, superClass) {
			if (typeof superClass !== "function" && superClass !== null) {
			throw new TypeError("Super expression must either be null or a function");
			}

			subClass.prototype = Object.create(superClass && superClass.prototype, {
			constructor: {
			value: subClass,
			writable: true,
			configurable: true
			}
			});
			if (superClass) _setPrototypeOf(subClass, superClass);
			}

			function _getPrototypeOf(o) {
			_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
			return o.__proto__ \|\| Object.getPrototypeOf(o);
			};
			return _getPrototypeOf(o);
			}

			function _setPrototypeOf(o, p) {
			_setPrototypeOf = Object.setPrototypeOf \|\| function _setPrototypeOf(o, p) {
			o.__proto__ = p;
			return o;
			};

			return _setPrototypeOf(o, p);
			}

			function _isNativeReflectConstruct() {
			if (typeof Reflect === "undefined" \|\| !Reflect.construct) return false;
			if (Reflect.construct.sham) return false;
			if (typeof Proxy === "function") return true;

			try {
			Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
			return true;
			} catch (e) {
			return false;
			}
			}

			function _construct(Parent, args, Class) {
			if (_isNativeReflectConstruct()) {
			_construct = Reflect.construct;
			} else {
			_construct = function _construct(Parent, args, Class) {
			var a = [null];
			a.push.apply(a, args);
			var Constructor = Function.bind.apply(Parent, a);
			var instance = new Constructor();
			if (Class) _setPrototypeOf(instance, Class.prototype);
			return instance;
			};
			}

			return _construct.apply(null, arguments);
			}

			function _isNativeFunction(fn) {
			return Function.toString.call(fn).indexOf("[native code]") !== -1;
			}

			function _wrapNativeSuper(Class) {
			var _cache = typeof Map === "function" ? new Map() : undefined;

			_wrapNativeSuper = function _wrapNativeSuper(Class) {
			if (Class === null \|\| !_isNativeFunction(Class)) return Class;

			if (typeof Class !== "function") {
			throw new TypeError("Super expression must either be null or a function");
			}

			if (typeof _cache !== "undefined") {
			if (_cache.has(Class)) return _cache.get(Class);

			_cache.set(Class, Wrapper);
			}

			function Wrapper() {
			return _construct(Class, arguments, _getPrototypeOf(this).constructor);
			}

			Wrapper.prototype = Object.create(Class.prototype, {
			constructor: {
			value: Wrapper,
			enumerable: false,
			writable: true,
			configurable: true
			}
			});
			return _setPrototypeOf(Wrapper, Class);
			};

			return _wrapNativeSuper(Class);
			}

			function _assertThisInitialized(self) {
			if (self === void 0) {
			throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
			}

			return self;
			}

			function _possibleConstructorReturn(self, call) {
			if (call && (typeof call === "object" \|\| typeof call === "function")) {
			return call;
			}

			return _assertThisInitialized(self);
			}

			function _createSuper(Derived) {
			var hasNativeReflectConstruct = _isNativeReflectConstruct();

			return function _createSuperInternal() {
			var Super = _getPrototypeOf(Derived),
			result;

			if (hasNativeReflectConstruct) {
			var NewTarget = _getPrototypeOf(this).constructor;

			result = Reflect.construct(Super, arguments, NewTarget);
			} else {
			result = Super.apply(this, arguments);
			}

			return _possibleConstructorReturn(this, result);
			};
			}

			function _superPropBase(object, property) {
			while (!Object.prototype.hasOwnProperty.call(object, property)) {
			object = _getPrototypeOf(object);
			if (object === null) break;
			}

			return object;
			}

			function _get(target, property, receiver) {
			if (typeof Reflect !== "undefined" && Reflect.get) {
			_get = Reflect.get;
			} else {
			_get = function _get(target, property, receiver) {
			var base = _superPropBase(target, property);

			if (!base) return;
			var desc = Object.getOwnPropertyDescriptor(base, property);

			if (desc.get) {
			return desc.get.call(receiver);
			}

			return desc.value;
			};
			}

			return _get(target, property, receiver \|\| target);
			}

			function _slicedToArray(arr, i) {
			return _arrayWithHoles(arr) \|\| _iterableToArrayLimit(arr, i) \|\| _unsupportedIterableToArray(arr, i) \|\| _nonIterableRest();
			}

			function _toArray(arr) {
			return _arrayWithHoles(arr) \|\| _iterableToArray(arr) \|\| _unsupportedIterableToArray(arr) \|\| _nonIterableRest();
			}

			function _arrayWithHoles(arr) {
			if (Array.isArray(arr)) return arr;
			}

			function _iterableToArray(iter) {
			if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
			}

			function _iterableToArrayLimit(arr, i) {
			if (typeof Symbol === "undefined" \|\| !(Symbol.iterator in Object(arr))) return;
			var _arr = [];
			var _n = true;
			var _d = false;
			var _e = undefined;

			try {
			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
			_arr.push(_s.value);

			if (i && _arr.length === i) break;
			}
			} catch (err) {
			_d = true;
			_e = err;
			} finally {
			try {
			if (!_n && _i["return"] != null) _i["return"]();
			} finally {
			if (_d) throw _e;
			}
			}

			return _arr;
			}

			function _unsupportedIterableToArray(o, minLen) {
			if (!o) return;
			if (typeof o === "string") return _arrayLikeToArray(o, minLen);
			var n = Object.prototype.toString.call(o).slice(8, -1);
			if (n === "Object" && o.constructor) n = o.constructor.name;
			if (n === "Map" \|\| n === "Set") return Array.from(o);
			if (n === "Arguments" \|\| /^(?:Ui\|I)nt(?:8\|16\|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
			}

			function _arrayLikeToArray(arr, len) {
			if (len == null \|\| len > arr.length) len = arr.length;

			for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];

			return arr2;
			}

			function _nonIterableRest() {
			throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
			}

			function _createForOfIteratorHelper(o, allowArrayLike) {
			var it;

			if (typeof Symbol === "undefined" \|\| o[Symbol.iterator] == null) {
			if (Array.isArray(o) \|\| (it = _unsupportedIterableToArray(o)) \|\| allowArrayLike && o && typeof o.length === "number") {
			if (it) o = it;
			var i = 0;

			var F = function () {};

			return {
			s: F,
			n: function () {
			if (i >= o.length) return {
			done: true
			};
			return {
			done: false,
			value: o[i++]
			};
			},
			e: function (e) {
			throw e;
			},
			f: F
			};
			}

			throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
			}

			var normalCompletion = true,
			didErr = false,
			err;
			return {
			s: function () {
			it = o[Symbol.iterator]();
			},
			n: function () {
			var step = it.next();
			normalCompletion = step.done;
			return step;
			},
			e: function (e) {
			didErr = true;
			err = e;
			},
			f: function () {
			try {
			if (!normalCompletion && it.return != null) it.return();
			} finally {
			if (didErr) throw err;
			}
			}
			};
			}

			var Char = {
			ANCHOR: '&',
			COMMENT: '#',
			TAG: '!',
			DIRECTIVES_END: '-',
			DOCUMENT_END: '.'
			};
			var Type = {
			ALIAS: 'ALIAS',
			BLANK_LINE: 'BLANK_LINE',
			BLOCK_FOLDED: 'BLOCK_FOLDED',
			BLOCK_LITERAL: 'BLOCK_LITERAL',
			COMMENT: 'COMMENT',
			DIRECTIVE: 'DIRECTIVE',
			DOCUMENT: 'DOCUMENT',
			FLOW_MAP: 'FLOW_MAP',
			FLOW_SEQ: 'FLOW_SEQ',
			MAP: 'MAP',
			MAP_KEY: 'MAP_KEY',
			MAP_VALUE: 'MAP_VALUE',
			PLAIN: 'PLAIN',
			QUOTE_DOUBLE: 'QUOTE_DOUBLE',
			QUOTE_SINGLE: 'QUOTE_SINGLE',
			SEQ: 'SEQ',
			SEQ_ITEM: 'SEQ_ITEM'
			};
			var defaultTagPrefix = 'tag:yaml.org,2002:';
			var defaultTags = {
			MAP: 'tag:yaml.org,2002:map',
			SEQ: 'tag:yaml.org,2002:seq',
			STR: 'tag:yaml.org,2002:str'
			};

			function findLineStarts(src) {
			var ls = [0];
			var offset = src.indexOf('\n');

			while (offset !== -1) {
			offset += 1;
			ls.push(offset);
			offset = src.indexOf('\n', offset);
			}

			return ls;
			}

			function getSrcInfo(cst) {
			var lineStarts, src;

			if (typeof cst === 'string') {
			lineStarts = findLineStarts(cst);
			src = cst;
			} else {
			if (Array.isArray(cst)) cst = cst[0];

			if (cst && cst.context) {
			if (!cst.lineStarts) cst.lineStarts = findLineStarts(cst.context.src);
			lineStarts = cst.lineStarts;
			src = cst.context.src;
			}
			}

			return {
			lineStarts: lineStarts,
			src: src
			};
			}
			/**
			* @typedef {Object} LinePos - One-indexed position in the source
			* @property {number} line
			* @property {number} col
			*/

			/**
			* Determine the line/col position matching a character offset.
			*
			* Accepts a source string or a CST document as the second parameter. With
			* the latter, starting indices for lines are cached in the document as
			* `lineStarts: number[]`.
			*
			* Returns a one-indexed `{ line, col }` location if found, or
			* `undefined` otherwise.
			*
			* @param {number} offset
			* @param {string\|Document\|Document[]} cst
			* @returns {?LinePos}
			*/


			function getLinePos(offset, cst) {
			if (typeof offset !== 'number' \|\| offset < 0) return null;

			var _getSrcInfo = getSrcInfo(cst),
			lineStarts = _getSrcInfo.lineStarts,
			src = _getSrcInfo.src;

			if (!lineStarts \|\| !src \|\| offset > src.length) return null;

			for (var i = 0; i < lineStarts.length; ++i) {
			var start = lineStarts[i];

			if (offset < start) {
			return {
			line: i,
			col: offset - lineStarts[i - 1] + 1
			};
			}

			if (offset === start) return {
			line: i + 1,
			col: 1
			};
			}

			var line = lineStarts.length;
			return {
			line: line,
			col: offset - lineStarts[line - 1] + 1
			};
			}
			/**
			* Get a specified line from the source.
			*
			* Accepts a source string or a CST document as the second parameter. With
			* the latter, starting indices for lines are cached in the document as
			* `lineStarts: number[]`.
			*
			* Returns the line as a string if found, or `null` otherwise.
			*
			* @param {number} line One-indexed line number
			* @param {string\|Document\|Document[]} cst
			* @returns {?string}
			*/

			function getLine(line, cst) {
			var _getSrcInfo2 = getSrcInfo(cst),
			lineStarts = _getSrcInfo2.lineStarts,
			src = _getSrcInfo2.src;

			if (!lineStarts \|\| !(line >= 1) \|\| line > lineStarts.length) return null;
			var start = lineStarts[line - 1];
			var end = lineStarts[line]; // undefined for last line; that's ok for slice()

			while (end && end > start && src[end - 1] === '\n') {
			--end;
			}

			return src.slice(start, end);
			}
			/**
			* Pretty-print the starting line from the source indicated by the range `pos`
			*
			* Trims output to `maxWidth` chars while keeping the starting column visible,
			* using `…` at either end to indicate dropped characters.
			*
			* Returns a two-line string (or `null`) with `\n` as separator; the second line
			* will hold appropriately indented `^` marks indicating the column range.
			*
			* @param {Object} pos
			* @param {LinePos} pos.start
			* @param {LinePos} [pos.end]
			* @param {string\|Document\|Document[]*} cst
			* @param {number} [maxWidth=80]
			* @returns {?string}
			*/

			function getPrettyContext(_ref, cst) {
			var start = _ref.start,
			end = _ref.end;
			var maxWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 80;
			var src = getLine(start.line, cst);
			if (!src) return null;
			var col = start.col;

			if (src.length > maxWidth) {
			if (col <= maxWidth - 10) {
			src = src.substr(0, maxWidth - 1) + '…';
			} else {
			var halfWidth = Math.round(maxWidth / 2);
			if (src.length > col + halfWidth) src = src.substr(0, col + halfWidth - 1) + '…';
			col -= src.length - maxWidth;
			src = '…' + src.substr(1 - maxWidth);
			}
			}

			var errLen = 1;
			var errEnd = '';

			if (end) {
			if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) {
			errLen = end.col - start.col;
			} else {
			errLen = Math.min(src.length + 1, maxWidth) - col;
			errEnd = '…';
			}
			}

			var offset = col > 1 ? ' '.repeat(col - 1) : '';
			var err = '^'.repeat(errLen);
			return "".concat(src, "\n").concat(offset).concat(err).concat(errEnd);
			}

			var Range = /#__PURE__/function () {
			function Range(start, end) {
			_classCallCheck(this, Range);

			this.start = start;
			this.end = end \|\| start;
			}

			_createClass(Range, [{
			key: "isEmpty",
			value: function isEmpty() {
			return typeof this.start !== 'number' \|\| !this.end \|\| this.end <= this.start;
			}
			/**
			* Set `origStart` and `origEnd` to point to the original source range for
			* this node, which may differ due to dropped CR characters.
			*
			* @param {number[]} cr - Positions of dropped CR characters
			* @param {number} offset - Starting index of `cr` from the last call
			* @returns {number} - The next offset, matching the one found for `origStart`
			*/

			}, {
			key: "setOrigRange",
			value: function setOrigRange(cr, offset) {
			var start = this.start,
			end = this.end;

			if (cr.length === 0 \|\| end <= cr[0]) {
			this.origStart = start;
			this.origEnd = end;
			return offset;
			}

			var i = offset;

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

			this.origStart = start + i;
			var nextOffset = i;

			while (i < cr.length) {
			// if end was at \n, it should now be at \r
			if (cr[i] >= end) break;else ++i;
			}

			this.origEnd = end + i;
			return nextOffset;
			}
			}], [{
			key: "copy",
			value: function copy(orig) {
			return new Range(orig.start, orig.end);
			}
			}]);

			return Range;
			}();

			/** Root class of all nodes */

			var Node = /#__PURE__/function () {
			function Node(type, props, context) {
			_classCallCheck(this, Node);

			Object.defineProperty(this, 'context', {
			value: context \|\| null,
			writable: true
			});
			this.error = null;
			this.range = null;
			this.valueRange = null;
			this.props = props \|\| [];
			this.type = type;
			this.value = null;
			}

			_createClass(Node, [{
			key: "getPropValue",
			value: function getPropValue(idx, key, skipKey) {
			if (!this.context) return null;
			var src = this.context.src;
			var prop = this.props[idx];
			return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null;
			}
			}, {
			key: "anchor",
			get: function get() {
			for (var i = 0; i < this.props.length; ++i) {
			var anchor = this.getPropValue(i, Char.ANCHOR, true);
			if (anchor != null) return anchor;
			}

			return null;
			}
			}, {
			key: "comment",
			get: function get() {
			var comments = [];

			for (var i = 0; i < this.props.length; ++i) {
			var comment = this.getPropValue(i, Char.COMMENT, true);
			if (comment != null) comments.push(comment);
			}

			return comments.length > 0 ? comments.join('\n') : null;
			}
			}, {
			key: "commentHasRequiredWhitespace",
			value: function commentHasRequiredWhitespace(start) {
			var src = this.context.src;
			if (this.header && start === this.header.end) return false;
			if (!this.valueRange) return false;
			var end = this.valueRange.end;
			return start !== end \|\| Node.atBlank(src, end - 1);
			}
			}, {
			key: "hasComment",
			get: function get() {
			if (this.context) {
			var src = this.context.src;

			for (var i = 0; i < this.props.length; ++i) {
			if (src[this.props[i].start] === Char.COMMENT) return true;
			}
			}

			return false;
			}
			}, {
			key: "hasProps",
			get: function get() {
			if (this.context) {
			var src = this.context.src;

			for (var i = 0; i < this.props.length; ++i) {
			if (src[this.props[i].start] !== Char.COMMENT) return true;
			}
			}

			return false;
			}
			}, {
			key: "includesTrailingLines",
			get: function get() {
			return false;
			}
			}, {
			key: "jsonLike",
			get: function get() {
			var jsonLikeTypes = [Type.FLOW_MAP, Type.FLOW_SEQ, Type.QUOTE_DOUBLE, Type.QUOTE_SINGLE];
			return jsonLikeTypes.indexOf(this.type) !== -1;
			}
			}, {
			key: "rangeAsLinePos",
			get: function get() {
			if (!this.range \|\| !this.context) return undefined;
			var start = getLinePos(this.range.start, this.context.root);
			if (!start) return undefined;
			var end = getLinePos(this.range.end, this.context.root);
			return {
			start: start,
			end: end
			};
			}
			}, {
			key: "rawValue",
			get: function get() {
			if (!this.valueRange \|\| !this.context) return null;
			var _this$valueRange = this.valueRange,
			start = _this$valueRange.start,
			end = _this$valueRange.end;
			return this.context.src.slice(start, end);
			}
			}, {
			key: "tag",
			get: function get() {
			for (var i = 0; i < this.props.length; ++i) {
			var tag = this.getPropValue(i, Char.TAG, false);

			if (tag != null) {
			if (tag[1] === '<') {
			return {
			verbatim: tag.slice(2, -1)
			};
			} else {
			// eslint-disable-next-line no-unused-vars
			var _tag$match = tag.match(/^(.!)([^!])$/),
			_tag$match2 = _slicedToArray(_tag$match, 3);
			_tag$match2[0];
			var handle = _tag$match2[1],
			suffix = _tag$match2[2];

			return {
			handle: handle,
			suffix: suffix
			};
			}
			}
			}

			return null;
			}
			}, {
			key: "valueRangeContainsNewline",
			get: function get() {
			if (!this.valueRange \|\| !this.context) return false;
			var _this$valueRange2 = this.valueRange,
			start = _this$valueRange2.start,
			end = _this$valueRange2.end;
			var src = this.context.src;

			for (var i = start; i < end; ++i) {
			if (src[i] === '\n') return true;
			}

			return false;
			}
			}, {
			key: "parseComment",
			value: function parseComment(start) {
			var src = this.context.src;

			if (src[start] === Char.COMMENT) {
			var end = Node.endOfLine(src, start + 1);
			var commentRange = new Range(start, end);
			this.props.push(commentRange);
			return end;
			}

			return start;
			}
			/**
			* Populates the `origStart` and `origEnd` values of all ranges for this
			* node. Extended by child classes to handle descendant nodes.
			*
			* @param {number[]} cr - Positions of dropped CR characters
			* @param {number} offset - Starting index of `cr` from the last call
			* @returns {number} - The next offset, matching the one found for `origStart`
			*/

			}, {
			key: "setOrigRanges",
			value: function setOrigRanges(cr, offset) {
			if (this.range) offset = this.range.setOrigRange(cr, offset);
			if (this.valueRange) this.valueRange.setOrigRange(cr, offset);
			this.props.forEach(function (prop) {
			return prop.setOrigRange(cr, offset);
			});
			return offset;
			}
			}, {
			key: "toString",
			value: function toString() {
			var src = this.context.src,
			range = this.range,
			value = this.value;
			if (value != null) return value;
			var str = src.slice(range.start, range.end);
			return Node.addStringTerminator(src, range.end, str);
			}
			}], [{
			key: "addStringTerminator",
			value: function addStringTerminator(src, offset, str) {
			if (str[str.length - 1] === '\n') return str;
			var next = Node.endOfWhiteSpace(src, offset);
			return next >= src.length \|\| src[next] === '\n' ? str + '\n' : str;
			} // ^(---\|...)

			}, {
			key: "atDocumentBoundary",
			value: function atDocumentBoundary(src, offset, sep) {
			var ch0 = src[offset];
			if (!ch0) return true;
			var prev = src[offset - 1];
			if (prev && prev !== '\n') return false;

			if (sep) {
			if (ch0 !== sep) return false;
			} else {
			if (ch0 !== Char.DIRECTIVES_END && ch0 !== Char.DOCUMENT_END) return false;
			}

			var ch1 = src[offset + 1];
			var ch2 = src[offset + 2];
			if (ch1 !== ch0 \|\| ch2 !== ch0) return false;
			var ch3 = src[offset + 3];
			return !ch3 \|\| ch3 === '\n' \|\| ch3 === '\t' \|\| ch3 === ' ';
			}
			}, {
			key: "endOfIdentifier",
			value: function endOfIdentifier(src, offset) {
			var ch = src[offset];
			var isVerbatim = ch === '<';
			var notOk = isVerbatim ? ['\n', '\t', ' ', '>'] : ['\n', '\t', ' ', '[', ']', '{', '}', ','];

			while (ch && notOk.indexOf(ch) === -1) {
			ch = src[offset += 1];
			}

			if (isVerbatim && ch === '>') offset += 1;
			return offset;
			}
			}, {
			key: "endOfIndent",
			value: function endOfIndent(src, offset) {
			var ch = src[offset];

			while (ch === ' ') {
			ch = src[offset += 1];
			}

			return offset;
			}
			}, {
			key: "endOfLine",
			value: function endOfLine(src, offset) {
			var ch = src[offset];

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

			return offset;
			}
			}, {
			key: "endOfWhiteSpace",
			value: function endOfWhiteSpace(src, offset) {
			var ch = src[offset];

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

			return offset;
			}
			}, {
			key: "startOfLine",
			value: function startOfLine(src, offset) {
			var ch = src[offset - 1];
			if (ch === '\n') return offset;

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

			return offset + 1;
			}
			/**
			* End of indentation, or null if the line's indent level is not more
			* than `indent`
			*
			* @param {string} src
			* @param {number} indent
			* @param {number} lineStart
			* @returns {?number}
			*/

			}, {
			key: "endOfBlockIndent",
			value: function endOfBlockIndent(src, indent, lineStart) {
			var inEnd = Node.endOfIndent(src, lineStart);

			if (inEnd > lineStart + indent) {
			return inEnd;
			} else {
			var wsEnd = Node.endOfWhiteSpace(src, inEnd);
			var ch = src[wsEnd];
			if (!ch \|\| ch === '\n') return wsEnd;
			}

			return null;
			}
			}, {
			key: "atBlank",
			value: function atBlank(src, offset, endAsBlank) {
			var ch = src[offset];
			return ch === '\n' \|\| ch === '\t' \|\| ch === ' ' \|\| endAsBlank && !ch;
			}
			}, {
			key: "nextNodeIsIndented",
			value: function nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) {
			if (!ch \|\| indentDiff < 0) return false;
			if (indentDiff > 0) return true;
			return indicatorAsIndent && ch === '-';
			} // should be at line or string end, or at next non-whitespace char

			}, {
			key: "normalizeOffset",
			value: function normalizeOffset(src, offset) {
			var ch = src[offset];
			return !ch ? offset : ch !== '\n' && src[offset - 1] === '\n' ? offset - 1 : Node.endOfWhiteSpace(src, offset);
			} // fold single newline into space, multiple newlines to N - 1 newlines
			// presumes src[offset] === '\n'

			}, {
			key: "foldNewline",
			value: function foldNewline(src, offset, indent) {
			var inCount = 0;
			var error = false;
			var fold = '';
			var ch = src[offset + 1];

			while (ch === ' ' \|\| ch === '\t' \|\| ch === '\n') {
			switch (ch) {
			case '\n':
			inCount = 0;
			offset += 1;
			fold += '\n';
			break;

			case '\t':
			if (inCount <= indent) error = true;
			offset = Node.endOfWhiteSpace(src, offset + 2) - 1;
			break;

			case ' ':
			inCount += 1;
			offset += 1;
			break;
			}

			ch = src[offset + 1];
			}

			if (!fold) fold = ' ';
			if (ch && inCount <= indent) error = true;
			return {
			fold: fold,
			offset: offset,
			error: error
			};
			}
			}]);

			return Node;
			}();

			var YAMLError = /#__PURE__/function (_Error) {
			_inherits(YAMLError, _Error);

			var _super = _createSuper(YAMLError);

			function YAMLError(name, source, message) {
			var _this;

			_classCallCheck(this, YAMLError);

			if (!message \|\| !(source instanceof Node)) throw new Error("Invalid arguments for new ".concat(name));
			_this = _super.call(this);
			_this.name = name;
			_this.message = message;
			_this.source = source;
			return _this;
			}

			_createClass(YAMLError, [{
			key: "makePretty",
			value: function makePretty() {
			if (!this.source) return;
			this.nodeType = this.source.type;
			var cst = this.source.context && this.source.context.root;

			if (typeof this.offset === 'number') {
			this.range = new Range(this.offset, this.offset + 1);
			var start = cst && getLinePos(this.offset, cst);

			if (start) {
			var end = {
			line: start.line,
			col: start.col + 1
			};
			this.linePos = {
			start: start,
			end: end
			};
			}

			delete this.offset;
			} else {
			this.range = this.source.range;
			this.linePos = this.source.rangeAsLinePos;
			}

			if (this.linePos) {
			var _this$linePos$start = this.linePos.start,
			line = _this$linePos$start.line,
			col = _this$linePos$start.col;
			this.message += " at line ".concat(line, ", column ").concat(col);
			var ctx = cst && getPrettyContext(this.linePos, cst);
			if (ctx) this.message += ":\n\n".concat(ctx, "\n");
			}

			delete this.source;
			}
			}]);

			return YAMLError;
			}( /#__PURE__/_wrapNativeSuper(Error));
			var YAMLReferenceError = /#__PURE__/function (_YAMLError) {
			_inherits(YAMLReferenceError, _YAMLError);

			var _super2 = _createSuper(YAMLReferenceError);

			function YAMLReferenceError(source, message) {
			_classCallCheck(this, YAMLReferenceError);

			return _super2.call(this, 'YAMLReferenceError', source, message);
			}

			return YAMLReferenceError;
			}(YAMLError);
			var YAMLSemanticError = /#__PURE__/function (_YAMLError2) {
			_inherits(YAMLSemanticError, _YAMLError2);

			var _super3 = _createSuper(YAMLSemanticError);

			function YAMLSemanticError(source, message) {
			_classCallCheck(this, YAMLSemanticError);

			return _super3.call(this, 'YAMLSemanticError', source, message);
			}

			return YAMLSemanticError;
			}(YAMLError);
			var YAMLSyntaxError = /#__PURE__/function (_YAMLError3) {
			_inherits(YAMLSyntaxError, _YAMLError3);

			var _super4 = _createSuper(YAMLSyntaxError);

			function YAMLSyntaxError(source, message) {
			_classCallCheck(this, YAMLSyntaxError);

			return _super4.call(this, 'YAMLSyntaxError', source, message);
			}

			return YAMLSyntaxError;
			}(YAMLError);
			var YAMLWarning = /#__PURE__/function (_YAMLError4) {
			_inherits(YAMLWarning, _YAMLError4);

			var _super5 = _createSuper(YAMLWarning);

			function YAMLWarning(source, message) {
			_classCallCheck(this, YAMLWarning);

			return _super5.call(this, 'YAMLWarning', source, message);
			}

			return YAMLWarning;
			}(YAMLError);

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

			var _super = _createSuper(PlainValue);

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

			return _super.apply(this, arguments);
			}

			_createClass(PlainValue, [{
			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 src = this.context.src;
			var ch = src[end - 1];

			while (start < end && (ch === '\n' \|\| ch === '\t' \|\| ch === ' ')) {
			ch = src[--end - 1];
			}

			var str = '';

			for (var i = start; i < end; ++i) {
			var _ch = src[i];

			if (_ch === '\n') {
			var _Node$foldNewline = Node.foldNewline(src, i, -1),
			fold = _Node$foldNewline.fold,
			offset = _Node$foldNewline.offset;

			str += fold;
			i = offset;
			} else if (_ch === ' ' \|\| _ch === '\t') {
			// trim trailing whitespace
			var wsStart = i;
			var next = src[i + 1];

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

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

			var ch0 = src[start];

			switch (ch0) {
			case '\t':
			{
			var msg = 'Plain value cannot start with a tab character';
			var errors = [new YAMLSemanticError(this, msg)];
			return {
			errors: errors,
			str: str
			};
			}

			case '@':
			case '`':
			{
			var _msg = "Plain value cannot start with reserved character ".concat(ch0);

			var _errors = [new YAMLSemanticError(this, _msg)];
			return {
			errors: _errors,
			str: str
			};
			}

			default:
			return str;
			}
			}
			}, {
			key: "parseBlockValue",
			value: function parseBlockValue(start) {
			var _this$context = this.context,
			indent = _this$context.indent,
			inFlow = _this$context.inFlow,
			src = _this$context.src;
			var offset = start;
			var valueEnd = start;

			for (var ch = src[offset]; ch === '\n'; ch = src[offset]) {
			if (Node.atDocumentBoundary(src, offset + 1)) break;
			var end = Node.endOfBlockIndent(src, indent, offset + 1);
			if (end === null \|\| src[end] === '#') break;

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

			if (this.valueRange.isEmpty()) this.valueRange.start = start;
			this.valueRange.end = valueEnd;
			return valueEnd;
			}
			/**
			* Parses a plain value from the source
			*
			* Accepted forms are:
			* ```
			* #comment
			*
			* first line
			*
			* first line #comment
			*
			* first line
			* block
			* lines
			*
			* #comment
			* block
			* lines
			* ```
			* where 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 scalar, may be `\n`
			*/

			}, {
			key: "parse",
			value: function parse(context, start) {
			this.context = context;
			var inFlow = context.inFlow,
			src = context.src;
			var offset = start;
			var ch = src[offset];

			if (ch && ch !== '#' && ch !== '\n') {
			offset = PlainValue.endOfLine(src, start, inFlow);
			}

			this.valueRange = new Range(start, offset);
			offset = Node.endOfWhiteSpace(src, offset);
			offset = this.parseComment(offset);

			if (!this.hasComment \|\| this.valueRange.isEmpty()) {
			offset = this.parseBlockValue(offset);
			}

			return offset;
			}
			}], [{
			key: "endOfLine",
			value: function endOfLine(src, start, inFlow) {
			var ch = src[start];
			var offset = start;

			while (ch && ch !== '\n') {
			if (inFlow && (ch === '[' \|\| ch === ']' \|\| ch === '{' \|\| ch === '}' \|\| ch === ',')) break;
			var next = src[offset + 1];
			if (ch === ':' && (!next \|\| next === '\n' \|\| next === '\t' \|\| next === ' ' \|\| inFlow && next === ',')) break;
			if ((ch === ' ' \|\| ch === '\t') && next === '#') break;
			offset += 1;
			ch = next;
			}

			return offset;
			}
			}]);

			return PlainValue;
			}(Node);

			export { Char as C, Node as N, PlainValue as P, Range as R, Type as T, YAMLSyntaxError as Y, _createForOfIteratorHelper as _, _typeof as a, _createClass as b, _classCallCheck as c, defaultTagPrefix as d, _defineProperty as e, YAMLWarning as f, YAMLSemanticError as g, _slicedToArray as h, YAMLError as i, _inherits as j, _createSuper as k, _get as l, _getPrototypeOf as m, defaultTags as n, YAMLReferenceError as o, _assertThisInitialized as p, _toArray as q, _possibleConstructorReturn as r };