yaml 1.6.0 → 1.8.0

package/browser/dist/schema/index.js

@@ -1,67 +1,48 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
-var _deprecation = require("../deprecation");
-
-var _constants = require("../constants");
-
-var _errors = require("../errors");
-
-var _stringify = require("../stringify");
-
-var _tags = require("../tags");
-
-var _string = require("../tags/failsafe/string");
-
-var _Alias = _interopRequireDefault(require("./Alias"));
-
-var _Collection = _interopRequireDefault(require("./Collection"));
-
-var _Node = _interopRequireDefault(require("./Node"));
-
-var _Pair = _interopRequireDefault(require("./Pair"));
-
-var _Scalar = _interopRequireDefault(require("./Scalar"));
+import _typeof from "@babel/runtime/helpers/typeof";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { warnOptionDeprecation } from '../warnings';
+import { Type } from '../constants';
+import { YAMLReferenceError, YAMLWarning } from '../errors';
+import { stringifyString } from '../stringify';
+import { schemas, tags } from '../tags';
+import { resolveString } from '../tags/failsafe/string';
+import Alias from './Alias';
+import Collection from './Collection';
+import Node from './Node';
+import Pair from './Pair';
+import Scalar from './Scalar';
 
 var isMap = function isMap(_ref) {
   var type = _ref.type;
-  return type === _constants.Type.FLOW_MAP || type === _constants.Type.MAP;
+  return type === Type.FLOW_MAP || type === Type.MAP;
 };
 
 var isSeq = function isSeq(_ref2) {
   var type = _ref2.type;
-  return type === _constants.Type.FLOW_SEQ || type === _constants.Type.SEQ;
+  return type === Type.FLOW_SEQ || type === Type.SEQ;
 };
 
-var Schema =
-/*#__PURE__*/
-function () {
+var Schema = /*#__PURE__*/function () {
   function Schema(_ref3) {
     var customTags = _ref3.customTags,
         merge = _ref3.merge,
         schema = _ref3.schema,
+        sortMapEntries = _ref3.sortMapEntries,
         deprecatedCustomTags = _ref3.tags;
-    (0, _classCallCheck2.default)(this, Schema);
+
+    _classCallCheck(this, Schema);
+
     this.merge = !!merge;
     this.name = schema;
-    this.tags = _tags.schemas[schema.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
+    this.sortMapEntries = sortMapEntries === true ? function (a, b) {
+      return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+    } : sortMapEntries || null;
+    this.tags = schemas[schema.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
 
     if (!this.tags) {
-      var keys = Object.keys(_tags.schemas).map(function (key) {
+      var keys = Object.keys(schemas).map(function (key) {
         return JSON.stringify(key);
       }).join(', ');
       throw new Error("Unknown schema \"".concat(schema, "\"; use one of ").concat(keys));
@@ -69,7 +50,7 @@ function () {
 
     if (!customTags && deprecatedCustomTags) {
       customTags = deprecatedCustomTags;
-      (0, _deprecation.warnOptionDeprecation)('tags', 'customTags');
+      warnOptionDeprecation('tags', 'customTags');
     }
 
     if (Array.isArray(customTags)) {
@@ -104,10 +85,10 @@ function () {
       var _tag = this.tags[i];
 
       if (typeof _tag === 'string') {
-        var tagObj = _tags.tags[_tag];
+        var tagObj = tags[_tag];
 
         if (!tagObj) {
-          var _keys = Object.keys(_tags.tags).map(function (key) {
+          var _keys = Object.keys(tags).map(function (key) {
             return JSON.stringify(key);
           }).join(', ');
 
@@ -119,9 +100,10 @@ function () {
     }
   }
 
-  (0, _createClass2.default)(Schema, [{
+  _createClass(Schema, [{
     key: "createNode",
     value: function createNode(value, wrapScalars, tag, ctx) {
+      if (value instanceof Node) return value;
       var tagObj;
 
       if (tag) {
@@ -141,8 +123,8 @@ function () {
 
         if (!tagObj) {
           if (typeof value.toJSON === 'function') value = value.toJSON();
-          if ((0, _typeof2.default)(value) !== 'object') return wrapScalars ? new _Scalar.default(value) : value;
-          tagObj = value instanceof Map ? _tags.tags.map : value[Symbol.iterator] ? _tags.tags.seq : _tags.tags.map;
+          if (_typeof(value) !== 'object') return wrapScalars ? new Scalar(value) : value;
+          tagObj = value instanceof Map ? tags.map : value[Symbol.iterator] ? tags.seq : tags.map;
         }
       }
 
@@ -157,23 +139,22 @@ function () {
 
       var obj = {};
 
-      if (value && (0, _typeof2.default)(value) === 'object' && ctx.prevObjects) {
-        var prev = ctx.prevObjects.find(function (o) {
-          return o.value === value;
-        });
+      if (value && _typeof(value) === 'object' && ctx.prevObjects) {
+        var prev = ctx.prevObjects.get(value);
 
         if (prev) {
-          var alias = new _Alias.default(prev); // leaves source dirty; must be cleaned by caller
+          var alias = new Alias(prev); // leaves source dirty; must be cleaned by caller
 
           ctx.aliasNodes.push(alias);
           return alias;
         }
 
         obj.value = value;
-        ctx.prevObjects.push(obj);
+        ctx.prevObjects.set(value, obj);
       }
 
-      obj.node = tagObj.createNode ? tagObj.createNode(this, value, ctx) : wrapScalars ? new _Scalar.default(value) : value;
+      obj.node = tagObj.createNode ? tagObj.createNode(this, value, ctx) : wrapScalars ? new Scalar(value) : value;
+      if (tag && obj.node instanceof Node) obj.node.tag = tag;
       return obj.node;
     }
   }, {
@@ -181,7 +162,7 @@ function () {
     value: function createPair(key, value, ctx) {
       var k = this.createNode(key, ctx.wrapScalars, null, ctx);
       var v = this.createNode(value, ctx.wrapScalars, null, ctx);
-      return new _Pair.default(k, v);
+      return new Pair(k, v);
     } // falls back to string on no match
 
   }, {
@@ -200,7 +181,7 @@ function () {
 
           if (match) {
             var res = resolve.apply(null, match);
-            if (!(res instanceof _Scalar.default)) res = new _Scalar.default(res);
+            if (!(res instanceof Scalar)) res = new Scalar(res);
             if (format) res.format = format;
             return res;
           }
@@ -208,7 +189,7 @@ function () {
       }
 
       if (this.tags.scalarFallback) str = this.tags.scalarFallback(str);
-      return new _Scalar.default(str);
+      return new Scalar(str);
     } // sets node.resolved on success
 
   }, {
@@ -227,16 +208,17 @@ function () {
       try {
         if (generic) {
           var res = generic.resolve(doc, node);
-          if (!(res instanceof _Collection.default)) res = new _Scalar.default(res);
+          if (!(res instanceof Collection)) res = new Scalar(res);
           node.resolved = res;
         } else {
-          var str = (0, _string.resolveString)(doc, node);
+          var str = resolveString(doc, node);
 
           if (typeof str === 'string' && tags.length > 0) {
             node.resolved = this.resolveScalar(str, tags);
           }
         }
       } catch (error) {
+        /* istanbul ignore if */
         if (!error.source) error.source = node;
         doc.errors.push(error);
         node.resolved = null;
@@ -250,26 +232,26 @@ function () {
     key: "resolveNodeWithFallback",
     value: function resolveNodeWithFallback(doc, node, tagName) {
       var res = this.resolveNode(doc, node, tagName);
-      if (node.hasOwnProperty('resolved')) return res;
+      if (Object.prototype.hasOwnProperty.call(node, 'resolved')) return res;
       var fallback = isMap(node) ? Schema.defaultTags.MAP : isSeq(node) ? Schema.defaultTags.SEQ : Schema.defaultTags.STR;
+      /* istanbul ignore else */
 
       if (fallback) {
-        doc.warnings.push(new _errors.YAMLWarning(node, "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback)));
+        doc.warnings.push(new YAMLWarning(node, "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback)));
 
         var _res = this.resolveNode(doc, node, fallback);
 
         _res.tag = tagName;
         return _res;
       } else {
-        doc.errors.push(new _errors.YAMLReferenceError(node, "The tag ".concat(tagName, " is unavailable")));
+        doc.errors.push(new YAMLReferenceError(node, "The tag ".concat(tagName, " is unavailable")));
+        return null;
       }
-
-      return null;
     }
   }, {
     key: "getTagObject",
     value: function getTagObject(item) {
-      if (item instanceof _Alias.default) return _Alias.default;
+      if (item instanceof Alias) return Alias;
 
       if (item.tag) {
         var match = this.tags.filter(function (t) {
@@ -282,7 +264,7 @@ function () {
 
       var tagObj, obj;
 
-      if (item instanceof _Scalar.default) {
+      if (item instanceof Scalar) {
         obj = item.value; // TODO: deprecate/remove class check
 
         var _match = this.tags.filter(function (t) {
@@ -302,7 +284,7 @@ function () {
       }
 
       if (!tagObj) {
-        var name = obj && obj.constructor ? obj.constructor.name : (0, _typeof2.default)(obj);
+        var name = obj && obj.constructor ? obj.constructor.name : _typeof(obj);
         throw new Error("Tag not resolved for ".concat(name, " value"));
       }
 
@@ -335,13 +317,13 @@ function () {
     value: function stringify(item, ctx, onComment, onChompKeep) {
       var tagObj;
 
-      if (!(item instanceof _Node.default)) {
+      if (!(item instanceof Node)) {
         var createCtx = {
           aliasNodes: [],
           onTagObj: function onTagObj(o) {
             return tagObj = o;
           },
-          prevObjects: []
+          prevObjects: new Map()
         };
         item = this.createNode(item, true, null, createCtx);
         var anchors = ctx.doc.anchors;
@@ -377,20 +359,24 @@ function () {
       }
 
       ctx.tags = this;
-      if (item instanceof _Pair.default) return item.toString(ctx, onComment, onChompKeep);
+      if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
       if (!tagObj) tagObj = this.getTagObject(item);
       var props = this.stringifyProps(item, tagObj, ctx);
-      var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof _Collection.default ? item.toString(ctx, onComment, onChompKeep) : (0, _stringify.stringifyString)(item, ctx, onComment, onChompKeep);
-      return props ? item instanceof _Collection.default && str[0] !== '{' && str[0] !== '[' ? "".concat(props, "\n").concat(ctx.indent).concat(str) : "".concat(props, " ").concat(str) : str;
+      if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
+      var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Collection ? item.toString(ctx, onComment, onChompKeep) : stringifyString(item, ctx, onComment, onChompKeep);
+      return props ? item instanceof Collection && str[0] !== '{' && str[0] !== '[' ? "".concat(props, "\n").concat(ctx.indent).concat(str) : "".concat(props, " ").concat(str) : str;
     }
   }]);
+
   return Schema;
 }();
 
-exports.default = Schema;
-(0, _defineProperty2.default)(Schema, "defaultPrefix", 'tag:yaml.org,2002:');
-(0, _defineProperty2.default)(Schema, "defaultTags", {
+_defineProperty(Schema, "defaultPrefix", 'tag:yaml.org,2002:');
+
+_defineProperty(Schema, "defaultTags", {
   MAP: 'tag:yaml.org,2002:map',
   SEQ: 'tag:yaml.org,2002:seq',
   STR: 'tag:yaml.org,2002:str'
-});
+});
+
+export { Schema as default };

package/browser/dist/schema/parseMap.js

@@ -1,78 +1,67 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parseMap;
-
-var _constants = require("../constants");
-
-var _PlainValue = _interopRequireDefault(require("../cst/PlainValue"));
-
-var _errors = require("../errors");
-
-var _Map = _interopRequireDefault(require("./Map"));
-
-var _Merge = _interopRequireWildcard(require("./Merge"));
-
-var _Pair = _interopRequireDefault(require("./Pair"));
-
-var _parseUtils = require("./parseUtils");
-
-var _Alias = _interopRequireDefault(require("./Alias"));
-
-function parseMap(doc, cst) {
-  if (cst.type !== _constants.Type.MAP && cst.type !== _constants.Type.FLOW_MAP) {
+import { Char, Type } from '../constants';
+import PlainValue from '../cst/PlainValue';
+import { YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from '../errors';
+import Map from './Map';
+import Merge, { MERGE_KEY } from './Merge';
+import Pair from './Pair';
+import { checkFlowCollectionEnd, checkKeyLength, resolveComments } from './parseUtils';
+import Alias from './Alias';
+import Collection from './Collection';
+export default function parseMap(doc, cst) {
+  if (cst.type !== Type.MAP && cst.type !== Type.FLOW_MAP) {
     var msg = "A ".concat(cst.type, " node cannot be resolved as a mapping");
-    doc.errors.push(new _errors.YAMLSyntaxError(cst, msg));
+    doc.errors.push(new YAMLSyntaxError(cst, msg));
     return null;
   }
 
-  var _ref = cst.type === _constants.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
+  var _ref = cst.type === Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
       comments = _ref.comments,
       items = _ref.items;
 
-  var map = new _Map.default();
+  var map = new Map();
   map.items = items;
-  (0, _parseUtils.resolveComments)(map, comments);
+  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.MERGE_KEY) {
-      items[i] = new _Merge.default(items[i]);
+    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.default) {
+        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 === _constants.Type.MAP || type === _constants.Type.FLOW_MAP) return false;
+          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 _errors.YAMLSemanticError(cst, error));
+      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 && iKey.hasOwnProperty('value') && iKey.value === jKey.value) {
+        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 _errors.YAMLSemanticError(cst, _msg));
+          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;
 }
@@ -86,7 +75,7 @@ var valueHasPairComment = function valueHasPairComment(_ref2) {
   if (props.length === 0) return false;
   var start = props[0].start;
   if (node && start > node.valueRange.start) return false;
-  if (src[start] !== _constants.Char.COMMENT) return false;
+  if (src[start] !== Char.COMMENT) return false;
 
   for (var i = lineStart; i < start; ++i) {
     if (src[i] === '\n') return false;
@@ -97,7 +86,7 @@ var valueHasPairComment = function valueHasPairComment(_ref2) {
 
 function resolvePairComment(item, pair) {
   if (!valueHasPairComment(item)) return;
-  var comment = item.getPropValue(0, _constants.Char.COMMENT, true);
+  var comment = item.getPropValue(0, Char.COMMENT, true);
   var found = false;
   var cb = pair.value.commentBefore;
 
@@ -126,14 +115,14 @@ function resolveBlockMapItems(doc, cst) {
     var item = cst.items[i];
 
     switch (item.type) {
-      case _constants.Type.BLANK_LINE:
+      case Type.BLANK_LINE:
         comments.push({
           afterKey: !!key,
           before: items.length
         });
         break;
 
-      case _constants.Type.COMMENT:
+      case Type.COMMENT:
         comments.push({
           afterKey: !!key,
           before: items.length,
@@ -141,21 +130,21 @@ function resolveBlockMapItems(doc, cst) {
         });
         break;
 
-      case _constants.Type.MAP_KEY:
-        if (key !== undefined) items.push(new _Pair.default(key));
+      case Type.MAP_KEY:
+        if (key !== undefined) items.push(new Pair(key));
         if (item.error) doc.errors.push(item.error);
         key = doc.resolveNode(item.node);
         keyStart = null;
         break;
 
-      case _constants.Type.MAP_VALUE:
+      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 === _constants.Type.MAP && !item.node.context.atLineStart) {
+          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 _errors.YAMLSemanticError(item.node, msg));
+            doc.errors.push(new YAMLSemanticError(item.node, msg));
           }
 
           var valueNode = item.node;
@@ -164,7 +153,7 @@ function resolveBlockMapItems(doc, cst) {
             // 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.default(_constants.Type.PLAIN, []);
+            valueNode = new PlainValue(Type.PLAIN, []);
             valueNode.context = {
               parent: item,
               src: item.context.src
@@ -186,17 +175,17 @@ function resolveBlockMapItems(doc, cst) {
             }
           }
 
-          var pair = new _Pair.default(key, doc.resolveNode(valueNode));
+          var pair = new Pair(key, doc.resolveNode(valueNode));
           resolvePairComment(item, pair);
           items.push(pair);
-          (0, _parseUtils.checkKeyLength)(doc.errors, cst, i, key, keyStart);
+          checkKeyLength(doc.errors, cst, i, key, keyStart);
           key = undefined;
           keyStart = null;
         }
         break;
 
       default:
-        if (key !== undefined) items.push(new _Pair.default(key));
+        if (key !== undefined) items.push(new Pair(key));
         key = doc.resolveNode(item);
         keyStart = item.range.start;
         if (item.error) doc.errors.push(item.error);
@@ -205,28 +194,28 @@ function resolveBlockMapItems(doc, cst) {
           var nextItem = cst.items[j];
 
           switch (nextItem && nextItem.type) {
-            case _constants.Type.BLANK_LINE:
-            case _constants.Type.COMMENT:
+            case Type.BLANK_LINE:
+            case Type.COMMENT:
               continue next;
 
-            case _constants.Type.MAP_VALUE:
+            case Type.MAP_VALUE:
               break next;
 
             default:
-              doc.errors.push(new _errors.YAMLSemanticError(item, 'Implicit map keys need to be followed by map values'));
+              doc.errors.push(new YAMLSemanticError(item, 'Implicit map keys need to be followed by map values'));
               break next;
           }
         }
 
         if (item.valueRangeContainsNewline) {
           var _msg2 = 'Implicit map keys need to be on a single line';
-          doc.errors.push(new _errors.YAMLSemanticError(item, _msg2));
+          doc.errors.push(new YAMLSemanticError(item, _msg2));
         }
 
     }
   }
 
-  if (key !== undefined) items.push(new _Pair.default(key));
+  if (key !== undefined) items.push(new Pair(key));
   return {
     comments: comments,
     items: items
@@ -242,11 +231,12 @@ function resolveFlowMapItems(doc, cst) {
   var next = '{';
 
   for (var i = 0; i < cst.items.length; ++i) {
-    (0, _parseUtils.checkKeyLength)(doc.errors, cst, i, key, keyStart);
+    checkKeyLength(doc.errors, cst, i, key, keyStart);
     var item = cst.items[i];
 
     if (typeof item.char === 'string') {
-      var char = item.char;
+      var char = item.char,
+          offset = item.offset;
 
       if (char === '?' && key === undefined && !explicitKey) {
         explicitKey = true;
@@ -268,7 +258,7 @@ function resolveFlowMapItems(doc, cst) {
         }
 
         if (key !== undefined) {
-          items.push(new _Pair.default(key));
+          items.push(new Pair(key));
           key = undefined;
           keyStart = null;
 
@@ -286,32 +276,35 @@ function resolveFlowMapItems(doc, cst) {
         continue;
       }
 
-      doc.errors.push(new _errors.YAMLSyntaxError(cst, "Flow map contains an unexpected ".concat(char)));
-    } else if (item.type === _constants.Type.BLANK_LINE) {
+      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 === _constants.Type.COMMENT) {
+    } else if (item.type === Type.COMMENT) {
       comments.push({
         afterKey: !!key,
         before: items.length,
         comment: item.comment
       });
     } else if (key === undefined) {
-      if (next === ',') doc.errors.push(new _errors.YAMLSemanticError(item, 'Separator , missing in flow map'));
+      if (next === ',') doc.errors.push(new YAMLSemanticError(item, 'Separator , missing in flow map'));
       key = doc.resolveNode(item);
       keyStart = explicitKey ? null : item.range.start; // TODO: add error for non-explicit multiline plain key
     } else {
-      if (next !== ',') doc.errors.push(new _errors.YAMLSemanticError(item, 'Indicator : missing in flow map entry'));
-      items.push(new _Pair.default(key, doc.resolveNode(item)));
+      if (next !== ',') doc.errors.push(new YAMLSemanticError(item, 'Indicator : missing in flow map entry'));
+      items.push(new Pair(key, doc.resolveNode(item)));
       key = undefined;
       explicitKey = false;
     }
   }
 
-  if (cst.items[cst.items.length - 1].char !== '}') doc.errors.push(new _errors.YAMLSemanticError(cst, 'Expected flow map to end with }'));
-  if (key !== undefined) items.push(new _Pair.default(key));
+  checkFlowCollectionEnd(doc.errors, cst);
+  if (key !== undefined) items.push(new Pair(key));
   return {
     comments: comments,
     items: items