@specship/specship-win32-arm64 0.13.0 → 0.13.1

package/lib/node_modules/yaml/dist/cli.mjs

@@ -1,5 +1,5 @@
-import { resolve } from 'path';
-import { parseArgs } from 'util';
+import { resolve } from 'node:path';
+import { parseArgs } from 'node:util';
 import { prettyToken } from './parse/cst.js';
 import { Lexer } from './parse/lexer.js';
 import { Parser } from './parse/parser.js';
@@ -23,7 +23,6 @@ Options:
   --help, -h    Show this message.
   --json, -j    Output JSON.
   --indent 2    Output pretty-printed data, indented by the given number of spaces.
-  --merge, -m   Enable support for "<<" merge keys.
 
 Additional options for bare "yaml" command:
   --doc, -d     Output pretty-printed JS Document objects.
@@ -49,7 +48,6 @@ async function cli(stdin, done, argv) {
                 doc: { type: 'boolean', short: 'd' },
                 help: { type: 'boolean', short: 'h' },
                 indent: { type: 'string', short: 'i' },
-                merge: { type: 'boolean', short: 'm' },
                 json: { type: 'boolean', short: 'j' },
                 single: { type: 'boolean', short: '1' },
                 strict: { type: 'boolean', short: 's' },
@@ -119,7 +117,7 @@ async function cli(stdin, done, argv) {
             const lineCounter = new LineCounter();
             const parser = new Parser(lineCounter.addNewLine);
             // @ts-expect-error Version is validated at runtime
-            const composer = new Composer({ version: opt.yaml, merge: opt.merge });
+            const composer = new Composer({ version: opt.yaml });
             const visitor = opt.visit
                 ? (await import(resolve(opt.visit))).default
                 : null;

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

@@ -1,7 +1,7 @@
-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';
+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';
 interface Props {
     anchor: SourceToken | null;
     tag: SourceToken | null;

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

@@ -61,13 +61,13 @@ function composeCollection(CN, ctx, token, props, onError) {
     let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
     if (!tag) {
         const kt = ctx.schema.knownTags[tagName];
-        if (kt?.collection === expType) {
+        if (kt && kt.collection === expType) {
             ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
             tag = kt;
         }
         else {
-            if (kt) {
-                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            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);

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

@@ -1,7 +1,7 @@
-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';
+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<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/lib/node_modules/yaml/dist/compose/compose-doc.js

@@ -9,7 +9,6 @@ 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,

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

@@ -1,11 +1,10 @@
-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';
+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';
 export interface ComposeContext {
-    atKey: boolean;
     atRoot: boolean;
     directives: Directives;
     options: Readonly<Required<Omit<ParseOptions, 'lineCounter'>>>;
@@ -25,5 +24,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').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.js").Scalar.Parsed;
 export {};

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

@@ -1,7 +1,6 @@
 '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');
@@ -9,7 +8,6 @@ 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;
@@ -30,36 +28,21 @@ function composeNode(ctx, token, props, onError) {
         case 'block-map':
         case 'block-seq':
         case 'flow-collection':
-            try {
-                node = composeCollection.composeCollection(CN, ctx, token, props, onError);
-                if (anchor)
-                    node.anchor = anchor.source.substring(1);
-            }
-            catch (error) {
-                // Almost certainly here due to a stack overflow
-                const message = error instanceof Error ? error.message : String(error);
-                onError(token, 'RESOURCE_EXHAUSTION', message);
-            }
+            node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
             break;
         default: {
             const message = token.type === 'error'
                 ? token.message
                 : `Unsupported token (type: ${token.type})`;
             onError(token, 'UNEXPECTED_TOKEN', message);
+            node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError);
             isSrcToken = false;
         }
     }
-    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, 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) {

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

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

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

@@ -12,16 +12,11 @@ function composeScalar(ctx, token, tagToken, onError) {
     const tagName = tagToken
         ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
         : null;
-    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];
+    const tag = tagToken && tagName
+        ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
+        : token.type === 'scalar'
+            ? findScalarTagByTest(ctx, value, token, onError)
+            : ctx.schema[identity.SCALAR];
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
@@ -69,9 +64,8 @@ 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({ 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];
+function findScalarTagByTest({ directives, schema }, value, token, onError) {
+    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[identity.SCALAR];

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

@@ -1,10 +1,9 @@
-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';
+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';
 type ErrorSource = number | [number, number] | Range | {
     offset: number;
     source?: string;

package/lib/node_modules/yaml/dist/compose/composer.js

@@ -1,6 +1,5 @@
 'use strict';
 
-var node_process = require('process');
 var directives = require('../doc/directives.js');
 var Document = require('../doc/Document.js');
 var errors = require('../errors.js');
@@ -97,10 +96,8 @@ class Composer {
             }
         }
         if (afterDoc) {
-            for (let i = 0; i < this.errors.length; ++i)
-                doc.errors.push(this.errors[i]);
-            for (let i = 0; i < this.warnings.length; ++i)
-                doc.warnings.push(this.warnings[i]);
+            Array.prototype.push.apply(doc.errors, this.errors);
+            Array.prototype.push.apply(doc.warnings, this.warnings);
         }
         else {
             doc.errors = this.errors;
@@ -136,7 +133,7 @@ class Composer {
     }
     /** Advance the composer by one CST token. */
     *next(token) {
-        if (node_process.env.LOG_STREAM)
+        if (process.env.LOG_STREAM)
             console.dir(token, { depth: null });
         switch (token.type) {
             case 'directive':

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

@@ -1,6 +1,6 @@
-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';
+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;

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

@@ -52,14 +52,12 @@ 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

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

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

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

@@ -1,6 +1,6 @@
-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';
+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;

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

@@ -9,8 +9,6 @@ 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) {
@@ -24,7 +22,7 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, ta
         });
         if (!props.found) {
             if (props.anchor || props.tag || value) {
-                if (value?.type === 'block-seq')
+                if (value && value.type === 'block-seq')
                     onError(props.end, 'BAD_INDENT', 'All sequence items must start at the same column');
                 else
                     onError(offset, 'MISSING_CHAR', 'Sequence item without - indicator');

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

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

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

@@ -1,7 +1,7 @@
-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>;
+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>;

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

@@ -20,8 +20,6 @@ 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];
@@ -101,14 +99,12 @@ 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,
@@ -135,7 +131,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 }
             }
             else if (value) {
-                if ('source' in value && value.source?.[0] === ':')
+                if ('source' in value && value.source && value.source[0] === ':')
                     onError(value, 'MISSING_CHAR', `Missing space after : in ${fcName}`);
                 else
                     onError(valueProps.start, 'MISSING_CHAR', `Missing , or : between ${fcName} items`);
@@ -169,8 +165,6 @@ 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;
@@ -179,7 +173,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const expectedEnd = isMap ? '}' : ']';
     const [ce, ...ee] = fc.end;
     let cePos = offset;
-    if (ce?.source === expectedEnd)
+    if (ce && ce.source === expectedEnd)
         cePos = ce.offset + ce.source.length;
     else {
         const name = fcName[0].toUpperCase() + fcName.substring(1);

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

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

package/lib/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;
     }
@@ -144,7 +144,7 @@ function doubleQuotedValue(source, onError) {
                     next = source[++i + 1];
             }
             else if (next === 'x' || next === 'u' || next === 'U') {
-                const length = next === 'x' ? 2 : next === 'u' ? 4 : 8;
+                const length = { x: 2, u: 4, U: 8 }[next];
                 res += parseCharCode(source, i + 1, length, onError);
                 i += length;
             }
@@ -214,14 +214,12 @@ function parseCharCode(source, offset, length, onError) {
     const cc = source.substr(offset, length);
     const ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc);
     const code = ok ? parseInt(cc, 16) : NaN;
-    try {
-        return String.fromCodePoint(code);
-    }
-    catch {
+    if (isNaN(code)) {
         const raw = source.substr(offset - 2, length + 2);
         onError(offset - 2, 'BAD_DQ_ESCAPE', `Invalid escape sequence ${raw}`);
         return raw;
     }
+    return String.fromCodePoint(code);
 }
 
 exports.resolveFlowScalar = resolveFlowScalar;

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

@@ -1,5 +1,5 @@
-import type { SourceToken, Token } from '../parse/cst';
-import type { ComposeErrorHandler } from './composer';
+import type { SourceToken, Token } from '../parse/cst.js';
+import type { ComposeErrorHandler } from './composer.js';
 export interface ResolvePropsArg {
     flow?: 'flow map' | 'flow sequence';
     indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';

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

@@ -57,7 +57,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (atNewline) {
                     if (comment)
                         comment += token.source;
-                    else if (!found || indicator !== 'seq-item-ind')
+                    else
                         spaceBefore = true;
                 }
                 else
@@ -74,7 +74,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (token.source.endsWith(':'))
                     onError(token.offset + token.source.length - 1, 'BAD_ALIAS', 'Anchor ending in : is ambiguous', true);
                 anchor = token;
-                start ?? (start = token.offset);
+                if (start === null)
+                    start = token.offset;
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;
@@ -83,7 +84,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (tag)
                     onError(token, 'MULTIPLE_TAGS', 'A node can have at most one tag');
                 tag = token;
-                start ?? (start = token.offset);
+                if (start === null)
+                    start = token.offset;
                 atNewline = false;
                 hasSpace = false;
                 reqSpace = true;

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { ParsedNode } from '../nodes/Node';
-import type { Pair } from '../nodes/Pair';
-import type { 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/lib/node_modules/yaml/dist/compose/util-map-includes.js

@@ -8,7 +8,11 @@ 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, b) => a === 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/lib/node_modules/yaml/dist/doc/Document.d.ts

@@ -1,14 +1,14 @@
-import type { YAMLError, YAMLWarning } from '../errors';
-import { Alias } from '../nodes/Alias';
-import { NODE_TYPE } from '../nodes/identity';
-import type { Node, NodeType, ParsedNode, Range } from '../nodes/Node';
-import { Pair } from '../nodes/Pair';
-import type { Scalar } from '../nodes/Scalar';
-import type { YAMLMap } from '../nodes/YAMLMap';
-import type { YAMLSeq } from '../nodes/YAMLSeq';
-import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options';
-import { Schema } from '../schema/Schema';
-import { Directives } from './directives';
+import type { YAMLError, YAMLWarning } from '../errors.js';
+import { Alias } from '../nodes/Alias.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';
+import type { YAMLSeq } from '../nodes/YAMLSeq.js';
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
+import { Schema } from '../schema/Schema.js';
+import { Directives } from './directives.js';
 export type Replacer = any[] | ((key: any, value: any) => unknown);
 export declare namespace Document {
     /** @ts-ignore The typing of directives fails in TS <= 4.2 */

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

@@ -37,7 +37,6 @@ class Document {
             logLevel: 'warn',
             prettyErrors: true,
             strict: true,
-            stringKeys: false,
             uniqueKeys: true,
             version: '1.2'
         }, options);
@@ -261,7 +260,7 @@ class Document {
                     this.directives.yaml.version = '1.1';
                 else
                     this.directives = new directives.Directives({ version: '1.1' });
-                opt = { resolveKnownTags: false, schema: 'yaml-1.1' };
+                opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };
                 break;
             case '1.2':
             case 'next':
@@ -269,7 +268,7 @@ class Document {
                     this.directives.yaml.version = version;
                 else
                     this.directives = new directives.Directives({ version });
-                opt = { resolveKnownTags: true, schema: 'core' };
+                opt = { merge: false, resolveKnownTags: true, schema: 'core' };
                 break;
             case null:
                 if (this.directives)

package/lib/node_modules/yaml/dist/doc/anchors.d.ts

@@ -1,5 +1,5 @@
-import type { Node } from '../nodes/Node';
-import type { Document } from './Document';
+import type { Node } from '../nodes/Node.js';
+import type { Document } from './Document.js';
 /**
  * Verify that the input string is a valid anchor.
  *