@salla.sa/twilight-components 1.1.4 → 1.1.5

package/dist/collection/plugins/tailwind-theme/node_modules/yaml/browser/dist/PlainValue-b8036b75.js

@@ -0,0 +1,1275 @@
+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 };