cdk8s-operator 0.1.407 → 0.1.408

package/node_modules/yaml/dist/{Document-9b4560a1.js → Document-a8d0fbf9.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-var PlainValue = require('./PlainValue-ec8e588e.js');
-var resolveSeq = require('./resolveSeq-d03cb037.js');
-var Schema = require('./Schema-88e323a7.js');
+var PlainValue = require('./PlainValue-516d5bc2.js');
+var resolveSeq = require('./resolveSeq-95613e94.js');
+var Schema = require('./Schema-bcc6c2d7.js');
 
 const defaultOptions = {
   anchorPrefix: 'a',
@@ -23,43 +23,33 @@ const scalarOptions = {
   get binary() {
     return resolveSeq.binaryOptions;
   },
-
   set binary(opt) {
     Object.assign(resolveSeq.binaryOptions, opt);
   },
-
   get bool() {
     return resolveSeq.boolOptions;
   },
-
   set bool(opt) {
     Object.assign(resolveSeq.boolOptions, opt);
   },
-
   get int() {
     return resolveSeq.intOptions;
   },
-
   set int(opt) {
     Object.assign(resolveSeq.intOptions, opt);
   },
-
   get null() {
     return resolveSeq.nullOptions;
   },
-
   set null(opt) {
     Object.assign(resolveSeq.nullOptions, opt);
   },
-
   get str() {
     return resolveSeq.strOptions;
   },
-
   set str(opt) {
     Object.assign(resolveSeq.strOptions, opt);
   }
-
 };
 const documentOptions = {
   '1.0': {
@@ -104,14 +94,11 @@ function stringifyTag(doc, tag) {
     const vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
     return vocab ? `!${vocab[1]}/${vocab[2]}` : `!${tag.replace(/^tag:/, '')}`;
   }
-
   let p = doc.tagPrefixes.find(p => tag.indexOf(p.prefix) === 0);
-
   if (!p) {
     const dtp = doc.getDefaults().tagPrefixes;
     p = dtp && dtp.find(p => tag.indexOf(p.prefix) === 0);
   }
-
   if (!p) return tag[0] === '!' ? tag : `!<${tag}>`;
   const suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, ch => ({
     '!': '%21',
@@ -126,61 +113,51 @@ function stringifyTag(doc, tag) {
 
 function getTagObject(tags, item) {
   if (item instanceof resolveSeq.Alias) return resolveSeq.Alias;
-
   if (item.tag) {
     const match = tags.filter(t => t.tag === item.tag);
     if (match.length > 0) return match.find(t => t.format === item.format) || match[0];
   }
-
   let tagObj, obj;
-
   if (item instanceof resolveSeq.Scalar) {
-    obj = item.value; // TODO: deprecate/remove class check
-
+    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(t => t.nodeClass && obj instanceof t.nodeClass);
   }
-
   if (!tagObj) {
     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
-
+}
 
+// 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(`&${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(item, ctx, onComment, onChompKeep) {
   const {
     anchors,
     schema
   } = ctx.doc;
   let tagObj;
-
   if (!(item instanceof resolveSeq.Node)) {
     const createCtx = {
       aliasNodes: [],
@@ -188,18 +165,15 @@ function stringify(item, ctx, onComment, onChompKeep) {
       prevObjects: new Map()
     };
     item = schema.createNode(item, true, null, createCtx);
-
     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;
       }
     }
   }
-
   if (item instanceof resolveSeq.Pair) return item.toString(ctx, onComment, onChompKeep);
   if (!tagObj) tagObj = getTagObject(schema.tags, item);
   const props = stringifyProps(item, tagObj, ctx);
@@ -213,18 +187,14 @@ class Anchors {
   static validAnchorNode(node) {
     return node instanceof resolveSeq.Scalar || node instanceof resolveSeq.YAMLSeq || node instanceof resolveSeq.YAMLMap;
   }
-
   constructor(prefix) {
     PlainValue._defineProperty(this, "map", Object.create(null));
-
     this.prefix = prefix;
   }
-
   createAlias(node, name) {
     this.setAnchor(node, name);
     return new resolveSeq.Alias(node);
   }
-
   createMergePair(...sources) {
     const merge = new resolveSeq.Merge();
     merge.value.items = sources.map(s => {
@@ -233,38 +203,32 @@ class Anchors {
       } else if (s instanceof resolveSeq.YAMLMap) {
         return this.createAlias(s);
       }
-
       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;
     }
-  } // During parsing, map & aliases contain CST nodes
-
+  }
 
+  // During parsing, map & aliases contain CST nodes
   resolveNodes() {
     const {
       map,
@@ -273,28 +237,22 @@ class Anchors {
     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');
     }
-
     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;
@@ -307,13 +265,10 @@ class Anchors {
         if (!node) return null;
         name = this.newName();
       }
-
       map[name] = node;
     }
-
     return name;
   }
-
 }
 
 const visit = (node, tags) => {
@@ -321,7 +276,6 @@ const visit = (node, tags) => {
     const {
       tag
     } = node;
-
     if (node instanceof resolveSeq.Collection) {
       if (tag) tags[tag] = true;
       node.items.forEach(n => visit(n, tags));
@@ -332,10 +286,8 @@ const visit = (node, tags) => {
       if (tag) tags[tag] = true;
     }
   }
-
   return tags;
 };
-
 const listTagNames = node => Object.keys(visit(node, {}));
 
 function parseContents(doc, contents) {
@@ -345,7 +297,6 @@ function parseContents(doc, contents) {
   };
   let body = undefined;
   let spaceBefore = false;
-
   for (const node of contents) {
     if (node.valueRange) {
       if (body !== undefined) {
@@ -353,21 +304,17 @@ function parseContents(doc, contents) {
         doc.errors.push(new PlainValue.YAMLSyntaxError(node, msg));
         break;
       }
-
       const res = resolveSeq.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 === PlainValue.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');
@@ -375,19 +322,15 @@ function parseContents(doc, contents) {
       }
     }
   }
-
   doc.contents = body || null;
-
   if (!body) {
     doc.comment = comments.before.concat(comments.after).join('\n') || null;
   } else {
     const cb = comments.before.join('\n');
-
     if (cb) {
       const cbNode = body instanceof resolveSeq.Collection && body.items[0] ? body.items[0] : body;
       cbNode.commentBefore = cbNode.commentBefore ? `${cb}\n${cbNode.commentBefore}` : cb;
     }
-
     doc.comment = comments.after.join('\n') || null;
   }
 }
@@ -396,51 +339,41 @@ function resolveTagDirective({
   tagPrefixes
 }, directive) {
   const [handle, prefix] = directive.parameters;
-
   if (!handle || !prefix) {
     const msg = 'Insufficient parameters given for %TAG directive';
     throw new PlainValue.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 PlainValue.YAMLSemanticError(directive, msg);
   }
-
   return {
     handle,
     prefix
   };
 }
-
 function resolveYamlDirective(doc, directive) {
   let [version] = directive.parameters;
   if (directive.name === 'YAML:1.0') version = '1.0';
-
   if (!version) {
     const msg = 'Insufficient parameters given for %YAML directive';
     throw new PlainValue.YAMLSemanticError(directive, msg);
   }
-
   if (!documentOptions[version]) {
     const v0 = doc.version || doc.options.version;
     const msg = `Document will be parsed as YAML ${v0} rather than YAML ${version}`;
     doc.warnings.push(new PlainValue.YAMLWarning(directive, msg));
   }
-
   return version;
 }
-
 function parseDirectives(doc, directives, prevDoc) {
   const directiveComments = [];
   let hasDirectives = false;
-
   for (const directive of directives) {
     const {
       comment,
       name
     } = directive;
-
     switch (name) {
       case 'TAG':
         try {
@@ -448,37 +381,29 @@ function parseDirectives(doc, directives, prevDoc) {
         } 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 PlainValue.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 PlainValue.YAMLWarning(directive, msg));
         }
-
     }
-
     if (comment) directiveComments.push(comment);
   }
-
   if (prevDoc && !hasDirectives && '1.1' === (doc.version || prevDoc.version || doc.options.version)) {
     const copyTagPrefix = ({
       handle,
@@ -487,11 +412,9 @@ function parseDirectives(doc, directives, prevDoc) {
       handle,
       prefix
     });
-
     doc.tagPrefixes = prevDoc.tagPrefixes.map(copyTagPrefix);
     doc.version = prevDoc.version;
   }
-
   doc.commentBefore = directiveComments.join('\n') || null;
 }
 
@@ -499,7 +422,6 @@ function assertCollection(contents) {
   if (contents instanceof resolveSeq.Collection) return true;
   throw new Error('Expected a YAML collection as document contents');
 }
-
 class Document {
   constructor(options) {
     this.anchors = new Anchors(options.anchorPrefix);
@@ -514,83 +436,67 @@ class Document {
     this.version = null;
     this.warnings = [];
   }
-
   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 (resolveSeq.isEmptyPath(path)) {
       if (this.contents == null) return false;
       this.contents = null;
       return true;
     }
-
     assertCollection(this.contents);
     return this.contents.deleteIn(path);
   }
-
   getDefaults() {
     return Document.defaults[this.version] || Document.defaults[this.options.version] || {};
   }
-
   get(key, keepScalar) {
     return this.contents instanceof resolveSeq.Collection ? this.contents.get(key, keepScalar) : undefined;
   }
-
   getIn(path, keepScalar) {
     if (resolveSeq.isEmptyPath(path)) return !keepScalar && this.contents instanceof resolveSeq.Scalar ? this.contents.value : this.contents;
     return this.contents instanceof resolveSeq.Collection ? this.contents.getIn(path, keepScalar) : undefined;
   }
-
   has(key) {
     return this.contents instanceof resolveSeq.Collection ? this.contents.has(key) : false;
   }
-
   hasIn(path) {
     if (resolveSeq.isEmptyPath(path)) return this.contents !== undefined;
     return this.contents instanceof resolveSeq.Collection ? this.contents.hasIn(path) : false;
   }
-
   set(key, value) {
     assertCollection(this.contents);
     this.contents.set(key, value);
   }
-
   setIn(path, value) {
     if (resolveSeq.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;
     }
-
     if (Array.isArray(customTags)) this.options.customTags = customTags;
     const opt = Object.assign({}, this.getDefaults(), this.options);
     this.schema = new Schema.Schema(opt);
   }
-
   parse(node, prevDoc) {
     if (this.options.keepCstNodes) this.cstNode = node;
     if (this.options.keepNodeTypes) this.type = 'DOCUMENT';
@@ -601,12 +507,10 @@ class Document {
       error,
       valueRange
     } = node;
-
     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;
@@ -614,23 +518,17 @@ class Document {
     this.anchors._cstAliases = [];
     parseContents(this, contents);
     this.anchors.resolveNodes();
-
     if (this.options.prettyErrors) {
       for (const error of this.errors) if (error instanceof PlainValue.YAMLError) error.makePretty();
-
       for (const warn of this.warnings) if (warn instanceof PlainValue.YAMLError) warn.makePretty();
     }
-
     return this;
   }
-
   listNonDefaultTags() {
     return listTagNames(this.contents).filter(t => t.indexOf(Schema.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({
@@ -641,7 +539,6 @@ class Document {
       this.tagPrefixes = this.tagPrefixes.filter(p => p.handle !== handle);
     }
   }
-
   toJSON(arg, onAnchor) {
     const {
       keepBlobsInJSON,
@@ -656,7 +553,6 @@ class Document {
       mapAsMap: keep && !!mapAsMap,
       maxAliasCount,
       stringify // 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], {
@@ -671,31 +567,24 @@ class Document {
     } 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}`);
     }
-
     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';
       }
-
       lines.push(vd);
       hasDirectives = true;
     }
-
     const tagNames = this.listNonDefaultTags();
     this.tagPrefixes.forEach(({
       handle,
@@ -707,49 +596,40 @@ class Document {
       }
     });
     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 // Requiring directly in nodes would create circular dependencies
-
     };
     let chompKeep = false;
     let contentComment = null;
-
     if (this.contents) {
       if (this.contents instanceof resolveSeq.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
-
+        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;
       }
-
       const onChompKeep = contentComment ? null : () => chompKeep = true;
       const body = stringify(this.contents, ctx, () => contentComment = null, onChompKeep);
       lines.push(resolveSeq.addComment(body, '', contentComment));
     } else if (this.contents !== undefined) {
       lines.push(stringify(this.contents, ctx));
     }
-
     if (this.comment) {
       if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') lines.push('');
       lines.push(this.comment.replace(/^/gm, '#'));
     }
-
     return lines.join('\n') + '\n';
   }
-
 }
-
 PlainValue._defineProperty(Document, "defaults", documentOptions);
 
 exports.Document = Document;