cdk8s 2.7.62 → 2.7.64

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

@@ -2,18 +2,22 @@ import { Pair } from '../nodes/Pair.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.js';
+import { flowIndentCheck } from './util-flow-indent-check.js';
 import { mapIncludes } from './util-map-includes.js';
 
 const startColMsg = 'All mapping items must start at the same column';
 function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
-    var _a;
     const map = new YAMLMap(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
     let offset = bm.offset;
-    for (const { start, key, sep, value } of bm.items) {
+    let commentEnd = null;
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
         // key properties
         const keyProps = resolveProps(start, {
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            next: key ?? sep?.[0],
             offset,
             onError,
             startOnNewline: true
@@ -27,7 +31,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                     onError(offset, 'BAD_INDENT', startColMsg);
             }
             if (!keyProps.anchor && !keyProps.tag && !sep) {
-                // TODO: assert being at last item?
+                commentEnd = keyProps.end;
                 if (keyProps.comment) {
                     if (map.comment)
                         map.comment += '\n' + keyProps.comment;
@@ -36,21 +40,24 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 }
                 continue;
             }
+            if (keyProps.hasNewlineAfterProp || containsNewline(key)) {
+                onError(key ?? start[start.length - 1], 'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
+            }
         }
-        else if (((_a = keyProps.found) === null || _a === void 0 ? void 0 : _a.indent) !== bm.indent)
+        else if (keyProps.found?.indent !== bm.indent) {
             onError(offset, 'BAD_INDENT', startColMsg);
-        if (implicitKey && containsNewline(key))
-            onError(key, // checked by containsNewline()
-            'MULTILINE_IMPLICIT_KEY', 'Implicit keys need to be on a single line');
+        }
         // key value
         const keyStart = keyProps.end;
         const keyNode = key
             ? composeNode(ctx, key, keyProps, onError)
             : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bm.indent, key, onError);
         if (mapIncludes(ctx, map.items, keyNode))
             onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
-        const valueProps = resolveProps(sep || [], {
+        const valueProps = resolveProps(sep ?? [], {
             indicator: 'map-value-ind',
             next: value,
             offset: keyNode.range[2],
@@ -60,7 +67,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
         offset = valueProps.end;
         if (valueProps.found) {
             if (implicitKey) {
-                if ((value === null || value === void 0 ? void 0 : value.type) === 'block-map' && !valueProps.hasNewline)
+                if (value?.type === 'block-map' && !valueProps.hasNewline)
                     onError(offset, 'BLOCK_AS_IMPLICIT_KEY', 'Nested mappings are not allowed in compact mappings');
                 if (ctx.options.strict &&
                     keyProps.start < valueProps.found.offset - 1024)
@@ -70,8 +77,13 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
             const valueNode = value
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+            if (ctx.schema.compat)
+                flowIndentCheck(bm.indent, value, onError);
             offset = valueNode.range[2];
-            map.items.push(new Pair(keyNode, valueNode));
+            const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
         else {
             // key with no value
@@ -83,10 +95,15 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            map.items.push(new Pair(keyNode));
+            const pair = new Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
     }
-    map.range = [bm.offset, offset, offset];
+    if (commentEnd && commentEnd < offset)
+        onError(commentEnd, 'IMPOSSIBLE', 'Map comment with trailing content');
+    map.range = [bm.offset, offset, commentEnd ?? offset];
     return map;
 }
 

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

@@ -17,8 +17,10 @@ function resolveBlockScalar(scalar, strict, onError) {
             break;
     }
     // shortcut for empty contents
-    if (!scalar.source || chompStart === 0) {
-        const value = header.chomp === '+' ? lines.map(line => line[0]).join('\n') : '';
+    if (chompStart === 0) {
+        const value = header.chomp === '+' && lines.length > 0
+            ? '\n'.repeat(Math.max(1, lines.length - 1))
+            : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -46,6 +48,11 @@ function resolveBlockScalar(scalar, strict, onError) {
         }
         offset += indent.length + content.length + 1;
     }
+    // include trailing more-indented empty lines in content
+    for (let i = lines.length - 1; i >= chompStart; --i) {
+        if (lines[i][0].length > trimIndent)
+            chompStart = i + 1;
+    }
     let value = '';
     let sep = '';
     let prevMoreIndented = false;
@@ -175,7 +182,9 @@ function splitLines(source) {
     const split = source.split(/\n( *)/);
     const first = split[0];
     const m = first.match(/^( *)/);
-    const line0 = m && m[1] ? [m[1], first.slice(m[1].length)] : ['', first];
+    const line0 = m?.[1]
+        ? [m[1], first.slice(m[1].length)]
+        : ['', first];
     const lines = [line0];
     for (let i = 1; i < split.length; i += 2)
         lines.push([split[i], split[i + 1]]);

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

@@ -1,9 +1,13 @@
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveProps } from './resolve-props.js';
+import { flowIndentCheck } from './util-flow-indent-check.js';
 
 function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     const seq = new YAMLSeq(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
     let offset = bs.offset;
+    let commentEnd = null;
     for (const { start, value } of bs.items) {
         const props = resolveProps(start, {
             indicator: 'seq-item-ind',
@@ -12,16 +16,15 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
             onError,
             startOnNewline: true
         });
-        offset = props.end;
         if (!props.found) {
             if (props.anchor || props.tag || value) {
                 if (value && value.type === 'block-seq')
-                    onError(offset, 'BAD_INDENT', 'All sequence items must start at the same column');
+                    onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
                 else
                     onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');
             }
             else {
-                // TODO: assert being at last item?
+                commentEnd = props.end;
                 if (props.comment)
                     seq.comment = props.comment;
                 continue;
@@ -29,11 +32,13 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
         }
         const node = value
             ? composeNode(ctx, value, props, onError)
-            : composeEmptyNode(ctx, offset, start, null, props, onError);
+            : composeEmptyNode(ctx, props.end, start, null, props, onError);
+        if (ctx.schema.compat)
+            flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }
-    seq.range = [bs.offset, offset, offset];
+    seq.range = [bs.offset, offset, commentEnd ?? offset];
     return seq;
 }
 

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

@@ -16,13 +16,17 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
         ? new YAMLMap(ctx.schema)
         : new YAMLSeq(ctx.schema);
     coll.flow = true;
-    let offset = fc.offset;
+    const atRoot = ctx.atRoot;
+    if (atRoot)
+        ctx.atRoot = false;
+    let offset = fc.offset + fc.start.source.length;
     for (let i = 0; i < fc.items.length; ++i) {
-        const { start, key, sep, value } = fc.items[i];
+        const collItem = fc.items[i];
+        const { start, key, sep, value } = collItem;
         const props = resolveProps(start, {
             flow: fcName,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            next: key ?? sep?.[0],
             offset,
             onError,
             startOnNewline: false
@@ -39,6 +43,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     else
                         coll.comment = props.comment;
                 }
+                offset = props.end;
                 continue;
             }
             if (!isMap && ctx.options.strict && containsNewline(key))
@@ -69,7 +74,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 if (prevItemComment) {
                     let prev = coll.items[coll.items.length - 1];
                     if (isPair(prev))
-                        prev = prev.value || prev.key;
+                        prev = prev.value ?? prev.key;
                     if (prev.comment)
                         prev.comment += '\n' + prevItemComment;
                     else
@@ -99,7 +104,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
             if (isBlock(key))
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
-            const valueProps = resolveProps(sep || [], {
+            const valueProps = resolveProps(sep ?? [], {
                 flow: fcName,
                 indicator: 'map-value-ind',
                 next: value,
@@ -145,6 +150,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
             if (isMap) {
                 const map = coll;
                 if (mapIncludes(ctx, map.items, keyNode))
@@ -166,7 +173,11 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     if (ce && ce.source === expectedEnd)
         cePos = ce.offset + ce.source.length;
     else {
-        onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
+        const name = fcName[0].toUpperCase() + fcName.substring(1);
+        const msg = atRoot
+            ? `${name} must end with a ${expectedEnd}`
+            : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
+        onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg);
         if (ce && ce.source.length !== 1)
             ee.unshift(ce);
     }

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

@@ -111,7 +111,7 @@ function foldLines(source) {
     const last = /[ \t]*(.*)/sy;
     last.lastIndex = pos;
     match = last.exec(source);
-    return res + sep + ((match && match[1]) || '');
+    return res + sep + (match?.[1] ?? '');
 }
 function doubleQuotedValue(source, onError) {
     let res = '';
@@ -135,6 +135,12 @@ function doubleQuotedValue(source, onError) {
                 while (next === ' ' || next === '\t')
                     next = source[++i + 1];
             }
+            else if (next === '\r' && source[i + 1] === '\n') {
+                // skip escaped CRLF newlines, but still trim the following line
+                next = source[++i + 1];
+                while (next === ' ' || next === '\t')
+                    next = source[++i + 1];
+            }
             else if (next === 'x' || next === 'u' || next === 'U') {
                 const length = { x: 2, u: 4, U: 8 }[next];
                 res += parseCharCode(source, i + 1, length, onError);
@@ -152,7 +158,7 @@ function doubleQuotedValue(source, onError) {
             let next = source[i + 1];
             while (next === ' ' || next === '\t')
                 next = source[++i + 1];
-            if (next !== '\n')
+            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
                 res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
         }
         else {

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

@@ -5,6 +5,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
     let comment = '';
     let commentSep = '';
     let hasNewline = false;
+    let hasNewlineAfterProp = false;
     let reqSpace = false;
     let anchor = null;
     let tag = null;
@@ -54,11 +55,15 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                     commentSep += token.source;
                 atNewline = true;
                 hasNewline = true;
+                if (anchor || tag)
+                    hasNewlineAfterProp = true;
                 hasSpace = true;
                 break;
             case 'anchor':
                 if (anchor)
                     onError(token, 'MULTIPLE_ANCHORS', 'A node can have at most one anchor');
+                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;
@@ -81,6 +86,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 // Could here handle preceding comments differently
                 if (anchor || tag)
                     onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`);
+                if (found)
+                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow ?? 'collection'}`);
                 found = token;
                 atNewline = false;
                 hasSpace = false;
@@ -116,10 +123,11 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
         spaceBefore,
         comment,
         hasNewline,
+        hasNewlineAfterProp,
         anchor,
         tag,
         end,
-        start: start !== null && start !== void 0 ? start : end
+        start: start ?? end
     };
 }
 

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

@@ -14,7 +14,7 @@ function emptyScalarPosition(offset, before, pos) {
             // Technically, an empty scalar is immediately after the last non-empty
             // node, but it's more useful to place it after any whitespace.
             st = before[++i];
-            while ((st === null || st === void 0 ? void 0 : st.type) === 'space') {
+            while (st?.type === 'space') {
                 offset += st.source.length;
                 st = before[++i];
             }

package/node_modules/yaml/browser/dist/compose/util-flow-indent-check.js

@@ -0,0 +1,15 @@
+import { containsNewline } from './util-contains-newline.js';
+
+function flowIndentCheck(indent, fc, onError) {
+    if (fc?.type === 'flow-collection') {
+        const end = fc.end[0];
+        if (end.indent === indent &&
+            (end.source === ']' || end.source === '}') &&
+            containsNewline(fc)) {
+            const msg = 'Flow end indicator should be more indented than parent';
+            onError(end, 'BAD_INDENT', msg, true);
+        }
+    }
+}
+
+export { flowIndentCheck };

package/node_modules/yaml/browser/dist/doc/Document.js

@@ -1,9 +1,8 @@
 import { Alias } from '../nodes/Alias.js';
 import { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';
-import { NODE_TYPE, DOC, isCollection, isScalar } from '../nodes/Node.js';
+import { NODE_TYPE, DOC, isNode, isCollection, isScalar } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
 import { toJS } from '../nodes/toJS.js';
-import { defaultOptions } from '../options.js';
 import { Schema } from '../schema/Schema.js';
 import { stringify } from '../stringify/stringify.js';
 import { stringifyDocument } from '../stringify/stringifyDocument.js';
@@ -31,11 +30,19 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const opt = Object.assign({}, defaultOptions, options);
+        const opt = Object.assign({
+            intAsBigInt: false,
+            keepSourceTokens: false,
+            logLevel: 'warn',
+            prettyErrors: true,
+            strict: true,
+            uniqueKeys: true,
+            version: '1.2'
+        }, options);
         this.options = opt;
         let { version } = opt;
-        if (options === null || options === void 0 ? void 0 : options.directives) {
-            this.directives = options.directives.atDocument();
+        if (options?._directives) {
+            this.directives = options._directives.atDocument();
             if (this.directives.yaml.explicit)
                 version = this.directives.yaml.version;
         }
@@ -48,6 +55,30 @@ class Document {
             this.contents = this.createNode(value, _replacer, options);
         }
     }
+    /**
+     * Create a deep copy of this Document and its contents.
+     *
+     * Custom Node values that inherit from `Object` still refer to their original instances.
+     */
+    clone() {
+        const copy = Object.create(Document.prototype, {
+            [NODE_TYPE]: { value: DOC }
+        });
+        copy.commentBefore = this.commentBefore;
+        copy.comment = this.comment;
+        copy.errors = this.errors.slice();
+        copy.warnings = this.warnings.slice();
+        copy.options = Object.assign({}, this.options);
+        if (this.directives)
+            copy.directives = this.directives.clone();
+        copy.schema = this.schema.clone();
+        copy.contents = isNode(this.contents)
+            ? this.contents.clone(copy.schema)
+            : this.contents;
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
     /** Adds a value to the document. */
     add(value) {
         if (assertCollection(this.contents))
@@ -71,6 +102,7 @@ class Document {
         if (!node.anchor) {
             const prev = anchorNames(this);
             node.anchor =
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
                 !name || prev.has(name) ? findNewAnchor(name || 'a', prev) : name;
         }
         return new Alias(node.anchor);
@@ -92,10 +124,13 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
-        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || 'a');
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options ?? {};
+        const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, 
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        anchorPrefix || 'a');
         const ctx = {
-            keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
+            aliasDuplicateObjects: aliasDuplicateObjects ?? true,
+            keepUndefined: keepUndefined ?? false,
             onAnchor,
             onTagObj,
             replacer: _replacer,
@@ -205,26 +240,48 @@ class Document {
     }
     /**
      * Change the YAML version and schema used by the document.
+     * A `null` version disables support for directives, explicit tags, anchors, and aliases.
+     * It also requires the `schema` option to be given as a `Schema` instance value.
      *
-     * Overrides all previously set schema options
+     * Overrides all previously set schema options.
      */
-    setSchema(version, options) {
-        let _options;
-        switch (String(version)) {
+    setSchema(version, options = {}) {
+        if (typeof version === 'number')
+            version = String(version);
+        let opt;
+        switch (version) {
             case '1.1':
-                this.directives.yaml.version = '1.1';
-                _options = Object.assign({ merge: true, resolveKnownTags: false, schema: 'yaml-1.1' }, options);
+                if (this.directives)
+                    this.directives.yaml.version = '1.1';
+                else
+                    this.directives = new Directives({ version: '1.1' });
+                opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };
                 break;
             case '1.2':
-                this.directives.yaml.version = '1.2';
-                _options = Object.assign({ merge: false, resolveKnownTags: true, schema: 'core' }, options);
+            case 'next':
+                if (this.directives)
+                    this.directives.yaml.version = version;
+                else
+                    this.directives = new Directives({ version });
+                opt = { merge: false, resolveKnownTags: true, schema: 'core' };
+                break;
+            case null:
+                if (this.directives)
+                    delete this.directives;
+                opt = null;
                 break;
             default: {
                 const sv = JSON.stringify(version);
-                throw new Error(`Expected '1.1' or '1.2' as version, but found: ${sv}`);
+                throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
             }
         }
-        this.schema = new Schema(_options);
+        // Not using `instanceof Schema` to allow for duck typing
+        if (options.schema instanceof Object)
+            this.schema = options.schema;
+        else if (opt)
+            this.schema = new Schema(Object.assign(opt, options));
+        else
+            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
     }
     // json & jsonArg are only used from toJSON()
     toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
@@ -237,7 +294,7 @@ class Document {
             maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
             stringify
         };
-        const res = toJS(this.contents, jsonArg || '', ctx);
+        const res = toJS(this.contents, jsonArg ?? '', ctx);
         if (typeof onAnchor === 'function')
             for (const { count, res } of ctx.anchors.values())
                 onAnchor(res, count);

package/node_modules/yaml/browser/dist/doc/anchors.js

@@ -37,7 +37,7 @@ function createNodeAnchors(doc, prefix) {
     const sourceObjects = new Map();
     let prevAnchors = null;
     return {
-        onAnchor(source) {
+        onAnchor: (source) => {
             aliasObjects.push(source);
             if (!prevAnchors)
                 prevAnchors = anchorNames(doc);
@@ -50,7 +50,7 @@ function createNodeAnchors(doc, prefix) {
          * of its child nodes are. This is why anchors are set only after all of
          * the nodes have been created.
          */
-        setAnchors() {
+        setAnchors: () => {
             for (const source of aliasObjects) {
                 const ref = sourceObjects.get(source);
                 if (typeof ref === 'object' &&

package/node_modules/yaml/browser/dist/doc/createNode.js

@@ -1,40 +1,41 @@
 import { Alias } from '../nodes/Alias.js';
-import { isNode, isPair, MAP, SEQ } from '../nodes/Node.js';
+import { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
 function findTagObject(value, tagName, tags) {
     if (tagName) {
         const match = tags.filter(t => t.tag === tagName);
-        const tagObj = match.find(t => !t.format) || match[0];
+        const tagObj = match.find(t => !t.format) ?? match[0];
         if (!tagObj)
             throw new Error(`Tag ${tagName} not found`);
         return tagObj;
     }
-    return tags.find(t => t.identify && t.identify(value) && !t.format);
+    return tags.find(t => t.identify?.(value) && !t.format);
 }
 function createNode(value, tagName, ctx) {
-    var _a, _b;
+    if (isDocument(value))
+        value = value.contents;
     if (isNode(value))
         return value;
     if (isPair(value)) {
-        const map = (_b = (_a = ctx.schema[MAP]).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
+        const map = ctx.schema[MAP].createNode?.(ctx.schema, null, ctx);
         map.items.push(value);
         return map;
     }
     if (value instanceof String ||
         value instanceof Number ||
         value instanceof Boolean ||
-        (typeof BigInt === 'function' && value instanceof BigInt) // not supported everywhere
+        (typeof BigInt !== 'undefined' && value instanceof BigInt) // not supported everywhere
     ) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
     // Detect duplicate references to the same object & use Alias nodes for all
     // after first. The `ref` wrapper allows for circular references to resolve.
     let ref = undefined;
-    if (value && typeof value === 'object') {
+    if (aliasDuplicateObjects && value && typeof value === 'object') {
         ref = sourceObjects.get(value);
         if (ref) {
             if (!ref.anchor)
@@ -46,12 +47,14 @@ function createNode(value, tagName, ctx) {
             sourceObjects.set(value, ref);
         }
     }
-    if (tagName && tagName.startsWith('!!'))
+    if (tagName?.startsWith('!!'))
         tagName = defaultTagPrefix + tagName.slice(2);
     let tagObj = findTagObject(value, tagName, schema.tags);
     if (!tagObj) {
-        if (value && typeof value.toJSON === 'function')
+        if (value && typeof value.toJSON === 'function') {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
             value = value.toJSON();
+        }
         if (!value || typeof value !== 'object') {
             const node = new Scalar(value);
             if (ref)
@@ -69,7 +72,7 @@ function createNode(value, tagName, ctx) {
         onTagObj(tagObj);
         delete ctx.onTagObj;
     }
-    const node = (tagObj === null || tagObj === void 0 ? void 0 : tagObj.createNode)
+    const node = tagObj?.createNode
         ? tagObj.createNode(ctx.schema, value, ctx)
         : new Scalar(value);
     if (tagName)

package/node_modules/yaml/browser/dist/doc/directives.js

@@ -16,10 +16,17 @@ class Directives {
          * The directives-end/doc-start marker `---`. If `null`, a marker may still be
          * included in the document's stringified representation.
          */
-        this.marker = null;
+        this.docStart = null;
+        /** The doc-end marker `...`.  */
+        this.docEnd = false;
         this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
         this.tags = Object.assign({}, Directives.defaultTags, tags);
     }
+    clone() {
+        const copy = new Directives(this.yaml, this.tags);
+        copy.docStart = this.docStart;
+        return copy;
+    }
     /**
      * During parsing, get a Directives instance for the current document and
      * update the stream state according to the current version's spec.
@@ -66,7 +73,7 @@ class Directives {
             }
             case '%YAML': {
                 this.yaml.explicit = true;
-                if (parts.length < 1) {
+                if (parts.length !== 1) {
                     onError(0, '%YAML directive should contain exactly one part');
                     return false;
                 }
@@ -76,7 +83,8 @@ class Directives {
                     return true;
                 }
                 else {
-                    onError(6, `Unsupported YAML version ${version}`, true);
+                    const isValid = /^\d+\.\d+$/.test(version);
+                    onError(6, `Unsupported YAML version ${version}`, isValid);
                     return false;
                 }
             }

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

@@ -47,7 +47,7 @@ const prettifyError = (src, lc) => (error) => {
         let count = 1;
         const end = error.linePos[1];
         if (end && end.line === line && end.col > col) {
-            count = Math.min(end.col - col, 80 - ci);
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
         }
         const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;