yaml 1.8.2 → 1.9.2

package/browser/dist/Anchors.js

@@ -1,17 +1,16 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import Alias from './schema/Alias';
-import Map from './schema/Map';
-import Merge from './schema/Merge';
-import Scalar from './schema/Scalar';
-import Seq from './schema/Seq';
-
-var Anchors = /*#__PURE__*/function () {
+import { Alias } from './schema/Alias';
+import { YAMLMap } from './schema/Map';
+import { Merge } from './schema/Merge';
+import { Scalar } from './schema/Scalar';
+import { YAMLSeq } from './schema/Seq';
+export var Anchors = /*#__PURE__*/function () {
   _createClass(Anchors, null, [{
     key: "validAnchorNode",
     value: function validAnchorNode(node) {
-      return node instanceof Scalar || node instanceof Seq || node instanceof Map;
+      return node instanceof Scalar || node instanceof YAMLSeq || node instanceof YAMLMap;
     }
   }]);
 
@@ -42,8 +41,8 @@ var Anchors = /*#__PURE__*/function () {
 
       merge.value.items = sources.map(function (s) {
         if (s instanceof Alias) {
-          if (s.source instanceof Map) return s;
-        } else if (s instanceof Map) {
+          if (s.source instanceof YAMLMap) return s;
+        } else if (s instanceof YAMLMap) {
           return _this.createAlias(s);
         }
 
@@ -128,6 +127,4 @@ var Anchors = /*#__PURE__*/function () {
   }]);
 
   return Anchors;
-}();
-
-export { Anchors as default };
+}();

package/browser/dist/Document.js

@@ -2,23 +2,30 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import addComment from './addComment';
-import Anchors from './Anchors';
+
+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 { addComment } from './addComment';
+import { Anchors } from './Anchors';
 import { Char, Type } from './constants';
 import { YAMLError, YAMLReferenceError, YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from './errors';
-import listTagNames from './listTagNames';
-import Schema from './schema';
-import Alias from './schema/Alias';
-import Collection, { isEmptyPath } from './schema/Collection';
-import Node from './schema/Node';
-import Scalar from './schema/Scalar';
-import _toJSON from './toJSON';
+import { listTagNames } from './listTagNames';
+import { Schema } from './schema';
+import { Alias } from './schema/Alias';
+import { Collection, isEmptyPath } from './schema/Collection';
+import { Node } from './schema/Node';
+import { Scalar } from './schema/Scalar';
+import { toJSON as _toJSON } from './toJSON';
 
 var isCollectionItem = function isCollectionItem(node) {
   return node && [Type.MAP_KEY, Type.MAP_VALUE, Type.SEQ_ITEM].includes(node.type);
 };
 
-var Document = /*#__PURE__*/function () {
+export var Document = /*#__PURE__*/function () {
   function Document(options) {
     _classCallCheck(this, Document);
 
@@ -156,52 +163,32 @@ var Document = /*#__PURE__*/function () {
       this.anchors.resolveNodes();
 
       if (this.options.prettyErrors) {
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
+        var _iterator = _createForOfIteratorHelper(this.errors),
+            _step;
 
         try {
-          for (var _iterator = this.errors[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
             var _error = _step.value;
             if (_error instanceof YAMLError) _error.makePretty();
           }
         } 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();
         }
 
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
+        var _iterator2 = _createForOfIteratorHelper(this.warnings),
+            _step2;
 
         try {
-          for (var _iterator2 = this.warnings[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
             var warn = _step2.value;
             if (warn instanceof YAMLError) warn.makePretty();
           }
         } 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();
         }
       }
 
@@ -478,12 +465,12 @@ var Document = /*#__PURE__*/function () {
         after: []
       };
       var props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props;
-      var _iteratorNormalCompletion3 = true;
-      var _didIteratorError3 = false;
-      var _iteratorError3 = undefined;
+
+      var _iterator3 = _createForOfIteratorHelper(props),
+          _step3;
 
       try {
-        for (var _iterator3 = props[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
           var _step3$value = _step3.value,
               start = _step3$value.start,
               end = _step3$value.end;
@@ -528,18 +515,9 @@ var Document = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _didIteratorError3 = true;
-        _iteratorError3 = err;
+        _iterator3.e(err);
       } finally {
-        try {
-          if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
-            _iterator3.return();
-          }
-        } finally {
-          if (_didIteratorError3) {
-            throw _iteratorError3;
-          }
-        }
+        _iterator3.f();
       }
 
       if (hasAnchor) {
@@ -677,7 +655,7 @@ var Document = /*#__PURE__*/function () {
     }
   }, {
     key: "toJSON",
-    value: function toJSON(arg) {
+    value: function toJSON(arg, onAnchor) {
       var _this3 = this;
 
       var _this$options = this.options,
@@ -687,25 +665,53 @@ var Document = /*#__PURE__*/function () {
       var keep = keepBlobsInJSON && (typeof arg !== 'string' || !(this.contents instanceof Scalar));
       var ctx = {
         doc: this,
+        indentStep: '  ',
         keep: keep,
         mapAsMap: keep && !!mapAsMap,
         maxAliasCount: maxAliasCount
       };
       var anchorNames = Object.keys(this.anchors.map);
-      if (anchorNames.length > 0) ctx.anchors = anchorNames.map(function (name) {
-        return {
+      if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(function (name) {
+        return [_this3.anchors.map[name], {
           alias: [],
           aliasCount: 0,
-          count: 1,
-          node: _this3.anchors.map[name]
-        };
-      });
-      return _toJSON(this.contents, arg, ctx);
+          count: 1
+        }];
+      }));
+
+      var res = _toJSON(this.contents, arg, ctx);
+
+      if (typeof onAnchor === 'function' && ctx.anchors) {
+        var _iterator4 = _createForOfIteratorHelper(ctx.anchors.values()),
+            _step4;
+
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var _step4$value = _step4.value,
+                count = _step4$value.count,
+                _res = _step4$value.res;
+            onAnchor(_res, count);
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+
+      return res;
     }
   }, {
     key: "toString",
     value: function toString() {
       if (this.errors.length > 0) throw new Error('Document with errors cannot be stringified');
+      var indentSize = this.options.indent;
+
+      if (!Number.isInteger(indentSize) || indentSize <= 0) {
+        var s = JSON.stringify(indentSize);
+        throw new Error("\"indent\" option must be a positive integer, not ".concat(s));
+      }
+
       this.setSchema();
       var lines = [];
       var hasDirectives = false;
@@ -743,7 +749,8 @@ var Document = /*#__PURE__*/function () {
       var ctx = {
         anchors: {},
         doc: this,
-        indent: ''
+        indent: '',
+        indentStep: ' '.repeat(indentSize)
       };
       var chompKeep = false;
       var contentComment = null;
@@ -814,6 +821,4 @@ _defineProperty(Document, "defaults", {
       prefix: Schema.defaultPrefix
     }]
   }
-});
-
-export { Document as default };
+});

package/browser/dist/addComment.js

@@ -3,6 +3,6 @@ export function addCommentBefore(str, indent, comment) {
   var cc = comment.replace(/[\s\S]^/gm, "$&".concat(indent, "#"));
   return "#".concat(cc, "\n").concat(indent).concat(str);
 }
-export default function addComment(str, indent, comment) {
+export function addComment(str, indent, comment) {
   return !comment ? str : comment.indexOf('\n') === -1 ? "".concat(str, " #").concat(comment) : "".concat(str, "\n") + comment.replace(/^/gm, "".concat(indent || '', "#"));
 }

package/browser/dist/cst/Alias.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 Alias = /*#__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 Alias = /*#__PURE__*/function (_Node) {
   _inherits(Alias, _Node);
 
+  var _super = _createSuper(Alias);
+
   function Alias() {
     _classCallCheck(this, Alias);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(Alias).apply(this, arguments));
+    return _super.apply(this, arguments);
   }
 
   _createClass(Alias, [{
@@ -37,6 +43,4 @@ var Alias = /*#__PURE__*/function (_Node) {
   }]);
 
   return Alias;
-}(Node);
-
-export { Alias as default };
+}(Node);

package/browser/dist/cst/BlankLine.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 { Type } from '../constants';
-import Node from './Node';
-import Range from './Range';
 
-var BlankLine = /*#__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 { Type } from '../constants';
+import { Node } from './Node';
+import { Range } from './Range';
+export var BlankLine = /*#__PURE__*/function (_Node) {
   _inherits(BlankLine, _Node);
 
+  var _super = _createSuper(BlankLine);
+
   function BlankLine() {
     _classCallCheck(this, BlankLine);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(BlankLine).call(this, Type.BLANK_LINE));
+    return _super.call(this, Type.BLANK_LINE);
   }
   /* istanbul ignore next */
 
@@ -22,7 +28,7 @@ var BlankLine = /*#__PURE__*/function (_Node) {
     key: "parse",
 
     /**
-     * Parses blank lines from the source
+     * Parses a blank line from the source
      *
      * @param {ParseContext} context
      * @param {number} start - Index of first \n character
@@ -30,16 +36,8 @@ var BlankLine = /*#__PURE__*/function (_Node) {
      */
     value: function parse(context, start) {
       this.context = context;
-      var src = context.src;
-      var offset = start + 1;
-
-      while (Node.atBlank(src, offset)) {
-        var lineEnd = Node.endOfWhiteSpace(src, offset);
-        if (lineEnd === '\n') offset = lineEnd + 1;else break;
-      }
-
-      this.range = new Range(start, offset);
-      return offset;
+      this.range = new Range(start, start + 1);
+      return start + 1;
     }
   }, {
     key: "includesTrailingLines",
@@ -51,6 +49,4 @@ var BlankLine = /*#__PURE__*/function (_Node) {
   }]);
 
   return BlankLine;
-}(Node);
-
-export { BlankLine as default };
+}(Node);

package/browser/dist/cst/BlockValue.js

@@ -1,27 +1,33 @@
 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 Node from './Node';
-import Range from './Range';
+import { Node } from './Node';
+import { Range } from './Range';
 export var Chomp = {
   CLIP: 'CLIP',
   KEEP: 'KEEP',
   STRIP: 'STRIP'
 };
-
-var BlockValue = /*#__PURE__*/function (_Node) {
+export var BlockValue = /*#__PURE__*/function (_Node) {
   _inherits(BlockValue, _Node);
 
+  var _super = _createSuper(BlockValue);
+
   function BlockValue(type, props) {
     var _this;
 
     _classCallCheck(this, BlockValue);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(BlockValue).call(this, type, props));
+    _this = _super.call(this, type, props);
     _this.blockIndent = null;
     _this.chomping = Chomp.CLIP;
     _this.header = null;
@@ -242,6 +248,4 @@ var BlockValue = /*#__PURE__*/function (_Node) {
   }]);
 
   return BlockValue;
-}(Node);
-
-export { BlockValue as default };
+}(Node);

package/browser/dist/cst/Collection.js

@@ -1,15 +1,20 @@
 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 { Type } from '../constants';
-import BlankLine from './BlankLine';
-import CollectionItem from './CollectionItem';
-import Comment from './Comment';
-import Node from './Node';
-import Range from './Range';
+import { BlankLine } from './BlankLine';
+import { CollectionItem } from './CollectionItem';
+import { Comment } from './Comment';
+import { Node } from './Node';
+import { Range } from './Range';
 export function grabCollectionEndComments(node) {
   var cnode = node;
 
@@ -47,10 +52,11 @@ export function grabCollectionEndComments(node) {
 
   return ca;
 }
-
-var Collection = /*#__PURE__*/function (_Node) {
+export var Collection = /*#__PURE__*/function (_Node) {
   _inherits(Collection, _Node);
 
+  var _super = _createSuper(Collection);
+
   _createClass(Collection, null, [{
     key: "nextContentHasIndent",
     value: function nextContentHasIndent(src, offset, indent) {
@@ -69,7 +75,7 @@ var Collection = /*#__PURE__*/function (_Node) {
 
     _classCallCheck(this, Collection);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Collection).call(this, firstItem.type === Type.SEQ_ITEM ? Type.SEQ : Type.MAP));
+    _this = _super.call(this, firstItem.type === Type.SEQ_ITEM ? Type.SEQ : Type.MAP);
 
     for (var i = firstItem.props.length - 1; i >= 0; --i) {
       if (firstItem.props[i].start < firstItem.context.lineStart) {
@@ -269,6 +275,4 @@ var Collection = /*#__PURE__*/function (_Node) {
   }]);
 
   return Collection;
-}(Node);
-
-export { Collection as default };
+}(Node);

package/browser/dist/cst/CollectionItem.js

@@ -1,24 +1,30 @@
 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 Node from './Node';
-import Range from './Range';
-
-var CollectionItem = /*#__PURE__*/function (_Node) {
+import { BlankLine } from './BlankLine';
+import { Node } from './Node';
+import { Range } from './Range';
+export var CollectionItem = /*#__PURE__*/function (_Node) {
   _inherits(CollectionItem, _Node);
 
+  var _super = _createSuper(CollectionItem);
+
   function CollectionItem(type, props) {
     var _this;
 
     _classCallCheck(this, CollectionItem);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(CollectionItem).call(this, type, props));
+    _this = _super.call(this, type, props);
     _this.node = null;
     return _this;
   }
@@ -131,6 +137,4 @@ var CollectionItem = /*#__PURE__*/function (_Node) {
   }]);
 
   return CollectionItem;
-}(Node);
-
-export { CollectionItem as default };
+}(Node);

package/browser/dist/cst/Comment.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 { Type } from '../constants';
-import Node from './Node';
-import Range from './Range';
 
-var Comment = /*#__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 { Type } from '../constants';
+import { Node } from './Node';
+import { Range } from './Range';
+export var Comment = /*#__PURE__*/function (_Node) {
   _inherits(Comment, _Node);
 
+  var _super = _createSuper(Comment);
+
   function Comment() {
     _classCallCheck(this, Comment);
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(Comment).call(this, Type.COMMENT));
+    return _super.call(this, Type.COMMENT);
   }
   /**
    * Parses a comment line from the source
@@ -35,6 +41,4 @@ var Comment = /*#__PURE__*/function (_Node) {
   }]);
 
   return Comment;
-}(Node);
-
-export { Comment as default };
+}(Node);

package/browser/dist/cst/Directive.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";
-import { Type } from '../constants';
-import Node from './Node';
-import Range from './Range';
 
-var Directive = /*#__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 { Type } from '../constants';
+import { Node } from './Node';
+import { Range } from './Range';
+export var Directive = /*#__PURE__*/function (_Node) {
   _inherits(Directive, _Node);
 
+  var _super = _createSuper(Directive);
+
   function Directive() {
     var _this;
 
     _classCallCheck(this, Directive);
 
-    _this = _possibleConstructorReturn(this, _getPrototypeOf(Directive).call(this, Type.DIRECTIVE));
+    _this = _super.call(this, Type.DIRECTIVE);
     _this.name = null;
     return _this;
   }
@@ -67,6 +73,4 @@ var Directive = /*#__PURE__*/function (_Node) {
   }]);
 
   return Directive;
-}(Node);
-
-export { Directive as default };
+}(Node);