yaml 1.8.3 → 1.10.0

package/browser/dist/schema/index.js

@@ -1,382 +0,0 @@
-import _typeof from "@babel/runtime/helpers/typeof";
-import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _createClass from "@babel/runtime/helpers/createClass";
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { warnOptionDeprecation } from '../warnings';
-import { Type } from '../constants';
-import { YAMLReferenceError, YAMLWarning } from '../errors';
-import { stringifyString } from '../stringify';
-import { schemas, tags } from '../tags';
-import { resolveString } from '../tags/failsafe/string';
-import Alias from './Alias';
-import Collection from './Collection';
-import Node from './Node';
-import Pair from './Pair';
-import Scalar from './Scalar';
-
-var isMap = function isMap(_ref) {
-  var type = _ref.type;
-  return type === Type.FLOW_MAP || type === Type.MAP;
-};
-
-var isSeq = function isSeq(_ref2) {
-  var type = _ref2.type;
-  return type === Type.FLOW_SEQ || type === Type.SEQ;
-};
-
-var Schema = /*#__PURE__*/function () {
-  function Schema(_ref3) {
-    var customTags = _ref3.customTags,
-        merge = _ref3.merge,
-        schema = _ref3.schema,
-        sortMapEntries = _ref3.sortMapEntries,
-        deprecatedCustomTags = _ref3.tags;
-
-    _classCallCheck(this, Schema);
-
-    this.merge = !!merge;
-    this.name = schema;
-    this.sortMapEntries = sortMapEntries === true ? function (a, b) {
-      return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
-    } : sortMapEntries || null;
-    this.tags = schemas[schema.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
-
-    if (!this.tags) {
-      var keys = Object.keys(schemas).map(function (key) {
-        return JSON.stringify(key);
-      }).join(', ');
-      throw new Error("Unknown schema \"".concat(schema, "\"; use one of ").concat(keys));
-    }
-
-    if (!customTags && deprecatedCustomTags) {
-      customTags = deprecatedCustomTags;
-      warnOptionDeprecation('tags', 'customTags');
-    }
-
-    if (Array.isArray(customTags)) {
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = customTags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var tag = _step.value;
-          this.tags = this.tags.concat(tag);
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
-    } else if (typeof customTags === 'function') {
-      this.tags = customTags(this.tags.slice());
-    }
-
-    for (var i = 0; i < this.tags.length; ++i) {
-      var _tag = this.tags[i];
-
-      if (typeof _tag === 'string') {
-        var tagObj = tags[_tag];
-
-        if (!tagObj) {
-          var _keys = Object.keys(tags).map(function (key) {
-            return JSON.stringify(key);
-          }).join(', ');
-
-          throw new Error("Unknown custom tag \"".concat(_tag, "\"; use one of ").concat(_keys));
-        }
-
-        this.tags[i] = tagObj;
-      }
-    }
-  }
-
-  _createClass(Schema, [{
-    key: "createNode",
-    value: function createNode(value, wrapScalars, tag, ctx) {
-      if (value instanceof Node) return value;
-      var tagObj;
-
-      if (tag) {
-        if (tag.startsWith('!!')) tag = Schema.defaultPrefix + tag.slice(2);
-        var match = this.tags.filter(function (t) {
-          return t.tag === tag;
-        });
-        tagObj = match.find(function (t) {
-          return !t.format;
-        }) || match[0];
-        if (!tagObj) throw new Error("Tag ".concat(tag, " not found"));
-      } else {
-        // TODO: deprecate/remove class check
-        tagObj = this.tags.find(function (t) {
-          return (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format;
-        });
-
-        if (!tagObj) {
-          if (typeof value.toJSON === 'function') value = value.toJSON();
-          if (_typeof(value) !== 'object') return wrapScalars ? new Scalar(value) : value;
-          tagObj = value instanceof Map ? tags.map : value[Symbol.iterator] ? tags.seq : tags.map;
-        }
-      }
-
-      if (!ctx) ctx = {
-        wrapScalars: wrapScalars
-      };else ctx.wrapScalars = wrapScalars;
-
-      if (ctx.onTagObj) {
-        ctx.onTagObj(tagObj);
-        delete ctx.onTagObj;
-      }
-
-      var obj = {};
-
-      if (value && _typeof(value) === 'object' && ctx.prevObjects) {
-        var prev = ctx.prevObjects.get(value);
-
-        if (prev) {
-          var alias = new Alias(prev); // leaves source dirty; must be cleaned by caller
-
-          ctx.aliasNodes.push(alias);
-          return alias;
-        }
-
-        obj.value = value;
-        ctx.prevObjects.set(value, obj);
-      }
-
-      obj.node = tagObj.createNode ? tagObj.createNode(this, value, ctx) : wrapScalars ? new Scalar(value) : value;
-      if (tag && obj.node instanceof Node) obj.node.tag = tag;
-      return obj.node;
-    }
-  }, {
-    key: "createPair",
-    value: function createPair(key, value, ctx) {
-      var k = this.createNode(key, ctx.wrapScalars, null, ctx);
-      var v = this.createNode(value, ctx.wrapScalars, null, ctx);
-      return new Pair(k, v);
-    } // falls back to string on no match
-
-  }, {
-    key: "resolveScalar",
-    value: function resolveScalar(str, tags) {
-      if (!tags) tags = this.tags;
-
-      for (var i = 0; i < tags.length; ++i) {
-        var _tags$i = tags[i],
-            format = _tags$i.format,
-            test = _tags$i.test,
-            resolve = _tags$i.resolve;
-
-        if (test) {
-          var match = str.match(test);
-
-          if (match) {
-            var res = resolve.apply(null, match);
-            if (!(res instanceof Scalar)) res = new Scalar(res);
-            if (format) res.format = format;
-            return res;
-          }
-        }
-      }
-
-      if (this.tags.scalarFallback) str = this.tags.scalarFallback(str);
-      return new Scalar(str);
-    } // sets node.resolved on success
-
-  }, {
-    key: "resolveNode",
-    value: function resolveNode(doc, node, tagName) {
-      var tags = this.tags.filter(function (_ref4) {
-        var tag = _ref4.tag;
-        return tag === tagName;
-      });
-      var generic = tags.find(function (_ref5) {
-        var test = _ref5.test;
-        return !test;
-      });
-      if (node.error) doc.errors.push(node.error);
-
-      try {
-        if (generic) {
-          var res = generic.resolve(doc, node);
-          if (!(res instanceof Collection)) res = new Scalar(res);
-          node.resolved = res;
-        } else {
-          var str = resolveString(doc, node);
-
-          if (typeof str === 'string' && tags.length > 0) {
-            node.resolved = this.resolveScalar(str, tags);
-          }
-        }
-      } catch (error) {
-        /* istanbul ignore if */
-        if (!error.source) error.source = node;
-        doc.errors.push(error);
-        node.resolved = null;
-      }
-
-      if (!node.resolved) return null;
-      if (tagName && node.tag) node.resolved.tag = tagName;
-      return node.resolved;
-    }
-  }, {
-    key: "resolveNodeWithFallback",
-    value: function resolveNodeWithFallback(doc, node, tagName) {
-      var res = this.resolveNode(doc, node, tagName);
-      if (Object.prototype.hasOwnProperty.call(node, 'resolved')) return res;
-      var fallback = isMap(node) ? Schema.defaultTags.MAP : isSeq(node) ? Schema.defaultTags.SEQ : Schema.defaultTags.STR;
-      /* istanbul ignore else */
-
-      if (fallback) {
-        doc.warnings.push(new YAMLWarning(node, "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback)));
-
-        var _res = this.resolveNode(doc, node, fallback);
-
-        _res.tag = tagName;
-        return _res;
-      } else {
-        doc.errors.push(new YAMLReferenceError(node, "The tag ".concat(tagName, " is unavailable")));
-        return null;
-      }
-    }
-  }, {
-    key: "getTagObject",
-    value: function getTagObject(item) {
-      if (item instanceof Alias) return Alias;
-
-      if (item.tag) {
-        var match = this.tags.filter(function (t) {
-          return t.tag === item.tag;
-        });
-        if (match.length > 0) return match.find(function (t) {
-          return t.format === item.format;
-        }) || match[0];
-      }
-
-      var tagObj, obj;
-
-      if (item instanceof Scalar) {
-        obj = item.value; // TODO: deprecate/remove class check
-
-        var _match = this.tags.filter(function (t) {
-          return t.identify && t.identify(obj) || t.class && obj instanceof t.class;
-        });
-
-        tagObj = _match.find(function (t) {
-          return t.format === item.format;
-        }) || _match.find(function (t) {
-          return !t.format;
-        });
-      } else {
-        obj = item;
-        tagObj = this.tags.find(function (t) {
-          return t.nodeClass && obj instanceof t.nodeClass;
-        });
-      }
-
-      if (!tagObj) {
-        var name = obj && obj.constructor ? obj.constructor.name : _typeof(obj);
-        throw new Error("Tag not resolved for ".concat(name, " value"));
-      }
-
-      return tagObj;
-    } // needs to be called before stringifier to allow for circular anchor refs
-
-  }, {
-    key: "stringifyProps",
-    value: function stringifyProps(node, tagObj, _ref6) {
-      var anchors = _ref6.anchors,
-          doc = _ref6.doc;
-      var props = [];
-      var anchor = doc.anchors.getName(node);
-
-      if (anchor) {
-        anchors[anchor] = node;
-        props.push("&".concat(anchor));
-      }
-
-      if (node.tag) {
-        props.push(doc.stringifyTag(node.tag));
-      } else if (!tagObj.default) {
-        props.push(doc.stringifyTag(tagObj.tag));
-      }
-
-      return props.join(' ');
-    }
-  }, {
-    key: "stringify",
-    value: function stringify(item, ctx, onComment, onChompKeep) {
-      var tagObj;
-
-      if (!(item instanceof Node)) {
-        var createCtx = {
-          aliasNodes: [],
-          onTagObj: function onTagObj(o) {
-            return tagObj = o;
-          },
-          prevObjects: new Map()
-        };
-        item = this.createNode(item, true, null, createCtx);
-        var anchors = ctx.doc.anchors;
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
-
-        try {
-          for (var _iterator2 = createCtx.aliasNodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var alias = _step2.value;
-            alias.source = alias.source.node;
-            var name = anchors.getName(alias.source);
-
-            if (!name) {
-              name = anchors.newName();
-              anchors.map[name] = alias.source;
-            }
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
-        }
-      }
-
-      ctx.tags = this;
-      if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
-      if (!tagObj) tagObj = this.getTagObject(item);
-      var props = this.stringifyProps(item, tagObj, ctx);
-      if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
-      var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Collection ? item.toString(ctx, onComment, onChompKeep) : stringifyString(item, ctx, onComment, onChompKeep);
-      return props ? item instanceof Collection && str[0] !== '{' && str[0] !== '[' ? "".concat(props, "\n").concat(ctx.indent).concat(str) : "".concat(props, " ").concat(str) : str;
-    }
-  }]);
-
-  return Schema;
-}();
-
-_defineProperty(Schema, "defaultPrefix", 'tag:yaml.org,2002:');
-
-_defineProperty(Schema, "defaultTags", {
-  MAP: 'tag:yaml.org,2002:map',
-  SEQ: 'tag:yaml.org,2002:seq',
-  STR: 'tag:yaml.org,2002:str'
-});
-
-export { Schema as default };

package/browser/dist/schema/parseMap.js

@@ -1,312 +0,0 @@
-import { Char, Type } from '../constants';
-import PlainValue from '../cst/PlainValue';
-import { YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from '../errors';
-import Map from './Map';
-import Merge, { MERGE_KEY } from './Merge';
-import Pair from './Pair';
-import { checkFlowCollectionEnd, checkKeyLength, resolveComments } from './parseUtils';
-import Alias from './Alias';
-import Collection from './Collection';
-export default function parseMap(doc, cst) {
-  if (cst.type !== Type.MAP && cst.type !== Type.FLOW_MAP) {
-    var msg = "A ".concat(cst.type, " node cannot be resolved as a mapping");
-    doc.errors.push(new YAMLSyntaxError(cst, msg));
-    return null;
-  }
-
-  var _ref = cst.type === Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
-      comments = _ref.comments,
-      items = _ref.items;
-
-  var map = new Map();
-  map.items = items;
-  resolveComments(map, comments);
-  var hasCollectionKey = false;
-
-  for (var i = 0; i < items.length; ++i) {
-    var iKey = items[i].key;
-    if (iKey instanceof Collection) hasCollectionKey = true;
-
-    if (doc.schema.merge && iKey && iKey.value === MERGE_KEY) {
-      items[i] = new Merge(items[i]);
-      var sources = items[i].value.items;
-      var error = null;
-      sources.some(function (node) {
-        if (node instanceof Alias) {
-          // During parsing, alias sources are CST nodes; to account for
-          // circular references their resolved values can't be used here.
-          var type = node.source.type;
-          if (type === Type.MAP || type === Type.FLOW_MAP) return false;
-          return error = 'Merge nodes aliases can only point to maps';
-        }
-
-        return error = 'Merge nodes can only have Alias nodes as values';
-      });
-      if (error) doc.errors.push(new YAMLSemanticError(cst, error));
-    } else {
-      for (var j = i + 1; j < items.length; ++j) {
-        var jKey = items[j].key;
-
-        if (iKey === jKey || iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, 'value') && iKey.value === jKey.value) {
-          var _msg = "Map keys must be unique; \"".concat(iKey, "\" is repeated");
-
-          doc.errors.push(new YAMLSemanticError(cst, _msg));
-          break;
-        }
-      }
-    }
-  }
-
-  if (hasCollectionKey && !doc.options.mapAsMap) {
-    var warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
-    doc.warnings.push(new YAMLWarning(cst, warn));
-  }
-
-  cst.resolved = map;
-  return map;
-}
-
-var valueHasPairComment = function valueHasPairComment(_ref2) {
-  var _ref2$context = _ref2.context,
-      lineStart = _ref2$context.lineStart,
-      node = _ref2$context.node,
-      src = _ref2$context.src,
-      props = _ref2.props;
-  if (props.length === 0) return false;
-  var start = props[0].start;
-  if (node && start > node.valueRange.start) return false;
-  if (src[start] !== Char.COMMENT) return false;
-
-  for (var i = lineStart; i < start; ++i) {
-    if (src[i] === '\n') return false;
-  }
-
-  return true;
-};
-
-function resolvePairComment(item, pair) {
-  if (!valueHasPairComment(item)) return;
-  var comment = item.getPropValue(0, Char.COMMENT, true);
-  var found = false;
-  var cb = pair.value.commentBefore;
-
-  if (cb && cb.startsWith(comment)) {
-    pair.value.commentBefore = cb.substr(comment.length + 1);
-    found = true;
-  } else {
-    var cc = pair.value.comment;
-
-    if (!item.node && cc && cc.startsWith(comment)) {
-      pair.value.comment = cc.substr(comment.length + 1);
-      found = true;
-    }
-  }
-
-  if (found) pair.comment = comment;
-}
-
-function resolveBlockMapItems(doc, cst) {
-  var comments = [];
-  var items = [];
-  var key = undefined;
-  var keyStart = null;
-
-  for (var i = 0; i < cst.items.length; ++i) {
-    var item = cst.items[i];
-
-    switch (item.type) {
-      case Type.BLANK_LINE:
-        comments.push({
-          afterKey: !!key,
-          before: items.length
-        });
-        break;
-
-      case Type.COMMENT:
-        comments.push({
-          afterKey: !!key,
-          before: items.length,
-          comment: item.comment
-        });
-        break;
-
-      case Type.MAP_KEY:
-        if (key !== undefined) items.push(new Pair(key));
-        if (item.error) doc.errors.push(item.error);
-        key = doc.resolveNode(item.node);
-        keyStart = null;
-        break;
-
-      case Type.MAP_VALUE:
-        {
-          if (key === undefined) key = null;
-          if (item.error) doc.errors.push(item.error);
-
-          if (!item.context.atLineStart && item.node && item.node.type === Type.MAP && !item.node.context.atLineStart) {
-            var msg = 'Nested mappings are not allowed in compact mappings';
-            doc.errors.push(new YAMLSemanticError(item.node, msg));
-          }
-
-          var valueNode = item.node;
-
-          if (!valueNode && item.props.length > 0) {
-            // Comments on an empty mapping value need to be preserved, so we
-            // need to construct a minimal empty node here to use instead of the
-            // missing `item.node`. -- eemeli/yaml#19
-            valueNode = new PlainValue(Type.PLAIN, []);
-            valueNode.context = {
-              parent: item,
-              src: item.context.src
-            };
-            var pos = item.range.start + 1;
-            valueNode.range = {
-              start: pos,
-              end: pos
-            };
-            valueNode.valueRange = {
-              start: pos,
-              end: pos
-            };
-
-            if (typeof item.range.origStart === 'number') {
-              var origPos = item.range.origStart + 1;
-              valueNode.range.origStart = valueNode.range.origEnd = origPos;
-              valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos;
-            }
-          }
-
-          var pair = new Pair(key, doc.resolveNode(valueNode));
-          resolvePairComment(item, pair);
-          items.push(pair);
-          checkKeyLength(doc.errors, cst, i, key, keyStart);
-          key = undefined;
-          keyStart = null;
-        }
-        break;
-
-      default:
-        if (key !== undefined) items.push(new Pair(key));
-        key = doc.resolveNode(item);
-        keyStart = item.range.start;
-        if (item.error) doc.errors.push(item.error);
-
-        next: for (var j = i + 1;; ++j) {
-          var nextItem = cst.items[j];
-
-          switch (nextItem && nextItem.type) {
-            case Type.BLANK_LINE:
-            case Type.COMMENT:
-              continue next;
-
-            case Type.MAP_VALUE:
-              break next;
-
-            default:
-              doc.errors.push(new YAMLSemanticError(item, 'Implicit map keys need to be followed by map values'));
-              break next;
-          }
-        }
-
-        if (item.valueRangeContainsNewline) {
-          var _msg2 = 'Implicit map keys need to be on a single line';
-          doc.errors.push(new YAMLSemanticError(item, _msg2));
-        }
-
-    }
-  }
-
-  if (key !== undefined) items.push(new Pair(key));
-  return {
-    comments: comments,
-    items: items
-  };
-}
-
-function resolveFlowMapItems(doc, cst) {
-  var comments = [];
-  var items = [];
-  var key = undefined;
-  var keyStart = null;
-  var explicitKey = false;
-  var next = '{';
-
-  for (var i = 0; i < cst.items.length; ++i) {
-    checkKeyLength(doc.errors, cst, i, key, keyStart);
-    var item = cst.items[i];
-
-    if (typeof item.char === 'string') {
-      var char = item.char,
-          offset = item.offset;
-
-      if (char === '?' && key === undefined && !explicitKey) {
-        explicitKey = true;
-        next = ':';
-        continue;
-      }
-
-      if (char === ':') {
-        if (key === undefined) key = null;
-
-        if (next === ':') {
-          next = ',';
-          continue;
-        }
-      } else {
-        if (explicitKey) {
-          if (key === undefined && char !== ',') key = null;
-          explicitKey = false;
-        }
-
-        if (key !== undefined) {
-          items.push(new Pair(key));
-          key = undefined;
-          keyStart = null;
-
-          if (char === ',') {
-            next = ':';
-            continue;
-          }
-        }
-      }
-
-      if (char === '}') {
-        if (i === cst.items.length - 1) continue;
-      } else if (char === next) {
-        next = ':';
-        continue;
-      }
-
-      var msg = "Flow map contains an unexpected ".concat(char);
-      var err = new YAMLSyntaxError(cst, msg);
-      err.offset = offset;
-      doc.errors.push(err);
-    } else if (item.type === Type.BLANK_LINE) {
-      comments.push({
-        afterKey: !!key,
-        before: items.length
-      });
-    } else if (item.type === Type.COMMENT) {
-      comments.push({
-        afterKey: !!key,
-        before: items.length,
-        comment: item.comment
-      });
-    } else if (key === undefined) {
-      if (next === ',') doc.errors.push(new YAMLSemanticError(item, 'Separator , missing in flow map'));
-      key = doc.resolveNode(item);
-      keyStart = explicitKey ? null : item.range.start; // TODO: add error for non-explicit multiline plain key
-    } else {
-      if (next !== ',') doc.errors.push(new YAMLSemanticError(item, 'Indicator : missing in flow map entry'));
-      items.push(new Pair(key, doc.resolveNode(item)));
-      key = undefined;
-      explicitKey = false;
-    }
-  }
-
-  checkFlowCollectionEnd(doc.errors, cst);
-  if (key !== undefined) items.push(new Pair(key));
-  return {
-    comments: comments,
-    items: items
-  };
-}