yaml 2.0.0-9 → 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 && ctx.mapAsMap ? new Map() : {};
+        const pair = ctx?.mapAsMap ? new Map() : {};
         return addPairToJSMap.addPairToJSMap(ctx, pair, this);
     }
     toString(ctx, onComment, onChompKeep) {
-        return ctx && 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 && 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,15 +28,19 @@ 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()
      * @param {Class} Type - If set, forces the returned collection type
      * @returns Instance of Type, Map, or Object
      */
-    toJSON(_?: unknown, ctx?: ToJSContext, Type?: any): any;
+    toJSON<T = unknown>(_?: unknown, ctx?: ToJSContext, Type?: {
+        new (): T;
+    }): any;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/dist/nodes/YAMLMap.js

@@ -39,12 +39,12 @@ class YAMLMap extends Collection.Collection {
             _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 = this.schema && this.schema.sortMapEntries;
+        const sortEntries = this.schema?.sortMapEntries;
         if (prev) {
             if (!overwrite)
                 throw new Error(`Key ${_pair.key} already set`);
@@ -74,8 +74,8 @@ class YAMLMap extends Collection.Collection {
     }
     get(key, keepScalar) {
         const it = findPair(this.items, key);
-        const node = it && 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);
@@ -89,8 +89,8 @@ class YAMLMap extends Collection.Collection {
      * @returns Instance of Type, Map, or Object
      */
     toJSON(_, ctx, Type) {
-        const map = Type ? new Type() : ctx && ctx.mapAsMap ? new Map() : {};
-        if (ctx && 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);
@@ -106,7 +106,7 @@ class YAMLMap extends Collection.Collection {
         if (!ctx.allNullValues && this.hasAllNullValues(false))
             ctx = Object.assign({}, ctx, { allNullValues: true });
         return stringifyCollection.stringifyCollection(this, ctx, {
-            blockItem: n => n.str,
+            blockItemPrefix: '',
             flowChars: { start: '{', end: '}' },
             itemIndent: ctx.indent || '',
             onChompKeep,

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 && ctx.onCreate)
+        if (ctx?.onCreate)
             ctx.onCreate(seq);
         let i = 0;
         for (const item of this.items)
@@ -87,7 +79,7 @@ class YAMLSeq extends Collection.Collection {
         if (!ctx)
             return JSON.stringify(this);
         return stringifyCollection.stringifyCollection(this, ctx, {
-            blockItem: n => (n.comment ? n.str : `- ${n.str}`),
+            blockItemPrefix: '- ',
             flowChars: { start: '[', end: ']' },
             itemIndent: (ctx.indent || '') + '  ',
             onChompKeep,

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 && 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

@@ -13,9 +13,11 @@ var Node = require('./Node.js');
  *   stringification.
  */
 function toJS(value, arg, ctx) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     if (Array.isArray(value))
         return value.map((v, i) => toJS(v, String(i), ctx));
     if (value && typeof value.toJSON === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         if (!ctx || !Node.hasAnchor(value))
             return value.toJSON(arg, ctx);
         const data = { aliasCount: 0, count: 1, res: undefined };
@@ -29,7 +31,7 @@ function toJS(value, arg, ctx) {
             ctx.onCreate(res);
         return res;
     }
-    if (typeof value === 'bigint' && !(ctx && ctx.keep))
+    if (typeof value === 'bigint' && !ctx?.keep)
         return Number(value);
     return value;
 }

package/dist/options.d.ts

@@ -5,7 +5,7 @@ import type { ParsedNode } from './nodes/Node.js';
 import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { LineCounter } from './parse/line-counter.js';
-import type { SchemaName } from './schema/Schema.js';
+import type { Schema } from './schema/Schema.js';
 import type { Tags } from './schema/tags.js';
 import type { CollectionTag, ScalarTag } from './schema/types.js';
 export declare type ParseOptions = {
@@ -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
      *
@@ -73,9 +74,17 @@ export declare type DocumentOptions = {
      *
      * Default: `"1.2"`
      */
-    version?: '1.1' | '1.2';
+    version?: '1.1' | '1.2' | 'next';
 };
 export declare type SchemaOptions = {
+    /**
+     * When parsing, warn about compatibility issues with the given schema.
+     * When stringifying, use scalar styles that are parsed correctly
+     * by the `compat` schema as well as the actual schema.
+     *
+     * Default: `null`
+     */
+    compat?: string | Tags | null;
     /**
      * Array of additional tags to include in the schema, or a function that may
      * modify the schema's base tag array.
@@ -99,9 +108,18 @@ export declare type SchemaOptions = {
     /**
      * The base schema to use.
      *
-     * Default: `"core"` for YAML 1.2, `"yaml-1.1"` for earlier versions
+     * The core library has built-in support for the following:
+     * - `'failsafe'`: A minimal schema that parses all scalars as strings
+     * - `'core'`: The YAML 1.2 core schema
+     * - `'json'`: The YAML 1.2 JSON schema, with minimal rules for JSON compatibility
+     * - `'yaml-1.1'`: The YAML 1.1 schema
+     *
+     * If using another (custom) schema, the `customTags` array needs to
+     * fully define the schema's tags.
+     *
+     * Default: `'core'` for YAML 1.2, `'yaml-1.1'` for earlier versions
      */
-    schema?: SchemaName;
+    schema?: string | Schema;
     /**
      * When adding to or stringifying a map, sort the entries.
      * If `true`, sort by comparing key values with `<`.
@@ -110,6 +128,10 @@ export declare type SchemaOptions = {
      * Default: `false`
      */
     sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
+    /**
+     * Override default values for `toString()` options.
+     */
+    toStringDefaults?: ToStringOptions;
 };
 export declare type CreateNodeOptions = {
     /**
@@ -175,6 +197,23 @@ export declare type ToStringOptions = {
      * Default: `true`
      */
     blockQuote?: boolean | 'folded' | 'literal';
+    /**
+     * Enforce `'block'` or `'flow'` style on maps and sequences.
+     * Empty collections will always be stringified as `{}` or `[]`.
+     *
+     * Default: `'any'`, allowing each node to set its style separately
+     * with its `flow: boolean` (default `false`) property.
+     */
+    collectionStyle?: 'any' | 'block' | 'flow';
+    /**
+     * Comment stringifier.
+     * Output should be valid for the current schema.
+     *
+     * By default, empty comment lines are left empty,
+     * lines consisting of a single space are replaced by `#`,
+     * and all other lines are prefixed with a `#`.
+     */
+    commentString?: (comment: string) => string;
     /**
      * The default type of string literal used to stringify implicit key values.
      * Output may use other types if required to fully represent the value.
@@ -290,11 +329,3 @@ export declare type ToStringOptions = {
      */
     verifyAliasOrder?: boolean;
 };
-/**
- * `yaml` defines document-specific options in three places: as an argument of
- * parse, create and stringify calls, in the values of `YAML.defaultOptions`,
- * and in the version-dependent `YAML.Document.defaults` object. Values set in
- * `YAML.defaultOptions` override version-dependent defaults, and argument
- * options override both.
- */
-export declare const defaultOptions: Required<Omit<ParseOptions, 'lineCounter'> & Omit<DocumentOptions, 'directives'>>;

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 && 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 && 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

@@ -155,7 +155,7 @@ class Lexer {
             this.lineEndPos = null;
         }
         this.atEnd = !incomplete;
-        let next = this.next || 'stream';
+        let next = this.next ?? 'stream';
         while (next && (incomplete || this.hasChars(1)))
             next = yield* this.parseNext(next);
     }
@@ -359,9 +359,14 @@ class Lexer {
         let indent = -1;
         do {
             nl = yield* this.pushNewline();
-            sp = yield* this.pushSpaces(true);
-            if (nl > 0)
+            if (nl > 0) {
+                sp = yield* this.pushSpaces(false);
                 this.indentValue = indent = sp;
+            }
+            else {
+                sp = 0;
+            }
+            sp += yield* this.pushSpaces(true);
         } while (nl + sp > 0);
         const line = this.getLine();
         if (line === null)
@@ -418,6 +423,7 @@ class Lexer {
             case ':': {
                 const next = this.charAt(1);
                 if (this.flowKey || isEmpty(next) || next === ',') {
+                    this.flowKey = false;
                     yield* this.pushCount(1);
                     yield* this.pushSpaces(true);
                     return 'flow';
@@ -534,9 +540,10 @@ class Lexer {
                 let ch = this.buffer[i];
                 if (ch === '\r')
                     ch = this.buffer[--i];
+                const lastChar = i; // Drop the line if last char not more indented
                 while (ch === ' ' || ch === '\t')
                     ch = this.buffer[--i];
-                if (ch === '\n' && i >= this.pos)
+                if (ch === '\n' && i >= this.pos && i + 1 + indent > lastChar)
                     nl = i;
                 else
                     break;
@@ -619,16 +626,21 @@ class Lexer {
                 return ((yield* this.pushUntil(isNotAnchorChar)) +
                     (yield* this.pushSpaces(true)) +
                     (yield* this.pushIndicators()));
-            case ':':
-            case '?': // this is an error outside flow collections
             case '-': // this is an error
-                if (isEmpty(this.charAt(1))) {
-                    if (this.flowLevel === 0)
+            case '?': // this is an error outside flow collections
+            case ':': {
+                const inFlow = this.flowLevel > 0;
+                const ch1 = this.charAt(1);
+                if (isEmpty(ch1) || (inFlow && invalidFlowScalarChars.includes(ch1))) {
+                    if (!inFlow)
                         this.indentNext = this.indentValue + 1;
+                    else if (this.flowKey)
+                        this.flowKey = false;
                     return ((yield* this.pushCount(1)) +
                         (yield* this.pushSpaces(true)) +
                         (yield* this.pushIndicators()));
                 }
+            }
         }
         return 0;
     }