cdk8s 2.7.103 → 2.7.105

package/node_modules/yaml/browser/dist/schema/yaml-1.1/omap.js

@@ -1,7 +1,7 @@
-import { YAMLSeq } from '../../nodes/YAMLSeq.js';
+import { isScalar, isPair } from '../../nodes/identity.js';
 import { toJS } from '../../nodes/toJS.js';
-import { isScalar, isPair } from '../../nodes/Node.js';
 import { YAMLMap } from '../../nodes/YAMLMap.js';
+import { YAMLSeq } from '../../nodes/YAMLSeq.js';
 import { resolvePairs, createPairs } from './pairs.js';
 
 class YAMLOMap extends YAMLSeq {
@@ -39,6 +39,12 @@ class YAMLOMap extends YAMLSeq {
         }
         return map;
     }
+    static from(schema, iterable, ctx) {
+        const pairs = createPairs(schema, iterable, ctx);
+        const omap = new this();
+        omap.items = pairs.items;
+        return omap;
+    }
 }
 YAMLOMap.tag = 'tag:yaml.org,2002:omap';
 const omap = {
@@ -62,12 +68,7 @@ const omap = {
         }
         return Object.assign(new YAMLOMap(), pairs);
     },
-    createNode(schema, iterable, ctx) {
-        const pairs = createPairs(schema, iterable, ctx);
-        const omap = new YAMLOMap();
-        omap.items = pairs.items;
-        return omap;
-    }
+    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
 };
 
 export { YAMLOMap, omap };

package/node_modules/yaml/browser/dist/schema/yaml-1.1/pairs.js

@@ -1,4 +1,4 @@
-import { isSeq, isPair, isMap } from '../../nodes/Node.js';
+import { isSeq, isPair, isMap } from '../../nodes/identity.js';
 import { Pair, createPair } from '../../nodes/Pair.js';
 import { Scalar } from '../../nodes/Scalar.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';

package/node_modules/yaml/browser/dist/schema/yaml-1.1/set.js

@@ -1,5 +1,5 @@
-import { isMap, isPair, isScalar } from '../../nodes/Node.js';
-import { createPair, Pair } from '../../nodes/Pair.js';
+import { isMap, isPair, isScalar } from '../../nodes/identity.js';
+import { Pair, createPair } from '../../nodes/Pair.js';
 import { YAMLMap, findPair } from '../../nodes/YAMLMap.js';
 
 class YAMLSet extends YAMLMap {
@@ -57,6 +57,17 @@ class YAMLSet extends YAMLMap {
         else
             throw new Error('Set items must all have null values');
     }
+    static from(schema, iterable, ctx) {
+        const { replacer } = ctx;
+        const set = new this(schema);
+        if (iterable && Symbol.iterator in Object(iterable))
+            for (let value of iterable) {
+                if (typeof replacer === 'function')
+                    value = replacer.call(iterable, value, value);
+                set.items.push(createPair(value, null, ctx));
+            }
+        return set;
+    }
 }
 YAMLSet.tag = 'tag:yaml.org,2002:set';
 const set = {
@@ -65,6 +76,7 @@ const set = {
     nodeClass: YAMLSet,
     default: false,
     tag: 'tag:yaml.org,2002:set',
+    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
     resolve(map, onError) {
         if (isMap(map)) {
             if (map.hasAllNullValues(true))
@@ -75,17 +87,6 @@ const set = {
         else
             onError('Expected a mapping for this tag');
         return map;
-    },
-    createNode(schema, iterable, ctx) {
-        const { replacer } = ctx;
-        const set = new YAMLSet(schema);
-        if (iterable && Symbol.iterator in Object(iterable))
-            for (let value of iterable) {
-                if (typeof replacer === 'function')
-                    value = replacer.call(iterable, value, value);
-                set.items.push(createPair(value, null, ctx));
-            }
-        return set;
     }
 };
 

package/node_modules/yaml/browser/dist/schema/yaml-1.1/timestamp.js

@@ -43,7 +43,7 @@ function stringifySexagesimal(node) {
     }
     return (sign +
         parts
-            .map(n => (n < 10 ? '0' + String(n) : String(n)))
+            .map(n => String(n).padStart(2, '0'))
             .join(':')
             .replace(/000000\d*$/, '') // % 60 may introduce error
     );

package/node_modules/yaml/browser/dist/stringify/stringify.js

@@ -1,5 +1,5 @@
 import { anchorIsValid } from '../doc/anchors.js';
-import { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/Node.js';
+import { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/identity.js';
 import { stringifyComment } from './stringifyComment.js';
 import { stringifyString } from './stringifyString.js';
 

package/node_modules/yaml/browser/dist/stringify/stringifyCollection.js

@@ -1,5 +1,5 @@
 import { Collection } from '../nodes/Collection.js';
-import { isNode, isPair } from '../nodes/Node.js';
+import { isNode, isPair } from '../nodes/identity.js';
 import { stringify } from './stringify.js';
 import { lineComment, indentComment } from './stringifyComment.js';
 

package/node_modules/yaml/browser/dist/stringify/stringifyDocument.js

@@ -1,4 +1,4 @@
-import { isNode } from '../nodes/Node.js';
+import { isNode } from '../nodes/identity.js';
 import { createStringifyContext, stringify } from './stringify.js';
 import { indentComment, lineComment } from './stringifyComment.js';
 

package/node_modules/yaml/browser/dist/stringify/stringifyPair.js

@@ -1,4 +1,4 @@
-import { isCollection, isNode, isScalar, isSeq } from '../nodes/Node.js';
+import { isCollection, isNode, isScalar, isSeq } from '../nodes/identity.js';
 import { Scalar } from '../nodes/Scalar.js';
 import { stringify } from './stringify.js';
 import { lineComment, indentComment } from './stringifyComment.js';

package/node_modules/yaml/browser/dist/stringify/stringifyString.js

@@ -146,6 +146,15 @@ function quotedString(value, ctx) {
     }
     return qs(value, ctx);
 }
+// The negative lookbehind avoids a polynomial search,
+// but isn't supported yet on Safari: https://caniuse.com/js-regexp-lookbehind
+let blockEndNewlines;
+try {
+    blockEndNewlines = new RegExp('(^|(?<!\n))\n+(?!\n|$)', 'g');
+}
+catch {
+    blockEndNewlines = /\n+(?!\n|$)/g;
+}
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     const { blockQuote, commentString, lineWidth } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
@@ -189,7 +198,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         value = value.slice(0, -end.length);
         if (end[end.length - 1] === '\n')
             end = end.slice(0, -1);
-        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
+        end = end.replace(blockEndNewlines, `$&${indent}`);
     }
     // determine indent indicator from whitespace at value start
     let startWithSpace = false;

package/node_modules/yaml/browser/dist/util.js

@@ -1,4 +1,6 @@
+export { createNode } from './doc/createNode.js';
 export { debug, warn } from './log.js';
+export { createPair } from './nodes/Pair.js';
 export { findPair } from './nodes/YAMLMap.js';
 export { toJS } from './nodes/toJS.js';
 export { map as mapTag } from './schema/common/map.js';

package/node_modules/yaml/browser/dist/visit.js

@@ -1,4 +1,4 @@
-import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/Node.js';
+import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from './nodes/identity.js';
 
 const BREAK = Symbol('break visit');
 const SKIP = Symbol('skip children');

package/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';

package/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;

package/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>;

package/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);

package/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);

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

@@ -1,7 +1,7 @@
 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';
 type ErrorSource = number | [number, number] | Range | {
@@ -20,7 +20,7 @@ export type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode, message
  * 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 {};

package/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;

package/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>;

package/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;

package/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>;

package/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;

package/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>;

package/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;

package/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;

package/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));

package/node_modules/yaml/dist/doc/Document.d.ts

@@ -1,6 +1,7 @@
 import type { YAMLError, YAMLWarning } from '../errors.js';
 import { Alias } from '../nodes/Alias.js';
-import { Node, NodeType, NODE_TYPE, ParsedNode, Range } from '../nodes/Node.js';
+import { NODE_TYPE } from '../nodes/identity.js';
+import type { Node, NodeType, ParsedNode, Range } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
 import type { Scalar } from '../nodes/Scalar.js';
 import type { YAMLMap } from '../nodes/YAMLMap.js';
@@ -10,20 +11,21 @@ import { Schema } from '../schema/Schema.js';
 import { Directives } from './directives.js';
 export type Replacer = any[] | ((key: any, value: any) => unknown);
 export declare namespace Document {
-    interface Parsed<T extends ParsedNode = ParsedNode> extends Document<T> {
+    /** @ts-ignore The typing of directives fails in TS <= 4.2 */
+    interface Parsed<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true> extends Document<Contents, Strict> {
         directives: Directives;
         range: Range;
     }
 }
-export declare class Document<T extends Node = Node> {
+export declare class Document<Contents extends Node = Node, Strict extends boolean = true> {
     readonly [NODE_TYPE]: symbol;
     /** A comment before this Document */
     commentBefore: string | null;
     /** A comment immediately after this Document */
     comment: string | null;
     /** The document contents. */
-    contents: T | null;
-    directives?: Directives;
+    contents: Strict extends true ? Contents | null : Contents;
+    directives: Strict extends true ? Directives | undefined : Directives;
     /** Errors encountered during parsing. */
     errors: YAMLError[];
     options: Required<Omit<ParseOptions & DocumentOptions, '_directives' | 'lineCounter' | 'version'>>;
@@ -49,7 +51,7 @@ export declare class Document<T extends Node = Node> {
      *
      * Custom Node values that inherit from `Object` still refer to their original instances.
      */
-    clone(): Document<T>;
+    clone(): Document<Contents, Strict>;
     /** Adds a value to the document. */
     add(value: any): void;
     /** Adds a value to the document. */
@@ -63,7 +65,7 @@ export declare class Document<T extends Node = Node> {
      * `name` will be used as a prefix for a new unique anchor.
      * If `name` is undefined, the generated anchor will use 'a' as a prefix.
      */
-    createAlias(node: Scalar | YAMLMap | YAMLSeq, name?: string): Alias;
+    createAlias(node: Strict extends true ? Scalar | YAMLMap | YAMLSeq : Node, name?: string): Alias;
     /**
      * Convert any value into a `Node` using the current schema, recursively
      * turning objects into collections.
@@ -90,13 +92,13 @@ export declare class Document<T extends Node = Node> {
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    get(key: unknown, keepScalar?: boolean): unknown;
+    get(key: unknown, keepScalar?: boolean): Strict extends true ? unknown : any;
     /**
      * Returns item at `path`, or `undefined` if not found. By default unwraps
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    getIn(path: Iterable<unknown> | null, keepScalar?: boolean): unknown;
+    getIn(path: Iterable<unknown> | null, keepScalar?: boolean): Strict extends true ? unknown : any;
     /**
      * Checks if the document includes a value with the key `key`.
      */