node_modules: upgrade

node_modules/yaml/dist/compose/compose-collection.d.ts

@@ -1,5 +1,11 @@
-import type { ParsedNode } from '../nodes/Node.js';
-import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function composeCollection(CN: ComposeNode, ctx: ComposeContext, token: BlockMap | BlockSequence | FlowCollection, tagToken: SourceToken | null, onError: ComposeErrorHandler): ParsedNode;
+import type { ParsedNode } from '../nodes/Node';
+import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+interface Props {
+    anchor: SourceToken | null;
+    tag: SourceToken | null;
+    newlineAfterProp: SourceToken | null;
+}
+export declare function composeCollection(CN: ComposeNode, ctx: ComposeContext, token: BlockMap | BlockSequence | FlowCollection, props: Props, onError: ComposeErrorHandler): ParsedNode;
+export {};

node_modules/yaml/dist/compose/compose-collection.js

@@ -25,10 +25,23 @@ function resolveCollection(CN, ctx, token, onError, tagName, tag) {
         coll.tag = tagName;
     return coll;
 }
-function composeCollection(CN, ctx, token, tagToken, onError) {
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
     const tagName = !tagToken
         ? null
         : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
     const expType = token.type === 'block-map'
         ? 'map'
         : token.type === 'block-seq'
@@ -42,8 +55,7 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
         !tagName ||
         tagName === '!' ||
         (tagName === YAMLMap.YAMLMap.tagName && expType === 'map') ||
-        (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq') ||
-        !expType) {
+        (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq')) {
         return resolveCollection(CN, ctx, token, onError, tagName);
     }
     let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
@@ -54,8 +66,8 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
             tag = kt;
         }
         else {
-            if (kt?.collection) {
-                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
             }
             else {
                 onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);

node_modules/yaml/dist/compose/compose-doc.d.ts

@@ -1,7 +1,7 @@
-import type { Directives } from '../doc/directives.js';
-import { Document } from '../doc/Document.js';
-import type { ParsedNode } from '../nodes/Node.js';
-import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
-import type * as CST from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ParsedNode } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type * as CST from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function composeDoc<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true>(options: ParseOptions & DocumentOptions & SchemaOptions, directives: Directives, { offset, start, value, end }: CST.Document, onError: ComposeErrorHandler): Document.Parsed<Contents, Strict>;

node_modules/yaml/dist/compose/compose-doc.js

@@ -9,6 +9,7 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
     const opts = Object.assign({ _directives: directives }, options);
     const doc = new Document.Document(undefined, opts);
     const ctx = {
+        atKey: false,
         atRoot: true,
         directives: doc.directives,
         options: doc.options,
@@ -19,6 +20,7 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
         next: value ?? end?.[0],
         offset,
         onError,
+        parentIndent: 0,
         startOnNewline: true
     });
     if (props.found) {

node_modules/yaml/dist/compose/compose-node.d.ts

@@ -1,10 +1,11 @@
-import type { Directives } from '../doc/directives.js';
-import type { ParsedNode } from '../nodes/Node.js';
-import type { ParseOptions } from '../options.js';
-import type { SourceToken, Token } from '../parse/cst.js';
-import type { Schema } from '../schema/Schema.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Directives } from '../doc/directives';
+import type { ParsedNode } from '../nodes/Node';
+import type { ParseOptions } from '../options';
+import type { SourceToken, Token } from '../parse/cst';
+import type { Schema } from '../schema/Schema';
+import type { ComposeErrorHandler } from './composer';
 export interface ComposeContext {
+    atKey: boolean;
     atRoot: boolean;
     directives: Directives;
     options: Readonly<Required<Omit<ParseOptions, 'lineCounter'>>>;
@@ -15,6 +16,7 @@ interface Props {
     comment: string;
     anchor: SourceToken | null;
     tag: SourceToken | null;
+    newlineAfterProp: SourceToken | null;
     end: number;
 }
 declare const CN: {
@@ -23,5 +25,5 @@ declare const CN: {
 };
 export type ComposeNode = typeof CN;
 export declare function composeNode(ctx: ComposeContext, token: Token, props: Props, onError: ComposeErrorHandler): ParsedNode;
-export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag, end }: Props, onError: ComposeErrorHandler): import("../index.js").Scalar.Parsed;
+export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag, end }: Props, onError: ComposeErrorHandler): import('../index').Scalar.Parsed;
 export {};

node_modules/yaml/dist/compose/compose-node.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var Alias = require('../nodes/Alias.js');
+var identity = require('../nodes/identity.js');
 var composeCollection = require('./compose-collection.js');
 var composeScalar = require('./compose-scalar.js');
 var resolveEnd = require('./resolve-end.js');
@@ -8,6 +9,7 @@ var utilEmptyScalarPosition = require('./util-empty-scalar-position.js');
 
 const CN = { composeNode, composeEmptyNode };
 function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
     const { spaceBefore, comment, anchor, tag } = props;
     let node;
     let isSrcToken = true;
@@ -28,7 +30,7 @@ function composeNode(ctx, token, props, onError) {
         case 'block-map':
         case 'block-seq':
         case 'flow-collection':
-            node = composeCollection.composeCollection(CN, ctx, token, tag, onError);
+            node = composeCollection.composeCollection(CN, ctx, token, props, onError);
             if (anchor)
                 node.anchor = anchor.source.substring(1);
             break;
@@ -43,6 +45,14 @@ function composeNode(ctx, token, props, onError) {
     }
     if (anchor && node.anchor === '')
         onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (atKey &&
+        ctx.options.stringKeys &&
+        (!identity.isScalar(node) ||
+            typeof node.value !== 'string' ||
+            (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) {
+        const msg = 'With stringKeys, all keys must be strings';
+        onError(tag ?? token, 'NON_STRING_KEY', msg);
+    }
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment) {

node_modules/yaml/dist/compose/compose-scalar.d.ts

@@ -1,5 +1,5 @@
-import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst.js';
-import type { ComposeContext } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import { Scalar } from '../nodes/Scalar';
+import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst';
+import type { ComposeContext } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 export declare function composeScalar(ctx: ComposeContext, token: FlowScalar | BlockScalar, tagToken: SourceToken | null, onError: ComposeErrorHandler): Scalar.Parsed;

node_modules/yaml/dist/compose/compose-scalar.js

@@ -7,16 +7,21 @@ var resolveFlowScalar = require('./resolve-flow-scalar.js');
 
 function composeScalar(ctx, token, tagToken, onError) {
     const { value, type, comment, range } = token.type === 'block-scalar'
-        ? resolveBlockScalar.resolveBlockScalar(token, ctx.options.strict, onError)
+        ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError)
         : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
     const tagName = tagToken
         ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
         : null;
-    const tag = tagToken && tagName
-        ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
-        : token.type === 'scalar'
-            ? findScalarTagByTest(ctx, value, token, onError)
-            : ctx.schema[identity.SCALAR];
+    let tag;
+    if (ctx.options.stringKeys && ctx.atKey) {
+        tag = ctx.schema[identity.SCALAR];
+    }
+    else if (tagName)
+        tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+    else if (token.type === 'scalar')
+        tag = findScalarTagByTest(ctx, value, token, onError);
+    else
+        tag = ctx.schema[identity.SCALAR];
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
@@ -64,8 +69,9 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
     return schema[identity.SCALAR];
 }
-function findScalarTagByTest({ directives, schema }, value, token, onError) {
-    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[identity.SCALAR];
+function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+    const tag = schema.tags.find(tag => (tag.default === true || (atKey && tag.default === 'key')) &&
+        tag.test?.test(value)) || schema[identity.SCALAR];
     if (schema.compat) {
         const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
             schema[identity.SCALAR];

node_modules/yaml/dist/compose/composer.d.ts

@@ -1,9 +1,10 @@
-import { Directives } from '../doc/directives.js';
-import { Document } from '../doc/Document.js';
-import { ErrorCode, YAMLParseError, YAMLWarning } from '../errors.js';
-import type { ParsedNode, Range } from '../nodes/Node.js';
-import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
-import type { Token } from '../parse/cst.js';
+import { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ErrorCode } from '../errors';
+import { YAMLParseError, YAMLWarning } from '../errors';
+import type { ParsedNode, Range } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type { Token } from '../parse/cst';
 type ErrorSource = number | [number, number] | Range | {
     offset: number;
     source?: string;

node_modules/yaml/dist/compose/composer.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var node_process = require('process');
 var directives = require('../doc/directives.js');
 var Document = require('../doc/Document.js');
 var errors = require('../errors.js');
@@ -133,7 +134,7 @@ class Composer {
     }
     /** Advance the composer by one CST token. */
     *next(token) {
-        if (process.env.LOG_STREAM)
+        if (node_process.env.LOG_STREAM)
             console.dir(token, { depth: null });
         switch (token.type) {
             case 'directive':

node_modules/yaml/dist/compose/resolve-block-map.d.ts

@@ -1,7 +1,6 @@
-import type { ParsedNode } from '../nodes/Node.js';
-import { YAMLMap } from '../nodes/YAMLMap.js';
-import type { BlockMap } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;
+import { YAMLMap } from '../nodes/YAMLMap';
+import type { BlockMap } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed;

node_modules/yaml/dist/compose/resolve-block-map.js

@@ -23,6 +23,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
             next: key ?? sep?.[0],
             offset,
             onError,
+            parentIndent: bm.indent,
             startOnNewline: true
         });
         const implicitKey = !keyProps.found;
@@ -43,7 +44,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
                 }
                 continue;
             }
-            if (keyProps.hasNewlineAfterProp || utilContainsNewline.containsNewline(key)) {
+            if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) {
                 onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
             }
         }
@@ -51,12 +52,14 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
             onError(offset, 'BAD_INDENT', startColMsg);
         }
         // key value
+        ctx.atKey = true;
         const keyStart = keyProps.end;
         const keyNode = key
             ? composeNode(ctx, key, keyProps, onError)
             : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
         if (ctx.schema.compat)
             utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError);
+        ctx.atKey = false;
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
             onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
@@ -65,6 +68,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, ta
             next: value,
             offset: keyNode.range[2],
             onError,
+            parentIndent: bm.indent,
             startOnNewline: !key || key.type === 'block-scalar'
         });
         offset = valueProps.end;

node_modules/yaml/dist/compose/resolve-block-scalar.d.ts

@@ -1,8 +1,9 @@
-import { Range } from '../nodes/Node.js';
-import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockScalar(scalar: BlockScalar, strict: boolean, onError: ComposeErrorHandler): {
+import type { Range } from '../nodes/Node';
+import { Scalar } from '../nodes/Scalar';
+import type { BlockScalar } from '../parse/cst';
+import type { ComposeContext } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function resolveBlockScalar(ctx: ComposeContext, scalar: BlockScalar, onError: ComposeErrorHandler): {
     value: string;
     type: Scalar.BLOCK_FOLDED | Scalar.BLOCK_LITERAL | null;
     comment: string;

node_modules/yaml/dist/compose/resolve-block-scalar.js

@@ -2,9 +2,9 @@
 
 var Scalar = require('../nodes/Scalar.js');
 
-function resolveBlockScalar(scalar, strict, onError) {
+function resolveBlockScalar(ctx, scalar, onError) {
     const start = scalar.offset;
-    const header = parseBlockScalarHeader(scalar, strict, onError);
+    const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
     if (!header)
         return { value: '', type: null, comment: '', range: [start, start, start] };
     const type = header.mode === '>' ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
@@ -46,6 +46,10 @@ function resolveBlockScalar(scalar, strict, onError) {
             if (header.indent === 0)
                 trimIndent = indent.length;
             contentStart = i;
+            if (trimIndent === 0 && !ctx.atRoot) {
+                const message = 'Block scalar values in collections must be indented';
+                onError(offset, 'BAD_INDENT', message);
+            }
             break;
         }
         offset += indent.length + content.length + 1;

node_modules/yaml/dist/compose/resolve-block-seq.d.ts

@@ -1,6 +1,6 @@
-import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { BlockSequence } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+import { YAMLSeq } from '../nodes/YAMLSeq';
+import type { BlockSequence } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLSeq.Parsed;

node_modules/yaml/dist/compose/resolve-block-seq.js

@@ -9,6 +9,8 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, ta
     const seq = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
+    if (ctx.atKey)
+        ctx.atKey = false;
     let offset = bs.offset;
     let commentEnd = null;
     for (const { start, value } of bs.items) {
@@ -17,6 +19,7 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, ta
             next: value,
             offset,
             onError,
+            parentIndent: bs.indent,
             startOnNewline: true
         });
         if (!props.found) {

node_modules/yaml/dist/compose/resolve-end.d.ts

@@ -1,5 +1,5 @@
-import type { SourceToken } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { SourceToken } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveEnd(end: SourceToken[] | undefined, offset: number, reqSpace: boolean, onError: ComposeErrorHandler): {
     comment: string;
     offset: number;

node_modules/yaml/dist/compose/resolve-flow-collection.d.ts

@@ -1,7 +1,7 @@
-import { YAMLMap } from '../nodes/YAMLMap.js';
-import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { FlowCollection } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null> | YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+import { YAMLMap } from '../nodes/YAMLMap';
+import { YAMLSeq } from '../nodes/YAMLSeq';
+import type { FlowCollection } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<import('../index').ParsedNode, import('../index').ParsedNode | null> | YAMLSeq.Parsed<import('../index').ParsedNode>;

node_modules/yaml/dist/compose/resolve-flow-collection.js

@@ -20,6 +20,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const atRoot = ctx.atRoot;
     if (atRoot)
         ctx.atRoot = false;
+    if (ctx.atKey)
+        ctx.atKey = false;
     let offset = fc.offset + fc.start.source.length;
     for (let i = 0; i < fc.items.length; ++i) {
         const collItem = fc.items[i];
@@ -30,6 +32,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
             next: key ?? sep?.[0],
             offset,
             onError,
+            parentIndent: fc.indent,
             startOnNewline: false
         });
         if (!props.found) {
@@ -98,12 +101,14 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
         else {
             // item is a key+value pair
             // key value
+            ctx.atKey = true;
             const keyStart = props.end;
             const keyNode = key
                 ? composeNode(ctx, key, props, onError)
                 : composeEmptyNode(ctx, keyStart, start, null, props, onError);
             if (isBlock(key))
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
+            ctx.atKey = false;
             // value properties
             const valueProps = resolveProps.resolveProps(sep ?? [], {
                 flow: fcName,
@@ -111,6 +116,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 next: value,
                 offset: keyNode.range[2],
                 onError,
+                parentIndent: fc.indent,
                 startOnNewline: false
             });
             if (valueProps.found) {
@@ -163,6 +169,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 const map = new YAMLMap.YAMLMap(ctx.schema);
                 map.flow = true;
                 map.items.push(pair);
+                const endRange = (valueNode ?? keyNode).range;
+                map.range = [keyNode.range[0], endRange[1], endRange[2]];
                 coll.items.push(map);
             }
             offset = valueNode ? valueNode.range[2] : valueProps.end;

node_modules/yaml/dist/compose/resolve-flow-scalar.d.ts

@@ -1,7 +1,7 @@
-import { Range } from '../nodes/Node.js';
-import { Scalar } from '../nodes/Scalar.js';
-import type { FlowScalar } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Range } from '../nodes/Node';
+import { Scalar } from '../nodes/Scalar';
+import type { FlowScalar } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveFlowScalar(scalar: FlowScalar, strict: boolean, onError: ComposeErrorHandler): {
     value: string;
     type: Scalar.PLAIN | Scalar.QUOTE_DOUBLE | Scalar.QUOTE_SINGLE | null;

node_modules/yaml/dist/compose/resolve-flow-scalar.js

@@ -86,7 +86,7 @@ function foldLines(source) {
         first = new RegExp('(.*?)(?<![ \t])[ \t]*\r?\n', 'sy');
         line = new RegExp('[ \t]*(.*?)(?:(?<![ \t])[ \t]*)?\r?\n', 'sy');
     }
-    catch (_) {
+    catch {
         first = /(.*?)[ \t]*\r?\n/sy;
         line = /[ \t]*(.*?)[ \t]*\r?\n/sy;
     }
@@ -191,19 +191,19 @@ function foldNewline(source, offset) {
     return { fold, offset };
 }
 const escapeCodes = {
-    '0': '\0',
-    a: '\x07',
-    b: '\b',
-    e: '\x1b',
-    f: '\f',
-    n: '\n',
-    r: '\r',
-    t: '\t',
-    v: '\v',
-    N: '\u0085',
-    _: '\u00a0',
-    L: '\u2028',
-    P: '\u2029',
+    '0': '\0', // null character
+    a: '\x07', // bell character
+    b: '\b', // backspace
+    e: '\x1b', // escape character
+    f: '\f', // form feed
+    n: '\n', // line feed
+    r: '\r', // carriage return
+    t: '\t', // horizontal tab
+    v: '\v', // vertical tab
+    N: '\u0085', // Unicode next line
+    _: '\u00a0', // Unicode non-breaking space
+    L: '\u2028', // Unicode line separator
+    P: '\u2029', // Unicode paragraph separator
     ' ': ' ',
     '"': '"',
     '/': '/',

node_modules/yaml/dist/compose/resolve-props.d.ts

@@ -1,22 +1,23 @@
-import type { SourceToken, Token } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { SourceToken, Token } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export interface ResolvePropsArg {
     flow?: 'flow map' | 'flow sequence';
     indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';
     next: Token | null | undefined;
     offset: number;
     onError: ComposeErrorHandler;
+    parentIndent: number;
     startOnNewline: boolean;
 }
-export declare function resolveProps(tokens: SourceToken[], { flow, indicator, next, offset, onError, startOnNewline }: ResolvePropsArg): {
+export declare function resolveProps(tokens: SourceToken[], { flow, indicator, next, offset, onError, parentIndent, startOnNewline }: ResolvePropsArg): {
     comma: SourceToken | null;
     found: SourceToken | null;
     spaceBefore: boolean;
     comment: string;
     hasNewline: boolean;
-    hasNewlineAfterProp: boolean;
     anchor: SourceToken | null;
     tag: SourceToken | null;
+    newlineAfterProp: SourceToken | null;
     end: number;
     start: number;
 };

node_modules/yaml/dist/compose/resolve-props.js

@@ -1,16 +1,17 @@
 'use strict';
 
-function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
+function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIndent, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
     let comment = '';
     let commentSep = '';
     let hasNewline = false;
-    let hasNewlineAfterProp = false;
     let reqSpace = false;
+    let tab = null;
     let anchor = null;
     let tag = null;
+    let newlineAfterProp = null;
     let comma = null;
     let found = null;
     let start = null;
@@ -22,16 +23,22 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
             reqSpace = false;
         }
+        if (tab) {
+            if (atNewline && token.type !== 'comment' && token.type !== 'newline') {
+                onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+            }
+            tab = null;
+        }
         switch (token.type) {
             case 'space':
                 // At the doc level, tabs at line start may be parsed
                 // as leading white space rather than indentation.
                 // In a flow collection, only the parser handles indent.
                 if (!flow &&
-                    atNewline &&
-                    indicator !== 'doc-start' &&
-                    token.source[0] === '\t')
-                    onError(token, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
+                    (indicator !== 'doc-start' || next?.type !== 'flow-collection') &&
+                    token.source.includes('\t')) {
+                    tab = token;
+                }
                 hasSpace = true;
                 break;
             case 'comment': {
@@ -50,7 +57,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 if (atNewline) {
                     if (comment)
                         comment += token.source;
-                    else
+                    else if (!found || indicator !== 'seq-item-ind')
                         spaceBefore = true;
                 }
                 else
@@ -58,7 +65,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 atNewline = true;
                 hasNewline = true;
                 if (anchor || tag)
-                    hasNewlineAfterProp = true;
+                    newlineAfterProp = token;
                 hasSpace = true;
                 break;
             case 'anchor':
@@ -67,8 +74,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 if (token.source.endsWith(':'))
                     onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
                 anchor = token;
-                if (start === null)
-                    start = token.offset;
+                start ?? (start = token.offset);
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;
@@ -77,8 +83,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 if (tag)
                     onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
                 tag = token;
-                if (start === null)
-                    start = token.offset;
+                start ?? (start = token.offset);
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;
@@ -91,7 +96,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 if (found)
                     onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow ?? 'collection'}`);
                 found = token;
-                atNewline = false;
+                atNewline =
+                    indicator === 'seq-item-ind' || indicator === 'explicit-key-ind';
                 hasSpace = false;
                 break;
             case 'comma':
@@ -117,17 +123,23 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
         next.type !== 'space' &&
         next.type !== 'newline' &&
         next.type !== 'comma' &&
-        (next.type !== 'scalar' || next.source !== ''))
+        (next.type !== 'scalar' || next.source !== '')) {
         onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
+    }
+    if (tab &&
+        ((atNewline && tab.indent <= parentIndent) ||
+            next?.type === 'block-map' ||
+            next?.type === 'block-seq'))
+        onError(tab, 'TAB_AS_INDENT', 'Tabs are not allowed as indentation');
     return {
         comma,
         found,
         spaceBefore,
         comment,
         hasNewline,
-        hasNewlineAfterProp,
         anchor,
         tag,
+        newlineAfterProp,
         end,
         start: start ?? end
     };

node_modules/yaml/dist/compose/util-contains-newline.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/cst.js';
+import type { Token } from '../parse/cst';
 export declare function containsNewline(key: Token | null | undefined): boolean | null;

node_modules/yaml/dist/compose/util-empty-scalar-position.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/cst.js';
+import type { Token } from '../parse/cst';
 export declare function emptyScalarPosition(offset: number, before: Token[] | undefined, pos: number | null): number;

node_modules/yaml/dist/compose/util-empty-scalar-position.js

@@ -2,8 +2,7 @@
 
 function emptyScalarPosition(offset, before, pos) {
     if (before) {
-        if (pos === null)
-            pos = before.length;
+        pos ?? (pos = before.length);
         for (let i = pos - 1; i >= 0; --i) {
             let st = before[i];
             switch (st.type) {

node_modules/yaml/dist/compose/util-flow-indent-check.d.ts

@@ -1,3 +1,3 @@
-import { Token } from '../parse/cst';
-import { ComposeErrorHandler } from './composer';
+import type { Token } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function flowIndentCheck(indent: number, fc: Token | null | undefined, onError: ComposeErrorHandler): void;

node_modules/yaml/dist/compose/util-map-includes.d.ts

@@ -1,4 +1,4 @@
-import type { ParsedNode } from '../nodes/Node.js';
-import type { Pair } from '../nodes/Pair.js';
-import type { ComposeContext } from './compose-node.js';
+import type { ParsedNode } from '../nodes/Node';
+import type { Pair } from '../nodes/Pair';
+import type { ComposeContext } from './compose-node';
 export declare function mapIncludes(ctx: ComposeContext, items: Pair<ParsedNode>[], search: ParsedNode): boolean;

node_modules/yaml/dist/compose/util-map-includes.js

@@ -8,11 +8,7 @@ function mapIncludes(ctx, items, search) {
         return false;
     const isEqual = typeof uniqueKeys === 'function'
         ? uniqueKeys
-        : (a, b) => a === b ||
-            (identity.isScalar(a) &&
-                identity.isScalar(b) &&
-                a.value === b.value &&
-                !(a.value === '<<' && ctx.schema.merge));
+        : (a, b) => a === b || (identity.isScalar(a) && identity.isScalar(b) && a.value === b.value);
     return items.some(pair => isEqual(pair.key, search));
 }