cdk8s-operator 0.1.407 → 0.1.409

package/node_modules/yaml/dist/{resolveSeq-d03cb037.js → resolveSeq-95613e94.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-var PlainValue = require('./PlainValue-ec8e588e.js');
+var PlainValue = require('./PlainValue-516d5bc2.js');
 
 function addCommentBefore(str, indent, comment) {
   if (!comment) return str;
@@ -15,7 +15,6 @@ class Node {}
 
 function toJSON(value, arg, ctx) {
   if (Array.isArray(value)) return value.map((v, i) => toJSON(v, String(i), ctx));
-
   if (value && typeof value.toJSON === 'function') {
     const anchor = ctx && ctx.anchors && ctx.anchors.get(value);
     if (anchor) ctx.onCreate = res => {
@@ -26,7 +25,6 @@ function toJSON(value, arg, ctx) {
     if (anchor && ctx.onCreate) ctx.onCreate(res);
     return res;
   }
-
   if ((!ctx || !ctx.keep) && typeof value === 'bigint') return Number(value);
   return value;
 }
@@ -36,23 +34,18 @@ class Scalar extends Node {
     super();
     this.value = value;
   }
-
   toJSON(arg, ctx) {
     return ctx && ctx.keep ? this.value : toJSON(this.value, arg, ctx);
   }
-
   toString() {
     return String(this.value);
   }
-
 }
 
 function collectionFromPath(schema, path, value) {
   let v = value;
-
   for (let i = path.length - 1; i >= 0; --i) {
     const k = path[i];
-
     if (Number.isInteger(k) && k >= 0) {
       const a = [];
       a[k] = v;
@@ -68,21 +61,17 @@ function collectionFromPath(schema, path, value) {
       v = o;
     }
   }
-
   return schema.createNode(v, false);
-} // null, undefined, or an empty non-string iterable (e.g. [])
-
+}
 
+// null, undefined, or an empty non-string iterable (e.g. [])
 const isEmptyPath = path => path == null || typeof path === 'object' && path[Symbol.iterator]().next().done;
 class Collection extends Node {
   constructor(schema) {
     super();
-
     PlainValue._defineProperty(this, "items", []);
-
     this.schema = schema;
   }
-
   addIn(path, value) {
     if (isEmptyPath(path)) this.add(value);else {
       const [key, ...rest] = path;
@@ -90,18 +79,15 @@ class Collection extends Node {
       if (node instanceof Collection) node.addIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
   }
-
   deleteIn([key, ...rest]) {
     if (rest.length === 0) return this.delete(key);
     const node = this.get(key, true);
     if (node instanceof Collection) return node.deleteIn(rest);else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
   }
-
   getIn([key, ...rest], keepScalar) {
     const node = this.get(key, true);
     if (rest.length === 0) return !keepScalar && node instanceof Scalar ? node.value : node;else return node instanceof Collection ? node.getIn(rest, keepScalar) : undefined;
   }
-
   hasAllNullValues() {
     return this.items.every(node => {
       if (!node || node.type !== 'PAIR') return false;
@@ -109,13 +95,11 @@ class Collection extends Node {
       return n == null || n instanceof Scalar && n.value == null && !n.commentBefore && !n.comment && !n.tag;
     });
   }
-
   hasIn([key, ...rest]) {
     if (rest.length === 0) return this.has(key);
     const node = this.get(key, true);
     return node instanceof Collection ? node.hasIn(rest) : false;
   }
-
   setIn([key, ...rest], value) {
     if (rest.length === 0) {
       this.set(key, value);
@@ -123,15 +107,13 @@ class Collection extends Node {
       const node = this.get(key, true);
       if (node instanceof Collection) node.setIn(rest, value);else if (node === undefined && this.schema) this.set(key, collectionFromPath(this.schema, rest, value));else throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
     }
-  } // overridden in implementations
+  }
 
+  // overridden in implementations
   /* istanbul ignore next */
-
-
   toJSON() {
     return null;
   }
-
   toString(ctx, {
     blockItem,
     flowChars,
@@ -156,7 +138,6 @@ class Collection extends Node {
     let hasItemWithNewLine = false;
     const nodes = this.items.reduce((nodes, item, i) => {
       let comment;
-
       if (item) {
         if (!chompKeep && item.spaceBefore) nodes.push({
           type: 'comment',
@@ -171,7 +152,6 @@ class Collection extends Node {
         if (item.comment) comment = item.comment;
         if (inFlow && (!chompKeep && item.spaceBefore || item.commentBefore || item.comment || item.key && (item.key.commentBefore || item.key.comment) || item.value && (item.value.commentBefore || item.value.comment))) hasItemWithNewLine = true;
       }
-
       chompKeep = false;
       let str = stringify(item, ctx, () => comment = null, () => chompKeep = true);
       if (inFlow && !hasItemWithNewLine && str.includes('\n')) hasItemWithNewLine = true;
@@ -185,7 +165,6 @@ class Collection extends Node {
       return nodes;
     }, []);
     let str;
-
     if (nodes.length === 0) {
       str = flowChars.start + flowChars.end;
     } else if (inFlow) {
@@ -194,14 +173,11 @@ class Collection extends Node {
         end
       } = flowChars;
       const strings = nodes.map(n => n.str);
-
       if (hasItemWithNewLine || strings.reduce((sum, str) => sum + str.length + 2, 2) > Collection.maxFlowStringSingleLineLength) {
         str = start;
-
         for (const s of strings) {
           str += s ? `\n${indentStep}${indent}${s}` : '\n';
         }
-
         str += `\n${indent}${end}`;
       } else {
         str = `${start} ${strings.join(' ')} ${end}`;
@@ -209,20 +185,15 @@ class Collection extends Node {
     } else {
       const strings = nodes.map(blockItem);
       str = strings.shift();
-
       for (const s of strings) str += s ? `\n${indent}${s}` : '\n';
     }
-
     if (this.comment) {
       str += '\n' + this.comment.replace(/^/gm, `${indent}#`);
       if (onComment) onComment();
     } else if (chompKeep && onChompKeep) onChompKeep();
-
     return str;
   }
-
 }
-
 PlainValue._defineProperty(Collection, "maxFlowStringSingleLineLength", 60);
 
 function asItemIndex(key) {
@@ -230,47 +201,38 @@ function asItemIndex(key) {
   if (idx && typeof idx === 'string') idx = Number(idx);
   return Number.isInteger(idx) && idx >= 0 ? idx : null;
 }
-
 class YAMLSeq extends Collection {
   add(value) {
     this.items.push(value);
   }
-
   delete(key) {
     const idx = asItemIndex(key);
     if (typeof idx !== 'number') return false;
     const del = this.items.splice(idx, 1);
     return del.length > 0;
   }
-
   get(key, keepScalar) {
     const idx = asItemIndex(key);
     if (typeof idx !== 'number') return undefined;
     const it = this.items[idx];
     return !keepScalar && it instanceof Scalar ? it.value : it;
   }
-
   has(key) {
     const idx = asItemIndex(key);
     return typeof idx === 'number' && idx < this.items.length;
   }
-
   set(key, value) {
     const idx = asItemIndex(key);
     if (typeof idx !== 'number') throw new Error(`Expected a valid index, not ${key}.`);
     this.items[idx] = value;
   }
-
   toJSON(_, ctx) {
     const seq = [];
     if (ctx && ctx.onCreate) ctx.onCreate(seq);
     let i = 0;
-
     for (const item of this.items) seq.push(toJSON(item, String(i++), ctx));
-
     return seq;
   }
-
   toString(ctx, onComment, onChompKeep) {
     if (!ctx) return JSON.stringify(this);
     return super.toString(ctx, {
@@ -283,7 +245,6 @@ class YAMLSeq extends Collection {
       itemIndent: (ctx.indent || '') + '  '
     }, onComment, onChompKeep);
   }
-
 }
 
 const stringifyKey = (key, jsKey, ctx) => {
@@ -300,7 +261,6 @@ const stringifyKey = (key, jsKey, ctx) => {
   });
   return JSON.stringify(jsKey);
 };
-
 class Pair extends Node {
   constructor(key, value = null) {
     super();
@@ -308,11 +268,9 @@ class Pair extends Node {
     this.value = value;
     this.type = Pair.Type.PAIR;
   }
-
   get commentBefore() {
     return this.key instanceof Node ? this.key.commentBefore : undefined;
   }
-
   set commentBefore(cb) {
     if (this.key == null) this.key = new Scalar(null);
     if (this.key instanceof Node) this.key.commentBefore = cb;else {
@@ -320,10 +278,8 @@ class Pair extends Node {
       throw new Error(msg);
     }
   }
-
   addToJSMap(ctx, map) {
     const key = toJSON(this.key, '', ctx);
-
     if (map instanceof Map) {
       const value = toJSON(this.value, key, ctx);
       map.set(key, value);
@@ -339,15 +295,12 @@ class Pair extends Node {
         configurable: true
       });else map[stringKey] = value;
     }
-
     return map;
   }
-
   toJSON(_, ctx) {
     const pair = ctx && ctx.mapAsMap ? new Map() : {};
     return this.addToJSMap(ctx, pair);
   }
-
   toString(ctx, onComment, onChompKeep) {
     if (!ctx || !ctx.doc) return JSON.stringify(this);
     const {
@@ -360,18 +313,15 @@ class Pair extends Node {
       value
     } = this;
     let keyComment = key instanceof Node && key.comment;
-
     if (simpleKeys) {
       if (keyComment) {
         throw new Error('With simple keys, key nodes cannot have comments');
       }
-
       if (key instanceof Collection) {
         const msg = 'With simple keys, collection cannot be used as a key value';
         throw new Error(msg);
       }
     }
-
     let explicitKey = !simpleKeys && (!key || keyComment || (key instanceof Node ? key instanceof Collection || key.type === PlainValue.Type.BLOCK_FOLDED || key.type === PlainValue.Type.BLOCK_LITERAL : typeof key === 'object'));
     const {
       doc,
@@ -386,70 +336,54 @@ class Pair extends Node {
     let chompKeep = false;
     let str = stringify(key, ctx, () => keyComment = null, () => chompKeep = true);
     str = addComment(str, ctx.indent, keyComment);
-
     if (!explicitKey && str.length > 1024) {
       if (simpleKeys) throw new Error('With simple keys, single line scalar must not span more than 1024 characters');
       explicitKey = true;
     }
-
     if (ctx.allNullValues && !simpleKeys) {
       if (this.comment) {
         str = addComment(str, ctx.indent, this.comment);
         if (onComment) onComment();
       } else if (chompKeep && !keyComment && onChompKeep) onChompKeep();
-
       return ctx.inFlow && !explicitKey ? str : `? ${str}`;
     }
-
     str = explicitKey ? `? ${str}\n${indent}:` : `${str}:`;
-
     if (this.comment) {
       // expected (but not strictly required) to be a single-line comment
       str = addComment(str, ctx.indent, this.comment);
       if (onComment) onComment();
     }
-
     let vcb = '';
     let valueComment = null;
-
     if (value instanceof Node) {
       if (value.spaceBefore) vcb = '\n';
-
       if (value.commentBefore) {
         const cs = value.commentBefore.replace(/^/gm, `${ctx.indent}#`);
         vcb += `\n${cs}`;
       }
-
       valueComment = value.comment;
     } else if (value && typeof value === 'object') {
       value = doc.schema.createNode(value, true);
     }
-
     ctx.implicitKey = false;
     if (!explicitKey && !this.comment && value instanceof Scalar) ctx.indentAtStart = str.length + 1;
     chompKeep = false;
-
     if (!indentSeq && indentSize >= 2 && !ctx.inFlow && !explicitKey && value instanceof YAMLSeq && value.type !== PlainValue.Type.FLOW_SEQ && !value.tag && !doc.anchors.getName(value)) {
       // If indentSeq === false, consider '- ' as part of indentation where possible
       ctx.indent = ctx.indent.substr(2);
     }
-
     const valueStr = stringify(value, ctx, () => valueComment = null, () => chompKeep = true);
     let ws = ' ';
-
     if (vcb || this.comment) {
       ws = `${vcb}\n${ctx.indent}`;
     } else if (!explicitKey && value instanceof Collection) {
       const flow = valueStr[0] === '[' || valueStr[0] === '{';
       if (!flow || valueStr.includes('\n')) ws = `\n${ctx.indent}`;
     } else if (valueStr[0] === '\n') ws = '';
-
     if (chompKeep && !valueComment && onChompKeep) onChompKeep();
     return addComment(str + ws + valueStr, ctx.indent, valueComment);
   }
-
 }
-
 PlainValue._defineProperty(Pair, "Type", {
   PAIR: 'PAIR',
   MERGE_PAIR: 'MERGE_PAIR'
@@ -461,22 +395,18 @@ const getAliasCount = (node, anchors) => {
     return anchor.count * anchor.aliasCount;
   } else if (node instanceof Collection) {
     let count = 0;
-
     for (const item of node.items) {
       const c = getAliasCount(item, anchors);
       if (c > count) count = c;
     }
-
     return count;
   } else if (node instanceof Pair) {
     const kc = getAliasCount(node.key, anchors);
     const vc = getAliasCount(node.value, anchors);
     return Math.max(kc, vc);
   }
-
   return 1;
 };
-
 class Alias extends Node {
   static stringify({
     range,
@@ -493,17 +423,14 @@ class Alias extends Node {
     const msg = doc.anchors.getName(source) ? 'Alias node must be after source node' : 'Source node not found for alias node';
     throw new Error(`${msg} [${range}]`);
   }
-
   constructor(source) {
     super();
     this.source = source;
     this.type = PlainValue.Type.ALIAS;
   }
-
   set tag(t) {
     throw new Error('Alias nodes cannot have tags');
   }
-
   toJSON(arg, ctx) {
     if (!ctx) return toJSON(this.source, arg, ctx);
     const {
@@ -512,45 +439,37 @@ class Alias extends Node {
     } = ctx;
     const anchor = anchors.get(this.source);
     /* istanbul ignore if */
-
     if (!anchor || anchor.res === undefined) {
       const msg = 'This should not happen: Alias anchor was not resolved?';
       if (this.cstNode) throw new PlainValue.YAMLReferenceError(this.cstNode, msg);else throw new ReferenceError(msg);
     }
-
     if (maxAliasCount >= 0) {
       anchor.count += 1;
       if (anchor.aliasCount === 0) anchor.aliasCount = getAliasCount(this.source, anchors);
-
       if (anchor.count * anchor.aliasCount > maxAliasCount) {
         const msg = 'Excessive alias count indicates a resource exhaustion attack';
         if (this.cstNode) throw new PlainValue.YAMLReferenceError(this.cstNode, msg);else throw new ReferenceError(msg);
       }
     }
-
     return anchor.res;
-  } // Only called when stringifying an alias mapping key while constructing
-  // Object output.
-
+  }
 
+  // Only called when stringifying an alias mapping key while constructing
+  // Object output.
   toString(ctx) {
     return Alias.stringify(this, ctx);
   }
-
 }
-
 PlainValue._defineProperty(Alias, "default", true);
 
 function findPair(items, key) {
   const k = key instanceof Scalar ? key.value : key;
-
   for (const it of items) {
     if (it instanceof Pair) {
       if (it.key === key || it.key === k) return it;
       if (it.key && it.key.value === k) return it;
     }
   }
-
   return undefined;
 }
 class YAMLMap extends Collection {
@@ -558,7 +477,6 @@ class YAMLMap extends Collection {
     if (!pair) pair = new Pair(pair);else if (!(pair instanceof Pair)) pair = new Pair(pair.key || pair, pair.value);
     const prev = findPair(this.items, pair.key);
     const sortEntries = this.schema && this.schema.sortMapEntries;
-
     if (prev) {
       if (overwrite) prev.value = pair.value;else throw new Error(`Key ${pair.key} already set`);
     } else if (sortEntries) {
@@ -568,51 +486,41 @@ class YAMLMap extends Collection {
       this.items.push(pair);
     }
   }
-
   delete(key) {
     const it = findPair(this.items, key);
     if (!it) return false;
     const del = this.items.splice(this.items.indexOf(it), 1);
     return del.length > 0;
   }
-
   get(key, keepScalar) {
     const it = findPair(this.items, key);
     const node = it && it.value;
     return !keepScalar && node instanceof Scalar ? node.value : node;
   }
-
   has(key) {
     return !!findPair(this.items, key);
   }
-
   set(key, value) {
     this.add(new Pair(key, value), true);
   }
+
   /**
    * @param {*} arg ignored
    * @param {*} ctx Conversion context, originally set in Document#toJSON()
    * @param {Class} Type If set, forces the returned collection type
    * @returns {*} Instance of Type, Map, or Object
    */
-
-
   toJSON(_, ctx, Type) {
     const map = Type ? new Type() : ctx && ctx.mapAsMap ? new Map() : {};
     if (ctx && ctx.onCreate) ctx.onCreate(map);
-
     for (const item of this.items) item.addToJSMap(ctx, map);
-
     return map;
   }
-
   toString(ctx, onComment, onChompKeep) {
     if (!ctx) return JSON.stringify(this);
-
     for (const item of this.items) {
       if (!(item instanceof Pair)) throw new Error(`Map items must all be pairs; found ${JSON.stringify(item)} instead`);
     }
-
     return super.toString(ctx, {
       blockItem: n => n.str,
       flowChars: {
@@ -623,7 +531,6 @@ class YAMLMap extends Collection {
       itemIndent: ctx.indent || ''
     }, onComment, onChompKeep);
   }
-
 }
 
 const MERGE_KEY = '<<';
@@ -631,36 +538,32 @@ class Merge extends Pair {
   constructor(pair) {
     if (pair instanceof Pair) {
       let seq = pair.value;
-
       if (!(seq instanceof YAMLSeq)) {
         seq = new YAMLSeq();
         seq.items.push(pair.value);
         seq.range = pair.value.range;
       }
-
       super(pair.key, seq);
       this.range = pair.range;
     } else {
       super(new Scalar(MERGE_KEY), new YAMLSeq());
     }
-
     this.type = Pair.Type.MERGE_PAIR;
-  } // If the value associated with a merge key is a single mapping node, each of
+  }
+
+  // If the value associated with a merge key is a single mapping node, each of
   // its key/value pairs is inserted into the current mapping, unless the key
   // already exists in it. If the value associated with the merge key is a
   // sequence, then this sequence is expected to contain mapping nodes and each
   // of these nodes is merged in turn according to its order in the sequence.
   // Keys in mapping nodes earlier in the sequence override keys specified in
   // later mapping nodes. -- http://yaml.org/type/merge.html
-
-
   addToJSMap(ctx, map) {
     for (const {
       source
     } of this.value.items) {
       if (!(source instanceof YAMLMap)) throw new Error('Merge sources must be maps');
       const srcMap = source.toJSON(null, ctx, Map);
-
       for (const [key, value] of srcMap) {
         if (map instanceof Map) {
           if (!map.has(key)) map.set(key, value);
@@ -676,10 +579,8 @@ class Merge extends Pair {
         }
       }
     }
-
     return map;
   }
-
   toString(ctx, onComment) {
     const seq = this.value;
     if (seq.items.length > 1) return super.toString(ctx, onComment);
@@ -688,7 +589,6 @@ class Merge extends Pair {
     this.value = seq;
     return str;
   }
-
 }
 
 const binaryOptions = {
@@ -717,6 +617,7 @@ const strOptions = {
   }
 };
 
+// falls back to string on no match
 function resolveScalar(str, tags, scalarFallback) {
   for (const {
     format,
@@ -725,7 +626,6 @@ function resolveScalar(str, tags, scalarFallback) {
   } of tags) {
     if (test) {
       const match = str.match(test);
-
       if (match) {
         let res = resolve.apply(null, match);
         if (!(res instanceof Scalar)) res = new Scalar(res);
@@ -734,29 +634,27 @@ function resolveScalar(str, tags, scalarFallback) {
       }
     }
   }
-
   if (scalarFallback) str = scalarFallback(str);
   return new Scalar(str);
 }
 
 const FOLD_FLOW = 'flow';
 const FOLD_BLOCK = 'block';
-const FOLD_QUOTED = 'quoted'; // presumes i+1 is at the start of a line
-// returns index of last newline in more-indented block
+const FOLD_QUOTED = 'quoted';
 
+// presumes i+1 is at the start of a line
+// returns index of last newline in more-indented block
 const consumeMoreIndentedLines = (text, i) => {
   let ch = text[i + 1];
-
   while (ch === ' ' || ch === '\t') {
     do {
       ch = text[i += 1];
     } while (ch && ch !== '\n');
-
     ch = text[i + 1];
   }
-
   return i;
 };
+
 /**
  * Tries to keep input at up to `lineWidth` characters, splitting only on spaces
  * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
@@ -777,8 +675,6 @@ const consumeMoreIndentedLines = (text, i) => {
  * @param {function} options.onFold Called once if any line of text exceeds
  *   lineWidth characters
  */
-
-
 function foldFlowLines(text, indent, mode, {
   indentAtStart,
   lineWidth = 80,
@@ -792,47 +688,37 @@ function foldFlowLines(text, indent, mode, {
   const folds = [];
   const escapedFolds = {};
   let end = lineWidth - indent.length;
-
   if (typeof indentAtStart === 'number') {
     if (indentAtStart > lineWidth - Math.max(2, minContentWidth)) folds.push(0);else end = lineWidth - indentAtStart;
   }
-
   let split = undefined;
   let prev = undefined;
   let overflow = false;
   let i = -1;
   let escStart = -1;
   let escEnd = -1;
-
   if (mode === FOLD_BLOCK) {
     i = consumeMoreIndentedLines(text, i);
     if (i !== -1) end = i + endStep;
   }
-
   for (let ch; ch = text[i += 1];) {
     if (mode === FOLD_QUOTED && ch === '\\') {
       escStart = i;
-
       switch (text[i + 1]) {
         case 'x':
           i += 3;
           break;
-
         case 'u':
           i += 5;
           break;
-
         case 'U':
           i += 9;
           break;
-
         default:
           i += 1;
       }
-
       escEnd = i;
     }
-
     if (ch === '\n') {
       if (mode === FOLD_BLOCK) i = consumeMoreIndentedLines(text, i);
       end = i + endStep;
@@ -843,7 +729,6 @@ function foldFlowLines(text, indent, mode, {
         const next = text[i + 1];
         if (next && next !== ' ' && next !== '\n' && next !== '\t') split = i;
       }
-
       if (i >= end) {
         if (split) {
           folds.push(split);
@@ -855,11 +740,10 @@ function foldFlowLines(text, indent, mode, {
             prev = ch;
             ch = text[i += 1];
             overflow = true;
-          } // Account for newline escape, but don't break preceding escape
-
-
-          const j = i > escEnd + 1 ? i - 2 : escStart - 1; // Bail out if lineWidth & minContentWidth are shorter than an escape string
-
+          }
+          // Account for newline escape, but don't break preceding escape
+          const j = i > escEnd + 1 ? i - 2 : escStart - 1;
+          // Bail out if lineWidth & minContentWidth are shorter than an escape string
           if (escapedFolds[j]) return text;
           folds.push(j);
           escapedFolds[j] = true;
@@ -870,15 +754,12 @@ function foldFlowLines(text, indent, mode, {
         }
       }
     }
-
     prev = ch;
   }
-
   if (overflow && onOverflow) onOverflow();
   if (folds.length === 0) return text;
   if (onFold) onFold();
   let res = text.slice(0, folds[0]);
-
   for (let i = 0; i < folds.length; ++i) {
     const fold = folds[i];
     const end = folds[i + 1] || text.length;
@@ -887,7 +768,6 @@ function foldFlowLines(text, indent, mode, {
       res += `\n${indent}${text.slice(fold + 1, end)}`;
     }
   }
-
   return res;
 }
 
@@ -895,18 +775,16 @@ const getFoldOptions = ({
   indentAtStart
 }) => indentAtStart ? Object.assign({
   indentAtStart
-}, strOptions.fold) : strOptions.fold; // Also checks for lines starting with %, as parsing the output as YAML 1.1 will
-// presume that's starting a new document.
-
+}, strOptions.fold) : strOptions.fold;
 
+// Also checks for lines starting with %, as parsing the output as YAML 1.1 will
+// presume that's starting a new document.
 const containsDocumentMarker = str => /^(%|---|\.\.\.)/m.test(str);
-
 function lineLengthOverLimit(str, lineWidth, indentLength) {
   if (!lineWidth || lineWidth < 0) return false;
   const limit = lineWidth - indentLength;
   const strLen = str.length;
   if (strLen <= limit) return false;
-
   for (let i = 0, start = 0; i < strLen; ++i) {
     if (str[i] === '\n') {
       if (i - start > limit) return true;
@@ -914,10 +792,8 @@ function lineLengthOverLimit(str, lineWidth, indentLength) {
       if (strLen - start <= limit) return false;
     }
   }
-
   return true;
 }
-
 function doubleQuotedString(value, ctx) {
   const {
     implicitKey
@@ -931,7 +807,6 @@ function doubleQuotedString(value, ctx) {
   const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
   let str = '';
   let start = 0;
-
   for (let i = 0, ch = json[i]; ch; ch = json[++i]) {
     if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') {
       // space before newline needs to be escaped to not be folded
@@ -940,85 +815,67 @@ function doubleQuotedString(value, ctx) {
       start = i;
       ch = '\\';
     }
-
     if (ch === '\\') switch (json[i + 1]) {
       case 'u':
         {
           str += json.slice(start, i);
           const code = json.substr(i + 2, 4);
-
           switch (code) {
             case '0000':
               str += '\\0';
               break;
-
             case '0007':
               str += '\\a';
               break;
-
             case '000b':
               str += '\\v';
               break;
-
             case '001b':
               str += '\\e';
               break;
-
             case '0085':
               str += '\\N';
               break;
-
             case '00a0':
               str += '\\_';
               break;
-
             case '2028':
               str += '\\L';
               break;
-
             case '2029':
               str += '\\P';
               break;
-
             default:
               if (code.substr(0, 2) === '00') str += '\\x' + code.substr(2);else str += json.substr(i, 6);
           }
-
           i += 5;
           start = i + 1;
         }
         break;
-
       case 'n':
         if (implicitKey || json[i + 2] === '"' || json.length < minMultiLineLength) {
           i += 1;
         } else {
           // folding will eat first newline
           str += json.slice(start, i) + '\n\n';
-
           while (json[i + 2] === '\\' && json[i + 3] === 'n' && json[i + 4] !== '"') {
             str += '\n';
             i += 2;
           }
-
-          str += indent; // space after newline needs to be escaped to not be folded
-
+          str += indent;
+          // space after newline needs to be escaped to not be folded
           if (json[i + 2] === ' ') str += '\\';
           i += 1;
           start = i + 1;
         }
-
         break;
-
       default:
         i += 1;
     }
   }
-
   str = start ? str + json.slice(start) : json;
   return implicitKey ? str : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
 }
-
 function singleQuotedString(value, ctx) {
   if (ctx.implicitKey) {
     if (/\n/.test(value)) return doubleQuotedString(value, ctx);
@@ -1026,12 +883,10 @@ function singleQuotedString(value, ctx) {
     // single quoted string can't have leading or trailing whitespace around newline
     if (/[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, ctx);
   }
-
   const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
   const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
   return ctx.implicitKey ? res : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
 }
-
 function blockString({
   comment,
   type,
@@ -1042,10 +897,8 @@ function blockString({
   if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
     return doubleQuotedString(value, ctx);
   }
-
   const indent = ctx.indent || (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
   const indentSize = indent ? '2' : '1'; // root is at -1
-
   const literal = type === PlainValue.Type.BLOCK_FOLDED ? false : type === PlainValue.Type.BLOCK_LITERAL ? true : !lineLengthOverLimit(value, strOptions.fold.lineWidth, indent.length);
   let header = literal ? '|' : '>';
   if (!value) return header + '\n';
@@ -1053,21 +906,17 @@ function blockString({
   let wsEnd = '';
   value = value.replace(/[\n\t ]*$/, ws => {
     const n = ws.indexOf('\n');
-
     if (n === -1) {
       header += '-'; // strip
     } else if (value === ws || n !== ws.length - 1) {
       header += '+'; // keep
-
       if (onChompKeep) onChompKeep();
     }
-
     wsEnd = ws.replace(/\n$/, '');
     return '';
   }).replace(/^[\n ]*/, ws => {
     if (ws.indexOf(' ') !== -1) header += indentSize;
     const m = ws.match(/ +$/);
-
     if (m) {
       wsStart = ws.slice(0, -m[0].length);
       return m[0];
@@ -1078,26 +927,21 @@ function blockString({
   });
   if (wsEnd) wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`);
   if (wsStart) wsStart = wsStart.replace(/\n+/g, `$&${indent}`);
-
   if (comment) {
     header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
     if (onComment) onComment();
   }
-
   if (!value) return `${header}${indentSize}\n${indent}${wsEnd}`;
-
   if (literal) {
     value = value.replace(/\n+/g, `$&${indent}`);
     return `${header}\n${indent}${wsStart}${value}${wsEnd}`;
   }
-
   value = value.replace(/\n+/g, '\n$&').replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
   //         ^ ind.line  ^ empty     ^ capture next empty lines only at end of indent
   .replace(/\n+/g, `$&${indent}`);
   const body = foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, FOLD_BLOCK, strOptions.fold);
   return `${header}\n${indent}${body}`;
 }
-
 function plainString(item, ctx, onComment, onChompKeep) {
   const {
     comment,
@@ -1110,11 +954,9 @@ function plainString(item, ctx, onComment, onChompKeep) {
     indent,
     inFlow
   } = ctx;
-
   if (implicitKey && /[\n[\]{},]/.test(value) || inFlow && /[[\]{},]/.test(value)) {
     return doubleQuotedString(value, ctx);
   }
-
   if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
     // not allowed:
     // - empty string, '-' or '?'
@@ -1124,21 +966,18 @@ function plainString(item, ctx, onComment, onChompKeep) {
     // - end with ' ' or ':'
     return implicitKey || inFlow || value.indexOf('\n') === -1 ? value.indexOf('"') !== -1 && value.indexOf("'") === -1 ? singleQuotedString(value, ctx) : doubleQuotedString(value, ctx) : blockString(item, ctx, onComment, onChompKeep);
   }
-
   if (!implicitKey && !inFlow && type !== PlainValue.Type.PLAIN && value.indexOf('\n') !== -1) {
     // Where allowed & type not set explicitly, prefer block style for multiline strings
     return blockString(item, ctx, onComment, onChompKeep);
   }
-
   if (indent === '' && containsDocumentMarker(value)) {
     ctx.forceBlockIndent = true;
     return blockString(item, ctx, onComment, onChompKeep);
   }
-
-  const str = value.replace(/\n+/g, `$&\n${indent}`); // Verify that output will be parsed as a string, as e.g. plain numbers and
+  const str = value.replace(/\n+/g, `$&\n${indent}`);
+  // Verify that output will be parsed as a string, as e.g. plain numbers and
   // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
   // and others in v1.1.
-
   if (actualString) {
     const {
       tags
@@ -1146,17 +985,13 @@ function plainString(item, ctx, onComment, onChompKeep) {
     const resolved = resolveScalar(str, tags, tags.scalarFallback).value;
     if (typeof resolved !== 'string') return doubleQuotedString(value, ctx);
   }
-
   const body = implicitKey ? str : foldFlowLines(str, indent, FOLD_FLOW, getFoldOptions(ctx));
-
   if (comment && !inFlow && (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
     if (onComment) onComment();
     return addCommentBefore(body, indent, comment);
   }
-
   return body;
 }
-
 function stringifyString(item, ctx, onComment, onChompKeep) {
   const {
     defaultType
@@ -1169,34 +1004,27 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     type,
     value
   } = item;
-
   if (typeof value !== 'string') {
     value = String(value);
     item = Object.assign({}, item, {
       value
     });
   }
-
   const _stringify = _type => {
     switch (_type) {
       case PlainValue.Type.BLOCK_FOLDED:
       case PlainValue.Type.BLOCK_LITERAL:
         return blockString(item, ctx, onComment, onChompKeep);
-
       case PlainValue.Type.QUOTE_DOUBLE:
         return doubleQuotedString(value, ctx);
-
       case PlainValue.Type.QUOTE_SINGLE:
         return singleQuotedString(value, ctx);
-
       case PlainValue.Type.PLAIN:
         return plainString(item, ctx, onComment, onChompKeep);
-
       default:
         return null;
     }
   };
-
   if (type !== PlainValue.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) {
     // force double quotes on control characters
     type = PlainValue.Type.QUOTE_DOUBLE;
@@ -1204,14 +1032,11 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
     // should not happen; blocks are not valid inside flow containers
     type = PlainValue.Type.QUOTE_DOUBLE;
   }
-
   let res = _stringify(type);
-
   if (res === null) {
     res = _stringify(defaultType);
     if (res === null) throw new Error(`Unsupported default string type ${defaultType}`);
   }
-
   return res;
 }
 
@@ -1224,57 +1049,44 @@ function stringifyNumber({
   if (typeof value === 'bigint') return String(value);
   if (!isFinite(value)) return isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf';
   let n = JSON.stringify(value);
-
   if (!format && minFractionDigits && (!tag || tag === 'tag:yaml.org,2002:float') && /^\d/.test(n)) {
     let i = n.indexOf('.');
-
     if (i < 0) {
       i = n.length;
       n += '.';
     }
-
     let d = minFractionDigits - (n.length - i - 1);
-
     while (d-- > 0) n += '0';
   }
-
   return n;
 }
 
 function checkFlowCollectionEnd(errors, cst) {
   let char, name;
-
   switch (cst.type) {
     case PlainValue.Type.FLOW_MAP:
       char = '}';
       name = 'flow map';
       break;
-
     case PlainValue.Type.FLOW_SEQ:
       char = ']';
       name = 'flow sequence';
       break;
-
     default:
       errors.push(new PlainValue.YAMLSemanticError(cst, 'Not a flow collection!?'));
       return;
   }
-
   let lastItem;
-
   for (let i = cst.items.length - 1; i >= 0; --i) {
     const item = cst.items[i];
-
     if (!item || item.type !== PlainValue.Type.COMMENT) {
       lastItem = item;
       break;
     }
   }
-
   if (lastItem && lastItem.char !== char) {
     const msg = `Expected ${name} to end with ${char}`;
     let err;
-
     if (typeof lastItem.offset === 'number') {
       err = new PlainValue.YAMLSemanticError(cst, msg);
       err.offset = lastItem.offset + 1;
@@ -1282,13 +1094,11 @@ function checkFlowCollectionEnd(errors, cst) {
       err = new PlainValue.YAMLSemanticError(lastItem, msg);
       if (lastItem.range && lastItem.range.end) err.offset = lastItem.range.end - lastItem.range.start;
     }
-
     errors.push(err);
   }
 }
 function checkFlowCommentSpace(errors, comment) {
   const prev = comment.context.src[comment.range.start - 1];
-
   if (prev !== '\n' && prev !== '\t' && prev !== ' ') {
     const msg = 'Comments must be separated from other tokens by white space characters';
     errors.push(new PlainValue.YAMLSemanticError(comment, msg));
@@ -1306,14 +1116,12 @@ function resolveComments(collection, comments) {
     comment
   } of comments) {
     let item = collection.items[before];
-
     if (!item) {
       if (comment !== undefined) {
         if (collection.comment) collection.comment += '\n' + comment;else collection.comment = comment;
       }
     } else {
       if (afterKey && item.value) item = item.value;
-
       if (comment === undefined) {
         if (afterKey || !item.commentBefore) item.spaceBefore = true;
       } else {
@@ -1341,45 +1149,37 @@ function resolveTagHandle(doc, node) {
     suffix
   } = node.tag;
   let prefix = doc.tagPrefixes.find(p => p.handle === handle);
-
   if (!prefix) {
     const dtp = doc.getDefaults().tagPrefixes;
     if (dtp) prefix = dtp.find(p => p.handle === handle);
     if (!prefix) throw new PlainValue.YAMLSemanticError(node, `The ${handle} tag handle is non-default and was not declared.`);
   }
-
   if (!suffix) throw new PlainValue.YAMLSemanticError(node, `The ${handle} tag has no suffix.`);
-
   if (handle === '!' && (doc.version || doc.options.version) === '1.0') {
     if (suffix[0] === '^') {
       doc.warnings.push(new PlainValue.YAMLWarning(node, 'YAML 1.0 ^ tag expansion is not supported'));
       return suffix;
     }
-
     if (/[:/]/.test(suffix)) {
       // word/foo -> tag:word.yaml.org,2002:foo
       const vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i);
       return vocab ? `tag:${vocab[1]}.yaml.org,2002:${vocab[2]}` : `tag:${suffix}`;
     }
   }
-
   return prefix.prefix + decodeURIComponent(suffix);
 }
-
 function resolveTagName(doc, node) {
   const {
     tag,
     type
   } = node;
   let nonSpecific = false;
-
   if (tag) {
     const {
       handle,
       suffix,
       verbatim
     } = tag;
-
     if (verbatim) {
       if (verbatim !== '!' && verbatim !== '!!') return verbatim;
       const msg = `Verbatim tags aren't resolved, so ${verbatim} is invalid.`;
@@ -1394,25 +1194,20 @@ function resolveTagName(doc, node) {
       }
     }
   }
-
   switch (type) {
     case PlainValue.Type.BLOCK_FOLDED:
     case PlainValue.Type.BLOCK_LITERAL:
     case PlainValue.Type.QUOTE_DOUBLE:
     case PlainValue.Type.QUOTE_SINGLE:
       return PlainValue.defaultTags.STR;
-
     case PlainValue.Type.FLOW_MAP:
     case PlainValue.Type.MAP:
       return PlainValue.defaultTags.MAP;
-
     case PlainValue.Type.FLOW_SEQ:
     case PlainValue.Type.SEQ:
       return PlainValue.defaultTags.SEQ;
-
     case PlainValue.Type.PLAIN:
       return nonSpecific ? PlainValue.defaultTags.STR : null;
-
     default:
       return null;
   }
@@ -1423,7 +1218,6 @@ function resolveByTagName(doc, node, tagName) {
     tags
   } = doc.schema;
   const matchWithTest = [];
-
   for (const tag of tags) {
     if (tag.tag === tagName) {
       if (tag.test) matchWithTest.push(tag);else {
@@ -1432,12 +1226,10 @@ function resolveByTagName(doc, node, tagName) {
       }
     }
   }
-
   const str = resolveString(doc, node);
   if (typeof str === 'string' && matchWithTest.length > 0) return resolveScalar(str, matchWithTest, tags.scalarFallback);
   return null;
 }
-
 function getFallbackTagName({
   type
 }) {
@@ -1445,31 +1237,30 @@ function getFallbackTagName({
     case PlainValue.Type.FLOW_MAP:
     case PlainValue.Type.MAP:
       return PlainValue.defaultTags.MAP;
-
     case PlainValue.Type.FLOW_SEQ:
     case PlainValue.Type.SEQ:
       return PlainValue.defaultTags.SEQ;
-
     default:
       return PlainValue.defaultTags.STR;
   }
 }
-
 function resolveTag(doc, node, tagName) {
   try {
     const res = resolveByTagName(doc, node, tagName);
-
     if (res) {
       if (tagName && node.tag) res.tag = tagName;
       return res;
     }
   } catch (error) {
-    /* istanbul ignore if */
-    if (!error.source) error.source = node;
-    doc.errors.push(error);
+    if (error instanceof PlainValue.YAMLError) {
+      if (!error.source) error.source = node;
+      doc.errors.push(error);
+    } else {
+      const msg = error instanceof Error ? error.message : String(error);
+      doc.errors.push(new PlainValue.YAMLSemanticError(node, msg));
+    }
     return null;
   }
-
   try {
     const fallback = getFallbackTagName(node);
     if (!fallback) throw new Error(`The tag ${tagName} is unavailable`);
@@ -1493,7 +1284,6 @@ const isCollectionItem = node => {
   } = node;
   return type === PlainValue.Type.MAP_KEY || type === PlainValue.Type.MAP_VALUE || type === PlainValue.Type.SEQ_ITEM;
 };
-
 function resolveNodeProps(errors, node) {
   const comments = {
     before: [],
@@ -1502,7 +1292,6 @@ function resolveNodeProps(errors, node) {
   let hasAnchor = false;
   let hasTag = false;
   const props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props;
-
   for (const {
     start,
     end
@@ -1514,7 +1303,6 @@ function resolveNodeProps(errors, node) {
             const msg = 'Comments must be separated from other tokens by white space characters';
             errors.push(new PlainValue.YAMLSemanticError(node, msg));
           }
-
           const {
             header,
             valueRange
@@ -1523,69 +1311,57 @@ function resolveNodeProps(errors, node) {
           cc.push(node.context.src.slice(start + 1, end));
           break;
         }
-      // Actual anchor & tag resolution is handled by schema, here we just complain
 
+      // Actual anchor & tag resolution is handled by schema, here we just complain
       case PlainValue.Char.ANCHOR:
         if (hasAnchor) {
           const msg = 'A node can have at most one anchor';
           errors.push(new PlainValue.YAMLSemanticError(node, msg));
         }
-
         hasAnchor = true;
         break;
-
       case PlainValue.Char.TAG:
         if (hasTag) {
           const msg = 'A node can have at most one tag';
           errors.push(new PlainValue.YAMLSemanticError(node, msg));
         }
-
         hasTag = true;
         break;
     }
   }
-
   return {
     comments,
     hasAnchor,
     hasTag
   };
 }
-
 function resolveNodeValue(doc, node) {
   const {
     anchors,
     errors,
     schema
   } = doc;
-
   if (node.type === PlainValue.Type.ALIAS) {
     const name = node.rawValue;
     const src = anchors.getNode(name);
-
     if (!src) {
       const msg = `Aliased anchor not found: ${name}`;
       errors.push(new PlainValue.YAMLReferenceError(node, msg));
       return null;
-    } // Lazy resolution for circular references
-
+    }
 
+    // Lazy resolution for circular references
     const res = new Alias(src);
-
     anchors._cstAliases.push(res);
-
     return res;
   }
-
   const tagName = resolveTagName(doc, node);
   if (tagName) return resolveTag(doc, node, tagName);
-
   if (node.type !== PlainValue.Type.PLAIN) {
     const msg = `Failed to resolve ${node.type} node here`;
     errors.push(new PlainValue.YAMLSyntaxError(node, msg));
     return null;
   }
-
   try {
     const str = resolveString(doc, node);
     return resolveScalar(str, schema.tags, schema.tags.scalarFallback);
@@ -1594,9 +1370,9 @@ function resolveNodeValue(doc, node) {
     errors.push(error);
     return null;
   }
-} // sets node.resolved on success
-
+}
 
+// sets node.resolved on success
 function resolveNode(doc, node) {
   if (!node) return null;
   if (node.error) doc.errors.push(node.error);
@@ -1605,43 +1381,36 @@ function resolveNode(doc, node) {
     hasAnchor,
     hasTag
   } = resolveNodeProps(doc.errors, node);
-
   if (hasAnchor) {
     const {
       anchors
     } = doc;
     const name = node.anchor;
-    const prev = anchors.getNode(name); // At this point, aliases for any preceding node with the same anchor
+    const prev = anchors.getNode(name);
+    // At this point, aliases for any preceding node with the same anchor
     // name have already been resolved, so it may safely be renamed.
-
-    if (prev) anchors.map[anchors.newName(name)] = prev; // During parsing, we need to store the CST node in anchors.map as
+    if (prev) anchors.map[anchors.newName(name)] = prev;
+    // During parsing, we need to store the CST node in anchors.map as
     // anchors need to be available during resolution to allow for
     // circular references.
-
     anchors.map[name] = node;
   }
-
   if (node.type === PlainValue.Type.ALIAS && (hasAnchor || hasTag)) {
     const msg = 'An alias node must not specify any properties';
     doc.errors.push(new PlainValue.YAMLSemanticError(node, msg));
   }
-
   const res = resolveNodeValue(doc, node);
-
   if (res) {
     res.range = [node.range.start, node.range.end];
     if (doc.options.keepCstNodes) res.cstNode = node;
     if (doc.options.keepNodeTypes) res.type = node.type;
     const cb = comments.before.join('\n');
-
     if (cb) {
       res.commentBefore = res.commentBefore ? `${res.commentBefore}\n${cb}` : cb;
     }
-
     const ca = comments.after.join('\n');
     if (ca) res.comment = res.comment ? `${res.comment}\n${ca}` : ca;
   }
-
   return node.resolved = res;
 }
 
@@ -1651,7 +1420,6 @@ function resolveMap(doc, cst) {
     doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg));
     return null;
   }
-
   const {
     comments,
     items
@@ -1660,13 +1428,11 @@ function resolveMap(doc, cst) {
   map.items = items;
   resolveComments(map, comments);
   let hasCollectionKey = false;
-
   for (let i = 0; i < items.length; ++i) {
     const {
       key: iKey
     } = items[i];
     if (iKey instanceof Collection) hasCollectionKey = true;
-
     if (doc.schema.merge && iKey && iKey.value === MERGE_KEY) {
       items[i] = new Merge(items[i]);
       const sources = items[i].value.items;
@@ -1681,7 +1447,6 @@ function resolveMap(doc, cst) {
           if (type === PlainValue.Type.MAP || type === PlainValue.Type.FLOW_MAP) return false;
           return error = 'Merge nodes aliases can only point to maps';
         }
-
         return error = 'Merge nodes can only have Alias nodes as values';
       });
       if (error) doc.errors.push(new PlainValue.YAMLSemanticError(cst, error));
@@ -1690,7 +1455,6 @@ function resolveMap(doc, cst) {
         const {
           key: jKey
         } = items[j];
-
         if (iKey === jKey || iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, 'value') && iKey.value === jKey.value) {
           const msg = `Map keys must be unique; "${iKey}" is repeated`;
           doc.errors.push(new PlainValue.YAMLSemanticError(cst, msg));
@@ -1699,16 +1463,13 @@ function resolveMap(doc, cst) {
       }
     }
   }
-
   if (hasCollectionKey && !doc.options.mapAsMap) {
     const warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
     doc.warnings.push(new PlainValue.YAMLWarning(cst, warn));
   }
-
   cst.resolved = map;
   return map;
 }
-
 const valueHasPairComment = ({
   context: {
     lineStart,
@@ -1723,42 +1484,33 @@ const valueHasPairComment = ({
   } = props[0];
   if (node && start > node.valueRange.start) return false;
   if (src[start] !== PlainValue.Char.COMMENT) return false;
-
   for (let i = lineStart; i < start; ++i) if (src[i] === '\n') return false;
-
   return true;
 };
-
 function resolvePairComment(item, pair) {
   if (!valueHasPairComment(item)) return;
   const comment = item.getPropValue(0, PlainValue.Char.COMMENT, true);
   let found = false;
   const cb = pair.value.commentBefore;
-
   if (cb && cb.startsWith(comment)) {
     pair.value.commentBefore = cb.substr(comment.length + 1);
     found = true;
   } else {
     const cc = pair.value.comment;
-
     if (!item.node && cc && cc.startsWith(comment)) {
       pair.value.comment = cc.substr(comment.length + 1);
       found = true;
     }
   }
-
   if (found) pair.comment = comment;
 }
-
 function resolveBlockMapItems(doc, cst) {
   const comments = [];
   const items = [];
   let key = undefined;
   let keyStart = null;
-
   for (let i = 0; i < cst.items.length; ++i) {
     const item = cst.items[i];
-
     switch (item.type) {
       case PlainValue.Type.BLANK_LINE:
         comments.push({
@@ -1766,7 +1518,6 @@ function resolveBlockMapItems(doc, cst) {
           before: items.length
         });
         break;
-
       case PlainValue.Type.COMMENT:
         comments.push({
           afterKey: !!key,
@@ -1774,26 +1525,21 @@ function resolveBlockMapItems(doc, cst) {
           comment: item.comment
         });
         break;
-
       case PlainValue.Type.MAP_KEY:
         if (key !== undefined) items.push(new Pair(key));
         if (item.error) doc.errors.push(item.error);
         key = resolveNode(doc, item.node);
         keyStart = null;
         break;
-
       case PlainValue.Type.MAP_VALUE:
         {
           if (key === undefined) key = null;
           if (item.error) doc.errors.push(item.error);
-
           if (!item.context.atLineStart && item.node && item.node.type === PlainValue.Type.MAP && !item.node.context.atLineStart) {
             const msg = 'Nested mappings are not allowed in compact mappings';
             doc.errors.push(new PlainValue.YAMLSemanticError(item.node, msg));
           }
-
           let valueNode = item.node;
-
           if (!valueNode && item.props.length > 0) {
             // Comments on an empty mapping value need to be preserved, so we
             // need to construct a minimal empty node here to use instead of the
@@ -1812,44 +1558,35 @@ function resolveBlockMapItems(doc, cst) {
               start: pos,
               end: pos
             };
-
             if (typeof item.range.origStart === 'number') {
               const origPos = item.range.origStart + 1;
               valueNode.range.origStart = valueNode.range.origEnd = origPos;
               valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos;
             }
           }
-
           const pair = new Pair(key, resolveNode(doc, valueNode));
           resolvePairComment(item, pair);
           items.push(pair);
-
           if (key && typeof keyStart === 'number') {
             if (item.range.start > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key));
           }
-
           key = undefined;
           keyStart = null;
         }
         break;
-
       default:
         if (key !== undefined) items.push(new Pair(key));
         key = resolveNode(doc, item);
         keyStart = item.range.start;
         if (item.error) doc.errors.push(item.error);
-
         next: for (let j = i + 1;; ++j) {
           const nextItem = cst.items[j];
-
           switch (nextItem && nextItem.type) {
             case PlainValue.Type.BLANK_LINE:
             case PlainValue.Type.COMMENT:
               continue next;
-
             case PlainValue.Type.MAP_VALUE:
               break next;
-
             default:
               {
                 const msg = 'Implicit map keys need to be followed by map values';
@@ -1858,47 +1595,38 @@ function resolveBlockMapItems(doc, cst) {
               }
           }
         }
-
         if (item.valueRangeContainsNewline) {
           const msg = 'Implicit map keys need to be on a single line';
           doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
         }
-
     }
   }
-
   if (key !== undefined) items.push(new Pair(key));
   return {
     comments,
     items
   };
 }
-
 function resolveFlowMapItems(doc, cst) {
   const comments = [];
   const items = [];
   let key = undefined;
   let explicitKey = false;
   let next = '{';
-
   for (let i = 0; i < cst.items.length; ++i) {
     const item = cst.items[i];
-
     if (typeof item.char === 'string') {
       const {
         char,
         offset
       } = item;
-
       if (char === '?' && key === undefined && !explicitKey) {
         explicitKey = true;
         next = ':';
         continue;
       }
-
       if (char === ':') {
         if (key === undefined) key = null;
-
         if (next === ':') {
           next = ',';
           continue;
@@ -1908,25 +1636,21 @@ function resolveFlowMapItems(doc, cst) {
           if (key === undefined && char !== ',') key = null;
           explicitKey = false;
         }
-
         if (key !== undefined) {
           items.push(new Pair(key));
           key = undefined;
-
           if (char === ',') {
             next = ':';
             continue;
           }
         }
       }
-
       if (char === '}') {
         if (i === cst.items.length - 1) continue;
       } else if (char === next) {
         next = ':';
         continue;
       }
-
       const msg = `Flow map contains an unexpected ${char}`;
       const err = new PlainValue.YAMLSyntaxError(cst, msg);
       err.offset = offset;
@@ -1953,7 +1677,6 @@ function resolveFlowMapItems(doc, cst) {
       explicitKey = false;
     }
   }
-
   checkFlowCollectionEnd(doc.errors, cst);
   if (key !== undefined) items.push(new Pair(key));
   return {
@@ -1968,7 +1691,6 @@ function resolveSeq(doc, cst) {
     doc.errors.push(new PlainValue.YAMLSyntaxError(cst, msg));
     return null;
   }
-
   const {
     comments,
     items
@@ -1976,60 +1698,48 @@ function resolveSeq(doc, cst) {
   const seq = new YAMLSeq();
   seq.items = items;
   resolveComments(seq, comments);
-
   if (!doc.options.mapAsMap && items.some(it => it instanceof Pair && it.key instanceof Collection)) {
     const warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
     doc.warnings.push(new PlainValue.YAMLWarning(cst, warn));
   }
-
   cst.resolved = seq;
   return seq;
 }
-
 function resolveBlockSeqItems(doc, cst) {
   const comments = [];
   const items = [];
-
   for (let i = 0; i < cst.items.length; ++i) {
     const item = cst.items[i];
-
     switch (item.type) {
       case PlainValue.Type.BLANK_LINE:
         comments.push({
           before: items.length
         });
         break;
-
       case PlainValue.Type.COMMENT:
         comments.push({
           comment: item.comment,
           before: items.length
         });
         break;
-
       case PlainValue.Type.SEQ_ITEM:
         if (item.error) doc.errors.push(item.error);
         items.push(resolveNode(doc, item.node));
-
         if (item.hasProps) {
           const msg = 'Sequence items cannot have tags or anchors before the - indicator';
           doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
         }
-
         break;
-
       default:
         if (item.error) doc.errors.push(item.error);
         doc.errors.push(new PlainValue.YAMLSyntaxError(item, `Unexpected ${item.type} node in sequence`));
     }
   }
-
   return {
     comments,
     items
   };
 }
-
 function resolveFlowSeqItems(doc, cst) {
   const comments = [];
   const items = [];
@@ -2038,16 +1748,13 @@ function resolveFlowSeqItems(doc, cst) {
   let keyStart = null;
   let next = '[';
   let prevItem = null;
-
   for (let i = 0; i < cst.items.length; ++i) {
     const item = cst.items[i];
-
     if (typeof item.char === 'string') {
       const {
         char,
         offset
       } = item;
-
       if (char !== ':' && (explicitKey || key !== undefined)) {
         if (explicitKey && key === undefined) key = next ? items.pop() : null;
         items.push(new Pair(key));
@@ -2055,7 +1762,6 @@ function resolveFlowSeqItems(doc, cst) {
         key = undefined;
         keyStart = null;
       }
-
       if (char === next) {
         next = null;
       } else if (!next && char === '?') {
@@ -2063,21 +1769,18 @@ function resolveFlowSeqItems(doc, cst) {
       } else if (next !== '[' && char === ':' && key === undefined) {
         if (next === ',') {
           key = items.pop();
-
           if (key instanceof Pair) {
             const msg = 'Chaining flow sequence pairs is invalid';
             const err = new PlainValue.YAMLSemanticError(cst, msg);
             err.offset = offset;
             doc.errors.push(err);
           }
-
           if (!explicitKey && typeof keyStart === 'number') {
             const keyEnd = item.range ? item.range.start : item.offset;
             if (keyEnd > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key));
             const {
               src
             } = prevItem.context;
-
             for (let i = keyStart; i < keyEnd; ++i) if (src[i] === '\n') {
               const msg = 'Implicit keys of flow sequence pairs need to be on a single line';
               doc.errors.push(new PlainValue.YAMLSemanticError(prevItem, msg));
@@ -2087,7 +1790,6 @@ function resolveFlowSeqItems(doc, cst) {
         } else {
           key = null;
         }
-
         keyStart = null;
         explicitKey = false;
         next = null;
@@ -2112,9 +1814,7 @@ function resolveFlowSeqItems(doc, cst) {
         const msg = `Expected a ${next} in flow sequence`;
         doc.errors.push(new PlainValue.YAMLSemanticError(item, msg));
       }
-
       const value = resolveNode(doc, item);
-
       if (key === undefined) {
         items.push(value);
         prevItem = item;
@@ -2122,12 +1822,10 @@ function resolveFlowSeqItems(doc, cst) {
         items.push(new Pair(key, value));
         key = undefined;
       }
-
       keyStart = item.range.start;
       next = ',';
     }
   }
-
   checkFlowCollectionEnd(doc.errors, cst);
   if (key !== undefined) items.push(new Pair(key));
   return {