yaml 1.8.2 → 1.9.2

package/browser/dist/schema/Pair.js

@@ -1,16 +1,23 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import _typeof from "@babel/runtime/helpers/typeof";
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
 // Published as 'yaml/pair'
-import addComment from '../addComment';
+import { addComment } from '../addComment';
 import { Type } from '../constants';
-import toJSON from '../toJSON';
-import Collection from './Collection';
-import Node from './Node';
-import Scalar from './Scalar';
+import { toJSON } from '../toJSON';
+import { Collection } from './Collection';
+import { Node } from './Node';
+import { Scalar } from './Scalar';
+import { YAMLSeq } from './Seq';
 
 var stringifyKey = function stringifyKey(key, jsKey, ctx) {
   if (jsKey === null) return '';
@@ -19,15 +26,18 @@ var stringifyKey = function stringifyKey(key, jsKey, ctx) {
     anchors: {},
     doc: ctx.doc,
     indent: '',
+    indentStep: ctx.indentStep,
     inFlow: true,
     inStringifyKey: true
   });
   return JSON.stringify(jsKey);
 };
 
-var Pair = /*#__PURE__*/function (_Node) {
+export var Pair = /*#__PURE__*/function (_Node) {
   _inherits(Pair, _Node);
 
+  var _super = _createSuper(Pair);
+
   function Pair(key) {
     var _this;
 
@@ -35,10 +45,10 @@ var Pair = /*#__PURE__*/function (_Node) {
 
     _classCallCheck(this, Pair);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Pair).call(this));
+    _this = _super.call(this);
     _this.key = key;
     _this.value = value;
-    _this.type = 'PAIR';
+    _this.type = Pair.Type.PAIR;
     return _this;
   }
 
@@ -69,7 +79,10 @@ var Pair = /*#__PURE__*/function (_Node) {
     key: "toString",
     value: function toString(ctx, onComment, onChompKeep) {
       if (!ctx || !ctx.doc) return JSON.stringify(this);
-      var simpleKeys = ctx.doc.options.simpleKeys;
+      var _ctx$doc$options = ctx.doc.options,
+          indentSize = _ctx$doc$options.indent,
+          indentSeq = _ctx$doc$options.indentSeq,
+          simpleKeys = _ctx$doc$options.simpleKeys;
       var key = this.key,
           value = this.value;
       var keyComment = key instanceof Node && key.comment;
@@ -88,10 +101,11 @@ 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,
           doc = _ctx.doc,
-          indent = _ctx.indent;
+          indent = _ctx.indent,
+          indentStep = _ctx.indentStep;
       ctx = Object.assign({}, ctx, {
         implicitKey: !explicitKey,
-        indent: indent + '  '
+        indent: indent + indentStep
       });
       var chompKeep = false;
       var str = doc.schema.stringify(key, ctx, function () {
@@ -137,6 +151,12 @@ var Pair = /*#__PURE__*/function (_Node) {
       ctx.implicitKey = false;
       if (!explicitKey && !this.comment && value instanceof Scalar) ctx.indentAtStart = str.length + 1;
       chompKeep = false;
+
+      if (!indentSeq && indentSize >= 2 && !ctx.inFlow && !explicitKey && value instanceof YAMLSeq && value.type !== Type.FLOW_SEQ && !value.tag && !doc.anchors.getName(value)) {
+        // If indentSeq === false, consider '- ' as part of indentation where possible
+        ctx.indent = ctx.indent.substr(2);
+      }
+
       var valueStr = doc.schema.stringify(value, ctx, function () {
         return valueComment = null;
       }, function () {
@@ -168,4 +188,7 @@ var Pair = /*#__PURE__*/function (_Node) {
   return Pair;
 }(Node);
 
-export { Pair as default };
+_defineProperty(Pair, "Type", {
+  PAIR: 'PAIR',
+  MERGE_PAIR: 'MERGE_PAIR'
+});

package/browser/dist/schema/Scalar.js

@@ -1,21 +1,27 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
+import _inherits from "@babel/runtime/helpers/inherits";
 import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
 import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
-import _inherits from "@babel/runtime/helpers/inherits";
-// Published as 'yaml/scalar'
-import _toJSON from '../toJSON';
-import Node from './Node';
 
-var Scalar = /*#__PURE__*/function (_Node) {
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+// Published as 'yaml/scalar'
+import { toJSON as _toJSON } from '../toJSON';
+import { Node } from './Node';
+export var Scalar = /*#__PURE__*/function (_Node) {
   _inherits(Scalar, _Node);
 
+  var _super = _createSuper(Scalar);
+
   function Scalar(value) {
     var _this;
 
     _classCallCheck(this, Scalar);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Scalar).call(this));
+    _this = _super.call(this);
     _this.value = value;
     return _this;
   }
@@ -33,6 +39,4 @@ var Scalar = /*#__PURE__*/function (_Node) {
   }]);
 
   return Scalar;
-}(Node);
-
-export { Scalar as default };
+}(Node);

package/browser/dist/schema/Seq.js

@@ -1,13 +1,24 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _get from "@babel/runtime/helpers/get";
 import _inherits from "@babel/runtime/helpers/inherits";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _createSuper(Derived) { return function () { var Super = _getPrototypeOf(Derived), result; if (_isNativeReflectConstruct()) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
 // Published as 'yaml/seq'
-import _toJSON from '../toJSON';
-import Collection from './Collection';
-import Scalar from './Scalar';
+import { toJSON as _toJSON } from '../toJSON';
+import { Collection } from './Collection';
+import { Scalar } from './Scalar';
 
 function asItemIndex(key) {
   var idx = key instanceof Scalar ? key.value : key;
@@ -15,13 +26,15 @@ function asItemIndex(key) {
   return Number.isInteger(idx) && idx >= 0 ? idx : null;
 }
 
-var YAMLSeq = /*#__PURE__*/function (_Collection) {
+export var YAMLSeq = /*#__PURE__*/function (_Collection) {
   _inherits(YAMLSeq, _Collection);
 
+  var _super = _createSuper(YAMLSeq);
+
   function YAMLSeq() {
     _classCallCheck(this, YAMLSeq);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSeq).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(YAMLSeq, [{
@@ -64,28 +77,19 @@ var YAMLSeq = /*#__PURE__*/function (_Collection) {
       var seq = [];
       if (ctx && ctx.onCreate) ctx.onCreate(seq);
       var i = 0;
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
+
+      var _iterator = _createForOfIteratorHelper(this.items),
+          _step;
 
       try {
-        for (var _iterator = this.items[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var item = _step.value;
           seq.push(_toJSON(item, String(i++), ctx));
         }
       } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
+        _iterator.e(err);
       } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
+        _iterator.f();
       }
 
       return seq;
@@ -109,6 +113,4 @@ var YAMLSeq = /*#__PURE__*/function (_Collection) {
   }]);
 
   return YAMLSeq;
-}(Collection);
-
-export { YAMLSeq as default };
+}(Collection);

package/browser/dist/schema/index.js

@@ -2,17 +2,24 @@ 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";
+
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 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';
+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;
@@ -24,7 +31,7 @@ var isSeq = function isSeq(_ref2) {
   return type === Type.FLOW_SEQ || type === Type.SEQ;
 };
 
-var Schema = /*#__PURE__*/function () {
+export var Schema = /*#__PURE__*/function () {
   function Schema(_ref3) {
     var customTags = _ref3.customTags,
         merge = _ref3.merge,
@@ -54,28 +61,18 @@ var Schema = /*#__PURE__*/function () {
     }
 
     if (Array.isArray(customTags)) {
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
+      var _iterator = _createForOfIteratorHelper(customTags),
+          _step;
 
       try {
-        for (var _iterator = customTags[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var tag = _step.value;
           this.tags = this.tags.concat(tag);
         }
       } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
+        _iterator.e(err);
       } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator.return != null) {
-            _iterator.return();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
+        _iterator.f();
       }
     } else if (typeof customTags === 'function') {
       this.tags = customTags(this.tags.slice());
@@ -327,12 +324,12 @@ var Schema = /*#__PURE__*/function () {
         };
         item = this.createNode(item, true, null, createCtx);
         var anchors = ctx.doc.anchors;
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
+
+        var _iterator2 = _createForOfIteratorHelper(createCtx.aliasNodes),
+            _step2;
 
         try {
-          for (var _iterator2 = createCtx.aliasNodes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var alias = _step2.value;
             alias.source = alias.source.node;
             var name = anchors.getName(alias.source);
@@ -343,18 +340,9 @@ var Schema = /*#__PURE__*/function () {
             }
           }
         } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
+          _iterator2.e(err);
         } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
+          _iterator2.f();
         }
       }
 
@@ -377,6 +365,4 @@ _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,13 +1,13 @@
 import { Char, Type } from '../constants';
-import PlainValue from '../cst/PlainValue';
+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 { YAMLMap } 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) {
+import { Alias } from './Alias';
+import { Collection } from './Collection';
+export 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 YAMLSyntaxError(cst, msg));
@@ -18,7 +18,7 @@ export default function parseMap(doc, cst) {
       comments = _ref.comments,
       items = _ref.items;
 
-  var map = new Map();
+  var map = new YAMLMap();
   map.items = items;
   resolveComments(map, comments);
   var hasCollectionKey = false;

package/browser/dist/schema/parseSeq.js

@@ -1,10 +1,10 @@
 import { Type } from '../constants';
 import { YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from '../errors';
-import Pair from './Pair';
+import { Pair } from './Pair';
 import { checkFlowCollectionEnd, checkKeyLength, resolveComments } from './parseUtils';
-import Seq from './Seq';
-import Collection from './Collection';
-export default function parseSeq(doc, cst) {
+import { YAMLSeq } from './Seq';
+import { Collection } from './Collection';
+export 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 YAMLSyntaxError(cst, msg));
@@ -15,7 +15,7 @@ export default function parseSeq(doc, cst) {
       comments = _ref.comments,
       items = _ref.items;
 
-  var seq = new Seq();
+  var seq = new YAMLSeq();
   seq.items = items;
   resolveComments(seq, comments);
 

package/browser/dist/schema/parseUtils.js

@@ -1,3 +1,9 @@
+function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 import { YAMLSemanticError } from '../errors';
 import { Type } from '../constants';
 export function checkFlowCollectionEnd(errors, cst) {
@@ -67,12 +73,11 @@ export function checkKeyLength(errors, node, itemIdx, key, keyStart) {
   }
 }
 export function resolveComments(collection, comments) {
-  var _iteratorNormalCompletion = true;
-  var _didIteratorError = false;
-  var _iteratorError = undefined;
+  var _iterator = _createForOfIteratorHelper(comments),
+      _step;
 
   try {
-    for (var _iterator = comments[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var _step$value = _step.value,
           afterKey = _step$value.afterKey,
           before = _step$value.before,
@@ -94,17 +99,8 @@ export function resolveComments(collection, comments) {
       }
     }
   } catch (err) {
-    _didIteratorError = true;
-    _iteratorError = err;
+    _iterator.e(err);
   } finally {
-    try {
-      if (!_iteratorNormalCompletion && _iterator.return != null) {
-        _iterator.return();
-      }
-    } finally {
-      if (_didIteratorError) {
-        throw _iteratorError;
-      }
-    }
+    _iterator.f();
   }
 }

package/browser/dist/stringify.js

@@ -1,6 +1,6 @@
 import { addCommentBefore } from './addComment';
 import { Type } from './constants';
-import foldFlowLines, { FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED } from './foldFlowLines';
+import { foldFlowLines, FOLD_BLOCK, FOLD_FLOW, FOLD_QUOTED } from './foldFlowLines';
 import { strOptions } from './tags/options';
 
 var getFoldOptions = function getFoldOptions(_ref) {
@@ -15,6 +15,7 @@ export function stringifyNumber(_ref2) {
       minFractionDigits = _ref2.minFractionDigits,
       tag = _ref2.tag,
       value = _ref2.value;
+  if (typeof value === 'bigint') return String(value);
   if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf';
   var n = JSON.stringify(value);
 

package/browser/dist/tags/core.js

@@ -1,7 +1,23 @@
-import Scalar from '../schema/Scalar';
+/* global BigInt */
+import { Scalar } from '../schema/Scalar';
 import { stringifyNumber } from '../stringify';
-import failsafe from './failsafe';
-import { boolOptions, nullOptions } from './options';
+import { failsafe } from './failsafe';
+import { boolOptions, intOptions, nullOptions } from './options';
+
+var intIdentify = function intIdentify(value) {
+  return typeof value === 'bigint' || Number.isInteger(value);
+};
+
+var intResolve = function intResolve(src, part, radix) {
+  return intOptions.asBigInt ? BigInt(src) : parseInt(part, radix);
+};
+
+function intStringify(node, radix, prefix) {
+  var value = node.value;
+  if (intIdentify(value) && value >= 0) return prefix + value.toString(radix);
+  return stringifyNumber(node);
+}
+
 export var nullObj = {
   identify: function identify(value) {
     return value == null;
@@ -38,46 +54,45 @@ export var boolObj = {
 };
 export var octObj = {
   identify: function identify(value) {
-    return typeof value === 'number';
+    return intIdentify(value) && value >= 0;
   },
   default: true,
   tag: 'tag:yaml.org,2002:int',
   format: 'OCT',
   test: /^0o([0-7]+)$/,
   resolve: function resolve(str, oct) {
-    return parseInt(oct, 8);
+    return intResolve(str, oct, 8);
   },
-  stringify: function stringify(_ref2) {
-    var value = _ref2.value;
-    return '0o' + value.toString(8);
+  options: intOptions,
+  stringify: function stringify(node) {
+    return intStringify(node, 8, '0o');
   }
 };
 export var intObj = {
-  identify: function identify(value) {
-    return typeof value === 'number';
-  },
+  identify: intIdentify,
   default: true,
   tag: 'tag:yaml.org,2002:int',
   test: /^[-+]?[0-9]+$/,
   resolve: function resolve(str) {
-    return parseInt(str, 10);
+    return intResolve(str, str, 10);
   },
+  options: intOptions,
   stringify: stringifyNumber
 };
 export var hexObj = {
   identify: function identify(value) {
-    return typeof value === 'number';
+    return intIdentify(value) && value >= 0;
   },
   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);
+    return intResolve(str, hex, 16);
   },
-  stringify: function stringify(_ref3) {
-    var value = _ref3.value;
-    return '0x' + value.toString(16);
+  options: intOptions,
+  stringify: function stringify(node) {
+    return intStringify(node, 16, '0x');
   }
 };
 export var nanObj = {
@@ -99,12 +114,12 @@ export var expObj = {
   default: true,
   tag: 'tag:yaml.org,2002:float',
   format: 'EXP',
-  test: /^[-+]?(?:0|[1-9][0-9]*)(\.[0-9]*)?[eE][-+]?[0-9]+$/,
+  test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
   resolve: function resolve(str) {
     return parseFloat(str);
   },
-  stringify: function stringify(_ref4) {
-    var value = _ref4.value;
+  stringify: function stringify(_ref2) {
+    var value = _ref2.value;
     return Number(value).toExponential();
   }
 };
@@ -114,12 +129,13 @@ export var floatObj = {
   },
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^[-+]?(?:0|[1-9][0-9]*)\.([0-9]*)$/,
-  resolve: function resolve(str, frac) {
+  test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
+  resolve: function resolve(str, frac1, frac2) {
+    var frac = frac1 || frac2;
     var node = new Scalar(parseFloat(str));
     if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
     return node;
   },
   stringify: stringifyNumber
 };
-export default failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);
+export var core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);

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

@@ -1,4 +1,4 @@
-import map from './map';
-import seq from './seq';
-import str from './string';
-export default [map, seq, str];
+import { map } from './map';
+import { seq } from './seq';
+import { string } from './string';
+export var failsafe = [map, seq, string];