text: import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
  import _get from "@babel/runtime/helpers/get";
  import _createClass from "@babel/runtime/helpers/createClass";
  import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
  import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
  import _inherits from "@babel/runtime/helpers/inherits";
  
  function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
  
  import { Type } from '../constants';
  import { BlankLine } from './BlankLine';
  import { CollectionItem } from './CollectionItem';
  import { Comment } from './Comment';
  import { Node } from './Node';
  import { Range } from './Range';
  export 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;
  }
  export var Collection = /*#__PURE__*/function (_Node) {
    _inherits(Collection, _Node);
  
    var _super = _createSuper(Collection);
  
    _createClass(Collection, null, [{
      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);
      }
    }]);
  
    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: "parse",
  
      /**
       * @param {ParseContext} context
       * @param {number} start - Index of first character
       * @returns {number} - Index of the character after this
       */
      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 (lineStart > start) offset = lineStart;
            break;
          }
  
          if (firstItem.type === Type.SEQ_ITEM !== (ch === '-')) {
            var typeswitch = true;
  
            if (ch === '-') {
              // map key may start with -, as long as it's followed by a non-whitespace char
              var _next = src[offset + 1];
              typeswitch = !_next || _next === '\n' || _next === '\t' || _next === ' ';
            }
  
            if (typeswitch) {
              if (lineStart > start) offset = lineStart;
              break;
            }
          }
  
          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: "includesTrailingLines",
      get: function get() {
        return this.items.length > 0;
      }
    }]);
  
    return Collection;
  }(Node);