cdk8s 2.7.62 → 2.7.64

package/node_modules/yaml/dist/parse/cst-scalar.d.ts

@@ -6,6 +6,12 @@ import type { BlockScalar, FlowScalar, SourceToken, Token } from './cst.js';
  * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
  * Otherwise, return `null`.
  */
+export declare function resolveAsScalar(token: FlowScalar | BlockScalar, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+    value: string;
+    type: Scalar.Type | null;
+    comment: string;
+    range: Range;
+};
 export declare function resolveAsScalar(token: Token | null | undefined, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
     value: string;
     type: Scalar.Type | null;

package/node_modules/yaml/dist/parse/cst-scalar.js

@@ -5,10 +5,6 @@ var resolveFlowScalar = require('../compose/resolve-flow-scalar.js');
 var errors = require('../errors.js');
 var stringifyString = require('../stringify/stringifyString.js');
 
-/**
- * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
- * Otherwise, return `null`.
- */
 function resolveAsScalar(token, strict = true, onError) {
     if (token) {
         const _onError = (pos, code, message) => {
@@ -44,15 +40,14 @@ function resolveAsScalar(token, strict = true, onError) {
  * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
  */
 function createScalarToken(value, context) {
-    var _a;
     const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
     const source = stringifyString.stringifyString({ type, value }, {
         implicitKey,
         indent: indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
-    const end = (_a = context.end) !== null && _a !== void 0 ? _a : [
+    const end = context.end ?? [
         { type: 'newline', offset: -1, indent, source: '\n' }
     ];
     switch (source[0]) {
@@ -119,7 +114,7 @@ function setScalarValue(token, value, context = {}) {
         implicitKey: implicitKey || indent === null,
         indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
     switch (source[0]) {
         case '|':

package/node_modules/yaml/dist/parse/cst-visit.d.ts

@@ -1,6 +1,6 @@
 import type { CollectionItem, Document } from './cst.js';
-export declare type VisitPath = readonly ['key' | 'value', number][];
-export declare type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
+export type VisitPath = readonly ['key' | 'value', number][];
+export type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
 /**
  * Apply a visitor to a CST document or item.
  *

package/node_modules/yaml/dist/parse/cst-visit.js

@@ -49,7 +49,7 @@ visit.REMOVE = REMOVE;
 visit.itemAtPath = (cst, path) => {
     let item = cst;
     for (const [field, index] of path) {
-        const tok = item && item[field];
+        const tok = item?.[field];
         if (tok && 'items' in tok) {
             item = tok.items[index];
         }
@@ -66,7 +66,7 @@ visit.itemAtPath = (cst, path) => {
 visit.parentCollection = (cst, path) => {
     const parent = visit.itemAtPath(cst, path.slice(0, -1));
     const field = path[path.length - 1][0];
-    const coll = parent && parent[field];
+    const coll = parent?.[field];
     if (coll && 'items' in coll)
         return coll;
     throw new Error('Parent collection not found');

package/node_modules/yaml/dist/parse/cst.d.ts

@@ -72,7 +72,7 @@ export interface BlockSequence {
         value?: Token;
     }>;
 }
-export declare type CollectionItem = {
+export type CollectionItem = {
     start: SourceToken[];
     key?: Token | null;
     sep?: SourceToken[];
@@ -86,8 +86,8 @@ export interface FlowCollection {
     items: CollectionItem[];
     end: SourceToken[];
 }
-export declare type Token = SourceToken | ErrorToken | Directive | Document | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
-export declare type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];
+export type Token = SourceToken | ErrorToken | Directive | Document | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
+export type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];
 /** The byte order mark */
 export declare const BOM = "\uFEFF";
 /** Start of doc-mode */

package/node_modules/yaml/dist/parse/lexer.d.ts

@@ -47,6 +47,8 @@ export declare class Lexer {
     private indentNext;
     /** Indentation level of the current line. */
     private indentValue;
+    /** Position of the next \n character. */
+    private lineEndPos;
     /** Stores the state of the lexer if reaching the end of incpomplete input */
     private next;
     /** A pointer to `buffer`; the current position of the lexer. */

package/node_modules/yaml/dist/parse/lexer.js

@@ -136,6 +136,8 @@ class Lexer {
         this.indentNext = 0;
         /** Indentation level of the current line. */
         this.indentValue = 0;
+        /** Position of the next \n character. */
+        this.lineEndPos = null;
         /** Stores the state of the lexer if reaching the end of incpomplete input */
         this.next = null;
         /** A pointer to `buffer`; the current position of the lexer. */
@@ -148,10 +150,12 @@ class Lexer {
      * @returns A generator of lexical tokens
      */
     *lex(source, incomplete = false) {
-        if (source)
+        if (source) {
             this.buffer = this.buffer ? this.buffer + source : source;
+            this.lineEndPos = null;
+        }
         this.atEnd = !incomplete;
-        let next = this.next || 'stream';
+        let next = this.next ?? 'stream';
         while (next && (incomplete || this.hasChars(1)))
             next = yield* this.parseNext(next);
     }
@@ -192,7 +196,11 @@ class Lexer {
         return offset;
     }
     getLine() {
-        let end = this.buffer.indexOf('\n', this.pos);
+        let end = this.lineEndPos;
+        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
+            end = this.buffer.indexOf('\n', this.pos);
+            this.lineEndPos = end;
+        }
         if (end === -1)
             return this.atEnd ? this.buffer.substring(this.pos) : null;
         if (this.buffer[end - 1] === '\r')
@@ -205,6 +213,7 @@ class Lexer {
     setNext(state) {
         this.buffer = this.buffer.substring(this.pos);
         this.pos = 0;
+        this.lineEndPos = null;
         this.next = state;
         return null;
     }
@@ -350,14 +359,19 @@ class Lexer {
         let indent = -1;
         do {
             nl = yield* this.pushNewline();
-            sp = yield* this.pushSpaces(true);
-            if (nl > 0)
+            if (nl > 0) {
+                sp = yield* this.pushSpaces(false);
                 this.indentValue = indent = sp;
+            }
+            else {
+                sp = 0;
+            }
+            sp += yield* this.pushSpaces(true);
         } while (nl + sp > 0);
         const line = this.getLine();
         if (line === null)
             return this.setNext('flow');
-        if ((indent !== -1 && indent < this.indentNext) ||
+        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
             (indent === 0 &&
                 (line.startsWith('---') || line.startsWith('...')) &&
                 isEmpty(line[3]))) {
@@ -375,8 +389,11 @@ class Lexer {
             }
         }
         let n = 0;
-        while (line[n] === ',')
-            n += (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+        while (line[n] === ',') {
+            n += yield* this.pushCount(1);
+            n += yield* this.pushSpaces(true);
+            this.flowKey = false;
+        }
         n += yield* this.pushIndicators();
         switch (line[n]) {
             case undefined:
@@ -406,6 +423,7 @@ class Lexer {
             case ':': {
                 const next = this.charAt(1);
                 if (this.flowKey || isEmpty(next) || next === ',') {
+                    this.flowKey = false;
                     yield* this.pushCount(1);
                     yield* this.pushSpaces(true);
                     return 'flow';
@@ -435,17 +453,19 @@ class Lexer {
                 end = this.buffer.indexOf('"', end + 1);
             }
         }
-        let nl = this.buffer.indexOf('\n', this.pos);
-        if (nl !== -1 && nl < end) {
-            while (nl !== -1 && nl < end) {
+        // Only looking for newlines within the quotes
+        const qb = this.buffer.substring(0, end);
+        let nl = qb.indexOf('\n', this.pos);
+        if (nl !== -1) {
+            while (nl !== -1) {
                 const cs = this.continueScalar(nl + 1);
                 if (cs === -1)
                     break;
-                nl = this.buffer.indexOf('\n', cs);
+                nl = qb.indexOf('\n', cs);
             }
-            if (nl !== -1 && nl < end) {
+            if (nl !== -1) {
                 // this is an error caused by an unexpected unindent
-                end = nl - 1;
+                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
             }
         }
         if (end === -1) {
@@ -520,9 +540,10 @@ class Lexer {
                 let ch = this.buffer[i];
                 if (ch === '\r')
                     ch = this.buffer[--i];
+                const lastChar = i; // Drop the line if last char not more indented
                 while (ch === ' ' || ch === '\t')
                     ch = this.buffer[--i];
-                if (ch === '\n' && i >= this.pos)
+                if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar)
                     nl = i;
                 else
                     break;
@@ -545,17 +566,18 @@ class Lexer {
                 end = i;
             }
             else if (isEmpty(ch)) {
-                const next = this.buffer[i + 1];
-                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
-                    break;
+                let next = this.buffer[i + 1];
                 if (ch === '\r') {
                     if (next === '\n') {
                         i += 1;
                         ch = '\n';
+                        next = this.buffer[i + 1];
                     }
                     else
                         end = i;
                 }
+                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
+                    break;
                 if (ch === '\n') {
                     const cs = this.continueScalar(i + 1);
                     if (cs === -1)
@@ -604,16 +626,21 @@ class Lexer {
                 return ((yield* this.pushUntil(isNotAnchorChar)) +
                     (yield* this.pushSpaces(true)) +
                     (yield* this.pushIndicators()));
-            case ':':
-            case '?': // this is an error outside flow collections
             case '-': // this is an error
-                if (isEmpty(this.charAt(1))) {
-                    if (this.flowLevel === 0)
+            case '?': // this is an error outside flow collections
+            case ':': {
+                const inFlow = this.flowLevel > 0;
+                const ch1 = this.charAt(1);
+                if (isEmpty(ch1) || (inFlow && invalidFlowScalarChars.includes(ch1))) {
+                    if (!inFlow)
                         this.indentNext = this.indentValue + 1;
+                    else if (this.flowKey)
+                        this.flowKey = false;
                     return ((yield* this.pushCount(1)) +
                         (yield* this.pushSpaces(true)) +
                         (yield* this.pushIndicators()));
                 }
+            }
         }
         return 0;
     }

package/node_modules/yaml/dist/parse/parser.js

@@ -9,7 +9,7 @@ function includesToken(list, type) {
             return true;
     return false;
 }
-function includesNonEmpty(list) {
+function findNonEmptyIndex(list) {
     for (let i = 0; i < list.length; ++i) {
         switch (list[i].type) {
             case 'space':
@@ -17,13 +17,13 @@ function includesNonEmpty(list) {
             case 'newline':
                 break;
             default:
-                return true;
+                return i;
         }
     }
-    return false;
+    return -1;
 }
 function isFlowToken(token) {
-    switch (token === null || token === void 0 ? void 0 : token.type) {
+    switch (token?.type) {
         case 'alias':
         case 'scalar':
         case 'single-quoted-scalar':
@@ -40,7 +40,7 @@ function getPrevProps(parent) {
             return parent.start;
         case 'block-map': {
             const it = parent.items[parent.items.length - 1];
-            return it.sep || it.start;
+            return it.sep ?? it.start;
         }
         case 'block-seq':
             return parent.items[parent.items.length - 1].start;
@@ -51,7 +51,6 @@ function getPrevProps(parent) {
 }
 /** Note: May modify input array */
 function getFirstKeyStartProps(prev) {
-    var _a;
     if (prev.length === 0)
         return [];
     let i = prev.length;
@@ -65,7 +64,7 @@ function getFirstKeyStartProps(prev) {
                 break loop;
         }
     }
-    while (((_a = prev[++i]) === null || _a === void 0 ? void 0 : _a.type) === 'space') {
+    while (prev[++i]?.type === 'space') {
         /* loop */
     }
     return prev.splice(i, prev.length);
@@ -207,6 +206,7 @@ class Parser {
                         this.indent += source.length;
                     break;
                 case 'doc-mode':
+                case 'flow-error-end':
                     return;
                 default:
                     this.atNewLine = false;
@@ -268,7 +268,7 @@ class Parser {
         return this.stack[this.stack.length - n];
     }
     *pop(error) {
-        const token = error || this.stack.pop();
+        const token = error ?? this.stack.pop();
         /* istanbul ignore if should not happen */
         if (!token) {
             const message = 'Tried to pop an empty stack';
@@ -279,9 +279,14 @@ class Parser {
         }
         else {
             const top = this.peek(1);
-            // For these, parent indent is needed instead of own
-            if (token.type === 'block-scalar' || token.type === 'flow-collection')
-                token.indent = 'indent' in top ? top.indent : -1;
+            if (token.type === 'block-scalar') {
+                // Block scalars use their parent rather than header indent
+                token.indent = 'indent' in top ? top.indent : 0;
+            }
+            else if (token.type === 'flow-collection' && top.type === 'document') {
+                // Ignore all indent for top-level flow collections
+                token.indent = 0;
+            }
             if (token.type === 'flow-collection')
                 fixFlowSeqItems(token);
             switch (top.type) {
@@ -340,7 +345,7 @@ class Parser {
                     !last.sep &&
                     !last.value &&
                     last.start.length > 0 &&
-                    !includesNonEmpty(last.start) &&
+                    findNonEmptyIndex(last.start) === -1 &&
                     (token.indent === 0 ||
                         last.start.every(st => st.type !== 'comment' || st.indent < token.indent))) {
                     if (top.type === 'document')
@@ -388,7 +393,7 @@ class Parser {
             return yield* this.lineEnd(doc);
         switch (this.type) {
             case 'doc-start': {
-                if (includesNonEmpty(doc.start)) {
+                if (findNonEmptyIndex(doc.start) !== -1) {
                     yield* this.pop();
                     yield* this.step();
                 }
@@ -468,7 +473,6 @@ class Parser {
         }
     }
     *blockMap(map) {
-        var _a;
         const it = map.items[map.items.length - 1];
         // it.sep is true-ish if pair already has key or : separator
         switch (this.type) {
@@ -477,26 +481,30 @@ class Parser {
                 if (it.value) {
                     const end = 'end' in it.value ? it.value.end : undefined;
                     const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
                     else
                         map.items.push({ start: [this.sourceToken] });
                 }
-                else if (it.sep)
+                else if (it.sep) {
                     it.sep.push(this.sourceToken);
-                else
+                }
+                else {
                     it.start.push(this.sourceToken);
+                }
                 return;
             case 'space':
             case 'comment':
-                if (it.value)
+                if (it.value) {
                     map.items.push({ start: [this.sourceToken] });
-                else if (it.sep)
+                }
+                else if (it.sep) {
                     it.sep.push(this.sourceToken);
+                }
                 else {
                     if (this.atIndentedComment(it.start, map.indent)) {
                         const prev = map.items[map.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        const end = prev?.value?.end;
                         if (Array.isArray(end)) {
                             Array.prototype.push.apply(end, it.start);
                             end.push(this.sourceToken);
@@ -509,66 +517,132 @@ class Parser {
                 return;
         }
         if (this.indent >= map.indent) {
-            const atNextItem = !this.onKeyLine &&
-                this.indent === map.indent &&
-                (it.sep || includesNonEmpty(it.start));
+            const atNextItem = !this.onKeyLine && this.indent === map.indent && it.sep;
+            // For empty nodes, assign newline-separated not indented empty tokens to following node
+            let start = [];
+            if (atNextItem && it.sep && !it.value) {
+                const nl = [];
+                for (let i = 0; i < it.sep.length; ++i) {
+                    const st = it.sep[i];
+                    switch (st.type) {
+                        case 'newline':
+                            nl.push(i);
+                            break;
+                        case 'space':
+                            break;
+                        case 'comment':
+                            if (st.indent > map.indent)
+                                nl.length = 0;
+                            break;
+                        default:
+                            nl.length = 0;
+                    }
+                }
+                if (nl.length >= 2)
+                    start = it.sep.splice(nl[1]);
+            }
             switch (this.type) {
                 case 'anchor':
                 case 'tag':
                     if (atNextItem || it.value) {
-                        map.items.push({ start: [this.sourceToken] });
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
                         this.onKeyLine = true;
                     }
-                    else if (it.sep)
+                    else if (it.sep) {
                         it.sep.push(this.sourceToken);
-                    else
+                    }
+                    else {
                         it.start.push(this.sourceToken);
+                    }
                     return;
                 case 'explicit-key-ind':
-                    if (!it.sep && !includesToken(it.start, 'explicit-key-ind'))
+                    if (!it.sep && !includesToken(it.start, 'explicit-key-ind')) {
                         it.start.push(this.sourceToken);
-                    else if (atNextItem || it.value)
-                        map.items.push({ start: [this.sourceToken] });
-                    else
+                    }
+                    else if (atNextItem || it.value) {
+                        start.push(this.sourceToken);
+                        map.items.push({ start });
+                    }
+                    else {
                         this.stack.push({
                             type: 'block-map',
                             offset: this.offset,
                             indent: this.indent,
                             items: [{ start: [this.sourceToken] }]
                         });
+                    }
                     this.onKeyLine = true;
                     return;
                 case 'map-value-ind':
-                    if (!it.sep)
-                        Object.assign(it, { key: null, sep: [this.sourceToken] });
-                    else if (it.value ||
-                        (atNextItem && !includesToken(it.start, 'explicit-key-ind')))
-                        map.items.push({ start: [], key: null, sep: [this.sourceToken] });
-                    else if (includesToken(it.sep, 'map-value-ind'))
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start: [], key: null, sep: [this.sourceToken] }]
-                        });
-                    else if (includesToken(it.start, 'explicit-key-ind') &&
-                        isFlowToken(it.key) &&
-                        !includesToken(it.sep, 'newline')) {
-                        const start = getFirstKeyStartProps(it.start);
-                        const key = it.key;
-                        const sep = it.sep;
-                        sep.push(this.sourceToken);
-                        // @ts-ignore type guard is wrong here
-                        delete it.key, delete it.sep;
-                        this.stack.push({
-                            type: 'block-map',
-                            offset: this.offset,
-                            indent: this.indent,
-                            items: [{ start, key, sep }]
-                        });
+                    if (includesToken(it.start, 'explicit-key-ind')) {
+                        if (!it.sep) {
+                            if (includesToken(it.start, 'newline')) {
+                                Object.assign(it, { key: null, sep: [this.sourceToken] });
+                            }
+                            else {
+                                const start = getFirstKeyStartProps(it.start);
+                                this.stack.push({
+                                    type: 'block-map',
+                                    offset: this.offset,
+                                    indent: this.indent,
+                                    items: [{ start, key: null, sep: [this.sourceToken] }]
+                                });
+                            }
+                        }
+                        else if (it.value) {
+                            map.items.push({ start: [], key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else if (isFlowToken(it.key) &&
+                            !includesToken(it.sep, 'newline')) {
+                            const start = getFirstKeyStartProps(it.start);
+                            const key = it.key;
+                            const sep = it.sep;
+                            sep.push(this.sourceToken);
+                            // @ts-expect-error type guard is wrong here
+                            delete it.key, delete it.sep;
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start, key, sep }]
+                            });
+                        }
+                        else if (start.length > 0) {
+                            // Not actually at next item
+                            it.sep = it.sep.concat(start, this.sourceToken);
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
+                    }
+                    else {
+                        if (!it.sep) {
+                            Object.assign(it, { key: null, sep: [this.sourceToken] });
+                        }
+                        else if (it.value || atNextItem) {
+                            map.items.push({ start, key: null, sep: [this.sourceToken] });
+                        }
+                        else if (includesToken(it.sep, 'map-value-ind')) {
+                            this.stack.push({
+                                type: 'block-map',
+                                offset: this.offset,
+                                indent: this.indent,
+                                items: [{ start: [], key: null, sep: [this.sourceToken] }]
+                            });
+                        }
+                        else {
+                            it.sep.push(this.sourceToken);
+                        }
                     }
-                    else
-                        it.sep.push(this.sourceToken);
                     this.onKeyLine = true;
                     return;
                 case 'alias':
@@ -577,7 +651,7 @@ class Parser {
                 case 'double-quoted-scalar': {
                     const fs = this.flowScalar(this.type);
                     if (atNextItem || it.value) {
-                        map.items.push({ start: [], key: fs, sep: [] });
+                        map.items.push({ start, key: fs, sep: [] });
                         this.onKeyLine = true;
                     }
                     else if (it.sep) {
@@ -594,8 +668,9 @@ class Parser {
                     if (bv) {
                         if (atNextItem &&
                             bv.type !== 'block-seq' &&
-                            includesToken(it.start, 'explicit-key-ind'))
-                            map.items.push({ start: [] });
+                            includesToken(it.start, 'explicit-key-ind')) {
+                            map.items.push({ start });
+                        }
                         this.stack.push(bv);
                         return;
                     }
@@ -606,15 +681,14 @@ class Parser {
         yield* this.step();
     }
     *blockSequence(seq) {
-        var _a;
         const it = seq.items[seq.items.length - 1];
         switch (this.type) {
             case 'newline':
                 if (it.value) {
                     const end = 'end' in it.value ? it.value.end : undefined;
                     const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
                     else
                         seq.items.push({ start: [this.sourceToken] });
                 }
@@ -628,7 +702,7 @@ class Parser {
                 else {
                     if (this.atIndentedComment(it.start, seq.indent)) {
                         const prev = seq.items[seq.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        const end = prev?.value?.end;
                         if (Array.isArray(end)) {
                             Array.prototype.push.apply(end, it.start);
                             end.push(this.sourceToken);
@@ -732,7 +806,7 @@ class Parser {
         else {
             const parent = this.peek(2);
             if (parent.type === 'block-map' &&
-                (this.type === 'map-value-ind' ||
+                ((this.type === 'map-value-ind' && parent.indent === fc.indent) ||
                     (this.type === 'newline' &&
                         !parent.items[parent.items.length - 1].sep))) {
                 yield* this.pop();