node_modules: upgrade

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

@@ -1,4 +1,4 @@
-import { ParsedNode } from '../nodes/Node.js';
+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';

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

@@ -1,40 +1,52 @@
 'use strict';
 
-var Node = require('../nodes/Node.js');
+var identity = require('../nodes/identity.js');
 var Scalar = require('../nodes/Scalar.js');
+var YAMLMap = require('../nodes/YAMLMap.js');
+var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveBlockMap = require('./resolve-block-map.js');
 var resolveBlockSeq = require('./resolve-block-seq.js');
 var resolveFlowCollection = require('./resolve-flow-collection.js');
 
-function composeCollection(CN, ctx, token, tagToken, onError) {
-    let coll;
-    switch (token.type) {
-        case 'block-map': {
-            coll = resolveBlockMap.resolveBlockMap(CN, ctx, token, onError);
-            break;
-        }
-        case 'block-seq': {
-            coll = resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError);
-            break;
-        }
-        case 'flow-collection': {
-            coll = resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError);
-            break;
-        }
-    }
-    if (!tagToken)
-        return coll;
-    const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
-    if (!tagName)
-        return coll;
-    // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap.resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError, tag);
     const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
     if (tagName === '!' || tagName === Coll.tagName) {
         coll.tag = Coll.tagName;
         return coll;
     }
-    const expType = Node.isMap(coll) ? 'map' : 'seq';
-    let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, tagToken, onError) {
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq') ||
+        !expType) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
     if (!tag) {
         const kt = ctx.schema.knownTags[tagName];
         if (kt && kt.collection === expType) {
@@ -42,13 +54,18 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
             tag = kt;
         }
         else {
-            onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
-            coll.tag = tagName;
-            return coll;
+            if (kt?.collection) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
         }
     }
-    const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
-    const node = Node.isNode(res)
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = identity.isNode(res)
         ? res
         : new Scalar.Scalar(res);
     node.range = coll.range;

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

@@ -1,6 +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';
-export declare function composeDoc(options: ParseOptions & DocumentOptions & SchemaOptions, directives: Directives, { offset, start, value, end }: CST.Document, onError: ComposeErrorHandler): Document.Parsed<import("../index.js").ParsedNode>;
+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

@@ -28,6 +28,7 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
             !props.hasNewline)
             onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
     }
+    // @ts-expect-error If Contents is set, let's trust the user
     doc.contents = value
         ? composeNode.composeNode(ctx, value, props, onError)
         : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);

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

@@ -21,7 +21,7 @@ declare const CN: {
     composeNode: typeof composeNode;
     composeEmptyNode: typeof composeEmptyNode;
 };
-export declare type ComposeNode = typeof 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 {};

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var Node = require('../nodes/Node.js');
+var identity = require('../nodes/identity.js');
 var Scalar = require('../nodes/Scalar.js');
 var resolveBlockScalar = require('./resolve-block-scalar.js');
 var resolveFlowScalar = require('./resolve-flow-scalar.js');
@@ -16,11 +16,11 @@ function composeScalar(ctx, token, tagToken, onError) {
         ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
         : token.type === 'scalar'
             ? findScalarTagByTest(ctx, value, token, onError)
-            : ctx.schema[Node.SCALAR];
+            : ctx.schema[identity.SCALAR];
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
-        scalar = Node.isScalar(res) ? res : new Scalar.Scalar(res);
+        scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
     }
     catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
@@ -41,7 +41,7 @@ function composeScalar(ctx, token, tagToken, onError) {
 }
 function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     if (tagName === '!')
-        return schema[Node.SCALAR]; // non-specific tag
+        return schema[identity.SCALAR]; // non-specific tag
     const matchWithTest = [];
     for (const tag of schema.tags) {
         if (!tag.collection && tag.tag === tagName) {
@@ -62,13 +62,13 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
         return kt;
     }
     onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
-    return schema[Node.SCALAR];
+    return schema[identity.SCALAR];
 }
 function findScalarTagByTest({ directives, schema }, value, token, onError) {
-    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[Node.SCALAR];
+    const tag = schema.tags.find(tag => tag.default && tag.test?.test(value)) || schema[identity.SCALAR];
     if (schema.compat) {
         const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
-            schema[Node.SCALAR];
+            schema[identity.SCALAR];
         if (tag.tag !== compat.tag) {
             const ts = directives.tagString(tag.tag);
             const cs = directives.tagString(compat.tag);

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

@@ -1,14 +1,14 @@
 import { Directives } from '../doc/directives.js';
 import { Document } from '../doc/Document.js';
 import { ErrorCode, YAMLParseError, YAMLWarning } from '../errors.js';
-import { Range } from '../nodes/Node.js';
+import type { ParsedNode, Range } from '../nodes/Node.js';
 import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
 import type { Token } from '../parse/cst.js';
-declare type ErrorSource = number | [number, number] | Range | {
+type ErrorSource = number | [number, number] | Range | {
     offset: number;
     source?: string;
 };
-export declare type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode, message: string, warning?: boolean) => void;
+export type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode, message: string, warning?: boolean) => void;
 /**
  * Compose a stream of CST nodes into a stream of YAML Documents.
  *
@@ -20,7 +20,7 @@ export declare type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode,
  * const docs = new Composer().compose(tokens)
  * ```
  */
-export declare class Composer {
+export declare class Composer<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true> {
     private directives;
     private doc;
     private options;
@@ -48,15 +48,15 @@ export declare class Composer {
      * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
      * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
      */
-    compose(tokens: Iterable<Token>, forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
+    compose(tokens: Iterable<Token>, forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
     /** Advance the composer by one CST token. */
-    next(token: Token): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
+    next(token: Token): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
     /**
      * Call at end of input to yield any remaining document.
      *
      * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
      * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
      */
-    end(forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<import("../nodes/Node.js").ParsedNode>, void, unknown>;
+    end(forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
 }
 export {};

node_modules/yaml/dist/compose/composer.js

@@ -3,7 +3,7 @@
 var directives = require('../doc/directives.js');
 var Document = require('../doc/Document.js');
 var errors = require('../errors.js');
-var Node = require('../nodes/Node.js');
+var identity = require('../nodes/identity.js');
 var composeDoc = require('./compose-doc.js');
 var resolveEnd = require('./resolve-end.js');
 
@@ -83,9 +83,9 @@ class Composer {
             else if (afterEmptyLine || doc.directives.docStart || !dc) {
                 doc.commentBefore = comment;
             }
-            else if (Node.isCollection(dc) && !dc.flow && dc.items.length > 0) {
+            else if (identity.isCollection(dc) && !dc.flow && dc.items.length > 0) {
                 let it = dc.items[0];
-                if (Node.isPair(it))
+                if (identity.isPair(it))
                     it = it.key;
                 const cb = it.commentBefore;
                 it.commentBefore = cb ? `${comment}\n${cb}` : comment;

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

@@ -1,6 +1,7 @@
 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): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;
+export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;

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

@@ -8,8 +8,9 @@ var utilFlowIndentCheck = require('./util-flow-indent-check.js');
 var utilMapIncludes = require('./util-map-includes.js');
 
 const startColMsg = 'All mapping items must start at the same column';
-function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
-    const map = new YAMLMap.YAMLMap(ctx.schema);
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap.YAMLMap;
+    const map = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bm.offset;

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

@@ -1,5 +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): YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLSeq.Parsed<import("../index.js").ParsedNode>;

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

@@ -4,8 +4,9 @@ var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveProps = require('./resolve-props.js');
 var utilFlowIndentCheck = require('./util-flow-indent-check.js');
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
-    const seq = new YAMLSeq.YAMLSeq(ctx.schema);
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq.YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bs.offset;

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

@@ -1,6 +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): YAMLMap.Parsed<import("../nodes/Node.js").ParsedNode, import("../nodes/Node.js").ParsedNode | null> | YAMLSeq.Parsed<import("../nodes/Node.js").ParsedNode>;
+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>;

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var Node = require('../nodes/Node.js');
+var identity = require('../nodes/identity.js');
 var Pair = require('../nodes/Pair.js');
 var YAMLMap = require('../nodes/YAMLMap.js');
 var YAMLSeq = require('../nodes/YAMLSeq.js');
@@ -11,12 +11,11 @@ var utilMapIncludes = require('./util-map-includes.js');
 
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
-function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
-    const coll = isMap
-        ? new YAMLMap.YAMLMap(ctx.schema)
-        : new YAMLSeq.YAMLSeq(ctx.schema);
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
     coll.flow = true;
     const atRoot = ctx.atRoot;
     if (atRoot)
@@ -75,7 +74,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 }
                 if (prevItemComment) {
                     let prev = coll.items[coll.items.length - 1];
-                    if (Node.isPair(prev))
+                    if (identity.isPair(prev))
                         prev = prev.value ?? prev.key;
                     if (prev.comment)
                         prev.comment += '\n' + prevItemComment;

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

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

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

@@ -1,6 +1,6 @@
 'use strict';
 
-var Node = require('../nodes/Node.js');
+var identity = require('../nodes/identity.js');
 
 function mapIncludes(ctx, items, search) {
     const { uniqueKeys } = ctx.options;
@@ -9,8 +9,8 @@ function mapIncludes(ctx, items, search) {
     const isEqual = typeof uniqueKeys === 'function'
         ? uniqueKeys
         : (a, b) => a === b ||
-            (Node.isScalar(a) &&
-                Node.isScalar(b) &&
+            (identity.isScalar(a) &&
+                identity.isScalar(b) &&
                 a.value === b.value &&
                 !(a.value === '<<' && ctx.schema.merge));
     return items.some(pair => isEqual(pair.key, search));