yaml 1.10.0 → 2.0.0-1

package/browser/dist/{resolveSeq-04825f30.js → stringifyNumber-d8af95b1.js}

@@ -1,4 +1,4 @@
-import { c as _classCallCheck, j as _inherits, k as _createSuper, b as _createClass, e as _defineProperty, p as _assertThisInitialized, a as _typeof, q as _toArray, T as Type, _ as _createForOfIteratorHelper, l as _get, m as _getPrototypeOf, o as YAMLReferenceError, r as _possibleConstructorReturn, h as _slicedToArray, g as YAMLSemanticError, n as defaultTags, f as YAMLWarning, C as Char, Y as YAMLSyntaxError, P as PlainValue } from './PlainValue-ff5147c6.js';
+import { b as _classCallCheck, l as _inherits, m as _createSuper, a as _createClass, _ as _typeof, d as defaultTagPrefix, c as _defineProperty, p as _assertThisInitialized, q as _toArray, T as Type, h as _createForOfIteratorHelper, n as _get, o as _getPrototypeOf, j as YAMLReferenceError } from './errors-2634d01a.js';
 
 function addCommentBefore(str, indent, comment) {
   if (!comment) return str;
@@ -13,9 +13,19 @@ var Node = function Node() {
   _classCallCheck(this, Node);
 };
 
-function toJSON(value, arg, ctx) {
+/**
+ * Recursively convert any node or its contents to native JavaScript
+ *
+ * @param value - The input value
+ * @param {string|null} arg - If `value` defines a `toJSON()` method, use this
+ *   as its first argument
+ * @param ctx - Conversion context, originally set in Document#toJS(). If
+ *   `{ keep: true }` is not set, output should be suitable for JSON
+ *   stringification.
+ */
+function toJS(value, arg, ctx) {
   if (Array.isArray(value)) return value.map(function (v, i) {
-    return toJSON(v, String(i), ctx);
+    return toJS(v, String(i), ctx);
   });
 
   if (value && typeof value.toJSON === 'function') {
@@ -29,10 +39,13 @@ function toJSON(value, arg, ctx) {
     return res;
   }
 
-  if ((!ctx || !ctx.keep) && typeof value === 'bigint') return Number(value);
+  if (!(ctx && ctx.keep) && typeof value === 'bigint') return Number(value);
   return value;
 }
 
+var isScalarValue = function isScalarValue(value) {
+  return !value || typeof value !== 'function' && _typeof(value) !== 'object';
+};
 var Scalar = /*#__PURE__*/function (_Node) {
   _inherits(Scalar, _Node);
 
@@ -50,8 +63,8 @@ var Scalar = /*#__PURE__*/function (_Node) {
 
   _createClass(Scalar, [{
     key: "toJSON",
-    value: function toJSON$1(arg, ctx) {
-      return ctx && ctx.keep ? this.value : toJSON(this.value, arg, ctx);
+    value: function toJSON(arg, ctx) {
+      return ctx && ctx.keep ? this.value : toJS(this.value, arg, ctx);
     }
   }, {
     key: "toString",
@@ -63,20 +76,98 @@ var Scalar = /*#__PURE__*/function (_Node) {
   return Scalar;
 }(Node);
 
+function findTagObject(value, tagName, tags) {
+  if (tagName) {
+    var match = tags.filter(function (t) {
+      return t.tag === tagName;
+    });
+    var tagObj = match.find(function (t) {
+      return !t.format;
+    }) || match[0];
+    if (!tagObj) throw new Error("Tag ".concat(tagName, " not found"));
+    return tagObj;
+  }
+
+  return tags.find(function (t) {
+    return t.identify && t.identify(value) && !t.format;
+  });
+}
+
+function createNode(value, tagName, ctx) {
+  if (value instanceof Node) return value;
+  var onAlias = ctx.onAlias,
+      onTagObj = ctx.onTagObj,
+      prevObjects = ctx.prevObjects,
+      wrapScalars = ctx.wrapScalars;
+  var _ctx$schema = ctx.schema,
+      map = _ctx$schema.map,
+      seq = _ctx$schema.seq,
+      tags = _ctx$schema.tags;
+  if (tagName && tagName.startsWith('!!')) tagName = defaultTagPrefix + tagName.slice(2);
+  var tagObj = findTagObject(value, tagName, tags);
+
+  if (!tagObj) {
+    if (typeof value.toJSON === 'function') value = value.toJSON();
+    if (!value || _typeof(value) !== 'object') return wrapScalars ? new Scalar(value) : value;
+    tagObj = value instanceof Map ? map : value[Symbol.iterator] ? seq : map;
+  }
+
+  if (onTagObj) {
+    onTagObj(tagObj);
+    delete ctx.onTagObj;
+  } // Detect duplicate references to the same object & use Alias nodes for all
+  // after first. The `obj` wrapper allows for circular references to resolve.
+
+
+  var obj = {
+    value: undefined,
+    node: undefined
+  };
+
+  if (value && _typeof(value) === 'object') {
+    var prev = prevObjects.get(value);
+    if (prev) return onAlias(prev);
+    obj.value = value;
+    prevObjects.set(value, obj);
+  }
+
+  obj.node = tagObj.createNode ? tagObj.createNode(ctx.schema, value, ctx) : wrapScalars ? new Scalar(value) : value;
+  if (tagName && obj.node instanceof Node) obj.node.tag = tagName;
+  return obj.node;
+}
+
 function collectionFromPath(schema, path, value) {
   var v = value;
 
   for (var i = path.length - 1; i >= 0; --i) {
     var k = path[i];
-    var o = Number.isInteger(k) && k >= 0 ? [] : {};
-    o[k] = v;
-    v = o;
+
+    if (Number.isInteger(k) && k >= 0) {
+      var a = [];
+      a[k] = v;
+      v = a;
+    } else {
+      var o = {};
+      Object.defineProperty(o, k, {
+        value: v,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      v = o;
+    }
   }
 
-  return schema.createNode(v, false);
+  return createNode(v, null, {
+    onAlias: function onAlias() {
+      throw new Error('Repeated objects are not supported here');
+    },
+    prevObjects: new Map(),
+    schema: schema,
+    wrapScalars: false
+  });
 } // null, undefined, or an empty non-string iterable (e.g. [])
 
-
 var isEmptyPath = function isEmptyPath(path) {
   return path == null || _typeof(path) === 'object' && path[Symbol.iterator]().next().done;
 };
@@ -164,9 +255,8 @@ var Collection = /*#__PURE__*/function (_Node) {
         var node = this.get(key, true);
         if (node instanceof Collection) node.setIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error("Expected YAML collection at ".concat(key, ". Remaining path: ").concat(rest));
       }
-    } // overridden in implementations
-
-    /* istanbul ignore next */
+    }
+    /* istanbul ignore next: overridden in implementations */
 
   }, {
     key: "toJSON",
@@ -348,11 +438,12 @@ var YAMLSeq = /*#__PURE__*/function (_Collection) {
     value: function set(key, value) {
       var idx = asItemIndex(key);
       if (typeof idx !== 'number') throw new Error("Expected a valid index, not ".concat(key, "."));
-      this.items[idx] = value;
+      var prev = this.items[idx];
+      if (prev instanceof Scalar && isScalarValue(value)) prev.value = value;else this.items[idx] = value;
     }
   }, {
     key: "toJSON",
-    value: function toJSON$1(_, ctx) {
+    value: function toJSON(_, ctx) {
       var seq = [];
       if (ctx && ctx.onCreate) ctx.onCreate(seq);
       var i = 0;
@@ -363,7 +454,7 @@ var YAMLSeq = /*#__PURE__*/function (_Collection) {
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var item = _step.value;
-          seq.push(toJSON(item, String(i++), ctx));
+          seq.push(toJS(item, String(i++), ctx));
         }
       } catch (err) {
         _iterator.e(err);
@@ -398,7 +489,7 @@ var stringifyKey = function stringifyKey(key, jsKey, ctx) {
   if (jsKey === null) return '';
   if (_typeof(jsKey) !== 'object') return String(jsKey);
   if (key instanceof Node && ctx && ctx.doc) return key.toString({
-    anchors: {},
+    anchors: Object.create(null),
     doc: ctx.doc,
     indent: '',
     indentStep: ctx.indentStep,
@@ -409,6 +500,11 @@ var stringifyKey = function stringifyKey(key, jsKey, ctx) {
   return JSON.stringify(jsKey);
 };
 
+function createPair(key, value, ctx) {
+  var k = createNode(key, null, ctx);
+  var v = createNode(value, null, ctx);
+  return new Pair(k, v);
+}
 var Pair = /*#__PURE__*/function (_Node) {
   _inherits(Pair, _Node);
 
@@ -431,16 +527,24 @@ var Pair = /*#__PURE__*/function (_Node) {
   _createClass(Pair, [{
     key: "addToJSMap",
     value: function addToJSMap(ctx, map) {
-      var key = toJSON(this.key, '', ctx);
+      var key = toJS(this.key, '', ctx);
 
       if (map instanceof Map) {
-        var value = toJSON(this.value, key, ctx);
+        var value = toJS(this.value, key, ctx);
         map.set(key, value);
       } else if (map instanceof Set) {
         map.add(key);
       } else {
         var stringKey = stringifyKey(this.key, key, ctx);
-        map[stringKey] = toJSON(this.value, stringKey, ctx);
+
+        var _value = toJS(this.value, stringKey, ctx);
+
+        if (stringKey in map) Object.defineProperty(map, stringKey, {
+          value: _value,
+          writable: true,
+          enumerable: true,
+          configurable: true
+        });else map[stringKey] = _value;
       }
 
       return map;
@@ -476,12 +580,13 @@ var Pair = /*#__PURE__*/function (_Node) {
 
       var explicitKey = !simpleKeys && (!key || keyComment || key instanceof Collection || key.type === Type.BLOCK_FOLDED || key.type === Type.BLOCK_LITERAL);
       var _ctx = ctx,
+          allNullValues = _ctx.allNullValues,
           doc = _ctx.doc,
           indent = _ctx.indent,
           indentStep = _ctx.indentStep,
           stringify = _ctx.stringify;
       ctx = Object.assign({}, ctx, {
-        implicitKey: !explicitKey,
+        implicitKey: !explicitKey && (simpleKeys || !allNullValues),
         indent: indent + indentStep
       });
       var chompKeep = false;
@@ -492,7 +597,7 @@ var Pair = /*#__PURE__*/function (_Node) {
       });
       str = addComment(str, ctx.indent, keyComment);
 
-      if (ctx.allNullValues && !simpleKeys) {
+      if (allNullValues && !simpleKeys) {
         if (this.comment) {
           str = addComment(str, ctx.indent, this.comment);
           if (onComment) onComment();
@@ -501,6 +606,15 @@ var Pair = /*#__PURE__*/function (_Node) {
         return ctx.inFlow ? str : "? ".concat(str);
       }
 
+      if (!explicitKey && str.length > 1024) {
+        if (!simpleKeys) {
+          explicitKey = true;
+        } else {
+          var _msg = 'With simple keys, single line scalar must not span more than 1024 characters';
+          throw new Error(_msg);
+        }
+      }
+
       str = explicitKey ? "? ".concat(str, "\n").concat(indent, ":") : "".concat(str, ":");
 
       if (this.comment) {
@@ -522,7 +636,7 @@ var Pair = /*#__PURE__*/function (_Node) {
 
         valueComment = value.comment;
       } else if (value && _typeof(value) === 'object') {
-        value = doc.schema.createNode(value, true);
+        value = doc.createNode(value);
       }
 
       ctx.implicitKey = false;
@@ -546,7 +660,7 @@ var Pair = /*#__PURE__*/function (_Node) {
       } else if (!explicitKey && value instanceof Collection) {
         var flow = valueStr[0] === '[' || valueStr[0] === '{';
         if (!flow || valueStr.includes('\n')) ws = "\n".concat(ctx.indent);
-      }
+      } else if (valueStr[0] === '\n') ws = '';
 
       if (chompKeep && !valueComment && onChompKeep) onChompKeep();
       return addComment(str + ws + valueStr, ctx.indent, valueComment);
@@ -642,8 +756,8 @@ var Alias = /*#__PURE__*/function (_Node) {
 
   _createClass(Alias, [{
     key: "toJSON",
-    value: function toJSON$1(arg, ctx) {
-      if (!ctx) return toJSON(this.source, arg, ctx);
+    value: function toJSON(arg, ctx) {
+      if (!ctx) return toJS(this.source, arg, ctx);
       var anchors = ctx.anchors,
           maxAliasCount = ctx.maxAliasCount;
       var anchor = anchors.get(this.source);
@@ -727,7 +841,9 @@ var YAMLMap = /*#__PURE__*/function (_Collection) {
       var sortEntries = this.schema && this.schema.sortMapEntries;
 
       if (prev) {
-        if (overwrite) prev.value = pair.value;else throw new Error("Key ".concat(pair.key, " already set"));
+        if (!overwrite) throw new Error("Key ".concat(pair.key, " already set")); // For scalars, keep the old node & its comments and anchors
+
+        if (prev.value instanceof Scalar && isScalarValue(pair.value)) prev.value.value = pair.value;else prev.value = pair.value;
       } else if (sortEntries) {
         var i = this.items.findIndex(function (item) {
           return sortEntries(pair, item) < 0;
@@ -763,10 +879,9 @@ var YAMLMap = /*#__PURE__*/function (_Collection) {
       this.add(new Pair(key, value), true);
     }
     /**
-     * @param {*} arg ignored
-     * @param {*} ctx Conversion context, originally set in Document#toJSON()
-     * @param {Class} Type If set, forces the returned collection type
-     * @returns {*} Instance of Type, Map, or Object
+     * @param ctx - Conversion context, originally set in Document#toJS()
+     * @param {Class} Type - If set, forces the returned collection type
+     * @returns Instance of Type, Map, or Object
      */
 
   }, {
@@ -827,103 +942,6 @@ var YAMLMap = /*#__PURE__*/function (_Collection) {
   return YAMLMap;
 }(Collection);
 
-var MERGE_KEY = '<<';
-var Merge = /*#__PURE__*/function (_Pair) {
-  _inherits(Merge, _Pair);
-
-  var _super = _createSuper(Merge);
-
-  function Merge(pair) {
-    var _this;
-
-    _classCallCheck(this, Merge);
-
-    if (pair instanceof Pair) {
-      var seq = pair.value;
-
-      if (!(seq instanceof YAMLSeq)) {
-        seq = new YAMLSeq();
-        seq.items.push(pair.value);
-        seq.range = pair.value.range;
-      }
-
-      _this = _super.call(this, pair.key, seq);
-      _this.range = pair.range;
-    } else {
-      _this = _super.call(this, new Scalar(MERGE_KEY), new YAMLSeq());
-    }
-
-    _this.type = Pair.Type.MERGE_PAIR;
-    return _possibleConstructorReturn(_this);
-  } // If the value associated with a merge key is a single mapping node, each of
-  // its key/value pairs is inserted into the current mapping, unless the key
-  // already exists in it. If the value associated with the merge key is a
-  // sequence, then this sequence is expected to contain mapping nodes and each
-  // of these nodes is merged in turn according to its order in the sequence.
-  // Keys in mapping nodes earlier in the sequence override keys specified in
-  // later mapping nodes. -- http://yaml.org/type/merge.html
-
-
-  _createClass(Merge, [{
-    key: "addToJSMap",
-    value: function addToJSMap(ctx, map) {
-      var _iterator = _createForOfIteratorHelper(this.value.items),
-          _step;
-
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var source = _step.value.source;
-          if (!(source instanceof YAMLMap)) throw new Error('Merge sources must be maps');
-          var srcMap = source.toJSON(null, ctx, Map);
-
-          var _iterator2 = _createForOfIteratorHelper(srcMap),
-              _step2;
-
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _step2$value = _slicedToArray(_step2.value, 2),
-                  key = _step2$value[0],
-                  value = _step2$value[1];
-
-              if (map instanceof Map) {
-                if (!map.has(key)) map.set(key, value);
-              } else if (map instanceof Set) {
-                map.add(key);
-              } else {
-                if (!Object.prototype.hasOwnProperty.call(map, key)) map[key] = value;
-              }
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
-          }
-        }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-
-      return map;
-    }
-  }, {
-    key: "toString",
-    value: function toString(ctx, onComment) {
-      var seq = this.value;
-      if (seq.items.length > 1) return _get(_getPrototypeOf(Merge.prototype), "toString", this).call(this, ctx, onComment);
-      this.value = seq.items[0];
-
-      var str = _get(_getPrototypeOf(Merge.prototype), "toString", this).call(this, ctx, onComment);
-
-      this.value = seq;
-      return str;
-    }
-  }]);
-
-  return Merge;
-}(Pair);
-
 var binaryOptions = {
   defaultType: Type.BLOCK_LITERAL,
   lineWidth: 76
@@ -940,6 +958,8 @@ var nullOptions = {
 };
 var strOptions = {
   defaultType: Type.PLAIN,
+  defaultKeyType: Type.PLAIN,
+  defaultQuoteSingle: false,
   doubleQuoted: {
     jsonEncoding: false,
     minMultiLineLength: 40
@@ -950,7 +970,7 @@ var strOptions = {
   }
 };
 
-function resolveScalar(str, tags, scalarFallback) {
+function resolveScalar(str, tags) {
   var _iterator = _createForOfIteratorHelper(tags),
       _step;
 
@@ -961,15 +981,11 @@ function resolveScalar(str, tags, scalarFallback) {
           test = _step$value.test,
           resolve = _step$value.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 (test && test.test(str)) {
+        var res = resolve(str);
+        if (!(res instanceof Scalar)) res = new Scalar(res);
+        if (format) res.format = format;
+        return res;
       }
     }
   } catch (err) {
@@ -978,8 +994,7 @@ function resolveScalar(str, tags, scalarFallback) {
     _iterator.f();
   }
 
-  if (scalarFallback) str = scalarFallback(str);
-  return new Scalar(str);
+  return new Scalar(str); // fallback to string
 }
 
 var FOLD_FLOW = 'flow';
@@ -1015,7 +1030,7 @@ var consumeMoreIndentedLines = function consumeMoreIndentedLines(text, i) {
  *   the first line, defaulting to `indent.length`
  * @param {number} [options.lineWidth=80]
  * @param {number} [options.minContentWidth=20] Allow highly indented lines to
- *   stretch the line width
+ *   stretch the line width or indent content from the start
  * @param {function} options.onFold Called once if the text is folded
  * @param {function} options.onFold Called once if any line of text exceeds
  *   lineWidth characters
@@ -1035,7 +1050,12 @@ function foldFlowLines(text, indent, mode, _ref) {
   if (text.length <= endStep) return text;
   var folds = [];
   var escapedFolds = {};
-  var end = lineWidth - (typeof indentAtStart === 'number' ? indentAtStart : indent.length);
+  var end = lineWidth - indent.length;
+
+  if (typeof indentAtStart === 'number') {
+    if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);else end = lineWidth - indentAtStart;
+  }
+
   var split = undefined;
   var prev = undefined;
   var overflow = false;
@@ -1114,8 +1134,10 @@ function foldFlowLines(text, indent, mode, _ref) {
 
     var _end = folds[_i + 1] || text.length;
 
-    if (mode === FOLD_QUOTED && escapedFolds[fold]) res += "".concat(text[fold], "\\");
-    res += "\n".concat(indent).concat(text.slice(fold + 1, _end));
+    if (fold === 0) res = "\n".concat(indent).concat(text.slice(0, _end));else {
+      if (mode === FOLD_QUOTED && escapedFolds[fold]) res += "".concat(text[fold], "\\");
+      res += "\n".concat(indent).concat(text.slice(fold + 1, _end));
+    }
   }
 
   return res;
@@ -1340,13 +1362,27 @@ function plainString(item, ctx, onComment, onChompKeep) {
   }
 
   if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
-    // not allowed:
+    var hasDouble = value.indexOf('"') !== -1;
+    var hasSingle = value.indexOf("'") !== -1;
+    var quotedString;
+
+    if (hasDouble && !hasSingle) {
+      quotedString = singleQuotedString;
+    } else if (hasSingle && !hasDouble) {
+      quotedString = doubleQuotedString;
+    } else if (strOptions.defaultQuoteSingle) {
+      quotedString = singleQuotedString;
+    } else {
+      quotedString = doubleQuotedString;
+    } // not allowed:
     // - empty string, '-' or '?'
     // - start with an indicator character (except [?:-]) or /[?-] /
     // - '\n ', ': ' or ' \n' anywhere
     // - '#' not preceded by a non-space char
     // - end with ' ' or ':'
-    return implicitKey || inFlow || value.indexOf('\n') === -1 ? value.indexOf('"') !== -1 && value.indexOf("'") === -1 ? singleQuotedString(value, ctx) : doubleQuotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
+
+
+    return implicitKey || inFlow || value.indexOf('\n') === -1 ? quotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
   }
 
   if (!implicitKey && !inFlow && type !== Type.PLAIN && value.indexOf('\n') !== -1) {
@@ -1365,7 +1401,7 @@ function plainString(item, ctx, onComment, onChompKeep) {
 
   if (actualString) {
     var tags = ctx.doc.schema.tags;
-    var resolved = resolveScalar(str, tags, tags.scalarFallback).value;
+    var resolved = resolveScalar(str, tags).value;
     if (typeof resolved !== 'string') return doubleQuotedString(value, ctx);
   }
 
@@ -1380,7 +1416,8 @@ function plainString(item, ctx, onComment, onChompKeep) {
 }
 
 function stringifyString(item, ctx, onComment, onChompKeep) {
-  var defaultType = strOptions.defaultType;
+  var defaultKeyType = strOptions.defaultKeyType,
+      defaultType = strOptions.defaultType;
   var implicitKey = ctx.implicitKey,
       inFlow = ctx.inFlow;
   var _item = item,
@@ -1394,11 +1431,17 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     });
   }
 
+  if (type !== Type.QUOTE_DOUBLE) {
+    // force double quotes on control characters & unpaired surrogates
+    if (/(?:[\0-\x08\x0B-\x1F\x7F-\x9F]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF])/.test(value)) type = Type.QUOTE_DOUBLE;
+  }
+
   var _stringify = function _stringify(_type) {
     switch (_type) {
       case Type.BLOCK_FOLDED:
       case Type.BLOCK_LITERAL:
-        return blockString(item, ctx, onComment, onChompKeep);
+        return implicitKey || inFlow ? doubleQuotedString(value, ctx) // blocks are not valid inside flow containers
+        : blockString(item, ctx, onComment, onChompKeep);
 
       case Type.QUOTE_DOUBLE:
         return doubleQuotedString(value, ctx);
@@ -1414,19 +1457,12 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     }
   };
 
-  if (type !== Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
-    // force double quotes on control characters
-    type = Type.QUOTE_DOUBLE;
-  } else if ((implicitKey || inFlow) && (type === Type.BLOCK_FOLDED || type === Type.BLOCK_LITERAL)) {
-    // should not happen; blocks are not valid inside flow containers
-    type = Type.QUOTE_DOUBLE;
-  }
-
   var res = _stringify(type);
 
   if (res === null) {
-    res = _stringify(defaultType);
-    if (res === null) throw new Error("Unsupported default string type ".concat(defaultType));
+    var t = implicitKey ? defaultKeyType : defaultType;
+    res = _stringify(t);
+    if (res === null) throw new Error("Unsupported default string type ".concat(t));
   }
 
   return res;
@@ -1459,915 +1495,4 @@ function stringifyNumber(_ref) {
   return n;
 }
 
-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();
-  }
-}
-
-// on error, will return { str: string, errors: Error[] }
-function resolveString(doc, node) {
-  var res = node.strValue;
-  if (!res) return '';
-  if (typeof res === 'string') return res;
-  res.errors.forEach(function (error) {
-    if (!error.source) error.source = node;
-    doc.errors.push(error);
-  });
-  return res.str;
-}
-
-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 resolveByTagName(doc, node, tagName) {
-  var tags = doc.schema.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) matchWithTest.push(tag);else {
-          var res = tag.resolve(doc, node);
-          return res instanceof Collection ? res : new Scalar(res);
-        }
-      }
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
-  }
-
-  var str = resolveString(doc, node);
-  if (typeof str === 'string' && matchWithTest.length > 0) return resolveScalar(str, matchWithTest, tags.scalarFallback);
-  return null;
-}
-
-function getFallbackTagName(_ref) {
-  var type = _ref.type;
-
-  switch (type) {
-    case Type.FLOW_MAP:
-    case Type.MAP:
-      return defaultTags.MAP;
-
-    case Type.FLOW_SEQ:
-    case Type.SEQ:
-      return defaultTags.SEQ;
-
-    default:
-      return defaultTags.STR;
-  }
-}
-
-function resolveTag(doc, node, tagName) {
-  try {
-    var res = resolveByTagName(doc, node, tagName);
-
-    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 {
-    var fallback = getFallbackTagName(node);
-    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 _res = resolveByTagName(doc, node, fallback);
-
-    _res.tag = tagName;
-    return _res;
-  } 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 = resolveString(doc, node);
-    return resolveScalar(str, schema.tags, schema.tags.scalarFallback);
-  } 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 resolveMap(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 YAMLMap();
-  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 _msg2 = 'Implicit map keys need to be followed by map values';
-                doc.errors.push(new YAMLSemanticError(item, _msg2));
-                break next;
-              }
-          }
-        }
-
-        if (item.valueRangeContainsNewline) {
-          var _msg3 = 'Implicit map keys need to be on a single line';
-          doc.errors.push(new YAMLSemanticError(item, _msg3));
-        }
-
-    }
-  }
-
-  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) {
-  if (cst.type !== Type.SEQ && cst.type !== Type.FLOW_SEQ) {
-    var msg = "A ".concat(cst.type, " node cannot be resolved as a sequence");
-    doc.errors.push(new YAMLSyntaxError(cst, msg));
-    return null;
-  }
-
-  var _ref = cst.type === Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
-      comments = _ref.comments,
-      items = _ref.items;
-
-  var seq = new YAMLSeq();
-  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
-  };
-}
-
-export { Alias as A, Collection as C, Merge as M, Node as N, Pair as P, Scalar as S, YAMLSeq as Y, boolOptions as a, binaryOptions as b, stringifyString as c, YAMLMap as d, isEmptyPath as e, addComment as f, resolveMap as g, resolveSeq as h, intOptions as i, resolveString as j, stringifyNumber as k, findPair as l, nullOptions as n, resolveNode as r, strOptions as s, toJSON as t };
+export { Alias as A, Collection as C, Node as N, Pair as P, Scalar as S, YAMLSeq as Y, boolOptions as a, binaryOptions as b, stringifyString as c, YAMLMap as d, createNode as e, isEmptyPath as f, collectionFromPath as g, addComment as h, intOptions as i, createPair as j, stringifyNumber as k, findPair as l, nullOptions as n, resolveScalar as r, strOptions as s, toJS as t };