yaml 1.3.1 → 1.5.1

package/browser/dist/schema/parseMap.js

@@ -9,7 +9,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parseMap;
 
-var _Node = require("../cst/Node");
+var _constants = require("../constants");
 
 var _PlainValue = _interopRequireDefault(require("../cst/PlainValue"));
 
@@ -26,13 +26,13 @@ var _parseUtils = require("./parseUtils");
 var _Alias = _interopRequireDefault(require("./Alias"));
 
 function parseMap(doc, cst) {
-  if (cst.type !== _Node.Type.MAP && cst.type !== _Node.Type.FLOW_MAP) {
+  if (cst.type !== _constants.Type.MAP && cst.type !== _constants.Type.FLOW_MAP) {
     var msg = "A ".concat(cst.type, " node cannot be resolved as a mapping");
     doc.errors.push(new _errors.YAMLSyntaxError(cst, msg));
     return null;
   }
 
-  var _ref = cst.type === _Node.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
+  var _ref = cst.type === _constants.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst),
       comments = _ref.comments,
       items = _ref.items;
 
@@ -52,7 +52,7 @@ function parseMap(doc, cst) {
           // 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 === _Node.Type.MAP || type === _Node.Type.FLOW_MAP) return false;
+          if (type === _constants.Type.MAP || type === _constants.Type.FLOW_MAP) return false;
           return error = 'Merge nodes aliases can only point to maps';
         }
 
@@ -86,7 +86,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] !== _Node.Char.COMMENT) return false;
+  if (src[start] !== _constants.Char.COMMENT) return false;
 
   for (var i = lineStart; i < start; ++i) {
     if (src[i] === '\n') return false;
@@ -97,7 +97,7 @@ var valueHasPairComment = function valueHasPairComment(_ref2) {
 
 function resolvePairComment(item, pair) {
   if (!valueHasPairComment(item)) return;
-  var comment = item.getPropValue(0, _Node.Char.COMMENT, true);
+  var comment = item.getPropValue(0, _constants.Char.COMMENT, true);
   var found = false;
   var cb = pair.value.commentBefore;
 
@@ -126,14 +126,14 @@ function resolveBlockMapItems(doc, cst) {
     var item = cst.items[i];
 
     switch (item.type) {
-      case _Node.Type.BLANK_LINE:
+      case _constants.Type.BLANK_LINE:
         comments.push({
           afterKey: !!key,
           before: items.length
         });
         break;
 
-      case _Node.Type.COMMENT:
+      case _constants.Type.COMMENT:
         comments.push({
           afterKey: !!key,
           before: items.length,
@@ -141,19 +141,19 @@ function resolveBlockMapItems(doc, cst) {
         });
         break;
 
-      case _Node.Type.MAP_KEY:
+      case _constants.Type.MAP_KEY:
         if (key !== undefined) items.push(new _Pair.default(key));
         if (item.error) doc.errors.push(item.error);
         key = doc.resolveNode(item.node);
         keyStart = null;
         break;
 
-      case _Node.Type.MAP_VALUE:
+      case _constants.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 === _Node.Type.MAP && !item.node.context.atLineStart) {
+          if (!item.context.atLineStart && item.node && item.node.type === _constants.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));
           }
@@ -164,7 +164,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(_Node.Type.PLAIN, []);
+            valueNode = new _PlainValue.default(_constants.Type.PLAIN, []);
             valueNode.context = {
               parent: item,
               src: item.context.src
@@ -205,11 +205,11 @@ function resolveBlockMapItems(doc, cst) {
           var nextItem = cst.items[j];
 
           switch (nextItem && nextItem.type) {
-            case _Node.Type.BLANK_LINE:
-            case _Node.Type.COMMENT:
+            case _constants.Type.BLANK_LINE:
+            case _constants.Type.COMMENT:
               continue next;
 
-            case _Node.Type.MAP_VALUE:
+            case _constants.Type.MAP_VALUE:
               break next;
 
             default:
@@ -287,12 +287,12 @@ function resolveFlowMapItems(doc, cst) {
       }
 
       doc.errors.push(new _errors.YAMLSyntaxError(cst, "Flow map contains an unexpected ".concat(char)));
-    } else if (item.type === _Node.Type.BLANK_LINE) {
+    } else if (item.type === _constants.Type.BLANK_LINE) {
       comments.push({
         afterKey: !!key,
         before: items.length
       });
-    } else if (item.type === _Node.Type.COMMENT) {
+    } else if (item.type === _constants.Type.COMMENT) {
       comments.push({
         afterKey: !!key,
         before: items.length,
@@ -316,7 +316,4 @@ function resolveFlowMapItems(doc, cst) {
     comments: comments,
     items: items
   };
-}
-
-module.exports = exports.default;
-module.exports.default = exports.default;
+}

package/browser/dist/schema/parseSeq.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = parseSeq;
 
-var _Node = require("../cst/Node");
+var _constants = require("../constants");
 
 var _errors = require("../errors");
 
@@ -18,13 +18,13 @@ var _parseUtils = require("./parseUtils");
 var _Seq = _interopRequireDefault(require("./Seq"));
 
 function parseSeq(doc, cst) {
-  if (cst.type !== _Node.Type.SEQ && cst.type !== _Node.Type.FLOW_SEQ) {
+  if (cst.type !== _constants.Type.SEQ && cst.type !== _constants.Type.FLOW_SEQ) {
     var msg = "A ".concat(cst.type, " node cannot be resolved as a sequence");
     doc.errors.push(new _errors.YAMLSyntaxError(cst, msg));
     return null;
   }
 
-  var _ref = cst.type === _Node.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
+  var _ref = cst.type === _constants.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst),
       comments = _ref.comments,
       items = _ref.items;
 
@@ -43,20 +43,20 @@ function resolveBlockSeqItems(doc, cst) {
     var item = cst.items[i];
 
     switch (item.type) {
-      case _Node.Type.BLANK_LINE:
+      case _constants.Type.BLANK_LINE:
         comments.push({
           before: items.length
         });
         break;
 
-      case _Node.Type.COMMENT:
+      case _constants.Type.COMMENT:
         comments.push({
           comment: item.comment,
           before: items.length
         });
         break;
 
-      case _Node.Type.SEQ_ITEM:
+      case _constants.Type.SEQ_ITEM:
         if (item.error) doc.errors.push(item.error);
         items.push(doc.resolveNode(item.node));
 
@@ -128,11 +128,11 @@ function resolveFlowSeqItems(doc, cst) {
 
         doc.errors.push(new _errors.YAMLSyntaxError(cst, _msg));
       }
-    } else if (item.type === _Node.Type.BLANK_LINE) {
+    } else if (item.type === _constants.Type.BLANK_LINE) {
       comments.push({
         before: items.length
       });
-    } else if (item.type === _Node.Type.COMMENT) {
+    } else if (item.type === _constants.Type.COMMENT) {
       comments.push({
         comment: item.comment,
         before: items.length
@@ -164,7 +164,4 @@ function resolveFlowSeqItems(doc, cst) {
     comments: comments,
     items: items
   };
-}
-
-module.exports = exports.default;
-module.exports.default = exports.default;
+}

package/browser/dist/{schema/_string.js → stringify.js}

@@ -5,29 +5,44 @@ var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWild
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.stringify = stringify;
-exports.str = exports.resolve = exports.strOptions = void 0;
+exports.stringifyNumber = stringifyNumber;
+exports.stringifyString = stringifyString;
 
-var _addComment = require("../addComment");
+var _addComment = require("./addComment");
 
-var _Node = require("../cst/Node");
+var _constants = require("./constants");
 
-var _foldFlowLines = _interopRequireWildcard(require("../foldFlowLines"));
+var _foldFlowLines = _interopRequireWildcard(require("./foldFlowLines"));
 
-var strOptions = {
-  defaultType: _Node.Type.PLAIN,
-  doubleQuoted: {
-    jsonEncoding: false,
-    minMultiLineLength: 40
-  },
-  fold: {
-    lineWidth: 80,
-    minContentWidth: 20
+var _options = require("./tags/options");
+
+function stringifyNumber(_ref) {
+  var format = _ref.format,
+      minFractionDigits = _ref.minFractionDigits,
+      tag = _ref.tag,
+      value = _ref.value;
+  if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf';
+  var n = JSON.stringify(value);
+
+  if (!format && minFractionDigits && (!tag || tag === 'tag:yaml.org,2002:float') && /^\d/.test(n)) {
+    var i = n.indexOf('.');
+
+    if (i < 0) {
+      i = n.length;
+      n += '.';
+    }
+
+    var d = minFractionDigits - (n.length - i - 1);
+
+    while (d-- > 0) {
+      n += '0';
+    }
   }
-};
-exports.strOptions = strOptions;
 
-var lineLengthOverLimit = function lineLengthOverLimit(str, limit) {
+  return n;
+}
+
+function lineLengthOverLimit(str, limit) {
   var strLen = str.length;
   if (strLen <= limit) return false;
 
@@ -40,26 +55,12 @@ var lineLengthOverLimit = function lineLengthOverLimit(str, limit) {
   }
 
   return true;
-};
-
-var resolve = function resolve(doc, node) {
-  // on error, will return { str: string, errors: Error[] }
-  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;
-};
-
-exports.resolve = resolve;
+}
 
-function doubleQuotedString(value, _ref) {
-  var implicitKey = _ref.implicitKey,
-      indent = _ref.indent;
-  var _strOptions$doubleQuo = strOptions.doubleQuoted,
+function doubleQuotedString(value, _ref2) {
+  var implicitKey = _ref2.implicitKey,
+      indent = _ref2.indent;
+  var _strOptions$doubleQuo = _options.strOptions.doubleQuoted,
       jsonEncoding = _strOptions$doubleQuo.jsonEncoding,
       minMultiLineLength = _strOptions$doubleQuo.minMultiLineLength;
   var json = JSON.stringify(value);
@@ -151,7 +152,7 @@ function doubleQuotedString(value, _ref) {
   }
 
   str = start ? str + json.slice(start) : json;
-  return implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_QUOTED, strOptions.fold);
+  return implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_QUOTED, _options.strOptions.fold);
 }
 
 function singleQuotedString(value, ctx) {
@@ -166,13 +167,13 @@ 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, strOptions.fold);
+  return implicitKey ? res : (0, _foldFlowLines.default)(res, indent, _foldFlowLines.FOLD_FLOW, _options.strOptions.fold);
 }
 
-function blockString(_ref2, ctx, onComment, onChompKeep) {
-  var comment = _ref2.comment,
-      type = _ref2.type,
-      value = _ref2.value;
+function blockString(_ref3, ctx, onComment, onChompKeep) {
+  var comment = _ref3.comment,
+      type = _ref3.type,
+      value = _ref3.value;
 
   // 1. Block can't end in whitespace unless the last line is non-empty.
   // 2. Strings consisting of only whitespace are best rendered explicitly.
@@ -183,7 +184,7 @@ function blockString(_ref2, ctx, onComment, onChompKeep) {
   var indent = ctx.indent || (ctx.forceBlockIndent ? ' ' : '');
   var indentSize = indent ? '2' : '1'; // root is at -1
 
-  var literal = type === _Node.Type.BLOCK_FOLDED ? false : type === _Node.Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, strOptions.fold.lineWidth - indent.length);
+  var literal = type === _constants.Type.BLOCK_FOLDED ? false : type === _constants.Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, _options.strOptions.fold.lineWidth - indent.length);
   var header = literal ? '|' : '>';
   if (!value) return header + '\n';
   var wsStart = '';
@@ -231,7 +232,7 @@ function blockString(_ref2, 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, strOptions.fold);
+  var body = (0, _foldFlowLines.default)("".concat(wsStart).concat(value).concat(wsEnd), indent, _foldFlowLines.FOLD_BLOCK, _options.strOptions.fold);
   return "".concat(header, "\n").concat(indent).concat(body);
 }
 
@@ -239,7 +240,8 @@ function plainString(item, ctx, onComment, onChompKeep) {
   var comment = item.comment,
       type = item.type,
       value = item.value;
-  var implicitKey = ctx.implicitKey,
+  var actualString = ctx.actualString,
+      implicitKey = ctx.implicitKey,
       indent = ctx.indent,
       inFlow = ctx.inFlow,
       tags = ctx.tags;
@@ -258,19 +260,19 @@ 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 !== _Node.Type.PLAIN && value.indexOf('\n') !== -1) {
+  if (!implicitKey && !inFlow && type !== _constants.Type.PLAIN && value.indexOf('\n') !== -1) {
     // Where allowed & type not set explicitly, prefer block style for multiline strings
     return blockString(item, ctx, onComment, onChompKeep);
-  } // Need to verify that output will be parsed as a string
-
+  }
 
-  var str = value.replace(/\n+/g, "$&\n".concat(indent));
+  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'.
 
-  if (typeof tags.resolveScalar(str).value !== 'string') {
+  if (actualString && /^[\w.+-]+$/.test(str) && typeof tags.resolveScalar(str).value !== 'string') {
     return doubleQuotedString(value, ctx);
   }
 
-  var body = implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_FLOW, strOptions.fold);
+  var body = implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_FLOW, _options.strOptions.fold);
 
   if (comment && !inFlow && (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
     if (onComment) onComment();
@@ -280,8 +282,8 @@ function plainString(item, ctx, onComment, onChompKeep) {
   return body;
 }
 
-function stringify(item, ctx, onComment, onChompKeep) {
-  var defaultType = strOptions.defaultType;
+function stringifyString(item, ctx, onComment, onChompKeep) {
+  var defaultType = _options.strOptions.defaultType;
   var implicitKey = ctx.implicitKey,
       inFlow = ctx.inFlow;
   var _item = item,
@@ -297,17 +299,17 @@ function stringify(item, ctx, onComment, onChompKeep) {
 
   var _stringify = function _stringify(_type) {
     switch (_type) {
-      case _Node.Type.BLOCK_FOLDED:
-      case _Node.Type.BLOCK_LITERAL:
+      case _constants.Type.BLOCK_FOLDED:
+      case _constants.Type.BLOCK_LITERAL:
         return blockString(item, ctx, onComment, onChompKeep);
 
-      case _Node.Type.QUOTE_DOUBLE:
+      case _constants.Type.QUOTE_DOUBLE:
         return doubleQuotedString(value, ctx);
 
-      case _Node.Type.QUOTE_SINGLE:
+      case _constants.Type.QUOTE_SINGLE:
         return singleQuotedString(value, ctx);
 
-      case _Node.Type.PLAIN:
+      case _constants.Type.PLAIN:
         return plainString(item, ctx, onComment, onChompKeep);
 
       default:
@@ -315,12 +317,12 @@ function stringify(item, ctx, onComment, onChompKeep) {
     }
   };
 
-  if (type !== _Node.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
+  if (type !== _constants.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
     // force double quotes on control characters
-    type = _Node.Type.QUOTE_DOUBLE;
-  } else if ((implicitKey || inFlow) && (type === _Node.Type.BLOCK_FOLDED || type === _Node.Type.BLOCK_LITERAL)) {
+    type = _constants.Type.QUOTE_DOUBLE;
+  } else if ((implicitKey || inFlow) && (type === _constants.Type.BLOCK_FOLDED || type === _constants.Type.BLOCK_LITERAL)) {
     // should not happen; blocks are not valid inside flow containers
-    type = _Node.Type.QUOTE_DOUBLE;
+    type = _constants.Type.QUOTE_DOUBLE;
   }
 
   var res = _stringify(type);
@@ -331,14 +333,4 @@ function stringify(item, ctx, onComment, onChompKeep) {
   }
 
   return res;
-}
-
-var str = {
-  class: String,
-  default: true,
-  tag: 'tag:yaml.org,2002:str',
-  resolve: resolve,
-  stringify: stringify,
-  options: strOptions
-};
-exports.str = str;
+}

package/browser/dist/tags/core.js

@@ -0,0 +1,132 @@
+"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([{
+  identify: function identify(value) {
+    return value == null;
+  },
+  createNode: function createNode(schema, value, ctx) {
+    return ctx.wrapScalars ? new _Scalar.default(null) : null;
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:null',
+  test: /^(?:~|[Nn]ull|NULL)?$/,
+  resolve: function resolve() {
+    return null;
+  },
+  options: _options.nullOptions,
+  stringify: function stringify() {
+    return _options.nullOptions.nullStr;
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'boolean';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:bool',
+  test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+  resolve: function resolve(str) {
+    return str[0] === 't' || str[0] === 'T';
+  },
+  options: _options.boolOptions,
+  stringify: function stringify(_ref) {
+    var value = _ref.value;
+    return value ? _options.boolOptions.trueStr : _options.boolOptions.falseStr;
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'OCT',
+  test: /^0o([0-7]+)$/,
+  resolve: function resolve(str, oct) {
+    return parseInt(oct, 8);
+  },
+  stringify: function stringify(_ref2) {
+    var value = _ref2.value;
+    return '0o' + value.toString(8);
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  test: /^[-+]?[0-9]+$/,
+  resolve: function resolve(str) {
+    return parseInt(str, 10);
+  },
+  stringify: _stringify.stringifyNumber
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:int',
+  format: 'HEX',
+  test: /^0x([0-9a-fA-F]+)$/,
+  resolve: function resolve(str, hex) {
+    return parseInt(hex, 16);
+  },
+  stringify: function stringify(_ref3) {
+    var value = _ref3.value;
+    return '0x' + value.toString(16);
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  test: /^(?:[-+]?\.inf|(\.nan))$/i,
+  resolve: function resolve(str, nan) {
+    return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+  },
+  stringify: _stringify.stringifyNumber
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  tag: 'tag:yaml.org,2002:float',
+  format: 'EXP',
+  test: /^[-+]?(?:0|[1-9][0-9]*)(\.[0-9]*)?[eE][-+]?[0-9]+$/,
+  resolve: function resolve(str) {
+    return parseFloat(str);
+  },
+  stringify: function stringify(_ref4) {
+    var value = _ref4.value;
+    return Number(value).toExponential();
+  }
+}, {
+  identify: function identify(value) {
+    return typeof value === 'number';
+  },
+  default: true,
+  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));
+    if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
+    return node;
+  },
+  stringify: _stringify.stringifyNumber
+}]);
+
+exports.default = _default;

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

@@ -0,0 +1,17 @@
+"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;

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

@@ -0,0 +1,65 @@
+"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"));
+
+function createMap(schema, obj, ctx) {
+  var map = new _Map.default();
+
+  if (obj instanceof Map) {
+    var _iteratorNormalCompletion = true;
+    var _didIteratorError = false;
+    var _iteratorError = undefined;
+
+    try {
+      for (var _iterator = obj[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+            key = _step$value[0],
+            value = _step$value[1];
+
+        map.items.push(schema.createPair(key, value, ctx));
+      }
+    } catch (err) {
+      _didIteratorError = true;
+      _iteratorError = err;
+    } finally {
+      try {
+        if (!_iteratorNormalCompletion && _iterator.return != null) {
+          _iterator.return();
+        }
+      } finally {
+        if (_didIteratorError) {
+          throw _iteratorError;
+        }
+      }
+    }
+  } else if (obj && (0, _typeof2.default)(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));
+    }
+  }
+
+  return map;
+}
+
+var _default = {
+  createNode: createMap,
+  default: true,
+  nodeClass: _Map.default,
+  tag: 'tag:yaml.org,2002:map',
+  resolve: _parseMap.default
+};
+exports.default = _default;