yaml 1.6.0 → 1.8.0

package/browser/dist/schema/parseSeq.js

@@ -1,36 +1,31 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parseSeq;
-
-var _constants = require("../constants");
-
-var _errors = require("../errors");
-
-var _Pair = _interopRequireDefault(require("./Pair"));
-
-var _parseUtils = require("./parseUtils");
-
-var _Seq = _interopRequireDefault(require("./Seq"));
-
-function parseSeq(doc, cst) {
-  if (cst.type !== _constants.Type.SEQ && cst.type !== _constants.Type.FLOW_SEQ) {
+import { Type } from '../constants';
+import { YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from '../errors';
+import Pair from './Pair';
+import { checkFlowCollectionEnd, checkKeyLength, resolveComments } from './parseUtils';
+import Seq from './Seq';
+import Collection from './Collection';
+export default function parseSeq(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 _errors.YAMLSyntaxError(cst, msg));
+    doc.errors.push(new YAMLSyntaxError(cst, msg));
     return null;
   }
 
-  var _ref = cst.type === _constants.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
+  var _ref = cst.type === Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
       comments = _ref.comments,
       items = _ref.items;
 
-  var seq = new _Seq.default();
+  var seq = new Seq();
   seq.items = items;
-  (0, _parseUtils.resolveComments)(seq, comments);
+  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;
 }
@@ -43,33 +38,33 @@ function resolveBlockSeqItems(doc, cst) {
     var item = cst.items[i];
 
     switch (item.type) {
-      case _constants.Type.BLANK_LINE:
+      case Type.BLANK_LINE:
         comments.push({
           before: items.length
         });
         break;
 
-      case _constants.Type.COMMENT:
+      case Type.COMMENT:
         comments.push({
           comment: item.comment,
           before: items.length
         });
         break;
 
-      case _constants.Type.SEQ_ITEM:
+      case Type.SEQ_ITEM:
         if (item.error) doc.errors.push(item.error);
         items.push(doc.resolveNode(item.node));
 
         if (item.hasProps) {
           var msg = 'Sequence items cannot have tags or anchors before the - indicator';
-          doc.errors.push(new _errors.YAMLSemanticError(item, msg));
+          doc.errors.push(new YAMLSemanticError(item, msg));
         }
 
         break;
 
       default:
         if (item.error) doc.errors.push(item.error);
-        doc.errors.push(new _errors.YAMLSyntaxError(item, "Unexpected ".concat(item.type, " node in sequence")));
+        doc.errors.push(new YAMLSyntaxError(item, "Unexpected ".concat(item.type, " node in sequence")));
     }
   }
 
@@ -91,11 +86,12 @@ function resolveFlowSeqItems(doc, cst) {
     var item = cst.items[i];
 
     if (typeof item.char === 'string') {
-      var char = item.char;
+      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.default(key));
+        items.push(new Pair(key));
         explicitKey = false;
         key = undefined;
         keyStart = null;
@@ -109,12 +105,14 @@ function resolveFlowSeqItems(doc, cst) {
         if (next === ',') {
           key = items.pop();
 
-          if (key instanceof _Pair.default) {
-            var msg = 'Chaining flow sequence pairs is invalid (e.g. [ a : b : c ])';
-            doc.errors.push(new _errors.YAMLSemanticError(char, msg));
+          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) (0, _parseUtils.checkKeyLength)(doc.errors, cst, i, key, keyStart);
+          if (!explicitKey) checkKeyLength(doc.errors, cst, i, key, keyStart);
         } else {
           key = null;
         }
@@ -126,22 +124,25 @@ function resolveFlowSeqItems(doc, cst) {
       } else if (next === '[' || char !== ']' || i < cst.items.length - 1) {
         var _msg = "Flow sequence contains an unexpected ".concat(char);
 
-        doc.errors.push(new _errors.YAMLSyntaxError(cst, _msg));
+        var _err = new YAMLSyntaxError(cst, _msg);
+
+        _err.offset = offset;
+        doc.errors.push(_err);
       }
-    } else if (item.type === _constants.Type.BLANK_LINE) {
+    } else if (item.type === Type.BLANK_LINE) {
       comments.push({
         before: items.length
       });
-    } else if (item.type === _constants.Type.COMMENT) {
+    } else if (item.type === Type.COMMENT) {
       comments.push({
         comment: item.comment,
         before: items.length
       });
     } else {
       if (next) {
-        var _msg2 = "Expected a ".concat(next, " here in flow sequence");
+        var _msg2 = "Expected a ".concat(next, " in flow sequence");
 
-        doc.errors.push(new _errors.YAMLSemanticError(item, _msg2));
+        doc.errors.push(new YAMLSemanticError(item, _msg2));
       }
 
       var value = doc.resolveNode(item);
@@ -149,7 +150,7 @@ function resolveFlowSeqItems(doc, cst) {
       if (key === undefined) {
         items.push(value);
       } else {
-        items.push(new _Pair.default(key, value));
+        items.push(new Pair(key, value));
         key = undefined;
       }
 
@@ -158,8 +159,8 @@ function resolveFlowSeqItems(doc, cst) {
     }
   }
 
-  if (cst.items[cst.items.length - 1].char !== ']') doc.errors.push(new _errors.YAMLSemanticError(cst, 'Expected flow sequence 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

package/browser/dist/schema/parseUtils.js

@@ -1,14 +1,51 @@
-"use strict";
+import { YAMLSemanticError } from '../errors';
+import { Type } from '../constants';
+export function checkFlowCollectionEnd(errors, cst) {
+  var char, name;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.checkKeyLength = checkKeyLength;
-exports.resolveComments = resolveComments;
+  switch (cst.type) {
+    case Type.FLOW_MAP:
+      char = '}';
+      name = 'flow map';
+      break;
 
-var _errors = require("../errors");
+    case Type.FLOW_SEQ:
+      char = ']';
+      name = 'flow sequence';
+      break;
 
-function checkKeyLength(errors, node, itemIdx, key, keyStart) {
+    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);
+  }
+}
+export function checkKeyLength(errors, node, itemIdx, key, keyStart) {
   if (!key || typeof keyStart !== 'number') return;
   var item = node.items[itemIdx];
   var keyEnd = item && item.range && item.range.start;
@@ -26,11 +63,10 @@ function checkKeyLength(errors, node, itemIdx, key, keyStart) {
 
   if (keyEnd > keyStart + 1024) {
     var k = String(key).substr(0, 8) + '...' + String(key).substr(-8);
-    errors.push(new _errors.YAMLSemanticError(node, "The \"".concat(k, "\" key is too long")));
+    errors.push(new YAMLSemanticError(node, "The \"".concat(k, "\" key is too long")));
   }
 }
-
-function resolveComments(collection, comments) {
+export function resolveComments(collection, comments) {
   var _iteratorNormalCompletion = true;
   var _didIteratorError = false;
   var _iteratorError = undefined;

package/browser/dist/stringify.js

@@ -1,26 +1,20 @@
-"use strict";
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.stringifyNumber = stringifyNumber;
-exports.stringifyString = stringifyString;
-
-var _addComment = require("./addComment");
-
-var _constants = require("./constants");
-
-var _foldFlowLines = _interopRequireWildcard(require("./foldFlowLines"));
-
-var _options = require("./tags/options");
-
-function stringifyNumber(_ref) {
-  var format = _ref.format,
-      minFractionDigits = _ref.minFractionDigits,
-      tag = _ref.tag,
-      value = _ref.value;
+import { addCommentBefore } from './addComment';
+import { Type } from './constants';
+import foldFlowLines, { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED } from './foldFlowLines';
+import { strOptions } from './tags/options';
+
+var getFoldOptions = function getFoldOptions(_ref) {
+  var indentAtStart = _ref.indentAtStart;
+  return indentAtStart ? Object.assign({
+    indentAtStart: indentAtStart
+  }, strOptions.fold) : strOptions.fold;
+};
+
+export function stringifyNumber(_ref2) {
+  var format = _ref2.format,
+      minFractionDigits = _ref2.minFractionDigits,
+      tag = _ref2.tag,
+      value = _ref2.value;
   if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf';
   var n = JSON.stringify(value);
 
@@ -57,10 +51,10 @@ function lineLengthOverLimit(str, limit) {
   return true;
 }
 
-function doubleQuotedString(value, _ref2) {
-  var implicitKey = _ref2.implicitKey,
-      indent = _ref2.indent;
-  var _strOptions$doubleQuo = _options.strOptions.doubleQuoted,
+function doubleQuotedString(value, ctx) {
+  var implicitKey = ctx.implicitKey,
+      indent = ctx.indent;
+  var _strOptions$doubleQuo = strOptions.doubleQuoted,
       jsonEncoding = _strOptions$doubleQuo.jsonEncoding,
       minMultiLineLength = _strOptions$doubleQuo.minMultiLineLength;
   var json = JSON.stringify(value);
@@ -152,7 +146,7 @@ function doubleQuotedString(value, _ref2) {
   }
 
   str = start ? str + json.slice(start) : json;
-  return implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_QUOTED, _options.strOptions.fold);
+  return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
 }
 
 function singleQuotedString(value, ctx) {
@@ -167,7 +161,7 @@ function singleQuotedString(value, ctx) {
   }
 
   var res = "'" + value.replace(/'/g, "''").replace(/\n+/g, "$&\n".concat(indent)) + "'";
-  return implicitKey ? res : (0, _foldFlowLines.default)(res, indent, _foldFlowLines.FOLD_FLOW, _options.strOptions.fold);
+  return implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
 }
 
 function blockString(_ref3, ctx, onComment, onChompKeep) {
@@ -184,7 +178,7 @@ function blockString(_ref3, ctx, onComment, onChompKeep) {
   var indent = ctx.indent || (ctx.forceBlockIndent ? ' ' : '');
   var indentSize = indent ? '2' : '1'; // root is at -1
 
-  var literal = type === _constants.Type.BLOCK_FOLDED ? false : type === _constants.Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, _options.strOptions.fold.lineWidth - indent.length);
+  var literal = type === Type.BLOCK_FOLDED ? false : type === Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, strOptions.fold.lineWidth - indent.length);
   var header = literal ? '|' : '>';
   if (!value) return header + '\n';
   var wsStart = '';
@@ -232,7 +226,7 @@ function blockString(_ref3, ctx, onComment, onChompKeep) {
   value = value.replace(/\n+/g, '\n$&').replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
   //         ^ ind.line  ^ empty     ^ capture next empty lines only at end of indent
   .replace(/\n+/g, "$&".concat(indent));
-  var body = (0, _foldFlowLines.default)("".concat(wsStart).concat(value).concat(wsEnd), indent, _foldFlowLines.FOLD_BLOCK, _options.strOptions.fold);
+  var body = foldFlowLines("".concat(wsStart).concat(value).concat(wsEnd), indent, FOLD_BLOCK, strOptions.fold);
   return "".concat(header, "\n").concat(indent).concat(body);
 }
 
@@ -260,30 +254,31 @@ function plainString(item, ctx, onComment, onChompKeep) {
     return implicitKey || inFlow || value.indexOf('\n') === -1 ? value.indexOf('"') !== -1 && value.indexOf("'") === -1 ? singleQuotedString(value, ctx) : doubleQuotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
   }
 
-  if (!implicitKey && !inFlow && type !== _constants.Type.PLAIN && value.indexOf('\n') !== -1) {
+  if (!implicitKey && !inFlow && type !== Type.PLAIN && value.indexOf('\n') !== -1) {
     // Where allowed & type not set explicitly, prefer block style for multiline strings
     return blockString(item, ctx, onComment, onChompKeep);
   }
 
-  var str = value.replace(/\n+/g, "$&\n".concat(indent)); // May need to verify that output will be parsed as a string, as plain numbers
-  // and booleans get parsed with those types, e.g. '42', 'true' & '0.9e-3'.
+  var str = value.replace(/\n+/g, "$&\n".concat(indent)); // Verify that output will be parsed as a string, as e.g. plain numbers and
+  // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
+  // and others in v1.1.
 
-  if (actualString && /^[\w.+-]+$/.test(str) && typeof tags.resolveScalar(str).value !== 'string') {
+  if (actualString && typeof tags.resolveScalar(str).value !== 'string') {
     return doubleQuotedString(value, ctx);
   }
 
-  var body = implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_FLOW, _options.strOptions.fold);
+  var body = implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
 
   if (comment && !inFlow && (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
     if (onComment) onComment();
-    return (0, _addComment.addCommentBefore)(body, indent, comment);
+    return addCommentBefore(body, indent, comment);
   }
 
   return body;
 }
 
-function stringifyString(item, ctx, onComment, onChompKeep) {
-  var defaultType = _options.strOptions.defaultType;
+export function stringifyString(item, ctx, onComment, onChompKeep) {
+  var defaultType = strOptions.defaultType;
   var implicitKey = ctx.implicitKey,
       inFlow = ctx.inFlow;
   var _item = item,
@@ -299,17 +294,17 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
 
   var _stringify = function _stringify(_type) {
     switch (_type) {
-      case _constants.Type.BLOCK_FOLDED:
-      case _constants.Type.BLOCK_LITERAL:
+      case Type.BLOCK_FOLDED:
+      case Type.BLOCK_LITERAL:
         return blockString(item, ctx, onComment, onChompKeep);
 
-      case _constants.Type.QUOTE_DOUBLE:
+      case Type.QUOTE_DOUBLE:
         return doubleQuotedString(value, ctx);
 
-      case _constants.Type.QUOTE_SINGLE:
+      case Type.QUOTE_SINGLE:
         return singleQuotedString(value, ctx);
 
-      case _constants.Type.PLAIN:
+      case Type.PLAIN:
         return plainString(item, ctx, onComment, onChompKeep);
 
       default:
@@ -317,12 +312,12 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     }
   };
 
-  if (type !== _constants.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
+  if (type !== Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
     // force double quotes on control characters
-    type = _constants.Type.QUOTE_DOUBLE;
-  } else if ((implicitKey || inFlow) && (type === _constants.Type.BLOCK_FOLDED || type === _constants.Type.BLOCK_LITERAL)) {
+    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 = _constants.Type.QUOTE_DOUBLE;
+    type = Type.QUOTE_DOUBLE;
   }
 
   var res = _stringify(type);

package/browser/dist/tags/core.js

@@ -1,26 +1,13 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _Scalar = _interopRequireDefault(require("../schema/Scalar"));
-
-var _stringify = require("../stringify");
-
-var _failsafe = _interopRequireDefault(require("./failsafe"));
-
-var _options = require("./options");
-
-var _default = _failsafe.default.concat([{
+import Scalar from '../schema/Scalar';
+import { stringifyNumber } from '../stringify';
+import failsafe from './failsafe';
+import { boolOptions, nullOptions } from './options';
+export var nullObj = {
   identify: function identify(value) {
     return value == null;
   },
   createNode: function createNode(schema, value, ctx) {
-    return ctx.wrapScalars ? new _Scalar.default(null) : null;
+    return ctx.wrapScalars ? new Scalar(null) : null;
   },
   default: true,
   tag: 'tag:yaml.org,2002:null',
@@ -28,11 +15,12 @@ var _default = _failsafe.default.concat([{
   resolve: function resolve() {
     return null;
   },
-  options: _options.nullOptions,
+  options: nullOptions,
   stringify: function stringify() {
-    return _options.nullOptions.nullStr;
+    return nullOptions.nullStr;
   }
-}, {
+};
+export var boolObj = {
   identify: function identify(value) {
     return typeof value === 'boolean';
   },
@@ -42,12 +30,13 @@ var _default = _failsafe.default.concat([{
   resolve: function resolve(str) {
     return str[0] === 't' || str[0] === 'T';
   },
-  options: _options.boolOptions,
+  options: boolOptions,
   stringify: function stringify(_ref) {
     var value = _ref.value;
-    return value ? _options.boolOptions.trueStr : _options.boolOptions.falseStr;
+    return value ? boolOptions.trueStr : boolOptions.falseStr;
   }
-}, {
+};
+export var octObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -62,7 +51,8 @@ var _default = _failsafe.default.concat([{
     var value = _ref2.value;
     return '0o' + value.toString(8);
   }
-}, {
+};
+export var intObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -72,8 +62,9 @@ var _default = _failsafe.default.concat([{
   resolve: function resolve(str) {
     return parseInt(str, 10);
   },
-  stringify: _stringify.stringifyNumber
-}, {
+  stringify: stringifyNumber
+};
+export var hexObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -88,7 +79,8 @@ var _default = _failsafe.default.concat([{
     var value = _ref3.value;
     return '0x' + value.toString(16);
   }
-}, {
+};
+export var nanObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -98,8 +90,9 @@ var _default = _failsafe.default.concat([{
   resolve: function resolve(str, nan) {
     return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
   },
-  stringify: _stringify.stringifyNumber
-}, {
+  stringify: stringifyNumber
+};
+export var expObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -114,7 +107,8 @@ var _default = _failsafe.default.concat([{
     var value = _ref4.value;
     return Number(value).toExponential();
   }
-}, {
+};
+export var floatObj = {
   identify: function identify(value) {
     return typeof value === 'number';
   },
@@ -122,11 +116,10 @@ var _default = _failsafe.default.concat([{
   tag: 'tag:yaml.org,2002:float',
   test: /^[-+]?(?:0|[1-9][0-9]*)\.([0-9]*)$/,
   resolve: function resolve(str, frac) {
-    var node = new _Scalar.default(parseFloat(str));
+    var node = new Scalar(parseFloat(str));
     if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
     return node;
   },
-  stringify: _stringify.stringifyNumber
-}]);
-
-exports.default = _default;
+  stringify: stringifyNumber
+};
+export default failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);

package/browser/dist/tags/failsafe/index.js

@@ -1,17 +1,4 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _map = _interopRequireDefault(require("./map"));
-
-var _seq = _interopRequireDefault(require("./seq"));
-
-var _string = _interopRequireDefault(require("./string"));
-
-var _default = [_map.default, _seq.default, _string.default];
-exports.default = _default;
+import map from './map';
+import seq from './seq';
+import str from './string';
+export default [map, seq, str];

package/browser/dist/tags/failsafe/map.js

@@ -1,22 +1,10 @@
-"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 _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
-var _Map = _interopRequireDefault(require("../../schema/Map"));
-
-var _parseMap = _interopRequireDefault(require("../../schema/parseMap"));
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import YAMLMap from '../../schema/Map';
+import parseMap from '../../schema/parseMap';
 
 function createMap(schema, obj, ctx) {
-  var map = new _Map.default();
+  var map = new YAMLMap(schema);
 
   if (obj instanceof Map) {
     var _iteratorNormalCompletion = true;
@@ -25,7 +13,7 @@ function createMap(schema, obj, ctx) {
 
     try {
       for (var _iterator = obj[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+        var _step$value = _slicedToArray(_step.value, 2),
             key = _step$value[0],
             value = _step$value[1];
 
@@ -45,21 +33,24 @@ function createMap(schema, obj, ctx) {
         }
       }
     }
-  } else if (obj && (0, _typeof2.default)(obj) === 'object') {
+  } else if (obj && _typeof(obj) === 'object') {
     for (var _i = 0, _Object$keys = Object.keys(obj); _i < _Object$keys.length; _i++) {
-      var key = _Object$keys[_i];
-      map.items.push(schema.createPair(key, obj[key], ctx));
+      var _key = _Object$keys[_i];
+      map.items.push(schema.createPair(_key, obj[_key], ctx));
     }
   }
 
+  if (typeof schema.sortMapEntries === 'function') {
+    map.items.sort(schema.sortMapEntries);
+  }
+
   return map;
 }
 
-var _default = {
+export default {
   createNode: createMap,
   default: true,
-  nodeClass: _Map.default,
+  nodeClass: YAMLMap,
   tag: 'tag:yaml.org,2002:map',
-  resolve: _parseMap.default
-};
-exports.default = _default;
+  resolve: parseMap
+};