yaml 2.0.1 → 2.1.0

package/dist/nodes/Node.d.ts

@@ -6,9 +6,13 @@ import type { Pair } from './Pair.js';
 import type { Scalar } from './Scalar.js';
 import type { YAMLMap } from './YAMLMap.js';
 import type { YAMLSeq } from './YAMLSeq.js';
-export declare type Node = Alias | Scalar | YAMLMap | YAMLSeq;
+export declare type Node<T = unknown> = Alias | Scalar<T> | YAMLMap<unknown, T> | YAMLSeq<T>;
+/** Utility type mapper */
+export declare type NodeType<T> = T extends string | number | bigint | boolean | null ? Scalar<T> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends {
+    [key: string | number]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : Node;
 export declare type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
-export declare type Range = [number, number, number];
+export declare type Range = [start: number, valueEnd: number, nodeEnd: number];
 export declare const ALIAS: unique symbol;
 export declare const DOC: unique symbol;
 export declare const MAP: unique symbol;
@@ -17,14 +21,14 @@ export declare const SCALAR: unique symbol;
 export declare const SEQ: unique symbol;
 export declare const NODE_TYPE: unique symbol;
 export declare const isAlias: (node: any) => node is Alias;
-export declare const isDocument: (node: any) => node is Document<unknown>;
-export declare const isMap: (node: any) => node is YAMLMap<unknown, unknown>;
-export declare const isPair: (node: any) => node is Pair<unknown, unknown>;
-export declare const isScalar: (node: any) => node is Scalar<unknown>;
-export declare const isSeq: (node: any) => node is YAMLSeq<unknown>;
-export declare function isCollection(node: any): node is YAMLMap | YAMLSeq;
-export declare function isNode(node: any): node is Node;
-export declare const hasAnchor: (node: unknown) => node is Scalar<unknown> | YAMLMap<unknown, unknown> | YAMLSeq<unknown>;
+export declare const isDocument: <T extends Node<unknown> = Node<unknown>>(node: any) => node is Document<T>;
+export declare const isMap: <K = unknown, V = unknown>(node: any) => node is YAMLMap<K, V>;
+export declare const isPair: <K = unknown, V = unknown>(node: any) => node is Pair<K, V>;
+export declare const isScalar: <T = unknown>(node: any) => node is Scalar<T>;
+export declare const isSeq: <T = unknown>(node: any) => node is YAMLSeq<T>;
+export declare function isCollection<K = unknown, V = unknown>(node: any): node is YAMLMap<K, V> | YAMLSeq<V>;
+export declare function isNode<T = unknown>(node: any): node is Node<T>;
+export declare const hasAnchor: <K = unknown, V = unknown>(node: unknown) => node is Scalar<V> | YAMLMap<K, V> | YAMLSeq<V>;
 export declare abstract class NodeBase {
     readonly [NODE_TYPE]: symbol;
     /** A comment on or immediately after this */

package/dist/nodes/Pair.d.ts

@@ -5,7 +5,7 @@ import type { StringifyContext } from '../stringify/stringify.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { NODE_TYPE } from './Node.js';
 import type { ToJSContext } from './toJS.js';
-export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
+export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node<unknown>, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
 export declare class Pair<K = unknown, V = unknown> {
     readonly [NODE_TYPE]: symbol;
     /** Always Node or null when parsed, but can be set to anything. */

package/dist/nodes/Pair.js

@@ -25,11 +25,11 @@ class Pair {
         return new Pair(key, value);
     }
     toJSON(_, ctx) {
-        const pair = (ctx === null || ctx === void 0 ? void 0 : ctx.mapAsMap) ? new Map() : {};
+        const pair = ctx?.mapAsMap ? new Map() : {};
         return addPairToJSMap.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
-        return (ctx === null || ctx === void 0 ? void 0 : ctx.doc)
+        return ctx?.doc
             ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
             : JSON.stringify(this);
     }

package/dist/nodes/Scalar.js

@@ -10,7 +10,7 @@ class Scalar extends Node.NodeBase {
         this.value = value;
     }
     toJSON(arg, ctx) {
-        return (ctx === null || ctx === void 0 ? void 0 : ctx.keep) ? this.value : toJS.toJS(this.value, arg, ctx);
+        return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
     }
     toString() {
         return String(this.value);

package/dist/nodes/YAMLMap.d.ts

@@ -4,6 +4,7 @@ import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
 import { ParsedNode, Range } from './Node.js';
 import { Pair } from './Pair.js';
+import { Scalar } from './Scalar.js';
 import type { ToJSContext } from './toJS.js';
 export declare function findPair<K = unknown, V = unknown>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
 export declare namespace YAMLMap {
@@ -27,9 +28,11 @@ export declare class YAMLMap<K = unknown, V = unknown> extends Collection {
         key: K;
         value: V;
     }, overwrite?: boolean): void;
-    delete(key: K): boolean;
-    get(key: K, keepScalar?: boolean): unknown;
-    has(key: K): boolean;
+    delete(key: unknown): boolean;
+    get(key: unknown, keepScalar: true): Scalar<V> | undefined;
+    get(key: unknown, keepScalar?: false): V | undefined;
+    get(key: unknown, keepScalar?: boolean): V | Scalar<V> | undefined;
+    has(key: unknown): boolean;
     set(key: K, value: V): void;
     /**
      * @param ctx - Conversion context, originally set in Document#toJS()

package/dist/nodes/YAMLMap.js

@@ -34,18 +34,17 @@ class YAMLMap extends Collection.Collection {
      *   collection will throw. Otherwise, overwrites the previous value.
      */
     add(pair, overwrite) {
-        var _a;
         let _pair;
         if (Node.isPair(pair))
             _pair = pair;
         else if (!pair || typeof pair !== 'object' || !('key' in pair)) {
             // In TypeScript, this never happens.
-            _pair = new Pair.Pair(pair, pair.value);
+            _pair = new Pair.Pair(pair, pair?.value);
         }
         else
             _pair = new Pair.Pair(pair.key, pair.value);
         const prev = findPair(this.items, _pair.key);
-        const sortEntries = (_a = this.schema) === null || _a === void 0 ? void 0 : _a.sortMapEntries;
+        const sortEntries = this.schema?.sortMapEntries;
         if (prev) {
             if (!overwrite)
                 throw new Error(`Key ${_pair.key} already set`);
@@ -75,8 +74,8 @@ class YAMLMap extends Collection.Collection {
     }
     get(key, keepScalar) {
         const it = findPair(this.items, key);
-        const node = it === null || it === void 0 ? void 0 : it.value;
-        return !keepScalar && Node.isScalar(node) ? node.value : node;
+        const node = it?.value;
+        return (!keepScalar && Node.isScalar(node) ? node.value : node) ?? undefined;
     }
     has(key) {
         return !!findPair(this.items, key);
@@ -90,8 +89,8 @@ class YAMLMap extends Collection.Collection {
      * @returns Instance of Type, Map, or Object
      */
     toJSON(_, ctx, Type) {
-        const map = Type ? new Type() : (ctx === null || ctx === void 0 ? void 0 : ctx.mapAsMap) ? new Map() : {};
-        if (ctx === null || ctx === void 0 ? void 0 : ctx.onCreate)
+        const map = Type ? new Type() : ctx?.mapAsMap ? new Map() : {};
+        if (ctx?.onCreate)
             ctx.onCreate(map);
         for (const item of this.items)
             addPairToJSMap.addPairToJSMap(ctx, map, item);

package/dist/nodes/YAMLSeq.d.ts

@@ -4,6 +4,7 @@ import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
 import { ParsedNode, Range } from './Node.js';
 import type { Pair } from './Pair.js';
+import { Scalar } from './Scalar.js';
 import { ToJSContext } from './toJS.js';
 export declare namespace YAMLSeq {
     interface Parsed<T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode> extends YAMLSeq<T> {
@@ -34,7 +35,9 @@ export declare class YAMLSeq<T = unknown> extends Collection {
      * `key` must contain a representation of an integer for this to succeed.
      * It may be wrapped in a `Scalar`.
      */
-    get(key: unknown, keepScalar?: boolean): unknown;
+    get(key: unknown, keepScalar: true): Scalar<T> | undefined;
+    get(key: unknown, keepScalar?: false): T | undefined;
+    get(key: unknown, keepScalar?: boolean): T | Scalar<T> | undefined;
     /**
      * Checks if the collection includes a value with the key `key`.
      *

package/dist/nodes/YAMLSeq.js

@@ -32,14 +32,6 @@ class YAMLSeq extends Collection.Collection {
         const del = this.items.splice(idx, 1);
         return del.length > 0;
     }
-    /**
-     * Returns item at `key`, 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).
-     *
-     * `key` must contain a representation of an integer for this to succeed.
-     * It may be wrapped in a `Scalar`.
-     */
     get(key, keepScalar) {
         const idx = asItemIndex(key);
         if (typeof idx !== 'number')
@@ -76,7 +68,7 @@ class YAMLSeq extends Collection.Collection {
     }
     toJSON(_, ctx) {
         const seq = [];
-        if (ctx === null || ctx === void 0 ? void 0 : ctx.onCreate)
+        if (ctx?.onCreate)
             ctx.onCreate(seq);
         let i = 0;
         for (const item of this.items)

package/dist/nodes/addPairToJSMap.js

@@ -8,7 +8,7 @@ var toJS = require('./toJS.js');
 
 const MERGE_KEY = '<<';
 function addPairToJSMap(ctx, map, { key, value }) {
-    if ((ctx === null || ctx === void 0 ? void 0 : ctx.doc.schema.merge) && isMergeKey(key)) {
+    if (ctx?.doc.schema.merge && isMergeKey(key)) {
         value = Node.isAlias(value) ? value.resolve(ctx.doc) : value;
         if (Node.isSeq(value))
             for (const it of value.items)

package/dist/nodes/toJS.js

@@ -31,7 +31,7 @@ function toJS(value, arg, ctx) {
             ctx.onCreate(res);
         return res;
     }
-    if (typeof value === 'bigint' && !(ctx === null || ctx === void 0 ? void 0 : ctx.keep))
+    if (typeof value === 'bigint' && !ctx?.keep)
         return Number(value);
     return value;
 }

package/dist/options.d.ts

@@ -58,10 +58,11 @@ export declare type ParseOptions = {
 };
 export declare type DocumentOptions = {
     /**
+     * @internal
      * Used internally by Composer. If set and includes an explicit version,
      * that overrides the `version` option.
      */
-    directives?: Directives;
+    _directives?: Directives;
     /**
      * Control the logging level during parsing
      *

package/dist/parse/cst-scalar.js

@@ -40,7 +40,6 @@ function resolveAsScalar(token, strict = true, onError) {
  * @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
  */
 function createScalarToken(value, context) {
-    var _a;
     const { implicitKey = false, indent, inFlow = false, offset = -1, type = 'PLAIN' } = context;
     const source = stringifyString.stringifyString({ type, value }, {
         implicitKey,
@@ -48,7 +47,7 @@ function createScalarToken(value, context) {
         inFlow,
         options: { blockQuote: true, lineWidth: -1 }
     });
-    const end = (_a = context.end) !== null && _a !== void 0 ? _a : [
+    const end = context.end ?? [
         { type: 'newline', offset: -1, indent, source: '\n' }
     ];
     switch (source[0]) {

package/dist/parse/cst-visit.js

@@ -49,7 +49,7 @@ visit.REMOVE = REMOVE;
 visit.itemAtPath = (cst, path) => {
     let item = cst;
     for (const [field, index] of path) {
-        const tok = item === null || item === void 0 ? void 0 : item[field];
+        const tok = item?.[field];
         if (tok && 'items' in tok) {
             item = tok.items[index];
         }
@@ -66,7 +66,7 @@ visit.itemAtPath = (cst, path) => {
 visit.parentCollection = (cst, path) => {
     const parent = visit.itemAtPath(cst, path.slice(0, -1));
     const field = path[path.length - 1][0];
-    const coll = parent === null || parent === void 0 ? void 0 : parent[field];
+    const coll = parent?.[field];
     if (coll && 'items' in coll)
         return coll;
     throw new Error('Parent collection not found');

package/dist/parse/lexer.js

@@ -150,13 +150,12 @@ class Lexer {
      * @returns A generator of lexical tokens
      */
     *lex(source, incomplete = false) {
-        var _a;
         if (source) {
             this.buffer = this.buffer ? this.buffer + source : source;
             this.lineEndPos = null;
         }
         this.atEnd = !incomplete;
-        let next = (_a = this.next) !== null && _a !== void 0 ? _a : 'stream';
+        let next = this.next ?? 'stream';
         while (next && (incomplete || this.hasChars(1)))
             next = yield* this.parseNext(next);
     }

package/dist/parse/parser.js

@@ -23,7 +23,7 @@ function findNonEmptyIndex(list) {
     return -1;
 }
 function isFlowToken(token) {
-    switch (token === null || token === void 0 ? void 0 : token.type) {
+    switch (token?.type) {
         case 'alias':
         case 'scalar':
         case 'single-quoted-scalar':
@@ -35,13 +35,12 @@ function isFlowToken(token) {
     }
 }
 function getPrevProps(parent) {
-    var _a;
     switch (parent.type) {
         case 'document':
             return parent.start;
         case 'block-map': {
             const it = parent.items[parent.items.length - 1];
-            return (_a = it.sep) !== null && _a !== void 0 ? _a : it.start;
+            return it.sep ?? it.start;
         }
         case 'block-seq':
             return parent.items[parent.items.length - 1].start;
@@ -52,7 +51,6 @@ function getPrevProps(parent) {
 }
 /** Note: May modify input array */
 function getFirstKeyStartProps(prev) {
-    var _a;
     if (prev.length === 0)
         return [];
     let i = prev.length;
@@ -66,7 +64,7 @@ function getFirstKeyStartProps(prev) {
                 break loop;
         }
     }
-    while (((_a = prev[++i]) === null || _a === void 0 ? void 0 : _a.type) === 'space') {
+    while (prev[++i]?.type === 'space') {
         /* loop */
     }
     return prev.splice(i, prev.length);
@@ -270,7 +268,7 @@ class Parser {
         return this.stack[this.stack.length - n];
     }
     *pop(error) {
-        const token = error !== null && error !== void 0 ? error : this.stack.pop();
+        const token = error ?? this.stack.pop();
         /* istanbul ignore if should not happen */
         if (!token) {
             const message = 'Tried to pop an empty stack';
@@ -475,7 +473,6 @@ class Parser {
         }
     }
     *blockMap(map) {
-        var _a;
         const it = map.items[map.items.length - 1];
         // it.sep is true-ish if pair already has key or : separator
         switch (this.type) {
@@ -484,8 +481,8 @@ class Parser {
                 if (it.value) {
                     const end = 'end' in it.value ? it.value.end : undefined;
                     const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
                     else
                         map.items.push({ start: [this.sourceToken] });
                 }
@@ -507,7 +504,7 @@ class Parser {
                 else {
                     if (this.atIndentedComment(it.start, map.indent)) {
                         const prev = map.items[map.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        const end = prev?.value?.end;
                         if (Array.isArray(end)) {
                             Array.prototype.push.apply(end, it.start);
                             end.push(this.sourceToken);
@@ -684,15 +681,14 @@ class Parser {
         yield* this.step();
     }
     *blockSequence(seq) {
-        var _a;
         const it = seq.items[seq.items.length - 1];
         switch (this.type) {
             case 'newline':
                 if (it.value) {
                     const end = 'end' in it.value ? it.value.end : undefined;
                     const last = Array.isArray(end) ? end[end.length - 1] : undefined;
-                    if ((last === null || last === void 0 ? void 0 : last.type) === 'comment')
-                        end === null || end === void 0 ? void 0 : end.push(this.sourceToken);
+                    if (last?.type === 'comment')
+                        end?.push(this.sourceToken);
                     else
                         seq.items.push({ start: [this.sourceToken] });
                 }
@@ -706,7 +702,7 @@ class Parser {
                 else {
                     if (this.atIndentedComment(it.start, seq.indent)) {
                         const prev = seq.items[seq.items.length - 2];
-                        const end = (_a = prev === null || prev === void 0 ? void 0 : prev.value) === null || _a === void 0 ? void 0 : _a.end;
+                        const end = prev?.value?.end;
                         if (Array.isArray(end)) {
                             Array.prototype.push.apply(end, it.start);
                             end.push(this.sourceToken);

package/dist/public-api.js

@@ -23,7 +23,7 @@ function parseOptions(options) {
  */
 function parseAllDocuments(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
-    const parser$1 = new parser.Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const parser$1 = new parser.Parser(lineCounter?.addNewLine);
     const composer$1 = new composer.Composer(options);
     const docs = Array.from(composer$1.compose(parser$1.parse(source)));
     if (prettyErrors && lineCounter)
@@ -38,7 +38,7 @@ function parseAllDocuments(source, options = {}) {
 /** Parse an input string into a single YAML.Document */
 function parseDocument(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
-    const parser$1 = new parser.Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const parser$1 = new parser.Parser(lineCounter?.addNewLine);
     const composer$1 = new composer.Composer(options);
     // `doc` is always set by compose.end(true) at the very latest
     let doc = null;
@@ -77,7 +77,6 @@ function parse(src, reviver, options) {
     return doc.toJS(Object.assign({ reviver: _reviver }, options));
 }
 function stringify(value, replacer, options) {
-    var _a;
     let _replacer = null;
     if (typeof replacer === 'function' || Array.isArray(replacer)) {
         _replacer = replacer;
@@ -92,7 +91,7 @@ function stringify(value, replacer, options) {
         options = indent < 1 ? undefined : indent > 8 ? { indent: 8 } : { indent };
     }
     if (value === undefined) {
-        const { keepUndefined } = (_a = options !== null && options !== void 0 ? options : replacer) !== null && _a !== void 0 ? _a : {};
+        const { keepUndefined } = options ?? replacer ?? {};
         if (!keepUndefined)
             return undefined;
     }

package/dist/schema/Schema.js

@@ -18,7 +18,7 @@ class Schema {
         this.name = (typeof schema === 'string' && schema) || 'core';
         this.knownTags = resolveKnownTags ? tags.coreKnownTags : {};
         this.tags = tags.getTags(customTags, this.name);
-        this.toStringOptions = toStringDefaults !== null && toStringDefaults !== void 0 ? toStringDefaults : null;
+        this.toStringOptions = toStringDefaults ?? null;
         Object.defineProperty(this, Node.MAP, { value: map.map });
         Object.defineProperty(this, Node.SCALAR, { value: string.string });
         Object.defineProperty(this, Node.SEQ, { value: seq.seq });

package/dist/schema/json-schema.d.ts

@@ -0,0 +1,69 @@
+declare type JsonSchema = boolean | ArraySchema | ObjectSchema | NumberSchema | StringSchema;
+declare type JsonType = 'array' | 'object' | 'string' | 'number' | 'integer' | 'boolean' | 'null';
+interface CommonSchema {
+    type?: JsonType | JsonType[];
+    const?: unknown;
+    enum?: unknown[];
+    format?: string;
+    allOf?: JsonSchema[];
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    not?: JsonSchema;
+    if?: JsonSchema;
+    then?: JsonSchema;
+    else?: JsonSchema;
+    $id?: string;
+    $defs?: Record<string, JsonSchema>;
+    $anchor?: string;
+    $dynamicAnchor?: string;
+    $ref?: string;
+    $dynamicRef?: string;
+    $schema?: string;
+    $vocabulary?: Record<string, boolean>;
+    $comment?: string;
+    default?: unknown;
+    deprecated?: boolean;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    title?: string;
+    description?: string;
+    examples?: unknown[];
+}
+interface ArraySchema extends CommonSchema {
+    prefixItems?: JsonSchema[];
+    items?: JsonSchema;
+    contains?: JsonSchema;
+    unevaluatedItems?: JsonSchema;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxContains?: number;
+    minContains?: number;
+}
+interface ObjectSchema extends CommonSchema {
+    properties?: Record<string, JsonSchema>;
+    patternProperties?: Record<string, JsonSchema>;
+    additionalProperties?: JsonSchema;
+    propertyNames?: JsonSchema;
+    unevaluatedProperties?: JsonSchema;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[];
+    dependentRequired?: Record<string, string[]>;
+    dependentSchemas?: Record<string, JsonSchema>;
+}
+interface StringSchema extends CommonSchema {
+    maxLength?: number;
+    minLength?: number;
+    patter?: string;
+    contentEncoding?: string;
+    contentMediaType?: string;
+    contentSchema?: JsonSchema;
+}
+interface NumberSchema extends CommonSchema {
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+}

package/dist/schema/yaml-1.1/omap.d.ts

@@ -8,9 +8,13 @@ export declare class YAMLOMap extends YAMLSeq {
         key: any;
         value: any;
     }, overwrite?: boolean | undefined) => void;
-    delete: (key: any) => boolean;
-    get: (key: any, keepScalar?: boolean | undefined) => unknown;
-    has: (key: any) => boolean;
+    delete: (key: unknown) => boolean;
+    get: {
+        (key: unknown, keepScalar: true): import("../../index.js").Scalar<any> | undefined;
+        (key: unknown, keepScalar?: false | undefined): any;
+        (key: unknown, keepScalar?: boolean | undefined): any;
+    };
+    has: (key: unknown) => boolean;
     set: (key: any, value: any) => void;
     /**
      * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,

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

@@ -24,7 +24,7 @@ class YAMLOMap extends YAMLSeq.YAMLSeq {
         if (!ctx)
             return super.toJSON(_);
         const map = new Map();
-        if (ctx === null || ctx === void 0 ? void 0 : ctx.onCreate)
+        if (ctx?.onCreate)
             ctx.onCreate(map);
         for (const pair of this.items) {
             let key, value;

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

@@ -6,7 +6,6 @@ var Scalar = require('../../nodes/Scalar.js');
 var YAMLSeq = require('../../nodes/YAMLSeq.js');
 
 function resolvePairs(seq, onError) {
-    var _a;
     if (Node.isSeq(seq)) {
         for (let i = 0; i < seq.items.length; ++i) {
             let item = seq.items[i];
@@ -21,7 +20,7 @@ function resolvePairs(seq, onError) {
                         ? `${item.commentBefore}\n${pair.key.commentBefore}`
                         : item.commentBefore;
                 if (item.comment) {
-                    const cn = (_a = pair.value) !== null && _a !== void 0 ? _a : pair.key;
+                    const cn = pair.value ?? pair.key;
                     cn.comment = cn.comment
                         ? `${item.comment}\n${cn.comment}`
                         : item.comment;

package/dist/schema/yaml-1.1/set.d.ts

@@ -12,9 +12,13 @@ export declare class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null
         key: T;
         value: Scalar<null> | null;
     }): void;
-    get(key?: T, keepPair?: boolean): unknown;
+    /**
+     * If `keepPair` is `true`, returns the Pair matching `key`.
+     * Otherwise, returns the value of that Pair's key.
+     */
+    get(key: unknown, keepPair?: boolean): any;
     set(key: T, value: boolean): void;
-    /** Will throw; `value` must be boolean */
+    /** @deprecated Will throw; `value` must be boolean */
     set(key: T, value: null): void;
     toJSON(_?: unknown, ctx?: ToJSContext): any;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;

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

@@ -24,6 +24,10 @@ class YAMLSet extends YAMLMap.YAMLMap {
         if (!prev)
             this.items.push(pair);
     }
+    /**
+     * If `keepPair` is `true`, returns the Pair matching `key`.
+     * Otherwise, returns the value of that Pair's key.
+     */
     get(key, keepPair) {
         const pair = YAMLMap.findPair(this.items, key);
         return !keepPair && Node.isPair(pair)

package/dist/stringify/stringify.js

@@ -45,26 +45,25 @@ function createStringifyContext(doc, options) {
     };
 }
 function getTagObject(tags, item) {
-    var _a, _b, _c, _d;
     if (item.tag) {
         const match = tags.filter(t => t.tag === item.tag);
         if (match.length > 0)
-            return (_a = match.find(t => t.format === item.format)) !== null && _a !== void 0 ? _a : match[0];
+            return match.find(t => t.format === item.format) ?? match[0];
     }
     let tagObj = undefined;
     let obj;
     if (Node.isScalar(item)) {
         obj = item.value;
-        const match = tags.filter(t => { var _a; return (_a = t.identify) === null || _a === void 0 ? void 0 : _a.call(t, obj); });
+        const match = tags.filter(t => t.identify?.(obj));
         tagObj =
-            (_b = match.find(t => t.format === item.format)) !== null && _b !== void 0 ? _b : match.find(t => !t.format);
+            match.find(t => t.format === item.format) ?? match.find(t => !t.format);
     }
     else {
         obj = item;
         tagObj = tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
     }
     if (!tagObj) {
-        const name = (_d = (_c = obj === null || obj === void 0 ? void 0 : obj.constructor) === null || _c === void 0 ? void 0 : _c.name) !== null && _d !== void 0 ? _d : typeof obj;
+        const name = obj?.constructor?.name ?? typeof obj;
         throw new Error(`Tag not resolved for ${name} value`);
     }
     return tagObj;
@@ -85,13 +84,12 @@ function stringifyProps(node, tagObj, { anchors: anchors$1, doc }) {
     return props.join(' ');
 }
 function stringify(item, ctx, onComment, onChompKeep) {
-    var _a, _b;
     if (Node.isPair(item))
         return item.toString(ctx, onComment, onChompKeep);
     if (Node.isAlias(item)) {
         if (ctx.doc.directives)
             return item.toString(ctx);
-        if ((_a = ctx.resolvedAliases) === null || _a === void 0 ? void 0 : _a.has(item)) {
+        if (ctx.resolvedAliases?.has(item)) {
             throw new TypeError(`Cannot stringify circular structure without alias nodes`);
         }
         else {
@@ -110,7 +108,7 @@ function stringify(item, ctx, onComment, onChompKeep) {
         tagObj = getTagObject(ctx.doc.schema.tags, node);
     const props = stringifyProps(node, tagObj, ctx);
     if (props.length > 0)
-        ctx.indentAtStart = ((_b = ctx.indentAtStart) !== null && _b !== void 0 ? _b : 0) + props.length + 1;
+        ctx.indentAtStart = (ctx.indentAtStart ?? 0) + props.length + 1;
     const str = typeof tagObj.stringify === 'function'
         ? tagObj.stringify(node, ctx, onComment, onChompKeep)
         : Node.isScalar(node)

package/dist/stringify/stringifyCollection.js

@@ -6,8 +6,7 @@ var stringify = require('./stringify.js');
 var stringifyComment = require('./stringifyComment.js');
 
 function stringifyCollection(collection, ctx, options) {
-    var _a;
-    const flow = (_a = ctx.inFlow) !== null && _a !== void 0 ? _a : collection.flow;
+    const flow = ctx.inFlow ?? collection.flow;
     const stringify = flow ? stringifyFlowCollection : stringifyBlockCollection;
     return stringify(collection, ctx, options);
 }

package/dist/stringify/stringifyDocument.js

@@ -5,7 +5,6 @@ var stringify = require('./stringify.js');
 var stringifyComment = require('./stringifyComment.js');
 
 function stringifyDocument(doc, options) {
-    var _a;
     const lines = [];
     let hasDirectives = options.directives === true;
     if (options.directives !== false && doc.directives) {
@@ -57,7 +56,7 @@ function stringifyDocument(doc, options) {
     else {
         lines.push(stringify.stringify(doc.contents, ctx));
     }
-    if ((_a = doc.directives) === null || _a === void 0 ? void 0 : _a.docEnd) {
+    if (doc.directives?.docEnd) {
         if (doc.comment) {
             const cs = commentString(doc.comment);
             if (cs.includes('\n')) {