yaml 2.0.0-10 → 2.0.0-5

package/browser/dist/compose/compose-doc.js

@@ -7,14 +7,13 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
     const opts = Object.assign({ directives }, options);
     const doc = new Document(undefined, opts);
     const ctx = {
-        atRoot: true,
         directives: doc.directives,
         options: doc.options,
         schema: doc.schema
     };
     const props = resolveProps(start, {
+        ctx,
         indicator: 'doc-start',
-        next: value || (end === null || end === void 0 ? void 0 : end[0]),
         offset,
         onError,
         startOnNewline: true

package/browser/dist/compose/compose-node.js

@@ -33,8 +33,6 @@ function composeNode(ctx, token, props, onError) {
             console.log(token);
             throw new Error(`Unsupporten token type: ${token.type}`);
     }
-    if (anchor && node.anchor === '')
-        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment) {
@@ -43,8 +41,6 @@ function composeNode(ctx, token, props, onError) {
         else
             node.commentBefore = comment;
     }
-    if (ctx.options.keepSourceTokens)
-        node.srcToken = token;
     return node;
 }
 function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
@@ -55,11 +51,8 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
         source: ''
     };
     const node = composeScalar(ctx, token, tag, onError);
-    if (anchor) {
+    if (anchor)
         node.anchor = anchor.source.substring(1);
-        if (node.anchor === '')
-            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
-    }
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment)
@@ -68,8 +61,6 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
     const alias = new Alias(source.substring(1));
-    if (alias.source === '')
-        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
     const valueEnd = offset + source.length;
     const re = resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];

package/browser/dist/compose/compose-scalar.js

@@ -1,4 +1,4 @@
-import { SCALAR, isScalar } from '../nodes/Node.js';
+import { isScalar, SCALAR } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 import { resolveBlockScalar } from './resolve-block-scalar.js';
 import { resolveFlowScalar } from './resolve-flow-scalar.js';
@@ -12,17 +12,14 @@ function composeScalar(ctx, token, tagToken, onError) {
         : null;
     const tag = tagToken && tagName
         ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
-        : token.type === 'scalar'
-            ? findScalarTagByTest(ctx, value, token, onError)
-            : ctx.schema[SCALAR];
+        : findScalarTagByTest(ctx.schema, value, token.type === 'scalar');
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
         scalar = isScalar(res) ? res : new Scalar(res);
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
         scalar = new Scalar(value);
     }
     scalar.range = range;
@@ -63,19 +60,15 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
     return schema[SCALAR];
 }
-function findScalarTagByTest({ directives, schema }, value, token, onError) {
-    const tag = schema.tags.find(tag => { var _a; return tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)); }) || schema[SCALAR];
-    if (schema.compat) {
-        const compat = schema.compat.find(tag => { var _a; return tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)); }) ||
-            schema[SCALAR];
-        if (tag.tag !== compat.tag) {
-            const ts = directives.tagString(tag.tag);
-            const cs = directives.tagString(compat.tag);
-            const msg = `Value may be parsed as either ${ts} or ${cs}`;
-            onError(token, 'TAG_RESOLVE_FAILED', msg, true);
+function findScalarTagByTest(schema, value, apply) {
+    var _a;
+    if (apply) {
+        for (const tag of schema.tags) {
+            if (tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)))
+                return tag;
         }
     }
-    return tag;
+    return schema[SCALAR];
 }
 
 export { composeScalar };

package/browser/dist/compose/composer.js

@@ -15,7 +15,6 @@ function getErrorPos(src) {
     return [offset, offset + (typeof source === 'string' ? source.length : 1)];
 }
 function parsePrelude(prelude) {
-    var _a;
     let comment = '';
     let atComment = false;
     let afterEmptyLine = false;
@@ -25,12 +24,12 @@ function parsePrelude(prelude) {
             case '#':
                 comment +=
                     (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
-                        (source.substring(1) || ' ');
+                        source.substring(1);
                 atComment = true;
                 afterEmptyLine = false;
                 break;
             case '%':
-                if (((_a = prelude[i + 1]) === null || _a === void 0 ? void 0 : _a[0]) !== '#')
+                if (prelude[i + 1][0] !== '#')
                     i += 1;
                 atComment = false;
                 break;

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

@@ -2,22 +2,17 @@ import { Pair } from '../nodes/Pair.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.js';
-import { flowIndentCheck } from './util-flow-indent-check.js';
-import { mapIncludes } from './util-map-includes.js';
 
 const startColMsg = 'All mapping items must start at the same column';
 function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
     const map = new YAMLMap(ctx.schema);
-    if (ctx.atRoot)
-        ctx.atRoot = false;
     let offset = bm.offset;
-    for (const collItem of bm.items) {
-        const { start, key, sep, value } = collItem;
+    for (const { start, key, sep, value } of bm.items) {
         // key properties
         const keyProps = resolveProps(start, {
+            ctx,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: true
@@ -51,14 +46,10 @@ 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)
-            flowIndentCheck(bm.indent, key, onError);
-        if (mapIncludes(ctx, map.items, keyNode))
-            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
         const valueProps = resolveProps(sep || [], {
+            ctx,
             indicator: 'map-value-ind',
-            next: value,
             offset: keyNode.range[2],
             onError,
             startOnNewline: !key || key.type === 'block-scalar'
@@ -76,13 +67,8 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
             const valueNode = value
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
-            if (ctx.schema.compat)
-                flowIndentCheck(bm.indent, value, onError);
             offset = valueNode.range[2];
-            const pair = new Pair(keyNode, valueNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            map.items.push(pair);
+            map.items.push(new Pair(keyNode, valueNode));
         }
         else {
             // key with no value
@@ -94,10 +80,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            const pair = new Pair(keyNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            map.items.push(pair);
+            map.items.push(new Pair(keyNode));
         }
     }
     map.range = [bm.offset, offset, offset];

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

@@ -18,7 +18,7 @@ function resolveBlockScalar(scalar, strict, onError) {
     }
     // shortcut for empty contents
     if (!scalar.source || chompStart === 0) {
-        const value = header.chomp === '+' ? '\n'.repeat(Math.max(0, lines.length - 1)) : '';
+        const value = header.chomp === '+' ? lines.map(line => line[0]).join('\n') : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -149,7 +149,7 @@ function parseBlockScalarHeader({ offset, props }, strict, onError) {
             case 'comment':
                 if (strict && !hasSpace) {
                     const message = 'Comments must be separated from other tokens by white space characters';
-                    onError(token, 'MISSING_CHAR', message);
+                    onError(token, 'COMMENT_SPACE', message);
                 }
                 length += token.source.length;
                 comment = token.source.substring(1);

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

@@ -1,16 +1,13 @@
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveProps } from './resolve-props.js';
-import { flowIndentCheck } from './util-flow-indent-check.js';
 
 function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     const seq = new YAMLSeq(ctx.schema);
-    if (ctx.atRoot)
-        ctx.atRoot = false;
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
         const props = resolveProps(start, {
+            ctx,
             indicator: 'seq-item-ind',
-            next: value,
             offset,
             onError,
             startOnNewline: true
@@ -33,8 +30,6 @@ 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)
-            flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }

package/browser/dist/compose/resolve-end.js

@@ -11,8 +11,8 @@ function resolveEnd(end, offset, reqSpace, onError) {
                     break;
                 case 'comment': {
                     if (reqSpace && !hasSpace)
-                        onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
-                    const cb = source.substring(1) || ' ';
+                        onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
+                    const cb = source.substring(1);
                     if (!comment)
                         comment = cb;
                     else

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

@@ -5,7 +5,6 @@ import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveEnd } from './resolve-end.js';
 import { resolveProps } from './resolve-props.js';
 import { containsNewline } from './util-contains-newline.js';
-import { mapIncludes } from './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');
@@ -16,17 +15,13 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
         ? new YAMLMap(ctx.schema)
         : new YAMLSeq(ctx.schema);
     coll.flow = true;
-    const atRoot = ctx.atRoot;
-    if (atRoot)
-        ctx.atRoot = false;
-    let offset = fc.offset + fc.start.source.length;
+    let offset = fc.offset;
     for (let i = 0; i < fc.items.length; ++i) {
-        const collItem = fc.items[i];
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep, value } = fc.items[i];
         const props = resolveProps(start, {
+            ctx,
             flow: fcName,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: false
@@ -43,7 +38,6 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     else
                         coll.comment = props.comment;
                 }
-                offset = props.end;
                 continue;
             }
             if (!isMap && ctx.options.strict && containsNewline(key))
@@ -105,9 +99,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
             const valueProps = resolveProps(sep || [], {
+                ctx,
                 flow: fcName,
                 indicator: 'map-value-ind',
-                next: value,
                 offset: keyNode.range[2],
                 onError,
                 startOnNewline: false
@@ -150,14 +144,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair(keyNode, valueNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            if (isMap) {
-                const map = coll;
-                if (mapIncludes(ctx, map.items, keyNode))
-                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
-                map.items.push(pair);
-            }
+            if (isMap)
+                coll.items.push(pair);
             else {
                 const map = new YAMLMap(ctx.schema);
                 map.flow = true;
@@ -171,13 +159,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const [ce, ...ee] = fc.end;
     let cePos = offset;
     if (ce && ce.source === expectedEnd)
-        cePos = ce.offset + ce.source.length;
+        cePos += ce.source.length;
     else {
-        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);
+        onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
         if (ce && ce.source.length !== 1)
             ee.unshift(ce);
     }

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

@@ -39,31 +39,25 @@ function resolveFlowScalar(scalar, strict, onError) {
     };
 }
 function plainValue(source, onError) {
-    let badChar = '';
+    let message = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            badChar = 'a tab character';
-            break;
-        case ',':
-            badChar = 'flow indicator character ,';
-            break;
-        case '%':
-            badChar = 'directive indicator character %';
+            message = 'Plain value cannot start with a tab character';
             break;
         case '|':
         case '>': {
-            badChar = `block scalar indicator ${source[0]}`;
+            message = `Plain value cannot start with block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            badChar = `reserved character ${source[0]}`;
+            message = `Plain value cannot start with reserved character ${source[0]}`;
             break;
         }
     }
-    if (badChar)
-        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+    if (message)
+        onError(0, 'BAD_SCALAR_START', message);
     return foldLines(source);
 }
 function singleQuotedValue(source, onError) {
@@ -135,12 +129,6 @@ 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);
@@ -158,7 +146,7 @@ function doubleQuotedValue(source, onError) {
             let next = source[i + 1];
             while (next === ' ' || next === '\t')
                 next = source[++i + 1];
-            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
+            if (next !== '\n')
                 res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
         }
         else {

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

@@ -1,24 +1,16 @@
-function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnNewline }) {
+function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNewline }) {
     let spaceBefore = false;
     let atNewline = startOnNewline;
     let hasSpace = startOnNewline;
     let comment = '';
     let commentSep = '';
     let hasNewline = false;
-    let reqSpace = false;
     let anchor = null;
     let tag = null;
     let comma = null;
     let found = null;
     let start = null;
     for (const token of tokens) {
-        if (reqSpace) {
-            if (token.type !== 'space' &&
-                token.type !== 'newline' &&
-                token.type !== 'comma')
-                onError(token.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
-            reqSpace = false;
-        }
         switch (token.type) {
             case 'space':
                 // At the doc level, tabs at line start may be parsed
@@ -32,29 +24,23 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                 hasSpace = true;
                 break;
             case 'comment': {
-                if (!hasSpace)
-                    onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
-                const cb = token.source.substring(1) || ' ';
+                if (ctx.options.strict && !hasSpace)
+                    onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
+                const cb = token.source.substring(1);
                 if (!comment)
                     comment = cb;
                 else
                     comment += commentSep + cb;
                 commentSep = '';
-                atNewline = false;
                 break;
             }
             case 'newline':
-                if (atNewline) {
-                    if (comment)
-                        comment += token.source;
-                    else
-                        spaceBefore = true;
-                }
-                else
-                    commentSep += token.source;
+                if (atNewline && !comment)
+                    spaceBefore = true;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
+                commentSep += token.source;
                 break;
             case 'anchor':
                 if (anchor)
@@ -64,7 +50,6 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
-                reqSpace = true;
                 break;
             case 'tag': {
                 if (tag)
@@ -74,15 +59,12 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
-                reqSpace = true;
                 break;
             }
             case indicator:
                 // Could here handle preceding comments differently
                 if (anchor || tag)
                     onError(token, 'BAD_PROP_ORDER', `Anchors and tags must be after the ${token.source} indicator`);
-                if (found)
-                    onError(token, 'UNEXPECTED_TOKEN', `Unexpected ${token.source} in ${flow || 'collection'}`);
                 found = token;
                 atNewline = false;
                 hasSpace = false;
@@ -105,13 +87,6 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
     }
     const last = tokens[tokens.length - 1];
     const end = last ? last.offset + last.source.length : offset;
-    if (reqSpace &&
-        next &&
-        next.type !== 'space' &&
-        next.type !== 'newline' &&
-        next.type !== 'comma' &&
-        (next.type !== 'scalar' || next.source !== ''))
-        onError(next.offset, 'MISSING_CHAR', 'Tags and anchors must be separated from the next token by white space');
     return {
         comma,
         found,

package/browser/dist/doc/Document.js

@@ -1,6 +1,6 @@
 import { Alias } from '../nodes/Alias.js';
 import { isEmptyPath, collectionFromPath } from '../nodes/Collection.js';
-import { NODE_TYPE, DOC, isNode, isCollection, isScalar } from '../nodes/Node.js';
+import { NODE_TYPE, DOC, isCollection, isScalar } from '../nodes/Node.js';
 import { Pair } from '../nodes/Pair.js';
 import { toJS } from '../nodes/toJS.js';
 import { defaultOptions } from '../options.js';
@@ -48,30 +48,6 @@ class Document {
             this.contents = this.createNode(value, _replacer, options);
         }
     }
-    /**
-     * Create a deep copy of this Document and its contents.
-     *
-     * Custom Node values that inherit from `Object` still refer to their original instances.
-     */
-    clone() {
-        const copy = Object.create(Document.prototype, {
-            [NODE_TYPE]: { value: DOC }
-        });
-        copy.commentBefore = this.commentBefore;
-        copy.comment = this.comment;
-        copy.errors = this.errors.slice();
-        copy.warnings = this.warnings.slice();
-        copy.options = Object.assign({}, this.options);
-        if (this.directives)
-            copy.directives = this.directives.clone();
-        copy.schema = this.schema.clone();
-        copy.contents = isNode(this.contents)
-            ? this.contents.clone(copy.schema)
-            : this.contents;
-        if (this.range)
-            copy.range = this.range.slice();
-        return copy;
-    }
     /** Adds a value to the document. */
     add(value) {
         if (assertCollection(this.contents))
@@ -116,10 +92,9 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
         const { onAnchor, setAnchors, sourceObjects } = createNodeAnchors(this, anchorPrefix || 'a');
         const ctx = {
-            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
             keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
             onAnchor,
             onTagObj,
@@ -230,47 +205,26 @@ 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 = {}) {
-        if (typeof version === 'number')
-            version = String(version);
-        let opt;
-        switch (version) {
+    setSchema(version, options) {
+        let _options;
+        switch (String(version)) {
             case '1.1':
-                if (this.directives)
-                    this.directives.yaml.version = '1.1';
-                else
-                    this.directives = new Directives({ version: '1.1' });
-                opt = { merge: true, resolveKnownTags: false, schema: 'yaml-1.1' };
+                this.directives.yaml.version = '1.1';
+                _options = Object.assign({ merge: true, resolveKnownTags: false, schema: 'yaml-1.1' }, options);
                 break;
             case '1.2':
-                if (this.directives)
-                    this.directives.yaml.version = '1.2';
-                else
-                    this.directives = new Directives({ version: '1.2' });
-                opt = { merge: false, resolveKnownTags: true, schema: 'core' };
-                break;
-            case null:
-                if (this.directives)
-                    delete this.directives;
-                opt = null;
+                this.directives.yaml.version = '1.2';
+                _options = Object.assign({ merge: false, resolveKnownTags: true, schema: 'core' }, options);
                 break;
             default: {
                 const sv = JSON.stringify(version);
-                throw new Error(`Expected '1.1', '1.2' or null as first argument, but found: ${sv}`);
+                throw new Error(`Expected '1.1' or '1.2' as version, but found: ${sv}`);
             }
         }
-        // Not using `instanceof Schema` to allow for duck typing
-        if (options.schema instanceof Object)
-            this.schema = options.schema;
-        else if (opt)
-            this.schema = new Schema(Object.assign(opt, options));
-        else
-            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+        this.schema = new Schema(_options);
     }
     // json & jsonArg are only used from toJSON()
     toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {

package/browser/dist/doc/createNode.js

@@ -1,5 +1,5 @@
 import { Alias } from '../nodes/Alias.js';
-import { isNode, isPair, MAP, SEQ, isDocument } from '../nodes/Node.js';
+import { isNode, isPair, MAP, SEQ } from '../nodes/Node.js';
 import { Scalar } from '../nodes/Scalar.js';
 
 const defaultTagPrefix = 'tag:yaml.org,2002:';
@@ -15,8 +15,6 @@ function findTagObject(value, tagName, tags) {
 }
 function createNode(value, tagName, ctx) {
     var _a, _b;
-    if (isDocument(value))
-        value = value.contents;
     if (isNode(value))
         return value;
     if (isPair(value)) {
@@ -32,11 +30,11 @@ function createNode(value, tagName, ctx) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { aliasDuplicateObjects, onAnchor, onTagObj, schema, sourceObjects } = ctx;
+    const { 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 (aliasDuplicateObjects && value && typeof value === 'object') {
+    if (value && typeof value === 'object') {
         ref = sourceObjects.get(value);
         if (ref) {
             if (!ref.anchor)
@@ -54,12 +52,8 @@ function createNode(value, tagName, ctx) {
     if (!tagObj) {
         if (value && typeof value.toJSON === 'function')
             value = value.toJSON();
-        if (!value || typeof value !== 'object') {
-            const node = new Scalar(value);
-            if (ref)
-                ref.node = node;
-            return node;
-        }
+        if (!value || typeof value !== 'object')
+            return new Scalar(value);
         tagObj =
             value instanceof Map
                 ? schema[MAP]

package/browser/dist/doc/directives.js

@@ -20,11 +20,6 @@ class Directives {
         this.yaml = Object.assign({}, Directives.defaultYaml, yaml);
         this.tags = Object.assign({}, Directives.defaultTags, tags);
     }
-    clone() {
-        const copy = new Directives(this.yaml, this.tags);
-        copy.marker = this.marker;
-        return copy;
-    }
     /**
      * During parsing, get a Directives instance for the current document and
      * update the stream state according to the current version's spec.