yaml 1.9.1 → 1.10.2

package/browser/dist/cst/FlowCollection.js

@@ -1,220 +0,0 @@
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _get from "@babel/runtime/helpers/get";
-import _inherits from "@babel/runtime/helpers/inherits";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-
-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 { YAMLSemanticError } from '../errors';
-import { BlankLine } from './BlankLine';
-import { Comment } from './Comment';
-import { Node } from './Node';
-import { Range } from './Range';
-export 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);

package/browser/dist/cst/Node.js

@@ -1,386 +0,0 @@
-import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import { Char, Type } from '../constants';
-import { getLinePos } from './source-utils';
-import { Range } from './Range';
-/** Root class of all nodes */
-
-export var Node = /*#__PURE__*/function () {
-  _createClass(Node, null, [{
-    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
-      };
-    }
-  }]);
-
-  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: "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: "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: "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: "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],
-                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;
-    }
-  }]);
-
-  return Node;
-}();