yaml 2.0.0-7 → 2.0.0

package/dist/compose/resolve-block-map.js

@@ -4,18 +4,22 @@ var Pair = require('../nodes/Pair.js');
 var YAMLMap = require('../nodes/YAMLMap.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
+var utilFlowIndentCheck = require('./util-flow-indent-check.js');
 var utilMapIncludes = require('./util-map-includes.js');
 
 const startColMsg = 'All mapping items must start at the same column';
 function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
     const map = new YAMLMap.YAMLMap(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
     let offset = bm.offset;
-    for (const { start, key, sep, value } of bm.items) {
+    for (const collItem of bm.items) {
+        const { start, key, sep, value } = collItem;
         // key properties
         const keyProps = resolveProps.resolveProps(start, {
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            next: key !== null && key !== void 0 ? key : sep === null || sep === void 0 ? void 0 : sep[0],
             offset,
             onError,
             startOnNewline: true
@@ -49,10 +53,12 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
         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);
         if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
             onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
-        const valueProps = resolveProps.resolveProps(sep || [], {
+        const valueProps = resolveProps.resolveProps(sep !== null && sep !== void 0 ? sep : [], {
             indicator: 'map-value-ind',
             next: value,
             offset: keyNode.range[2],
@@ -72,8 +78,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)
+                utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
             offset = valueNode.range[2];
-            map.items.push(new Pair.Pair(keyNode, valueNode));
+            const pair = new Pair.Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
         else {
             // key with no value
@@ -85,7 +96,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            map.items.push(new Pair.Pair(keyNode));
+            const pair = new Pair.Pair(keyNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            map.items.push(pair);
         }
     }
     map.range = [bm.offset, offset, offset];

package/dist/compose/resolve-block-scalar.js

@@ -19,8 +19,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;
@@ -48,6 +50,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;
@@ -177,7 +184,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 === null || m === void 0 ? void 0 : 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/dist/compose/resolve-block-seq.js

@@ -2,9 +2,12 @@
 
 var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveProps = require('./resolve-props.js');
+var utilFlowIndentCheck = require('./util-flow-indent-check.js');
 
 function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     const seq = new YAMLSeq.YAMLSeq(ctx.schema);
+    if (ctx.atRoot)
+        ctx.atRoot = false;
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
         const props = resolveProps.resolveProps(start, {
@@ -32,6 +35,8 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
         const node = value
             ? composeNode(ctx, value, props, onError)
             : composeEmptyNode(ctx, offset, start, null, props, onError);
+        if (ctx.schema.compat)
+            utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }

package/dist/compose/resolve-flow-collection.js

@@ -12,19 +12,24 @@ var utilMapIncludes = require('./util-map-includes.js');
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
 function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+    var _a;
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
     const coll = isMap
         ? new YAMLMap.YAMLMap(ctx.schema)
         : new YAMLSeq.YAMLSeq(ctx.schema);
     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.resolveProps(start, {
             flow: fcName,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
+            next: key !== null && key !== void 0 ? key : sep === null || sep === void 0 ? void 0 : sep[0],
             offset,
             onError,
             startOnNewline: false
@@ -41,6 +46,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     else
                         coll.comment = props.comment;
                 }
+                offset = props.end;
                 continue;
             }
             if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
@@ -71,7 +77,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 if (prevItemComment) {
                     let prev = coll.items[coll.items.length - 1];
                     if (Node.isPair(prev))
-                        prev = prev.value || prev.key;
+                        prev = (_a = prev.value) !== null && _a !== void 0 ? _a : prev.key;
                     if (prev.comment)
                         prev.comment += '\n' + prevItemComment;
                     else
@@ -101,7 +107,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
             if (isBlock(key))
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
-            const valueProps = resolveProps.resolveProps(sep || [], {
+            const valueProps = resolveProps.resolveProps(sep !== null && sep !== void 0 ? sep : [], {
                 flow: fcName,
                 indicator: 'map-value-ind',
                 next: value,
@@ -147,6 +153,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair.Pair(keyNode, valueNode);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
             if (isMap) {
                 const map = coll;
                 if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
@@ -168,7 +176,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/dist/compose/resolve-flow-scalar.js

@@ -74,6 +74,7 @@ function singleQuotedValue(source, onError) {
     return foldLines(source.slice(1, -1)).replace(/''/g, "'");
 }
 function foldLines(source) {
+    var _a;
     /**
      * The negative lookbehind here and in the `re` RegExp is to
      * prevent causing a polynomial search time in certain cases.
@@ -113,7 +114,7 @@ function foldLines(source) {
     const last = /[ \t]*(.*)/sy;
     last.lastIndex = pos;
     match = last.exec(source);
-    return res + sep + ((match && match[1]) || '');
+    return res + sep + ((_a = match === null || match === void 0 ? void 0 : match[1]) !== null && _a !== void 0 ? _a : '');
 }
 function doubleQuotedValue(source, onError) {
     let res = '';
@@ -137,6 +138,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);
@@ -154,7 +161,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/dist/compose/resolve-props.d.ts

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

package/dist/compose/resolve-props.js

@@ -61,6 +61,8 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
             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;
@@ -83,6 +85,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 !== null && flow !== void 0 ? flow : 'collection'}`);
                 found = token;
                 atNewline = false;
                 hasSpace = false;

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

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

package/dist/compose/util-flow-indent-check.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var utilContainsNewline = require('./util-contains-newline.js');
+
+function flowIndentCheck(indent, fc, onError) {
+    if ((fc === null || fc === void 0 ? void 0 : fc.type) === 'flow-collection') {
+        const end = fc.end[0];
+        if (end.indent === indent &&
+            (end.source === ']' || end.source === '}') &&
+            utilContainsNewline.containsNewline(fc)) {
+            const msg = 'Flow end indicator should be more indented than parent';
+            onError(end, 'BAD_INDENT', msg, true);
+        }
+    }
+}
+
+exports.flowIndentCheck = flowIndentCheck;

package/dist/doc/Document.d.ts

@@ -5,12 +5,13 @@ 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 { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
 import { Schema } from '../schema/Schema.js';
 import { Directives } from './directives.js';
 export declare type Replacer = any[] | ((key: any, value: any) => unknown);
 export declare namespace Document {
     interface Parsed<T extends ParsedNode = ParsedNode> extends Document<T> {
+        directives: Directives;
         range: Range;
     }
 }
@@ -22,7 +23,7 @@ export declare class Document<T = unknown> {
     comment: string | null;
     /** The document contents. */
     contents: T | null;
-    directives: Directives;
+    directives?: Directives;
     /** Errors encountered during parsing. */
     errors: YAMLError[];
     options: Required<Omit<ParseOptions & DocumentOptions, 'lineCounter' | 'directives' | 'version'>>;
@@ -43,6 +44,12 @@ export declare class Document<T = unknown> {
      */
     constructor(value?: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
     constructor(value: any, replacer: null | Replacer, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+    /**
+     * Create a deep copy of this Document and its contents.
+     *
+     * Custom Node values that inherit from `Object` still refer to their original instances.
+     */
+    clone(): Document<T>;
     /** Adds a value to the document. */
     add(value: any): void;
     /** Adds a value to the document. */
@@ -110,10 +117,12 @@ export declare class Document<T = unknown> {
     setIn(path: Iterable<unknown>, value: unknown): void;
     /**
      * 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: '1.1' | '1.2', options?: SchemaOptions): void;
+    setSchema(version: '1.1' | '1.2' | 'next' | null, options?: SchemaOptions): void;
     /** A plain JavaScript representation of the document `contents`. */
     toJS(opt?: ToJSOptions & {
         [ignored: string]: unknown;

package/dist/doc/Document.js

@@ -5,7 +5,6 @@ var Collection = require('../nodes/Collection.js');
 var Node = require('../nodes/Node.js');
 var Pair = require('../nodes/Pair.js');
 var toJS = require('../nodes/toJS.js');
-var options = require('../options.js');
 var Schema = require('../schema/Schema.js');
 var stringify = require('../stringify/stringify.js');
 var stringifyDocument = require('../stringify/stringifyDocument.js');
@@ -15,7 +14,7 @@ var createNode = require('./createNode.js');
 var directives = require('./directives.js');
 
 class Document {
-    constructor(value, replacer, options$1) {
+    constructor(value, replacer, options) {
         /** A comment before this Document */
         this.commentBefore = null;
         /** A comment immediately after this Document */
@@ -29,27 +28,59 @@ class Document {
         if (typeof replacer === 'function' || Array.isArray(replacer)) {
             _replacer = replacer;
         }
-        else if (options$1 === undefined && replacer) {
-            options$1 = replacer;
+        else if (options === undefined && replacer) {
+            options = replacer;
             replacer = undefined;
         }
-        const opt = Object.assign({}, options.defaultOptions, options$1);
+        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$1 === null || options$1 === void 0 ? void 0 : options$1.directives) {
-            this.directives = options$1.directives.atDocument();
+        if (options === null || options === void 0 ? void 0 : options.directives) {
+            this.directives = options.directives.atDocument();
             if (this.directives.yaml.explicit)
                 version = this.directives.yaml.version;
         }
         else
             this.directives = new directives.Directives({ version });
-        this.setSchema(version, options$1);
+        this.setSchema(version, options);
         if (value === undefined)
             this.contents = null;
         else {
-            this.contents = this.createNode(value, _replacer, options$1);
+            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.NODE_TYPE]: { value: Node.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 = Node.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))
@@ -73,6 +104,7 @@ class Document {
         if (!node.anchor) {
             const prev = anchors.anchorNames(this);
             node.anchor =
+                // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
                 !name || prev.has(name) ? anchors.findNewAnchor(name || 'a', prev) : name;
         }
         return new Alias.Alias(node.anchor);
@@ -94,9 +126,12 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
-        const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, anchorPrefix || 'a');
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options !== null && options !== void 0 ? options : {};
+        const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, 
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        anchorPrefix || 'a');
         const ctx = {
+            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
             keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
             onAnchor,
             onTagObj,
@@ -207,26 +242,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.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.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.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.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 } = {}) {
@@ -239,7 +296,7 @@ class Document {
             maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100,
             stringify: stringify.stringify
         };
-        const res = toJS.toJS(this.contents, jsonArg || '', ctx);
+        const res = toJS.toJS(this.contents, jsonArg !== null && jsonArg !== void 0 ? jsonArg : '', ctx);
         if (typeof onAnchor === 'function')
             for (const { count, res } of ctx.anchors.values())
                 onAnchor(res, count);

package/dist/doc/anchors.d.ts

@@ -10,13 +10,13 @@ export declare function anchorNames(root: Document | Node): Set<string>;
 /** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
 export declare function findNewAnchor(prefix: string, exclude: Set<string>): string;
 export declare function createNodeAnchors(doc: Document, prefix: string): {
-    onAnchor(source: unknown): string;
+    onAnchor: (source: unknown) => string;
     /**
      * With circular references, the source node is only resolved after all
      * of its child nodes are. This is why anchors are set only after all of
      * the nodes have been created.
      */
-    setAnchors(): void;
+    setAnchors: () => void;
     sourceObjects: Map<unknown, {
         anchor: string | null;
         node: Node | null;

package/dist/doc/anchors.js

@@ -39,7 +39,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);
@@ -52,7 +52,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/dist/doc/createNode.d.ts

@@ -3,8 +3,9 @@ import type { Schema } from '../schema/Schema.js';
 import type { CollectionTag, ScalarTag } from '../schema/types.js';
 import type { Replacer } from './Document.js';
 export interface CreateNodeContext {
-    keepUndefined?: boolean;
-    onAnchor(source: unknown): string;
+    aliasDuplicateObjects: boolean;
+    keepUndefined: boolean;
+    onAnchor: (source: unknown) => string;
     onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
     sourceObjects: Map<unknown, {
         anchor: string | null;

package/dist/doc/createNode.js

@@ -6,17 +6,20 @@ var Scalar = require('../nodes/Scalar.js');
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
 function findTagObject(value, tagName, tags) {
+    var _a;
     if (tagName) {
         const match = tags.filter(t => t.tag === tagName);
-        const tagObj = match.find(t => !t.format) || match[0];
+        const tagObj = (_a = match.find(t => !t.format)) !== null && _a !== void 0 ? _a : 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 => { var _a; return ((_a = t.identify) === null || _a === void 0 ? void 0 : _a.call(t, value)) && !t.format; });
 }
 function createNode(value, tagName, ctx) {
     var _a, _b;
+    if (Node.isDocument(value))
+        value = value.contents;
     if (Node.isNode(value))
         return value;
     if (Node.isPair(value)) {
@@ -32,11 +35,11 @@ function createNode(value, tagName, ctx) {
         // 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)
@@ -48,12 +51,14 @@ function createNode(value, tagName, ctx) {
             sourceObjects.set(value, ref);
         }
     }
-    if (tagName && tagName.startsWith('!!'))
+    if (tagName === null || tagName === void 0 ? void 0 : 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.Scalar(value);
             if (ref)

package/dist/doc/directives.d.ts

@@ -3,7 +3,7 @@ export declare class Directives {
     static defaultYaml: Directives['yaml'];
     static defaultTags: Directives['tags'];
     yaml: {
-        version: '1.1' | '1.2';
+        version: '1.1' | '1.2' | 'next';
         explicit?: boolean;
     };
     tags: Record<string, string>;
@@ -11,7 +11,9 @@ export declare class Directives {
      * The directives-end/doc-start marker `---`. If `null`, a marker may still be
      * included in the document's stringified representation.
      */
-    marker: true | null;
+    docStart: true | null;
+    /** The doc-end marker `...`.  */
+    docEnd: boolean;
     /**
      * Used when parsing YAML 1.1, where:
      * > If the document specifies no directives, it is parsed using the same
@@ -20,6 +22,7 @@ export declare class Directives {
      */
     private atNextDocument?;
     constructor(yaml?: Directives['yaml'], tags?: Directives['tags']);
+    clone(): Directives;
     /**
      * During parsing, get a Directives instance for the current document and
      * update the stream state according to the current version's spec.