cdk8s-operator 0.1.407 → 0.1.409

package/node_modules/yaml/browser/dist/index.js

@@ -1,10 +1,10 @@
-import { d as defaultTagPrefix, _ as _createForOfIteratorHelper, a as _typeof, b as _createClass, c as _classCallCheck, e as _defineProperty, Y as YAMLSyntaxError, T as Type, f as YAMLWarning, g as YAMLSemanticError, h as _slicedToArray, i as YAMLError, j as _inherits, k as _createSuper } from './PlainValue-b8036b75.js';
 import { parse as parse$1 } from './parse-cst.js';
-import { b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions, N as Node, P as Pair, S as Scalar, c as stringifyString, A as Alias, Y as YAMLSeq, d as YAMLMap, M as Merge, C as Collection, r as resolveNode, e as isEmptyPath, t as toJSON, f as addComment } from './resolveSeq-492ab440.js';
-import { S as Schema } from './Schema-e94716c8.js';
-import { w as warn } from './warnings-df54cb69.js';
+import { d as defaultTagPrefix, _ as _defineProperty, T as Type, Y as YAMLSyntaxError, a as YAMLWarning, b as YAMLSemanticError, c as YAMLError } from './PlainValue-183afbad.js';
+import { b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions, N as Node, P as Pair, S as Scalar, c as stringifyString, A as Alias, Y as YAMLSeq, d as YAMLMap, M as Merge, C as Collection, r as resolveNode, e as isEmptyPath, t as toJSON, f as addComment } from './resolveSeq-67caf78a.js';
+import { S as Schema } from './Schema-9530c078.js';
+import { w as warn } from './warnings-5e4358fe.js';
 
-var defaultOptions = {
+const defaultOptions = {
   anchorPrefix: 'a',
   customTags: null,
   indent: 2,
@@ -19,49 +19,39 @@ var defaultOptions = {
   simpleKeys: false,
   version: '1.2'
 };
-var scalarOptions = {
+const 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);
   }
-
 };
-var documentOptions = {
+const documentOptions = {
   '1.0': {
     schema: 'yaml-1.1',
     merge: true,
@@ -99,280 +89,196 @@ var documentOptions = {
 
 function stringifyTag(doc, tag) {
   if ((doc.version || doc.options.version) === '1.0') {
-    var priv = tag.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
+    const priv = tag.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
     if (priv) return '!' + priv[1];
-    var vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
-    return vocab ? "!".concat(vocab[1], "/").concat(vocab[2]) : "!".concat(tag.replace(/^tag:/, ''));
+    const vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
+    return vocab ? `!${vocab[1]}/${vocab[2]}` : `!${tag.replace(/^tag:/, '')}`;
   }
-
-  var p = doc.tagPrefixes.find(function (p) {
-    return tag.indexOf(p.prefix) === 0;
-  });
-
+  let p = doc.tagPrefixes.find(p => tag.indexOf(p.prefix) === 0);
   if (!p) {
-    var dtp = doc.getDefaults().tagPrefixes;
-    p = dtp && dtp.find(function (p) {
-      return tag.indexOf(p.prefix) === 0;
-    });
+    const dtp = doc.getDefaults().tagPrefixes;
+    p = dtp && dtp.find(p => tag.indexOf(p.prefix) === 0);
   }
-
-  if (!p) return tag[0] === '!' ? tag : "!<".concat(tag, ">");
-  var suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, function (ch) {
-    return {
-      '!': '%21',
-      ',': '%2C',
-      '[': '%5B',
-      ']': '%5D',
-      '{': '%7B',
-      '}': '%7D'
-    }[ch];
-  });
+  if (!p) return tag[0] === '!' ? tag : `!<${tag}>`;
+  const suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, ch => ({
+    '!': '%21',
+    ',': '%2C',
+    '[': '%5B',
+    ']': '%5D',
+    '{': '%7B',
+    '}': '%7D'
+  })[ch]);
   return p.handle + suffix;
 }
 
 function getTagObject(tags, item) {
   if (item instanceof Alias) return Alias;
-
   if (item.tag) {
-    var match = tags.filter(function (t) {
-      return t.tag === item.tag;
-    });
-    if (match.length > 0) return match.find(function (t) {
-      return t.format === item.format;
-    }) || match[0];
+    const match = tags.filter(t => t.tag === item.tag);
+    if (match.length > 0) return match.find(t => t.format === item.format) || match[0];
   }
-
-  var tagObj, obj;
-
+  let tagObj, obj;
   if (item instanceof Scalar) {
-    obj = item.value; // TODO: deprecate/remove class check
-
-    var _match = tags.filter(function (t) {
-      return t.identify && t.identify(obj) || t.class && obj instanceof t.class;
-    });
-
-    tagObj = _match.find(function (t) {
-      return t.format === item.format;
-    }) || _match.find(function (t) {
-      return !t.format;
-    });
+    obj = item.value;
+    // TODO: deprecate/remove class check
+    const match = tags.filter(t => t.identify && t.identify(obj) || t.class && obj instanceof t.class);
+    tagObj = match.find(t => t.format === item.format) || match.find(t => !t.format);
   } else {
     obj = item;
-    tagObj = tags.find(function (t) {
-      return t.nodeClass && obj instanceof t.nodeClass;
-    });
+    tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
   }
-
   if (!tagObj) {
-    var name = obj && obj.constructor ? obj.constructor.name : _typeof(obj);
-    throw new Error("Tag not resolved for ".concat(name, " value"));
+    const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
+    throw new Error(`Tag not resolved for ${name} value`);
   }
-
   return tagObj;
-} // needs to be called before value stringifier to allow for circular anchor refs
-
-
-function stringifyProps(node, tagObj, _ref) {
-  var anchors = _ref.anchors,
-      doc = _ref.doc;
-  var props = [];
-  var anchor = doc.anchors.getName(node);
+}
 
+// needs to be called before value stringifier to allow for circular anchor refs
+function stringifyProps(node, tagObj, {
+  anchors,
+  doc
+}) {
+  const props = [];
+  const anchor = doc.anchors.getName(node);
   if (anchor) {
     anchors[anchor] = node;
-    props.push("&".concat(anchor));
+    props.push(`&${anchor}`);
   }
-
   if (node.tag) {
     props.push(stringifyTag(doc, node.tag));
   } else if (!tagObj.default) {
     props.push(stringifyTag(doc, tagObj.tag));
   }
-
   return props.join(' ');
 }
-
 function stringify$1(item, ctx, onComment, onChompKeep) {
-  var _ctx$doc = ctx.doc,
-      anchors = _ctx$doc.anchors,
-      schema = _ctx$doc.schema;
-  var tagObj;
-
+  const {
+    anchors,
+    schema
+  } = ctx.doc;
+  let tagObj;
   if (!(item instanceof Node)) {
-    var createCtx = {
+    const createCtx = {
       aliasNodes: [],
-      onTagObj: function onTagObj(o) {
-        return tagObj = o;
-      },
+      onTagObj: o => tagObj = o,
       prevObjects: new Map()
     };
     item = schema.createNode(item, true, null, createCtx);
-
-    var _iterator = _createForOfIteratorHelper(createCtx.aliasNodes),
-        _step;
-
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var alias = _step.value;
-        alias.source = alias.source.node;
-        var name = anchors.getName(alias.source);
-
-        if (!name) {
-          name = anchors.newName();
-          anchors.map[name] = alias.source;
-        }
+    for (const alias of createCtx.aliasNodes) {
+      alias.source = alias.source.node;
+      let name = anchors.getName(alias.source);
+      if (!name) {
+        name = anchors.newName();
+        anchors.map[name] = alias.source;
       }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
     }
   }
-
   if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
   if (!tagObj) tagObj = getTagObject(schema.tags, item);
-  var props = stringifyProps(item, tagObj, ctx);
+  const props = stringifyProps(item, tagObj, ctx);
   if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
-  var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Scalar ? stringifyString(item, ctx, onComment, onChompKeep) : item.toString(ctx, onComment, onChompKeep);
+  const str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Scalar ? stringifyString(item, ctx, onComment, onChompKeep) : item.toString(ctx, onComment, onChompKeep);
   if (!props) return str;
-  return item instanceof Scalar || str[0] === '{' || str[0] === '[' ? "".concat(props, " ").concat(str) : "".concat(props, "\n").concat(ctx.indent).concat(str);
+  return item instanceof Scalar || str[0] === '{' || str[0] === '[' ? `${props} ${str}` : `${props}\n${ctx.indent}${str}`;
 }
 
-var Anchors = /*#__PURE__*/function () {
-  function Anchors(prefix) {
-    _classCallCheck(this, Anchors);
-
+class Anchors {
+  static validAnchorNode(node) {
+    return node instanceof Scalar || node instanceof YAMLSeq || node instanceof YAMLMap;
+  }
+  constructor(prefix) {
     _defineProperty(this, "map", Object.create(null));
-
     this.prefix = prefix;
   }
-
-  _createClass(Anchors, [{
-    key: "createAlias",
-    value: function createAlias(node, name) {
-      this.setAnchor(node, name);
-      return new Alias(node);
-    }
-  }, {
-    key: "createMergePair",
-    value: function createMergePair() {
-      var _this = this;
-
-      var merge = new Merge();
-
-      for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
-        sources[_key] = arguments[_key];
+  createAlias(node, name) {
+    this.setAnchor(node, name);
+    return new Alias(node);
+  }
+  createMergePair(...sources) {
+    const merge = new Merge();
+    merge.value.items = sources.map(s => {
+      if (s instanceof Alias) {
+        if (s.source instanceof YAMLMap) return s;
+      } else if (s instanceof YAMLMap) {
+        return this.createAlias(s);
       }
-
-      merge.value.items = sources.map(function (s) {
-        if (s instanceof Alias) {
-          if (s.source instanceof YAMLMap) return s;
-        } else if (s instanceof YAMLMap) {
-          return _this.createAlias(s);
-        }
-
-        throw new Error('Merge sources must be Map nodes or their Aliases');
-      });
-      return merge;
-    }
-  }, {
-    key: "getName",
-    value: function getName(node) {
-      var map = this.map;
-      return Object.keys(map).find(function (a) {
-        return map[a] === node;
-      });
-    }
-  }, {
-    key: "getNames",
-    value: function getNames() {
-      return Object.keys(this.map);
-    }
-  }, {
-    key: "getNode",
-    value: function getNode(name) {
-      return this.map[name];
+      throw new Error('Merge sources must be Map nodes or their Aliases');
+    });
+    return merge;
+  }
+  getName(node) {
+    const {
+      map
+    } = this;
+    return Object.keys(map).find(a => map[a] === node);
+  }
+  getNames() {
+    return Object.keys(this.map);
+  }
+  getNode(name) {
+    return this.map[name];
+  }
+  newName(prefix) {
+    if (!prefix) prefix = this.prefix;
+    const names = Object.keys(this.map);
+    for (let i = 1; true; ++i) {
+      const name = `${prefix}${i}`;
+      if (!names.includes(name)) return name;
     }
-  }, {
-    key: "newName",
-    value: function newName(prefix) {
-      if (!prefix) prefix = this.prefix;
-      var names = Object.keys(this.map);
-
-      for (var i = 1; true; ++i) {
-        var name = "".concat(prefix).concat(i);
-        if (!names.includes(name)) return name;
-      }
-    } // During parsing, map & aliases contain CST nodes
-
-  }, {
-    key: "resolveNodes",
-    value: function resolveNodes() {
-      var map = this.map,
-          _cstAliases = this._cstAliases;
-      Object.keys(map).forEach(function (a) {
-        map[a] = map[a].resolved;
-      });
-
-      _cstAliases.forEach(function (a) {
-        a.source = a.source.resolved;
-      });
+  }
 
-      delete this._cstAliases;
+  // During parsing, map & aliases contain CST nodes
+  resolveNodes() {
+    const {
+      map,
+      _cstAliases
+    } = this;
+    Object.keys(map).forEach(a => {
+      map[a] = map[a].resolved;
+    });
+    _cstAliases.forEach(a => {
+      a.source = a.source.resolved;
+    });
+    delete this._cstAliases;
+  }
+  setAnchor(node, name) {
+    if (node != null && !Anchors.validAnchorNode(node)) {
+      throw new Error('Anchors may only be set for Scalar, Seq and Map nodes');
     }
-  }, {
-    key: "setAnchor",
-    value: function setAnchor(node, name) {
-      if (node != null && !Anchors.validAnchorNode(node)) {
-        throw new Error('Anchors may only be set for Scalar, Seq and Map nodes');
-      }
-
-      if (name && /[\x00-\x19\s,[\]{}]/.test(name)) {
-        throw new Error('Anchor names must not contain whitespace or control characters');
-      }
-
-      var map = this.map;
-      var prev = node && Object.keys(map).find(function (a) {
-        return map[a] === node;
-      });
-
-      if (prev) {
-        if (!name) {
-          return prev;
-        } else if (prev !== name) {
-          delete map[prev];
-          map[name] = node;
-        }
-      } else {
-        if (!name) {
-          if (!node) return null;
-          name = this.newName();
-        }
-
+    if (name && /[\x00-\x19\s,[\]{}]/.test(name)) {
+      throw new Error('Anchor names must not contain whitespace or control characters');
+    }
+    const {
+      map
+    } = this;
+    const prev = node && Object.keys(map).find(a => map[a] === node);
+    if (prev) {
+      if (!name) {
+        return prev;
+      } else if (prev !== name) {
+        delete map[prev];
         map[name] = node;
       }
-
-      return name;
-    }
-  }], [{
-    key: "validAnchorNode",
-    value: function validAnchorNode(node) {
-      return node instanceof Scalar || node instanceof YAMLSeq || node instanceof YAMLMap;
+    } else {
+      if (!name) {
+        if (!node) return null;
+        name = this.newName();
+      }
+      map[name] = node;
     }
-  }]);
-
-  return Anchors;
-}();
-
-var visit = function visit(node, tags) {
-  if (node && _typeof(node) === 'object') {
-    var tag = node.tag;
+    return name;
+  }
+}
 
+const visit = (node, tags) => {
+  if (node && typeof node === 'object') {
+    const {
+      tag
+    } = node;
     if (node instanceof Collection) {
       if (tag) tags[tag] = true;
-      node.items.forEach(function (n) {
-        return visit(n, tags);
-      });
+      node.items.forEach(n => visit(n, tags));
     } else if (node instanceof Pair) {
       visit(node.key, tags);
       visit(node.value, tags);
@@ -380,197 +286,135 @@ var visit = function visit(node, tags) {
       if (tag) tags[tag] = true;
     }
   }
-
   return tags;
 };
-
-var listTagNames = function listTagNames(node) {
-  return Object.keys(visit(node, {}));
-};
+const listTagNames = node => Object.keys(visit(node, {}));
 
 function parseContents(doc, contents) {
-  var comments = {
+  const comments = {
     before: [],
     after: []
   };
-  var body = undefined;
-  var spaceBefore = false;
-
-  var _iterator = _createForOfIteratorHelper(contents),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var node = _step.value;
-
-      if (node.valueRange) {
-        if (body !== undefined) {
-          var msg = 'Document contains trailing content not separated by a ... or --- line';
-          doc.errors.push(new YAMLSyntaxError(node, msg));
-          break;
-        }
-
-        var res = resolveNode(doc, node);
-
-        if (spaceBefore) {
-          res.spaceBefore = true;
-          spaceBefore = false;
-        }
-
-        body = res;
-      } else if (node.comment !== null) {
-        var cc = body === undefined ? comments.before : comments.after;
-        cc.push(node.comment);
-      } else if (node.type === Type.BLANK_LINE) {
-        spaceBefore = true;
-
-        if (body === undefined && comments.before.length > 0 && !doc.commentBefore) {
-          // space-separated comments at start are parsed as document comments
-          doc.commentBefore = comments.before.join('\n');
-          comments.before = [];
-        }
+  let body = undefined;
+  let spaceBefore = false;
+  for (const node of contents) {
+    if (node.valueRange) {
+      if (body !== undefined) {
+        const msg = 'Document contains trailing content not separated by a ... or --- line';
+        doc.errors.push(new YAMLSyntaxError(node, msg));
+        break;
+      }
+      const res = resolveNode(doc, node);
+      if (spaceBefore) {
+        res.spaceBefore = true;
+        spaceBefore = false;
+      }
+      body = res;
+    } else if (node.comment !== null) {
+      const cc = body === undefined ? comments.before : comments.after;
+      cc.push(node.comment);
+    } else if (node.type === Type.BLANK_LINE) {
+      spaceBefore = true;
+      if (body === undefined && comments.before.length > 0 && !doc.commentBefore) {
+        // space-separated comments at start are parsed as document comments
+        doc.commentBefore = comments.before.join('\n');
+        comments.before = [];
       }
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
-
   doc.contents = body || null;
-
   if (!body) {
     doc.comment = comments.before.concat(comments.after).join('\n') || null;
   } else {
-    var cb = comments.before.join('\n');
-
+    const cb = comments.before.join('\n');
     if (cb) {
-      var cbNode = body instanceof Collection && body.items[0] ? body.items[0] : body;
-      cbNode.commentBefore = cbNode.commentBefore ? "".concat(cb, "\n").concat(cbNode.commentBefore) : cb;
+      const cbNode = body instanceof Collection && body.items[0] ? body.items[0] : body;
+      cbNode.commentBefore = cbNode.commentBefore ? `${cb}\n${cbNode.commentBefore}` : cb;
     }
-
     doc.comment = comments.after.join('\n') || null;
   }
 }
 
-function resolveTagDirective(_ref, directive) {
-  var tagPrefixes = _ref.tagPrefixes;
-
-  var _directive$parameters = _slicedToArray(directive.parameters, 2),
-      handle = _directive$parameters[0],
-      prefix = _directive$parameters[1];
-
+function resolveTagDirective({
+  tagPrefixes
+}, directive) {
+  const [handle, prefix] = directive.parameters;
   if (!handle || !prefix) {
-    var msg = 'Insufficient parameters given for %TAG directive';
+    const msg = 'Insufficient parameters given for %TAG directive';
     throw new YAMLSemanticError(directive, msg);
   }
-
-  if (tagPrefixes.some(function (p) {
-    return p.handle === handle;
-  })) {
-    var _msg = 'The %TAG directive must only be given at most once per handle in the same document.';
-    throw new YAMLSemanticError(directive, _msg);
+  if (tagPrefixes.some(p => p.handle === handle)) {
+    const msg = 'The %TAG directive must only be given at most once per handle in the same document.';
+    throw new YAMLSemanticError(directive, msg);
   }
-
   return {
-    handle: handle,
-    prefix: prefix
+    handle,
+    prefix
   };
 }
-
 function resolveYamlDirective(doc, directive) {
-  var _directive$parameters2 = _slicedToArray(directive.parameters, 1),
-      version = _directive$parameters2[0];
-
+  let [version] = directive.parameters;
   if (directive.name === 'YAML:1.0') version = '1.0';
-
   if (!version) {
-    var msg = 'Insufficient parameters given for %YAML directive';
+    const msg = 'Insufficient parameters given for %YAML directive';
     throw new YAMLSemanticError(directive, msg);
   }
-
   if (!documentOptions[version]) {
-    var v0 = doc.version || doc.options.version;
-
-    var _msg2 = "Document will be parsed as YAML ".concat(v0, " rather than YAML ").concat(version);
-
-    doc.warnings.push(new YAMLWarning(directive, _msg2));
+    const v0 = doc.version || doc.options.version;
+    const msg = `Document will be parsed as YAML ${v0} rather than YAML ${version}`;
+    doc.warnings.push(new YAMLWarning(directive, msg));
   }
-
   return version;
 }
-
 function parseDirectives(doc, directives, prevDoc) {
-  var directiveComments = [];
-  var hasDirectives = false;
-
-  var _iterator = _createForOfIteratorHelper(directives),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var directive = _step.value;
-      var comment = directive.comment,
-          name = directive.name;
-
-      switch (name) {
-        case 'TAG':
-          try {
-            doc.tagPrefixes.push(resolveTagDirective(doc, directive));
-          } catch (error) {
-            doc.errors.push(error);
-          }
-
-          hasDirectives = true;
-          break;
-
-        case 'YAML':
-        case 'YAML:1.0':
-          if (doc.version) {
-            var msg = 'The %YAML directive must only be given at most once per document.';
-            doc.errors.push(new YAMLSemanticError(directive, msg));
-          }
-
-          try {
-            doc.version = resolveYamlDirective(doc, directive);
-          } catch (error) {
-            doc.errors.push(error);
-          }
-
-          hasDirectives = true;
-          break;
-
-        default:
-          if (name) {
-            var _msg3 = "YAML only supports %TAG and %YAML directives, and not %".concat(name);
-
-            doc.warnings.push(new YAMLWarning(directive, _msg3));
-          }
-
-      }
-
-      if (comment) directiveComments.push(comment);
+  const directiveComments = [];
+  let hasDirectives = false;
+  for (const directive of directives) {
+    const {
+      comment,
+      name
+    } = directive;
+    switch (name) {
+      case 'TAG':
+        try {
+          doc.tagPrefixes.push(resolveTagDirective(doc, directive));
+        } catch (error) {
+          doc.errors.push(error);
+        }
+        hasDirectives = true;
+        break;
+      case 'YAML':
+      case 'YAML:1.0':
+        if (doc.version) {
+          const msg = 'The %YAML directive must only be given at most once per document.';
+          doc.errors.push(new YAMLSemanticError(directive, msg));
+        }
+        try {
+          doc.version = resolveYamlDirective(doc, directive);
+        } catch (error) {
+          doc.errors.push(error);
+        }
+        hasDirectives = true;
+        break;
+      default:
+        if (name) {
+          const msg = `YAML only supports %TAG and %YAML directives, and not %${name}`;
+          doc.warnings.push(new YAMLWarning(directive, msg));
+        }
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+    if (comment) directiveComments.push(comment);
   }
-
   if (prevDoc && !hasDirectives && '1.1' === (doc.version || prevDoc.version || doc.options.version)) {
-    var copyTagPrefix = function copyTagPrefix(_ref2) {
-      var handle = _ref2.handle,
-          prefix = _ref2.prefix;
-      return {
-        handle: handle,
-        prefix: prefix
-      };
-    };
-
+    const copyTagPrefix = ({
+      handle,
+      prefix
+    }) => ({
+      handle,
+      prefix
+    });
     doc.tagPrefixes = prevDoc.tagPrefixes.map(copyTagPrefix);
     doc.version = prevDoc.version;
   }
-
   doc.commentBefore = directiveComments.join('\n') || null;
 }
 
@@ -578,11 +422,8 @@ function assertCollection(contents) {
   if (contents instanceof Collection) return true;
   throw new Error('Expected a YAML collection as document contents');
 }
-
-var Document$1 = /*#__PURE__*/function () {
-  function Document(options) {
-    _classCallCheck(this, Document);
-
+class Document$1 {
+  constructor(options) {
     this.anchors = new Anchors(options.anchorPrefix);
     this.commentBefore = null;
     this.comment = null;
@@ -595,408 +436,257 @@ var Document$1 = /*#__PURE__*/function () {
     this.version = null;
     this.warnings = [];
   }
-
-  _createClass(Document, [{
-    key: "add",
-    value: function add(value) {
-      assertCollection(this.contents);
-      return this.contents.add(value);
-    }
-  }, {
-    key: "addIn",
-    value: function addIn(path, value) {
-      assertCollection(this.contents);
-      this.contents.addIn(path, value);
-    }
-  }, {
-    key: "delete",
-    value: function _delete(key) {
-      assertCollection(this.contents);
-      return this.contents.delete(key);
-    }
-  }, {
-    key: "deleteIn",
-    value: function deleteIn(path) {
-      if (isEmptyPath(path)) {
-        if (this.contents == null) return false;
-        this.contents = null;
-        return true;
-      }
-
-      assertCollection(this.contents);
-      return this.contents.deleteIn(path);
-    }
-  }, {
-    key: "getDefaults",
-    value: function getDefaults() {
-      return Document.defaults[this.version] || Document.defaults[this.options.version] || {};
-    }
-  }, {
-    key: "get",
-    value: function get(key, keepScalar) {
-      return this.contents instanceof Collection ? this.contents.get(key, keepScalar) : undefined;
-    }
-  }, {
-    key: "getIn",
-    value: function getIn(path, keepScalar) {
-      if (isEmptyPath(path)) return !keepScalar && this.contents instanceof Scalar ? this.contents.value : this.contents;
-      return this.contents instanceof Collection ? this.contents.getIn(path, keepScalar) : undefined;
-    }
-  }, {
-    key: "has",
-    value: function has(key) {
-      return this.contents instanceof Collection ? this.contents.has(key) : false;
-    }
-  }, {
-    key: "hasIn",
-    value: function hasIn(path) {
-      if (isEmptyPath(path)) return this.contents !== undefined;
-      return this.contents instanceof Collection ? this.contents.hasIn(path) : false;
+  add(value) {
+    assertCollection(this.contents);
+    return this.contents.add(value);
+  }
+  addIn(path, value) {
+    assertCollection(this.contents);
+    this.contents.addIn(path, value);
+  }
+  delete(key) {
+    assertCollection(this.contents);
+    return this.contents.delete(key);
+  }
+  deleteIn(path) {
+    if (isEmptyPath(path)) {
+      if (this.contents == null) return false;
+      this.contents = null;
+      return true;
     }
-  }, {
-    key: "set",
-    value: function set(key, value) {
+    assertCollection(this.contents);
+    return this.contents.deleteIn(path);
+  }
+  getDefaults() {
+    return Document$1.defaults[this.version] || Document$1.defaults[this.options.version] || {};
+  }
+  get(key, keepScalar) {
+    return this.contents instanceof Collection ? this.contents.get(key, keepScalar) : undefined;
+  }
+  getIn(path, keepScalar) {
+    if (isEmptyPath(path)) return !keepScalar && this.contents instanceof Scalar ? this.contents.value : this.contents;
+    return this.contents instanceof Collection ? this.contents.getIn(path, keepScalar) : undefined;
+  }
+  has(key) {
+    return this.contents instanceof Collection ? this.contents.has(key) : false;
+  }
+  hasIn(path) {
+    if (isEmptyPath(path)) return this.contents !== undefined;
+    return this.contents instanceof Collection ? this.contents.hasIn(path) : false;
+  }
+  set(key, value) {
+    assertCollection(this.contents);
+    this.contents.set(key, value);
+  }
+  setIn(path, value) {
+    if (isEmptyPath(path)) this.contents = value;else {
       assertCollection(this.contents);
-      this.contents.set(key, value);
+      this.contents.setIn(path, value);
     }
-  }, {
-    key: "setIn",
-    value: function setIn(path, value) {
-      if (isEmptyPath(path)) this.contents = value;else {
-        assertCollection(this.contents);
-        this.contents.setIn(path, value);
-      }
+  }
+  setSchema(id, customTags) {
+    if (!id && !customTags && this.schema) return;
+    if (typeof id === 'number') id = id.toFixed(1);
+    if (id === '1.0' || id === '1.1' || id === '1.2') {
+      if (this.version) this.version = id;else this.options.version = id;
+      delete this.options.schema;
+    } else if (id && typeof id === 'string') {
+      this.options.schema = id;
     }
-  }, {
-    key: "setSchema",
-    value: function setSchema(id, customTags) {
-      if (!id && !customTags && this.schema) return;
-      if (typeof id === 'number') id = id.toFixed(1);
-
-      if (id === '1.0' || id === '1.1' || id === '1.2') {
-        if (this.version) this.version = id;else this.options.version = id;
-        delete this.options.schema;
-      } else if (id && typeof id === 'string') {
-        this.options.schema = id;
-      }
-
-      if (Array.isArray(customTags)) this.options.customTags = customTags;
-      var opt = Object.assign({}, this.getDefaults(), this.options);
-      this.schema = new Schema(opt);
+    if (Array.isArray(customTags)) this.options.customTags = customTags;
+    const opt = Object.assign({}, this.getDefaults(), this.options);
+    this.schema = new Schema(opt);
+  }
+  parse(node, prevDoc) {
+    if (this.options.keepCstNodes) this.cstNode = node;
+    if (this.options.keepNodeTypes) this.type = 'DOCUMENT';
+    const {
+      directives = [],
+      contents = [],
+      directivesEndMarker,
+      error,
+      valueRange
+    } = node;
+    if (error) {
+      if (!error.source) error.source = this;
+      this.errors.push(error);
     }
-  }, {
-    key: "parse",
-    value: function parse(node, prevDoc) {
-      if (this.options.keepCstNodes) this.cstNode = node;
-      if (this.options.keepNodeTypes) this.type = 'DOCUMENT';
-      var _node$directives = node.directives,
-          directives = _node$directives === void 0 ? [] : _node$directives,
-          _node$contents = node.contents,
-          contents = _node$contents === void 0 ? [] : _node$contents,
-          directivesEndMarker = node.directivesEndMarker,
-          error = node.error,
-          valueRange = node.valueRange;
-
-      if (error) {
-        if (!error.source) error.source = this;
-        this.errors.push(error);
-      }
-
-      parseDirectives(this, directives, prevDoc);
-      if (directivesEndMarker) this.directivesEndMarker = true;
-      this.range = valueRange ? [valueRange.start, valueRange.end] : null;
-      this.setSchema();
-      this.anchors._cstAliases = [];
-      parseContents(this, contents);
-      this.anchors.resolveNodes();
-
-      if (this.options.prettyErrors) {
-        var _iterator = _createForOfIteratorHelper(this.errors),
-            _step;
-
-        try {
-          for (_iterator.s(); !(_step = _iterator.n()).done;) {
-            var _error = _step.value;
-            if (_error instanceof YAMLError) _error.makePretty();
-          }
-        } catch (err) {
-          _iterator.e(err);
-        } finally {
-          _iterator.f();
-        }
-
-        var _iterator2 = _createForOfIteratorHelper(this.warnings),
-            _step2;
-
-        try {
-          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-            var warn = _step2.value;
-            if (warn instanceof YAMLError) warn.makePretty();
-          }
-        } catch (err) {
-          _iterator2.e(err);
-        } finally {
-          _iterator2.f();
-        }
-      }
-
-      return this;
+    parseDirectives(this, directives, prevDoc);
+    if (directivesEndMarker) this.directivesEndMarker = true;
+    this.range = valueRange ? [valueRange.start, valueRange.end] : null;
+    this.setSchema();
+    this.anchors._cstAliases = [];
+    parseContents(this, contents);
+    this.anchors.resolveNodes();
+    if (this.options.prettyErrors) {
+      for (const error of this.errors) if (error instanceof YAMLError) error.makePretty();
+      for (const warn of this.warnings) if (warn instanceof YAMLError) warn.makePretty();
     }
-  }, {
-    key: "listNonDefaultTags",
-    value: function listNonDefaultTags() {
-      return listTagNames(this.contents).filter(function (t) {
-        return t.indexOf(Schema.defaultPrefix) !== 0;
+    return this;
+  }
+  listNonDefaultTags() {
+    return listTagNames(this.contents).filter(t => t.indexOf(Schema.defaultPrefix) !== 0);
+  }
+  setTagPrefix(handle, prefix) {
+    if (handle[0] !== '!' || handle[handle.length - 1] !== '!') throw new Error('Handle must start and end with !');
+    if (prefix) {
+      const prev = this.tagPrefixes.find(p => p.handle === handle);
+      if (prev) prev.prefix = prefix;else this.tagPrefixes.push({
+        handle,
+        prefix
       });
+    } else {
+      this.tagPrefixes = this.tagPrefixes.filter(p => p.handle !== handle);
     }
-  }, {
-    key: "setTagPrefix",
-    value: function setTagPrefix(handle, prefix) {
-      if (handle[0] !== '!' || handle[handle.length - 1] !== '!') throw new Error('Handle must start and end with !');
-
-      if (prefix) {
-        var prev = this.tagPrefixes.find(function (p) {
-          return p.handle === handle;
-        });
-        if (prev) prev.prefix = prefix;else this.tagPrefixes.push({
-          handle: handle,
-          prefix: prefix
-        });
-      } else {
-        this.tagPrefixes = this.tagPrefixes.filter(function (p) {
-          return p.handle !== handle;
-        });
-      }
+  }
+  toJSON(arg, onAnchor) {
+    const {
+      keepBlobsInJSON,
+      mapAsMap,
+      maxAliasCount
+    } = this.options;
+    const keep = keepBlobsInJSON && (typeof arg !== 'string' || !(this.contents instanceof Scalar));
+    const ctx = {
+      doc: this,
+      indentStep: '  ',
+      keep,
+      mapAsMap: keep && !!mapAsMap,
+      maxAliasCount,
+      stringify: stringify$1 // Requiring directly in Pair would create circular dependencies
+    };
+    const anchorNames = Object.keys(this.anchors.map);
+    if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(name => [this.anchors.map[name], {
+      alias: [],
+      aliasCount: 0,
+      count: 1
+    }]));
+    const res = toJSON(this.contents, arg, ctx);
+    if (typeof onAnchor === 'function' && ctx.anchors) for (const {
+      count,
+      res
+    } of ctx.anchors.values()) onAnchor(res, count);
+    return res;
+  }
+  toString() {
+    if (this.errors.length > 0) throw new Error('Document with errors cannot be stringified');
+    const indentSize = this.options.indent;
+    if (!Number.isInteger(indentSize) || indentSize <= 0) {
+      const s = JSON.stringify(indentSize);
+      throw new Error(`"indent" option must be a positive integer, not ${s}`);
     }
-  }, {
-    key: "toJSON",
-    value: function toJSON$1(arg, onAnchor) {
-      var _this = this;
-
-      var _this$options = this.options,
-          keepBlobsInJSON = _this$options.keepBlobsInJSON,
-          mapAsMap = _this$options.mapAsMap,
-          maxAliasCount = _this$options.maxAliasCount;
-      var keep = keepBlobsInJSON && (typeof arg !== 'string' || !(this.contents instanceof Scalar));
-      var ctx = {
-        doc: this,
-        indentStep: '  ',
-        keep: keep,
-        mapAsMap: keep && !!mapAsMap,
-        maxAliasCount: maxAliasCount,
-        stringify: stringify$1 // Requiring directly in Pair would create circular dependencies
-
-      };
-      var anchorNames = Object.keys(this.anchors.map);
-      if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(function (name) {
-        return [_this.anchors.map[name], {
-          alias: [],
-          aliasCount: 0,
-          count: 1
-        }];
-      }));
-
-      var res = toJSON(this.contents, arg, ctx);
-
-      if (typeof onAnchor === 'function' && ctx.anchors) {
-        var _iterator3 = _createForOfIteratorHelper(ctx.anchors.values()),
-            _step3;
-
-        try {
-          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-            var _step3$value = _step3.value,
-                count = _step3$value.count,
-                _res = _step3$value.res;
-            onAnchor(_res, count);
-          }
-        } catch (err) {
-          _iterator3.e(err);
-        } finally {
-          _iterator3.f();
-        }
+    this.setSchema();
+    const lines = [];
+    let hasDirectives = false;
+    if (this.version) {
+      let vd = '%YAML 1.2';
+      if (this.schema.name === 'yaml-1.1') {
+        if (this.version === '1.0') vd = '%YAML:1.0';else if (this.version === '1.1') vd = '%YAML 1.1';
       }
-
-      return res;
+      lines.push(vd);
+      hasDirectives = true;
     }
-  }, {
-    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;
-
-      if (this.version) {
-        var vd = '%YAML 1.2';
-
-        if (this.schema.name === 'yaml-1.1') {
-          if (this.version === '1.0') vd = '%YAML:1.0';else if (this.version === '1.1') vd = '%YAML 1.1';
-        }
-
-        lines.push(vd);
+    const tagNames = this.listNonDefaultTags();
+    this.tagPrefixes.forEach(({
+      handle,
+      prefix
+    }) => {
+      if (tagNames.some(t => t.indexOf(prefix) === 0)) {
+        lines.push(`%TAG ${handle} ${prefix}`);
         hasDirectives = true;
       }
-
-      var tagNames = this.listNonDefaultTags();
-      this.tagPrefixes.forEach(function (_ref) {
-        var handle = _ref.handle,
-            prefix = _ref.prefix;
-
-        if (tagNames.some(function (t) {
-          return t.indexOf(prefix) === 0;
-        })) {
-          lines.push("%TAG ".concat(handle, " ").concat(prefix));
-          hasDirectives = true;
-        }
-      });
-      if (hasDirectives || this.directivesEndMarker) lines.push('---');
-
-      if (this.commentBefore) {
-        if (hasDirectives || !this.directivesEndMarker) lines.unshift('');
-        lines.unshift(this.commentBefore.replace(/^/gm, '#'));
-      }
-
-      var ctx = {
-        anchors: Object.create(null),
-        doc: this,
-        indent: '',
-        indentStep: ' '.repeat(indentSize),
-        stringify: stringify$1 // Requiring directly in nodes would create circular dependencies
-
-      };
-      var chompKeep = false;
-      var contentComment = null;
-
-      if (this.contents) {
-        if (this.contents instanceof Node) {
-          if (this.contents.spaceBefore && (hasDirectives || this.directivesEndMarker)) lines.push('');
-          if (this.contents.commentBefore) lines.push(this.contents.commentBefore.replace(/^/gm, '#')); // top-level block scalars need to be indented if followed by a comment
-
-          ctx.forceBlockIndent = !!this.comment;
-          contentComment = this.contents.comment;
-        }
-
-        var onChompKeep = contentComment ? null : function () {
-          return chompKeep = true;
-        };
-        var body = stringify$1(this.contents, ctx, function () {
-          return contentComment = null;
-        }, onChompKeep);
-        lines.push(addComment(body, '', contentComment));
-      } else if (this.contents !== undefined) {
-        lines.push(stringify$1(this.contents, ctx));
-      }
-
-      if (this.comment) {
-        if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') lines.push('');
-        lines.push(this.comment.replace(/^/gm, '#'));
+    });
+    if (hasDirectives || this.directivesEndMarker) lines.push('---');
+    if (this.commentBefore) {
+      if (hasDirectives || !this.directivesEndMarker) lines.unshift('');
+      lines.unshift(this.commentBefore.replace(/^/gm, '#'));
+    }
+    const ctx = {
+      anchors: Object.create(null),
+      doc: this,
+      indent: '',
+      indentStep: ' '.repeat(indentSize),
+      stringify: stringify$1 // Requiring directly in nodes would create circular dependencies
+    };
+    let chompKeep = false;
+    let contentComment = null;
+    if (this.contents) {
+      if (this.contents instanceof Node) {
+        if (this.contents.spaceBefore && (hasDirectives || this.directivesEndMarker)) lines.push('');
+        if (this.contents.commentBefore) lines.push(this.contents.commentBefore.replace(/^/gm, '#'));
+        // top-level block scalars need to be indented if followed by a comment
+        ctx.forceBlockIndent = !!this.comment;
+        contentComment = this.contents.comment;
       }
-
-      return lines.join('\n') + '\n';
+      const onChompKeep = contentComment ? null : () => chompKeep = true;
+      const body = stringify$1(this.contents, ctx, () => contentComment = null, onChompKeep);
+      lines.push(addComment(body, '', contentComment));
+    } else if (this.contents !== undefined) {
+      lines.push(stringify$1(this.contents, ctx));
     }
-  }]);
-
-  return Document;
-}();
-
+    if (this.comment) {
+      if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') lines.push('');
+      lines.push(this.comment.replace(/^/gm, '#'));
+    }
+    return lines.join('\n') + '\n';
+  }
+}
 _defineProperty(Document$1, "defaults", documentOptions);
 
-function createNode(value) {
-  var wrapScalars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  var tag = arguments.length > 2 ? arguments[2] : undefined;
-
+function createNode(value, wrapScalars = true, tag) {
   if (tag === undefined && typeof wrapScalars === 'string') {
     tag = wrapScalars;
     wrapScalars = true;
   }
-
-  var options = Object.assign({}, Document$1.defaults[defaultOptions.version], defaultOptions);
-  var schema = new Schema(options);
+  const options = Object.assign({}, Document$1.defaults[defaultOptions.version], defaultOptions);
+  const schema = new Schema(options);
   return schema.createNode(value, wrapScalars, tag);
 }
-
-var Document = /*#__PURE__*/function (_YAMLDocument) {
-  _inherits(Document, _YAMLDocument);
-
-  var _super = _createSuper(Document);
-
-  function Document(options) {
-    _classCallCheck(this, Document);
-
-    return _super.call(this, Object.assign({}, defaultOptions, options));
+class Document extends Document$1 {
+  constructor(options) {
+    super(Object.assign({}, defaultOptions, options));
   }
-
-  return Document;
-}(Document$1);
-
+}
 function parseAllDocuments(src, options) {
-  var stream = [];
-  var prev;
-
-  var _iterator = _createForOfIteratorHelper(parse$1(src)),
-      _step;
-
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var cstDoc = _step.value;
-      var doc = new Document(options);
-      doc.parse(cstDoc, prev);
-      stream.push(doc);
-      prev = doc;
-    }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
+  const stream = [];
+  let prev;
+  for (const cstDoc of parse$1(src)) {
+    const doc = new Document(options);
+    doc.parse(cstDoc, prev);
+    stream.push(doc);
+    prev = doc;
   }
-
   return stream;
 }
-
 function parseDocument(src, options) {
-  var cst = parse$1(src);
-  var doc = new Document(options).parse(cst[0]);
-
+  const cst = parse$1(src);
+  const doc = new Document(options).parse(cst[0]);
   if (cst.length > 1) {
-    var errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
+    const errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
     doc.errors.unshift(new YAMLSemanticError(cst[1], errMsg));
   }
-
   return doc;
 }
-
 function parse(src, options) {
-  var doc = parseDocument(src, options);
-  doc.warnings.forEach(function (warning) {
-    return warn(warning);
-  });
+  const doc = parseDocument(src, options);
+  doc.warnings.forEach(warning => warn(warning));
   if (doc.errors.length > 0) throw doc.errors[0];
   return doc.toJSON();
 }
-
 function stringify(value, options) {
-  var doc = new Document(options);
+  const doc = new Document(options);
   doc.contents = value;
   return String(doc);
 }
-
-var YAML = {
-  createNode: createNode,
-  defaultOptions: defaultOptions,
-  Document: Document,
-  parse: parse,
-  parseAllDocuments: parseAllDocuments,
+const YAML = {
+  createNode,
+  defaultOptions,
+  Document,
+  parse,
+  parseAllDocuments,
   parseCST: parse$1,
-  parseDocument: parseDocument,
-  scalarOptions: scalarOptions,
-  stringify: stringify
+  parseDocument,
+  scalarOptions,
+  stringify
 };
 
 export { YAML };