yaml 2.0.0-5 → 2.0.0-9

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

@@ -8,8 +8,8 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
         const props = resolveProps.resolveProps(start, {
-            ctx,
             indicator: 'seq-item-ind',
+            next: value,
             offset,
             onError,
             startOnNewline: true

package/dist/compose/resolve-end.js

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

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

@@ -7,6 +7,7 @@ var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveEnd = require('./resolve-end.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
+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');
@@ -19,11 +20,12 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     coll.flow = true;
     let offset = fc.offset;
     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, {
-            ctx,
             flow: fcName,
             indicator: 'explicit-key-ind',
+            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: false
@@ -101,9 +103,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
             const valueProps = resolveProps.resolveProps(sep || [], {
-                ctx,
                 flow: fcName,
                 indicator: 'map-value-ind',
+                next: value,
                 offset: keyNode.range[2],
                 onError,
                 startOnNewline: false
@@ -146,8 +148,14 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair.Pair(keyNode, valueNode);
-            if (isMap)
-                coll.items.push(pair);
+            if (ctx.options.keepSourceTokens)
+                pair.srcToken = collItem;
+            if (isMap) {
+                const map = coll;
+                if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
+                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
+                map.items.push(pair);
+            }
             else {
                 const map = new YAMLMap.YAMLMap(ctx.schema);
                 map.flow = true;
@@ -161,7 +169,7 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const [ce, ...ee] = fc.end;
     let cePos = offset;
     if (ce && ce.source === expectedEnd)
-        cePos += ce.source.length;
+        cePos = ce.offset + ce.source.length;
     else {
         onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
         if (ce && ce.source.length !== 1)

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

@@ -41,25 +41,31 @@ function resolveFlowScalar(scalar, strict, onError) {
     };
 }
 function plainValue(source, onError) {
-    let message = '';
+    let badChar = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            message = 'Plain value cannot start with a tab character';
+            badChar = 'a tab character';
+            break;
+        case ',':
+            badChar = 'flow indicator character ,';
+            break;
+        case '%':
+            badChar = 'directive indicator character %';
             break;
         case '|':
         case '>': {
-            message = `Plain value cannot start with block scalar indicator ${source[0]}`;
+            badChar = `block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            message = `Plain value cannot start with reserved character ${source[0]}`;
+            badChar = `reserved character ${source[0]}`;
             break;
         }
     }
-    if (message)
-        onError(0, 'BAD_SCALAR_START', message);
+    if (badChar)
+        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
     return foldLines(source);
 }
 function singleQuotedValue(source, onError) {
@@ -131,6 +137,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);
@@ -148,7 +160,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,15 +1,14 @@
-import type { SourceToken } from '../parse/cst.js';
-import type { ComposeContext } from './compose-node.js';
+import type { SourceToken, Token } from '../parse/cst.js';
 import type { ComposeErrorHandler } from './composer.js';
 export interface ResolvePropsArg {
-    ctx: ComposeContext;
     flow?: string;
     indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';
+    next: Token | null | undefined;
     offset: number;
     onError: ComposeErrorHandler;
     startOnNewline: boolean;
 }
-export declare function resolveProps(tokens: SourceToken[], { ctx, flow, indicator, offset, onError, startOnNewline }: ResolvePropsArg): {
+export declare function resolveProps(tokens: SourceToken[], { flow, indicator, next, offset, onError, startOnNewline }: ResolvePropsArg): {
     comma: SourceToken | null;
     found: SourceToken | null;
     spaceBefore: boolean;

package/dist/compose/resolve-props.js

@@ -1,18 +1,26 @@
 'use strict';
 
-function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNewline }) {
+function resolveProps(tokens, { flow, indicator, next, 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
@@ -26,23 +34,29 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                 hasSpace = true;
                 break;
             case 'comment': {
-                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 (!hasSpace)
+                    onError(token, 'MISSING_CHAR', '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 && !comment)
-                    spaceBefore = true;
+                if (atNewline) {
+                    if (comment)
+                        comment += token.source;
+                    else
+                        spaceBefore = true;
+                }
+                else
+                    commentSep += token.source;
                 atNewline = true;
                 hasNewline = true;
                 hasSpace = true;
-                commentSep += token.source;
                 break;
             case 'anchor':
                 if (anchor)
@@ -52,6 +66,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             case 'tag': {
                 if (tag)
@@ -61,6 +76,7 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
+                reqSpace = true;
                 break;
             }
             case indicator:
@@ -89,6 +105,13 @@ function resolveProps(tokens, { ctx, flow, indicator, offset, onError, startOnNe
     }
     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/dist/compose/util-map-includes.d.ts

@@ -0,0 +1,4 @@
+import { ParsedNode } from '../nodes/Node';
+import { Pair } from '../nodes/Pair';
+import { ComposeContext } from './compose-node';
+export declare function mapIncludes(ctx: ComposeContext, items: Pair<ParsedNode>[], search: ParsedNode): boolean;

package/dist/compose/util-map-includes.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+
+function mapIncludes(ctx, items, search) {
+    const { uniqueKeys } = ctx.options;
+    if (uniqueKeys === false)
+        return false;
+    const isEqual = typeof uniqueKeys === 'function'
+        ? uniqueKeys
+        : (a, b) => a === b ||
+            (Node.isScalar(a) &&
+                Node.isScalar(b) &&
+                a.value === b.value &&
+                !(a.value === '<<' && ctx.schema.merge));
+    return items.some(pair => isEqual(pair.key, search));
+}
+
+exports.mapIncludes = mapIncludes;

package/dist/doc/Document.d.ts

@@ -27,8 +27,10 @@ export declare class Document<T = unknown> {
     errors: YAMLError[];
     options: Required<Omit<ParseOptions & DocumentOptions, 'lineCounter' | 'directives' | 'version'>>;
     /**
-     * The [start, value-end, node-end] character offsets for the part of the
-     * source parsed into this document (undefined if not parsed).
+     * The `[start, value-end, node-end]` character offsets for the part of the
+     * source parsed into this document (undefined if not parsed). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
      */
     range?: Range;
     /** The schema used with the document. Use `setSchema()` to change. */
@@ -41,6 +43,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. */

package/dist/doc/Document.js

@@ -50,6 +50,29 @@ class Document {
             this.contents = this.createNode(value, _replacer, options$1);
         }
     }
+    /**
+     * 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);
+        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))
@@ -94,9 +117,10 @@ class Document {
             options = replacer;
             replacer = undefined;
         }
-        const { anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
         const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, anchorPrefix || 'a');
         const ctx = {
+            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
             keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
             onAnchor,
             onTagObj,

package/dist/doc/createNode.d.ts

@@ -3,7 +3,8 @@ 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;
+    aliasDuplicateObjects: boolean;
+    keepUndefined: boolean;
     onAnchor(source: unknown): string;
     onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
     sourceObjects: Map<unknown, {

package/dist/doc/createNode.js

@@ -17,6 +17,8 @@ function findTagObject(value, tagName, tags) {
 }
 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 +34,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)
@@ -54,8 +56,12 @@ function createNode(value, tagName, ctx) {
     if (!tagObj) {
         if (value && typeof value.toJSON === 'function')
             value = value.toJSON();
-        if (!value || typeof value !== 'object')
-            return new Scalar.Scalar(value);
+        if (!value || typeof value !== 'object') {
+            const node = new Scalar.Scalar(value);
+            if (ref)
+                ref.node = node;
+            return node;
+        }
         tagObj =
             value instanceof Map
                 ? schema[Node.MAP]

package/dist/doc/directives.d.ts

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

package/dist/doc/directives.js

@@ -22,6 +22,11 @@ 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.

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { LineCounter } from './parse/line-counter';
-export declare type ErrorCode = 'ALIAS_PROPS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'COMMENT_SPACE' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_ANCHOR' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN';
+export declare type ErrorCode = 'ALIAS_PROPS' | 'BAD_ALIAS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'DUPLICATE_KEY' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN';
 export declare type LinePos = {
     line: number;
     col: number;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export { Composer } from './compose/composer.js';
 export { Document } from './doc/Document.js';
 export { Schema } from './schema/Schema.js';
-export { YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
+export { ErrorCode, YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
 export { Alias } from './nodes/Alias.js';
-export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, Node, ParsedNode } from './nodes/Node.js';
+export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, Node, ParsedNode, Range } from './nodes/Node.js';
 export { Pair } from './nodes/Pair.js';
 export { Scalar } from './nodes/Scalar.js';
 export { YAMLMap } from './nodes/YAMLMap.js';

package/dist/node_modules/tslib/tslib.es6.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+
+exports.__extends = __extends;
+exports.__generator = __generator;
+exports.__values = __values;

package/dist/nodes/Alias.d.ts

@@ -1,13 +1,17 @@
-import type { Document } from '../doc/Document';
+import type { Document } from '../doc/Document.js';
+import type { FlowScalar } from '../parse/cst.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { NodeBase, Range } from './Node.js';
 import type { Scalar } from './Scalar';
 import type { ToJSContext } from './toJS.js';
-import type { YAMLMap } from './YAMLMap';
-import type { YAMLSeq } from './YAMLSeq';
+import type { YAMLMap } from './YAMLMap.js';
+import type { YAMLSeq } from './YAMLSeq.js';
 export declare namespace Alias {
     interface Parsed extends Alias {
         range: Range;
+        srcToken?: FlowScalar & {
+            type: 'alias';
+        };
     }
 }
 export declare class Alias extends NodeBase {

package/dist/nodes/Collection.d.ts

@@ -15,6 +15,12 @@ export declare abstract class Collection extends NodeBase {
      */
     flow?: boolean;
     constructor(type: symbol, schema?: Schema);
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema?: Schema): Collection;
     /** Adds a value to the collection. */
     abstract add(value: unknown): void;
     /**
@@ -47,21 +53,21 @@ export declare abstract class Collection extends NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn([key, ...rest]: Iterable<unknown>): boolean;
+    deleteIn(path: Iterable<unknown>): boolean;
     /**
      * 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).
      */
-    getIn([key, ...rest]: Iterable<unknown>, keepScalar?: boolean): unknown;
+    getIn(path: Iterable<unknown>, keepScalar?: boolean): unknown;
     hasAllNullValues(allowScalar?: boolean): boolean;
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn([key, ...rest]: Iterable<unknown>): boolean;
+    hasIn(path: Iterable<unknown>): boolean;
     /**
      * Sets a value in this collection. For `!!set`, `value` needs to be a
      * boolean to add/remove the item from the set.
      */
-    setIn([key, ...rest]: Iterable<unknown>, value: unknown): void;
+    setIn(path: Iterable<unknown>, value: unknown): void;
 }