yaml 1.8.1 → 1.9.1

package/browser/dist/cst/Document.js

@@ -1,21 +1,27 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
-import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
-import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
 import _get from "@babel/runtime/helpers/get";
 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";
+
+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; } }
+
 import { Char, Type } from '../constants';
 import { YAMLSemanticError, YAMLSyntaxError } from '../errors';
-import BlankLine from './BlankLine';
+import { BlankLine } from './BlankLine';
 import { grabCollectionEndComments } from './Collection';
-import Comment from './Comment';
-import Directive from './Directive';
-import Node from './Node';
-import Range from './Range';
-
-var Document = /*#__PURE__*/function (_Node) {
+import { Comment } from './Comment';
+import { Directive } from './Directive';
+import { Node } from './Node';
+import { Range } from './Range';
+export var Document = /*#__PURE__*/function (_Node) {
   _inherits(Document, _Node);
 
+  var _super = _createSuper(Document);
+
   _createClass(Document, null, [{
     key: "startCommentOrEndBlankLine",
     value: function startCommentOrEndBlankLine(src, start) {
@@ -30,7 +36,7 @@ var Document = /*#__PURE__*/function (_Node) {
 
     _classCallCheck(this, Document);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Document).call(this, Type.DOCUMENT));
+    _this = _super.call(this, Type.DOCUMENT);
     _this.directives = null;
     _this.contents = null;
     _this.directivesEndMarker = null;
@@ -277,6 +283,4 @@ var Document = /*#__PURE__*/function (_Node) {
   }]);
 
   return Document;
-}(Node);
-
-export { Document as default };
+}(Node);

package/browser/dist/cst/FlowCollection.js

@@ -1,25 +1,31 @@
 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 _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; } }
+
 import { Type } from '../constants';
 import { YAMLSemanticError } from '../errors';
-import BlankLine from './BlankLine';
-import Comment from './Comment';
-import Node from './Node';
-import Range from './Range';
-
-var FlowCollection = /*#__PURE__*/function (_Node) {
+import { BlankLine } from './BlankLine';
+import { Comment } from './Comment';
+import { Node } from './Node';
+import { Range } from './Range';
+export var FlowCollection = /*#__PURE__*/function (_Node) {
   _inherits(FlowCollection, _Node);
 
+  var _super = _createSuper(FlowCollection);
+
   function FlowCollection(type, props) {
     var _this;
 
     _classCallCheck(this, FlowCollection);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(FlowCollection).call(this, type, props));
+    _this = _super.call(this, type, props);
     _this.items = null;
     return _this;
   }
@@ -29,7 +35,7 @@ var FlowCollection = /*#__PURE__*/function (_Node) {
     value: function prevNodeIsJsonLike() {
       var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.items.length;
       var node = this.items[idx - 1];
-      return !!node && (node.jsonLike || node.type === Type.COMMENT && this.nodeIsJsonLike(idx - 1));
+      return !!node && (node.jsonLike || node.type === Type.COMMENT && this.prevNodeIsJsonLike(idx - 1));
     }
     /**
      * @param {ParseContext} context
@@ -211,6 +217,4 @@ var FlowCollection = /*#__PURE__*/function (_Node) {
   }]);
 
   return FlowCollection;
-}(Node);
-
-export { FlowCollection as default };
+}(Node);

package/browser/dist/cst/Node.js

@@ -3,10 +3,10 @@ import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import { Char, Type } from '../constants';
 import { getLinePos } from './source-utils';
-import Range from './Range';
+import { Range } from './Range';
 /** Root class of all nodes */
 
-var Node = /*#__PURE__*/function () {
+export var Node = /*#__PURE__*/function () {
   _createClass(Node, null, [{
     key: "addStringTerminator",
     value: function addStringTerminator(src, offset, str) {
@@ -383,6 +383,4 @@ var Node = /*#__PURE__*/function () {
   }]);
 
   return Node;
-}();
-
-export { Node as default };
+}();

package/browser/dist/cst/ParseContext.js

@@ -3,16 +3,16 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 import { Char, Type } from '../constants';
 import { YAMLSyntaxError } from '../errors';
-import Alias from './Alias';
-import BlockValue from './BlockValue';
-import Collection from './Collection';
-import CollectionItem from './CollectionItem';
-import FlowCollection from './FlowCollection';
-import Node from './Node';
-import PlainValue from './PlainValue';
-import QuoteDouble from './QuoteDouble';
-import QuoteSingle from './QuoteSingle';
-import Range from './Range';
+import { Alias } from './Alias';
+import { BlockValue } from './BlockValue';
+import { Collection } from './Collection';
+import { CollectionItem } from './CollectionItem';
+import { FlowCollection } from './FlowCollection';
+import { Node } from './Node';
+import { PlainValue } from './PlainValue';
+import { QuoteDouble } from './QuoteDouble';
+import { QuoteSingle } from './QuoteSingle';
+import { Range } from './Range';
 
 function createNewNode(type, props) {
   switch (type) {
@@ -60,7 +60,7 @@ function createNewNode(type, props) {
  */
 
 
-var ParseContext = /*#__PURE__*/function () {
+export var ParseContext = /*#__PURE__*/function () {
   _createClass(ParseContext, null, [{
     key: "parseType",
     value: function parseType(src, offset, inFlow) {
@@ -243,6 +243,4 @@ var ParseContext = /*#__PURE__*/function () {
   }]);
 
   return ParseContext;
-}();
-
-export { ParseContext as default };
+}();

package/browser/dist/cst/PlainValue.js

@@ -1,18 +1,24 @@
 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 Node from './Node';
-import Range from './Range';
 
-var PlainValue = /*#__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; } }
+
+import { Node } from './Node';
+import { Range } from './Range';
+export var PlainValue = /*#__PURE__*/function (_Node) {
   _inherits(PlainValue, _Node);
 
+  var _super = _createSuper(PlainValue);
+
   function PlainValue() {
     _classCallCheck(this, PlainValue);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(PlainValue).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(PlainValue, [{
@@ -161,6 +167,4 @@ var PlainValue = /*#__PURE__*/function (_Node) {
   }]);
 
   return PlainValue;
-}(Node);
-
-export { PlainValue as default };
+}(Node);

package/browser/dist/cst/QuoteDouble.js

@@ -1,19 +1,25 @@
 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 { YAMLSemanticError, YAMLSyntaxError } from '../errors';
-import Node from './Node';
-import Range from './Range';
 
-var QuoteDouble = /*#__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; } }
+
+import { YAMLSemanticError, YAMLSyntaxError } from '../errors';
+import { Node } from './Node';
+import { Range } from './Range';
+export var QuoteDouble = /*#__PURE__*/function (_Node) {
   _inherits(QuoteDouble, _Node);
 
+  var _super = _createSuper(QuoteDouble);
+
   function QuoteDouble() {
     _classCallCheck(this, QuoteDouble);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(QuoteDouble).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(QuoteDouble, [{
@@ -236,6 +242,4 @@ var QuoteDouble = /*#__PURE__*/function (_Node) {
   }]);
 
   return QuoteDouble;
-}(Node);
-
-export { QuoteDouble as default };
+}(Node);

package/browser/dist/cst/QuoteSingle.js

@@ -1,19 +1,25 @@
 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 { YAMLSemanticError, YAMLSyntaxError } from '../errors';
-import Node from './Node';
-import Range from './Range';
 
-var QuoteSingle = /*#__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; } }
+
+import { YAMLSemanticError, YAMLSyntaxError } from '../errors';
+import { Node } from './Node';
+import { Range } from './Range';
+export var QuoteSingle = /*#__PURE__*/function (_Node) {
   _inherits(QuoteSingle, _Node);
 
+  var _super = _createSuper(QuoteSingle);
+
   function QuoteSingle() {
     _classCallCheck(this, QuoteSingle);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(QuoteSingle).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(QuoteSingle, [{
@@ -111,6 +117,4 @@ var QuoteSingle = /*#__PURE__*/function (_Node) {
   }]);
 
   return QuoteSingle;
-}(Node);
-
-export { QuoteSingle as default };
+}(Node);

package/browser/dist/cst/Range.js

@@ -1,7 +1,6 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
-
-var Range = /*#__PURE__*/function () {
+export var Range = /*#__PURE__*/function () {
   _createClass(Range, null, [{
     key: "copy",
     value: function copy(orig) {
@@ -62,6 +61,4 @@ var Range = /*#__PURE__*/function () {
   }]);
 
   return Range;
-}();
-
-export { Range as default };
+}();

package/browser/dist/cst/parse.js

@@ -1,7 +1,7 @@
 // Published as 'yaml/parse-cst'
-import Document from './Document';
-import ParseContext from './ParseContext';
-export default function parse(src) {
+import { Document } from './Document';
+import { ParseContext } from './ParseContext';
+export function parse(src) {
   var cr = [];
 
   if (src.indexOf('\r') !== -1) {

package/browser/dist/errors.js

@@ -1,22 +1,29 @@
 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 _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
-import Node from './cst/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; } }
+
+import { Node } from './cst/Node';
 import { getLinePos, getPrettyContext } from './cst/source-utils';
-import Range from './cst/Range';
+import { Range } from './cst/Range';
 export var YAMLError = /*#__PURE__*/function (_Error) {
   _inherits(YAMLError, _Error);
 
+  var _super = _createSuper(YAMLError);
+
   function YAMLError(name, source, message) {
     var _this;
 
     _classCallCheck(this, YAMLError);
 
     if (!message || !(source instanceof Node)) throw new Error("Invalid arguments for new ".concat(name));
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(YAMLError).call(this));
+    _this = _super.call(this);
     _this.name = name;
     _this.message = message;
     _this.source = source;
@@ -69,10 +76,12 @@ export var YAMLError = /*#__PURE__*/function (_Error) {
 export var YAMLReferenceError = /*#__PURE__*/function (_YAMLError) {
   _inherits(YAMLReferenceError, _YAMLError);
 
+  var _super2 = _createSuper(YAMLReferenceError);
+
   function YAMLReferenceError(source, message) {
     _classCallCheck(this, YAMLReferenceError);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLReferenceError).call(this, 'YAMLReferenceError', source, message));
+    return _super2.call(this, 'YAMLReferenceError', source, message);
   }
 
   return YAMLReferenceError;
@@ -80,10 +89,12 @@ export var YAMLReferenceError = /*#__PURE__*/function (_YAMLError) {
 export var YAMLSemanticError = /*#__PURE__*/function (_YAMLError2) {
   _inherits(YAMLSemanticError, _YAMLError2);
 
+  var _super3 = _createSuper(YAMLSemanticError);
+
   function YAMLSemanticError(source, message) {
     _classCallCheck(this, YAMLSemanticError);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSemanticError).call(this, 'YAMLSemanticError', source, message));
+    return _super3.call(this, 'YAMLSemanticError', source, message);
   }
 
   return YAMLSemanticError;
@@ -91,10 +102,12 @@ export var YAMLSemanticError = /*#__PURE__*/function (_YAMLError2) {
 export var YAMLSyntaxError = /*#__PURE__*/function (_YAMLError3) {
   _inherits(YAMLSyntaxError, _YAMLError3);
 
+  var _super4 = _createSuper(YAMLSyntaxError);
+
   function YAMLSyntaxError(source, message) {
     _classCallCheck(this, YAMLSyntaxError);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSyntaxError).call(this, 'YAMLSyntaxError', source, message));
+    return _super4.call(this, 'YAMLSyntaxError', source, message);
   }
 
   return YAMLSyntaxError;
@@ -102,10 +115,12 @@ export var YAMLSyntaxError = /*#__PURE__*/function (_YAMLError3) {
 export var YAMLWarning = /*#__PURE__*/function (_YAMLError4) {
   _inherits(YAMLWarning, _YAMLError4);
 
+  var _super5 = _createSuper(YAMLWarning);
+
   function YAMLWarning(source, message) {
     _classCallCheck(this, YAMLWarning);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLWarning).call(this, 'YAMLWarning', source, message));
+    return _super5.call(this, 'YAMLWarning', source, message);
   }
 
   return YAMLWarning;

package/browser/dist/foldFlowLines.js

@@ -38,7 +38,7 @@ var consumeMoreIndentedLines = function consumeMoreIndentedLines(text, i) {
  */
 
 
-export default function foldFlowLines(text, indent, mode, _ref) {
+export function foldFlowLines(text, indent, mode, _ref) {
   var indentAtStart = _ref.indentAtStart,
       _ref$lineWidth = _ref.lineWidth,
       lineWidth = _ref$lineWidth === void 0 ? 80 : _ref$lineWidth,

package/browser/dist/index.js

@@ -1,15 +1,29 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+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 parseCST from './cst/parse';
-import YAMLDocument from './Document';
+
+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; } }
+
+import { parse as parseCST } from './cst/parse';
+import { Document as YAMLDocument } from './Document';
 import { YAMLSemanticError } from './errors';
-import Schema from './schema';
+import { Schema } from './schema';
+import { binaryOptions, boolOptions, intOptions, nullOptions, strOptions } from './tags/options';
 import { warn } from './warnings';
 var defaultOptions = {
   anchorPrefix: 'a',
   customTags: null,
+  indent: 2,
+  indentSeq: true,
   keepCstNodes: false,
   keepNodeTypes: true,
   keepBlobsInJSON: true,
@@ -20,6 +34,48 @@ var defaultOptions = {
   simpleKeys: false,
   version: '1.2'
 };
+var scalarOptions = {
+  get binary() {
+    return binaryOptions;
+  },
+
+  set binary(opt) {
+    Object.assign(binaryOptions, opt);
+  },
+
+  get bool() {
+    return boolOptions;
+  },
+
+  set bool(opt) {
+    Object.assign(boolOptions, opt);
+  },
+
+  get int() {
+    return intOptions;
+  },
+
+  set int(opt) {
+    Object.assign(intOptions, opt);
+  },
+
+  get null() {
+    return nullOptions;
+  },
+
+  set null(opt) {
+    Object.assign(nullOptions, opt);
+  },
+
+  get str() {
+    return strOptions;
+  },
+
+  set str(opt) {
+    Object.assign(strOptions, opt);
+  }
+
+};
 
 function createNode(value) {
   var wrapScalars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
@@ -38,10 +94,12 @@ function createNode(value) {
 var Document = /*#__PURE__*/function (_YAMLDocument) {
   _inherits(Document, _YAMLDocument);
 
+  var _super = _createSuper(Document);
+
   function Document(options) {
     _classCallCheck(this, Document);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(Document).call(this, Object.assign({}, defaultOptions, options)));
+    return _super.call(this, Object.assign({}, defaultOptions, options));
   }
 
   return Document;
@@ -50,12 +108,12 @@ var Document = /*#__PURE__*/function (_YAMLDocument) {
 function parseAllDocuments(src, options) {
   var stream = [];
   var prev;
-  var _iteratorNormalCompletion = true;
-  var _didIteratorError = false;
-  var _iteratorError = undefined;
+
+  var _iterator = _createForOfIteratorHelper(parseCST(src)),
+      _step;
 
   try {
-    for (var _iterator = parseCST(src)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
       var cstDoc = _step.value;
       var doc = new Document(options);
       doc.parse(cstDoc, prev);
@@ -63,18 +121,9 @@ function parseAllDocuments(src, options) {
       prev = doc;
     }
   } 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 stream;
@@ -107,7 +156,7 @@ function stringify(value, options) {
   return String(doc);
 }
 
-export default {
+export var YAML = {
   createNode: createNode,
   defaultOptions: defaultOptions,
   Document: Document,
@@ -115,5 +164,6 @@ export default {
   parseAllDocuments: parseAllDocuments,
   parseCST: parseCST,
   parseDocument: parseDocument,
+  scalarOptions: scalarOptions,
   stringify: stringify
 };

package/browser/dist/listTagNames.js

@@ -1,7 +1,7 @@
 import _typeof from "@babel/runtime/helpers/typeof";
-import Collection from './schema/Collection';
-import Pair from './schema/Pair';
-import Scalar from './schema/Scalar';
+import { Collection } from './schema/Collection';
+import { Pair } from './schema/Pair';
+import { Scalar } from './schema/Scalar';
 
 var visit = function visit(node, tags) {
   if (node && _typeof(node) === 'object') {
@@ -23,6 +23,6 @@ var visit = function visit(node, tags) {
   return tags;
 };
 
-export default (function (node) {
+export var listTagNames = function listTagNames(node) {
   return Object.keys(visit(node, {}));
-});
+};