yaml 1.10.0 → 2.0.0-1

package/browser/dist/index.js

@@ -1,8 +1,8 @@
-import { d as defaultTagPrefix, _ as _createForOfIteratorHelper, a as _typeof, b as _createClass, c as _classCallCheck, e as _defineProperty, Y as YAMLSyntaxError, T as Type, f as YAMLWarning, g as YAMLSemanticError, h as _slicedToArray, i as YAMLError, j as _inherits, k as _createSuper } from './PlainValue-ff5147c6.js';
-import { parse as parse$1 } from './parse-cst.js';
-import { b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions, N as Node, P as Pair, S as Scalar, c as stringifyString, A as Alias, Y as YAMLSeq, d as YAMLMap, M as Merge, C as Collection, r as resolveNode, e as isEmptyPath, t as toJSON, f as addComment } from './resolveSeq-04825f30.js';
-import { S as Schema } from './Schema-2bf2c74e.js';
-import { w as warn } from './warnings-0e4b70d3.js';
+import { d as defaultTagPrefix, _ as _typeof, a as _createClass, b as _classCallCheck, c as _defineProperty, e as _slicedToArray, Y as YAMLSemanticError, T as Type, f as defaultTags, g as YAMLWarning, h as _createForOfIteratorHelper, i as YAMLSyntaxError, C as Char, j as YAMLReferenceError, k as YAMLError } from './errors-2634d01a.js';
+import { P as PlainValue, D as Document$1, p as parse$1 } from './parse-d1ba890f.js';
+export { p as parseCST } from './parse-d1ba890f.js';
+import { b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions, N as Node, P as Pair, S as Scalar, c as stringifyString, A as Alias, Y as YAMLSeq, d as YAMLMap, C as Collection, r as resolveScalar, e as createNode, f as isEmptyPath, g as collectionFromPath, t as toJS, h as addComment } from './stringifyNumber-d8af95b1.js';
+import { M as Merge, a as MERGE_KEY, S as Schema } from './Schema-ea978338.js';
 
 var defaultOptions = {
   anchorPrefix: 'a',
@@ -11,11 +11,10 @@ var defaultOptions = {
   indentSeq: true,
   keepCstNodes: false,
   keepNodeTypes: true,
-  keepBlobsInJSON: true,
+  keepUndefined: false,
   mapAsMap: false,
   maxAliasCount: 100,
-  prettyErrors: false,
-  // TODO Set true in v2
+  prettyErrors: true,
   simpleKeys: false,
   version: '1.2'
 };
@@ -87,6 +86,7 @@ var documentOptions = {
   '1.2': {
     schema: 'core',
     merge: false,
+    resolveKnownTags: true,
     tagPrefixes: [{
       handle: '!',
       prefix: '!'
@@ -145,10 +145,10 @@ function getTagObject(tags, item) {
   var tagObj, obj;
 
   if (item instanceof Scalar) {
-    obj = item.value; // TODO: deprecate/remove class check
+    obj = item.value;
 
     var _match = tags.filter(function (t) {
-      return t.identify && t.identify(obj) || t.class && obj instanceof t.class;
+      return t.identify && t.identify(obj);
     });
 
     tagObj = _match.find(function (t) {
@@ -193,40 +193,16 @@ function stringifyProps(node, tagObj, _ref) {
 }
 
 function stringify(item, ctx, onComment, onChompKeep) {
-  var _ctx$doc = ctx.doc,
-      anchors = _ctx$doc.anchors,
-      schema = _ctx$doc.schema;
+  var schema = ctx.doc.schema;
   var tagObj;
 
   if (!(item instanceof Node)) {
-    var createCtx = {
-      aliasNodes: [],
+    item = ctx.doc.createNode(item, {
       onTagObj: function onTagObj(o) {
         return tagObj = o;
       },
-      prevObjects: new Map()
-    };
-    item = schema.createNode(item, true, null, createCtx);
-
-    var _iterator = _createForOfIteratorHelper(createCtx.aliasNodes),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var alias = _step.value;
-        alias.source = alias.source.node;
-        var name = anchors.getName(alias.source);
-
-        if (!name) {
-          name = anchors.newName();
-          anchors.map[name] = alias.source;
-        }
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
+      wrapScalars: true
+    });
   }
 
   if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
@@ -249,7 +225,7 @@ var Anchors = /*#__PURE__*/function () {
   function Anchors(prefix) {
     _classCallCheck(this, Anchors);
 
-    _defineProperty(this, "map", {});
+    _defineProperty(this, "map", Object.create(null));
 
     this.prefix = prefix;
   }
@@ -366,6 +342,58 @@ var Anchors = /*#__PURE__*/function () {
   return Anchors;
 }();
 
+/**
+ * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec,
+ * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the
+ * 2021 edition: https://tc39.es/ecma262/#sec-json.parse
+ *
+ * Includes extensions for handling Map and Set objects.
+ */
+function applyReviver(reviver, obj, key, val) {
+  if (val && _typeof(val) === 'object') {
+    if (Array.isArray(val)) {
+      for (var i = 0, len = val.length; i < len; ++i) {
+        var v0 = val[i];
+        var v1 = applyReviver(reviver, val, String(i), v0);
+        if (v1 === undefined) delete val[i];else if (v1 !== v0) val[i] = v1;
+      }
+    } else if (val instanceof Map) {
+      for (var _i = 0, _Array$from = Array.from(val.keys()); _i < _Array$from.length; _i++) {
+        var k = _Array$from[_i];
+
+        var _v = val.get(k);
+
+        var _v2 = applyReviver(reviver, val, k, _v);
+
+        if (_v2 === undefined) val.delete(k);else if (_v2 !== _v) val.set(k, _v2);
+      }
+    } else if (val instanceof Set) {
+      for (var _i2 = 0, _Array$from2 = Array.from(val); _i2 < _Array$from2.length; _i2++) {
+        var _v3 = _Array$from2[_i2];
+
+        var _v4 = applyReviver(reviver, val, _v3, _v3);
+
+        if (_v4 === undefined) val.delete(_v3);else if (_v4 !== _v3) {
+          val.delete(_v3);
+          val.add(_v4);
+        }
+      }
+    } else {
+      for (var _i3 = 0, _Object$entries = Object.entries(val); _i3 < _Object$entries.length; _i3++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i3], 2),
+            _k = _Object$entries$_i[0],
+            _v5 = _Object$entries$_i[1];
+
+        var _v6 = applyReviver(reviver, val, _k, _v5);
+
+        if (_v6 === undefined) delete val[_k];else if (_v6 !== _v5) val[_k] = _v6;
+      }
+    }
+  }
+
+  return reviver.call(obj, key, val);
+}
+
 var visit = function visit(node, tags) {
   if (node && _typeof(node) === 'object') {
     var tag = node.tag;
@@ -390,6 +418,934 @@ var listTagNames = function listTagNames(node) {
   return Object.keys(visit(node, {}));
 };
 
+function resolveTagHandle(doc, node) {
+  var _node$tag = node.tag,
+      handle = _node$tag.handle,
+      suffix = _node$tag.suffix;
+  var prefix = doc.tagPrefixes.find(function (p) {
+    return p.handle === handle;
+  });
+
+  if (!prefix) {
+    var dtp = doc.getDefaults().tagPrefixes;
+    if (dtp) prefix = dtp.find(function (p) {
+      return p.handle === handle;
+    });
+    if (!prefix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag handle is non-default and was not declared."));
+  }
+
+  if (!suffix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag has no suffix."));
+
+  if (handle === '!' && (doc.version || doc.options.version) === '1.0') {
+    if (suffix[0] === '^') {
+      doc.warnings.push(new YAMLWarning(node, 'YAML 1.0 ^ tag expansion is not supported'));
+      return suffix;
+    }
+
+    if (/[:/]/.test(suffix)) {
+      // word/foo -> tag:word.yaml.org,2002:foo
+      var vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i);
+      return vocab ? "tag:".concat(vocab[1], ".yaml.org,2002:").concat(vocab[2]) : "tag:".concat(suffix);
+    }
+  }
+
+  return prefix.prefix + decodeURIComponent(suffix);
+}
+
+function resolveTagName(doc, node) {
+  var tag = node.tag,
+      type = node.type;
+  var nonSpecific = false;
+
+  if (tag) {
+    var handle = tag.handle,
+        suffix = tag.suffix,
+        verbatim = tag.verbatim;
+
+    if (verbatim) {
+      if (verbatim !== '!' && verbatim !== '!!') return verbatim;
+      var msg = "Verbatim tags aren't resolved, so ".concat(verbatim, " is invalid.");
+      doc.errors.push(new YAMLSemanticError(node, msg));
+    } else if (handle === '!' && !suffix) {
+      nonSpecific = true;
+    } else {
+      try {
+        return resolveTagHandle(doc, node);
+      } catch (error) {
+        doc.errors.push(error);
+      }
+    }
+  }
+
+  switch (type) {
+    case Type.BLOCK_FOLDED:
+    case Type.BLOCK_LITERAL:
+    case Type.QUOTE_DOUBLE:
+    case Type.QUOTE_SINGLE:
+      return defaultTags.STR;
+
+    case Type.FLOW_MAP:
+    case Type.MAP:
+      return defaultTags.MAP;
+
+    case Type.FLOW_SEQ:
+    case Type.SEQ:
+      return defaultTags.SEQ;
+
+    case Type.PLAIN:
+      return nonSpecific ? defaultTags.STR : null;
+
+    default:
+      return null;
+  }
+}
+
+function checkFlowCollectionEnd(errors, cst) {
+  var char, name;
+
+  switch (cst.type) {
+    case Type.FLOW_MAP:
+      char = '}';
+      name = 'flow map';
+      break;
+
+    case Type.FLOW_SEQ:
+      char = ']';
+      name = 'flow sequence';
+      break;
+
+    default:
+      errors.push(new YAMLSemanticError(cst, 'Not a flow collection!?'));
+      return;
+  }
+
+  var lastItem;
+
+  for (var i = cst.items.length - 1; i >= 0; --i) {
+    var item = cst.items[i];
+
+    if (!item || item.type !== Type.COMMENT) {
+      lastItem = item;
+      break;
+    }
+  }
+
+  if (lastItem && lastItem.char !== char) {
+    var msg = "Expected ".concat(name, " to end with ").concat(char);
+    var err;
+
+    if (typeof lastItem.offset === 'number') {
+      err = new YAMLSemanticError(cst, msg);
+      err.offset = lastItem.offset + 1;
+    } else {
+      err = new YAMLSemanticError(lastItem, msg);
+      if (lastItem.range && lastItem.range.end) err.offset = lastItem.range.end - lastItem.range.start;
+    }
+
+    errors.push(err);
+  }
+}
+function checkFlowCommentSpace(errors, comment) {
+  var prev = comment.context.src[comment.range.start - 1];
+
+  if (prev !== '\n' && prev !== '\t' && prev !== ' ') {
+    var msg = 'Comments must be separated from other tokens by white space characters';
+    errors.push(new YAMLSemanticError(comment, msg));
+  }
+}
+function getLongKeyError(source, key) {
+  var sk = String(key);
+  var k = sk.substr(0, 8) + '...' + sk.substr(-8);
+  return new YAMLSemanticError(source, "The \"".concat(k, "\" key is too long"));
+}
+function resolveComments(collection, comments) {
+  var _iterator = _createForOfIteratorHelper(comments),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          afterKey = _step$value.afterKey,
+          before = _step$value.before,
+          comment = _step$value.comment;
+      var item = collection.items[before];
+
+      if (!item) {
+        if (comment !== undefined) {
+          if (collection.comment) collection.comment += '\n' + comment;else collection.comment = comment;
+        }
+      } else {
+        if (afterKey && item.value) item = item.value;
+
+        if (comment === undefined) {
+          if (afterKey || !item.commentBefore) item.spaceBefore = true;
+        } else {
+          if (item.commentBefore) item.commentBefore += '\n' + comment;else item.commentBefore = comment;
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+}
+
+function resolveMap(doc, cst) {
+  var _ref = cst.type === Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
+      comments = _ref.comments,
+      items = _ref.items;
+
+  var map = new YAMLMap(doc.schema);
+  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 = resolveNode(doc, 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, resolveNode(doc, valueNode));
+          resolvePairComment(item, pair);
+          items.push(pair);
+
+          if (key && typeof keyStart === 'number') {
+            if (item.range.start > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key));
+          }
+
+          key = undefined;
+          keyStart = null;
+        }
+        break;
+
+      default:
+        if (key !== undefined) items.push(new Pair(key));
+        key = resolveNode(doc, 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:
+              {
+                var _msg = 'Implicit map keys need to be followed by map values';
+                doc.errors.push(new YAMLSemanticError(item, _msg));
+                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 explicitKey = false;
+  var next = '{';
+
+  for (var i = 0; i < cst.items.length; ++i) {
+    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;
+
+          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) {
+      checkFlowCommentSpace(doc.errors, item);
+      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 = resolveNode(doc, item);
+    } else {
+      if (next !== ',') doc.errors.push(new YAMLSemanticError(item, 'Indicator : missing in flow map entry'));
+      items.push(new Pair(key, resolveNode(doc, item)));
+      key = undefined;
+      explicitKey = false;
+    }
+  }
+
+  checkFlowCollectionEnd(doc.errors, cst);
+  if (key !== undefined) items.push(new Pair(key));
+  return {
+    comments: comments,
+    items: items
+  };
+}
+
+function resolveSeq(doc, cst) {
+  var _ref = cst.type === Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
+      comments = _ref.comments,
+      items = _ref.items;
+
+  var seq = new YAMLSeq(doc.schema);
+  seq.items = items;
+  resolveComments(seq, comments);
+
+  if (!doc.options.mapAsMap && items.some(function (it) {
+    return it instanceof Pair && it.key instanceof Collection;
+  })) {
+    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 = seq;
+  return seq;
+}
+
+function resolveBlockSeqItems(doc, cst) {
+  var comments = [];
+  var items = [];
+
+  for (var i = 0; i < cst.items.length; ++i) {
+    var item = cst.items[i];
+
+    switch (item.type) {
+      case Type.BLANK_LINE:
+        comments.push({
+          before: items.length
+        });
+        break;
+
+      case Type.COMMENT:
+        comments.push({
+          comment: item.comment,
+          before: items.length
+        });
+        break;
+
+      case Type.SEQ_ITEM:
+        if (item.error) doc.errors.push(item.error);
+        items.push(resolveNode(doc, item.node));
+
+        if (item.hasProps) {
+          var msg = 'Sequence items cannot have tags or anchors before the - indicator';
+          doc.errors.push(new YAMLSemanticError(item, msg));
+        }
+
+        break;
+
+      default:
+        if (item.error) doc.errors.push(item.error);
+        doc.errors.push(new YAMLSyntaxError(item, "Unexpected ".concat(item.type, " node in sequence")));
+    }
+  }
+
+  return {
+    comments: comments,
+    items: items
+  };
+}
+
+function resolveFlowSeqItems(doc, cst) {
+  var comments = [];
+  var items = [];
+  var explicitKey = false;
+  var key = undefined;
+  var keyStart = null;
+  var next = '[';
+  var prevItem = null;
+
+  for (var i = 0; i < cst.items.length; ++i) {
+    var item = cst.items[i];
+
+    if (typeof item.char === 'string') {
+      var char = item.char,
+          offset = item.offset;
+
+      if (char !== ':' && (explicitKey || key !== undefined)) {
+        if (explicitKey && key === undefined) key = next ? items.pop() : null;
+        items.push(new Pair(key));
+        explicitKey = false;
+        key = undefined;
+        keyStart = null;
+      }
+
+      if (char === next) {
+        next = null;
+      } else if (!next && char === '?') {
+        explicitKey = true;
+      } else if (next !== '[' && char === ':' && key === undefined) {
+        if (next === ',') {
+          key = items.pop();
+
+          if (key instanceof Pair) {
+            var msg = 'Chaining flow sequence pairs is invalid';
+            var err = new YAMLSemanticError(cst, msg);
+            err.offset = offset;
+            doc.errors.push(err);
+          }
+
+          if (!explicitKey && typeof keyStart === 'number') {
+            var keyEnd = item.range ? item.range.start : item.offset;
+            if (keyEnd > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key));
+            var src = prevItem.context.src;
+
+            for (var _i = keyStart; _i < keyEnd; ++_i) {
+              if (src[_i] === '\n') {
+                var _msg = 'Implicit keys of flow sequence pairs need to be on a single line';
+                doc.errors.push(new YAMLSemanticError(prevItem, _msg));
+                break;
+              }
+            }
+          }
+        } else {
+          key = null;
+        }
+
+        keyStart = null;
+        explicitKey = false;
+        next = null;
+      } else if (next === '[' || char !== ']' || i < cst.items.length - 1) {
+        var _msg2 = "Flow sequence contains an unexpected ".concat(char);
+
+        var _err = new YAMLSyntaxError(cst, _msg2);
+
+        _err.offset = offset;
+        doc.errors.push(_err);
+      }
+    } else if (item.type === Type.BLANK_LINE) {
+      comments.push({
+        before: items.length
+      });
+    } else if (item.type === Type.COMMENT) {
+      checkFlowCommentSpace(doc.errors, item);
+      comments.push({
+        comment: item.comment,
+        before: items.length
+      });
+    } else {
+      if (next) {
+        var _msg3 = "Expected a ".concat(next, " in flow sequence");
+
+        doc.errors.push(new YAMLSemanticError(item, _msg3));
+      }
+
+      var value = resolveNode(doc, item);
+
+      if (key === undefined) {
+        items.push(value);
+        prevItem = item;
+      } else {
+        items.push(new Pair(key, value));
+        key = undefined;
+      }
+
+      keyStart = item.range.start;
+      next = ',';
+    }
+  }
+
+  checkFlowCollectionEnd(doc.errors, cst);
+  if (key !== undefined) items.push(new Pair(key));
+  return {
+    comments: comments,
+    items: items
+  };
+}
+
+function resolveByTagName(_ref, tagName, value, onError) {
+  var knownTags = _ref.knownTags,
+      tags = _ref.tags;
+  var matchWithTest = [];
+
+  var _iterator = _createForOfIteratorHelper(tags),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var tag = _step.value;
+
+      if (tag.tag === tagName) {
+        if (tag.test) {
+          if (typeof value === 'string') matchWithTest.push(tag);else onError("The tag ".concat(tagName, " cannot be applied to a collection"));
+        } else {
+          var _res = tag.resolve(value, onError);
+
+          return _res instanceof Collection ? _res : new Scalar(_res);
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  if (matchWithTest.length > 0) return resolveScalar(value, matchWithTest);
+  var kt = knownTags[tagName];
+
+  if (kt) {
+    tags.push(Object.assign({}, kt, {
+      default: false,
+      test: undefined
+    }));
+    var res = kt.resolve(value, onError);
+    return res instanceof Collection ? res : new Scalar(res);
+  }
+
+  return null;
+}
+
+function resolveTag(doc, node, tagName) {
+  var MAP = defaultTags.MAP,
+      SEQ = defaultTags.SEQ,
+      STR = defaultTags.STR;
+  var value, fallback;
+
+  var onError = function onError(message) {
+    return doc.errors.push(new YAMLSemanticError(node, message));
+  };
+
+  try {
+    switch (node.type) {
+      case Type.FLOW_MAP:
+      case Type.MAP:
+        value = resolveMap(doc, node);
+        fallback = MAP;
+        if (tagName === SEQ || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a mapping"));
+        break;
+
+      case Type.FLOW_SEQ:
+      case Type.SEQ:
+        value = resolveSeq(doc, node);
+        fallback = SEQ;
+        if (tagName === MAP || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a sequence"));
+        break;
+
+      default:
+        value = node.strValue || '';
+
+        if (typeof value !== 'string') {
+          value.errors.forEach(function (error) {
+            return doc.errors.push(error);
+          });
+          value = value.str;
+        }
+
+        if (tagName === MAP || tagName === SEQ) onError("The tag ".concat(tagName, " cannot be applied to a scalar"));
+        fallback = STR;
+    }
+
+    var res = resolveByTagName(doc.schema, tagName, value, onError);
+
+    if (res) {
+      if (tagName && node.tag) res.tag = tagName;
+      return res;
+    }
+  } catch (error) {
+    /* istanbul ignore if */
+    if (!error.source) error.source = node;
+    doc.errors.push(error);
+    return null;
+  }
+
+  try {
+    if (!fallback) throw new Error("The tag ".concat(tagName, " is unavailable"));
+    var msg = "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback);
+    doc.warnings.push(new YAMLWarning(node, msg));
+
+    var _res2 = resolveByTagName(doc.schema, fallback, value, onError);
+
+    _res2.tag = tagName;
+    return _res2;
+  } catch (error) {
+    var refError = new YAMLReferenceError(node, error.message);
+    refError.stack = error.stack;
+    doc.errors.push(refError);
+    return null;
+  }
+}
+
+var isCollectionItem = function isCollectionItem(node) {
+  if (!node) return false;
+  var type = node.type;
+  return type === Type.MAP_KEY || type === Type.MAP_VALUE || type === Type.SEQ_ITEM;
+};
+
+function resolveNodeProps(errors, node) {
+  var comments = {
+    before: [],
+    after: []
+  };
+  var hasAnchor = false;
+  var hasTag = false;
+  var props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props;
+
+  var _iterator = _createForOfIteratorHelper(props),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _step$value = _step.value,
+          start = _step$value.start,
+          end = _step$value.end;
+
+      switch (node.context.src[start]) {
+        case Char.COMMENT:
+          {
+            if (!node.commentHasRequiredWhitespace(start)) {
+              var msg = 'Comments must be separated from other tokens by white space characters';
+              errors.push(new YAMLSemanticError(node, msg));
+            }
+
+            var header = node.header,
+                valueRange = node.valueRange;
+            var cc = valueRange && (start > valueRange.start || header && start > header.start) ? comments.after : comments.before;
+            cc.push(node.context.src.slice(start + 1, end));
+            break;
+          }
+        // Actual anchor & tag resolution is handled by schema, here we just complain
+
+        case Char.ANCHOR:
+          if (hasAnchor) {
+            var _msg = 'A node can have at most one anchor';
+            errors.push(new YAMLSemanticError(node, _msg));
+          }
+
+          hasAnchor = true;
+          break;
+
+        case Char.TAG:
+          if (hasTag) {
+            var _msg2 = 'A node can have at most one tag';
+            errors.push(new YAMLSemanticError(node, _msg2));
+          }
+
+          hasTag = true;
+          break;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return {
+    comments: comments,
+    hasAnchor: hasAnchor,
+    hasTag: hasTag
+  };
+}
+
+function resolveNodeValue(doc, node) {
+  var anchors = doc.anchors,
+      errors = doc.errors,
+      schema = doc.schema;
+
+  if (node.type === Type.ALIAS) {
+    var name = node.rawValue;
+    var src = anchors.getNode(name);
+
+    if (!src) {
+      var msg = "Aliased anchor not found: ".concat(name);
+      errors.push(new YAMLReferenceError(node, msg));
+      return null;
+    } // Lazy resolution for circular references
+
+
+    var res = new Alias(src);
+
+    anchors._cstAliases.push(res);
+
+    return res;
+  }
+
+  var tagName = resolveTagName(doc, node);
+  if (tagName) return resolveTag(doc, node, tagName);
+
+  if (node.type !== Type.PLAIN) {
+    var _msg3 = "Failed to resolve ".concat(node.type, " node here");
+
+    errors.push(new YAMLSyntaxError(node, _msg3));
+    return null;
+  }
+
+  try {
+    var str = node.strValue || '';
+
+    if (typeof str !== 'string') {
+      str.errors.forEach(function (error) {
+        return doc.errors.push(error);
+      });
+      str = str.str;
+    }
+
+    return resolveScalar(str, schema.tags);
+  } catch (error) {
+    if (!error.source) error.source = node;
+    errors.push(error);
+    return null;
+  }
+} // sets node.resolved on success
+
+
+function resolveNode(doc, node) {
+  if (!node) return null;
+  if (node.error) doc.errors.push(node.error);
+
+  var _resolveNodeProps = resolveNodeProps(doc.errors, node),
+      comments = _resolveNodeProps.comments,
+      hasAnchor = _resolveNodeProps.hasAnchor,
+      hasTag = _resolveNodeProps.hasTag;
+
+  if (hasAnchor) {
+    var anchors = doc.anchors;
+    var name = node.anchor;
+    var prev = anchors.getNode(name); // At this point, aliases for any preceding node with the same anchor
+    // name have already been resolved, so it may safely be renamed.
+
+    if (prev) anchors.map[anchors.newName(name)] = prev; // During parsing, we need to store the CST node in anchors.map as
+    // anchors need to be available during resolution to allow for
+    // circular references.
+
+    anchors.map[name] = node;
+  }
+
+  if (node.type === Type.ALIAS && (hasAnchor || hasTag)) {
+    var msg = 'An alias node must not specify any properties';
+    doc.errors.push(new YAMLSemanticError(node, msg));
+  }
+
+  var res = resolveNodeValue(doc, node);
+
+  if (res) {
+    res.range = [node.range.start, node.range.end];
+    if (doc.options.keepCstNodes) res.cstNode = node;
+    if (doc.options.keepNodeTypes) res.type = node.type;
+    var cb = comments.before.join('\n');
+
+    if (cb) {
+      res.commentBefore = res.commentBefore ? "".concat(res.commentBefore, "\n").concat(cb) : cb;
+    }
+
+    var ca = comments.after.join('\n');
+    if (ca) res.comment = res.comment ? "".concat(res.comment, "\n").concat(ca) : ca;
+  }
+
+  return node.resolved = res;
+}
+
 function parseContents(doc, contents) {
   var comments = {
     before: [],
@@ -582,20 +1538,35 @@ function assertCollection(contents) {
 }
 
 var Document = /*#__PURE__*/function () {
-  function Document(options) {
+  function Document(value, replacer, options) {
     _classCallCheck(this, Document);
 
-    this.anchors = new Anchors(options.anchorPrefix);
+    if (options === undefined && replacer && _typeof(replacer) === 'object' && !Array.isArray(replacer)) {
+      options = replacer;
+      replacer = undefined;
+    }
+
+    this.options = Object.assign({}, defaultOptions, options);
+    this.anchors = new Anchors(this.options.anchorPrefix);
     this.commentBefore = null;
     this.comment = null;
-    this.contents = null;
     this.directivesEndMarker = null;
     this.errors = [];
-    this.options = options;
     this.schema = null;
     this.tagPrefixes = [];
     this.version = null;
     this.warnings = [];
+
+    if (value === undefined) {
+      // note that this.schema is left as null here
+      this.contents = null;
+    } else if (value instanceof Document$1) {
+      this.parse(value);
+    } else {
+      this.contents = this.createNode(value, {
+        replacer: replacer
+      });
+    }
   }
 
   _createClass(Document, [{
@@ -610,6 +1581,69 @@ var Document = /*#__PURE__*/function () {
       assertCollection(this.contents);
       this.contents.addIn(path, value);
     }
+  }, {
+    key: "createNode",
+    value: function createNode$1(value) {
+      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          keepUndefined = _ref.keepUndefined,
+          onTagObj = _ref.onTagObj,
+          replacer = _ref.replacer,
+          tag = _ref.tag,
+          wrapScalars = _ref.wrapScalars;
+
+      this.setSchema();
+      if (typeof replacer === 'function') value = replacer.call({
+        '': value
+      }, '', value);else if (Array.isArray(replacer)) {
+        var keyToStr = function keyToStr(v) {
+          return typeof v === 'number' || v instanceof String || v instanceof Number;
+        };
+
+        var asStr = replacer.filter(keyToStr).map(String);
+        if (asStr.length > 0) replacer = replacer.concat(asStr);
+      }
+      if (typeof keepUndefined !== 'boolean') keepUndefined = !!this.options.keepUndefined;
+      var aliasNodes = [];
+      var ctx = {
+        keepUndefined: keepUndefined,
+        onAlias: function onAlias(source) {
+          var alias = new Alias(source);
+          aliasNodes.push(alias);
+          return alias;
+        },
+        onTagObj: onTagObj,
+        prevObjects: new Map(),
+        replacer: replacer,
+        schema: this.schema,
+        wrapScalars: wrapScalars !== false
+      };
+
+      var node = createNode(value, tag, ctx);
+
+      for (var _i = 0, _aliasNodes = aliasNodes; _i < _aliasNodes.length; _i++) {
+        var alias = _aliasNodes[_i];
+        // With circular references, the source node is only resolved after all of
+        // its child nodes are. This is why anchors are set only after all of the
+        // nodes have been created.
+        alias.source = alias.source.node;
+        var name = this.anchors.getName(alias.source);
+
+        if (!name) {
+          name = this.anchors.newName();
+          this.anchors.map[name] = alias.source;
+        }
+      }
+
+      return node;
+    }
+  }, {
+    key: "createPair",
+    value: function createPair(key, value) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var k = this.createNode(key, options);
+      var v = this.createNode(value, options);
+      return new Pair(k, v);
+    }
   }, {
     key: "delete",
     value: function _delete(key) {
@@ -658,13 +1692,21 @@ var Document = /*#__PURE__*/function () {
   }, {
     key: "set",
     value: function set(key, value) {
-      assertCollection(this.contents);
-      this.contents.set(key, value);
+      if (this.contents == null) {
+        this.setSchema();
+        this.contents = collectionFromPath(this.schema, [key], value);
+      } else {
+        assertCollection(this.contents);
+        this.contents.set(key, value);
+      }
     }
   }, {
     key: "setIn",
     value: function setIn(path, value) {
-      if (isEmptyPath(path)) this.contents = value;else {
+      if (isEmptyPath(path)) this.contents = value;else if (this.contents == null) {
+        this.setSchema();
+        this.contents = collectionFromPath(this.schema, path, value);
+      } else {
         assertCollection(this.contents);
         this.contents.setIn(path, value);
       }
@@ -748,7 +1790,7 @@ var Document = /*#__PURE__*/function () {
     key: "listNonDefaultTags",
     value: function listNonDefaultTags() {
       return listTagNames(this.contents).filter(function (t) {
-        return t.indexOf(Schema.defaultPrefix) !== 0;
+        return t.indexOf(defaultTagPrefix) !== 0;
       });
     }
   }, {
@@ -771,37 +1813,38 @@ var Document = /*#__PURE__*/function () {
       }
     }
   }, {
-    key: "toJSON",
-    value: function toJSON$1(arg, onAnchor) {
-      var _this = this;
-
-      var _this$options = this.options,
-          keepBlobsInJSON = _this$options.keepBlobsInJSON,
-          mapAsMap = _this$options.mapAsMap,
-          maxAliasCount = _this$options.maxAliasCount;
-      var keep = keepBlobsInJSON && (typeof arg !== 'string' || !(this.contents instanceof Scalar));
+    key: "toJS",
+    value: function toJS$1() {
+      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+          json = _ref2.json,
+          jsonArg = _ref2.jsonArg,
+          mapAsMap = _ref2.mapAsMap,
+          onAnchor = _ref2.onAnchor,
+          reviver = _ref2.reviver;
+
+      var anchorNodes = Object.values(this.anchors.map).map(function (node) {
+        return [node, {
+          alias: [],
+          aliasCount: 0,
+          count: 1
+        }];
+      });
+      var anchors = anchorNodes.length > 0 ? new Map(anchorNodes) : null;
       var ctx = {
+        anchors: anchors,
         doc: this,
         indentStep: '  ',
-        keep: keep,
-        mapAsMap: keep && !!mapAsMap,
-        maxAliasCount: maxAliasCount,
+        keep: !json,
+        mapAsMap: typeof mapAsMap === 'boolean' ? mapAsMap : !!this.options.mapAsMap,
+        maxAliasCount: this.options.maxAliasCount,
         stringify: stringify // Requiring directly in Pair would create circular dependencies
 
       };
-      var anchorNames = Object.keys(this.anchors.map);
-      if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(function (name) {
-        return [_this.anchors.map[name], {
-          alias: [],
-          aliasCount: 0,
-          count: 1
-        }];
-      }));
 
-      var res = toJSON(this.contents, arg, ctx);
+      var res = toJS(this.contents, jsonArg || '', ctx);
 
-      if (typeof onAnchor === 'function' && ctx.anchors) {
-        var _iterator3 = _createForOfIteratorHelper(ctx.anchors.values()),
+      if (typeof onAnchor === 'function' && anchors) {
+        var _iterator3 = _createForOfIteratorHelper(anchors.values()),
             _step3;
 
         try {
@@ -818,7 +1861,19 @@ var Document = /*#__PURE__*/function () {
         }
       }
 
-      return res;
+      return typeof reviver === 'function' ? applyReviver(reviver, {
+        '': res
+      }, '', res) : res;
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON(jsonArg, onAnchor) {
+      return this.toJS({
+        json: true,
+        jsonArg: jsonArg,
+        mapAsMap: false,
+        onAnchor: onAnchor
+      });
     }
   }, {
     key: "toString",
@@ -847,9 +1902,9 @@ var Document = /*#__PURE__*/function () {
       }
 
       var tagNames = this.listNonDefaultTags();
-      this.tagPrefixes.forEach(function (_ref) {
-        var handle = _ref.handle,
-            prefix = _ref.prefix;
+      this.tagPrefixes.forEach(function (_ref3) {
+        var handle = _ref3.handle,
+            prefix = _ref3.prefix;
 
         if (tagNames.some(function (t) {
           return t.indexOf(prefix) === 0;
@@ -866,7 +1921,7 @@ var Document = /*#__PURE__*/function () {
       }
 
       var ctx = {
-        anchors: {},
+        anchors: Object.create(null),
         doc: this,
         indent: '',
         indentStep: ' '.repeat(indentSize),
@@ -892,7 +1947,7 @@ var Document = /*#__PURE__*/function () {
           return contentComment = null;
         }, onChompKeep);
         lines.push(addComment(body, '', contentComment));
-      } else if (this.contents !== undefined) {
+      } else {
         lines.push(stringify(this.contents, ctx));
       }
 
@@ -910,33 +1965,23 @@ var Document = /*#__PURE__*/function () {
 
 _defineProperty(Document, "defaults", documentOptions);
 
-function createNode(value) {
-  var wrapScalars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  var tag = arguments.length > 2 ? arguments[2] : undefined;
-
-  if (tag === undefined && typeof wrapScalars === 'string') {
-    tag = wrapScalars;
-    wrapScalars = true;
-  }
-
-  var options = Object.assign({}, Document.defaults[defaultOptions.version], defaultOptions);
-  var schema = new Schema(options);
-  return schema.createNode(value, wrapScalars, tag);
-}
-
-var Document$1 = /*#__PURE__*/function (_YAMLDocument) {
-  _inherits(Document, _YAMLDocument);
+/* global console, process, YAML_SILENCE_WARNINGS */
+function warn(warning, type) {
+  if (typeof YAML_SILENCE_WARNINGS !== 'undefined' && YAML_SILENCE_WARNINGS) return;
 
-  var _super = _createSuper(Document);
+  if (typeof process !== 'undefined') {
+    if (process.env.YAML_SILENCE_WARNINGS) return; // This will throw in Jest if `warning` is an Error instance due to
+    // https://github.com/facebook/jest/issues/2549
 
-  function Document(options) {
-    _classCallCheck(this, Document);
+    if (process.emitWarning) {
+      process.emitWarning(warning, type);
+      return;
+    }
+  } // eslint-disable-next-line no-console
 
-    return _super.call(this, Object.assign({}, defaultOptions, options));
-  }
 
-  return Document;
-}(Document);
+  console.warn(type ? "".concat(type, ": ").concat(warning) : warning);
+}
 
 function parseAllDocuments(src, options) {
   var stream = [];
@@ -948,7 +1993,7 @@ function parseAllDocuments(src, options) {
   try {
     for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var cstDoc = _step.value;
-      var doc = new Document$1(options);
+      var doc = new Document(undefined, null, options);
       doc.parse(cstDoc, prev);
       stream.push(doc);
       prev = doc;
@@ -961,10 +2006,9 @@ function parseAllDocuments(src, options) {
 
   return stream;
 }
-
 function parseDocument(src, options) {
   var cst = parse$1(src);
-  var doc = new Document$1(options).parse(cst[0]);
+  var doc = new Document(cst[0], null, options);
 
   if (cst.length > 1) {
     var errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
@@ -973,32 +2017,41 @@ function parseDocument(src, options) {
 
   return doc;
 }
+function parse(src, reviver, options) {
+  if (options === undefined && reviver && _typeof(reviver) === 'object') {
+    options = reviver;
+    reviver = undefined;
+  }
 
-function parse(src, options) {
   var doc = parseDocument(src, options);
   doc.warnings.forEach(function (warning) {
     return warn(warning);
   });
   if (doc.errors.length > 0) throw doc.errors[0];
-  return doc.toJSON();
+  return doc.toJS({
+    reviver: reviver
+  });
 }
+function stringify$1(value, replacer, options) {
+  if (typeof options === 'string') options = options.length;
+
+  if (typeof options === 'number') {
+    var indent = Math.round(options);
+    options = indent < 1 ? undefined : indent > 8 ? {
+      indent: 8
+    } : {
+      indent: indent
+    };
+  }
 
-function stringify$1(value, options) {
-  var doc = new Document$1(options);
-  doc.contents = value;
-  return String(doc);
-}
+  if (value === undefined) {
+    var _ref = options || replacer || {},
+        keepUndefined = _ref.keepUndefined;
 
-var YAML = {
-  createNode: createNode,
-  defaultOptions: defaultOptions,
-  Document: Document$1,
-  parse: parse,
-  parseAllDocuments: parseAllDocuments,
-  parseCST: parse$1,
-  parseDocument: parseDocument,
-  scalarOptions: scalarOptions,
-  stringify: stringify$1
-};
+    if (!keepUndefined) return undefined;
+  }
+
+  return new Document(value, replacer, options).toString();
+}
 
-export { YAML };
+export { Document, defaultOptions, parse, parseAllDocuments, parseDocument, scalarOptions, stringify$1 as stringify };