yaml 2.0.0-10 → 2.0.0-5

package/dist/compose/resolve-props.js

@@ -1,26 +1,18 @@
 'use strict';
 
-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
@@ -34,29 +26,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)
@@ -66,7 +52,6 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, startOnN
                     start = token.offset;
                 atNewline = false;
                 hasSpace = false;
-                reqSpace = true;
                 break;
             case 'tag': {
                 if (tag)
@@ -76,15 +61,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;
@@ -107,13 +89,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/dist/doc/Document.d.ts

@@ -11,7 +11,6 @@ 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;
     }
 }
@@ -23,15 +22,13 @@ 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'>>;
     /**
-     * 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.
+     * The [start, value-end, node-end] character offsets for the part of the
+     * source parsed into this document (undefined if not parsed).
      */
     range?: Range;
     /** The schema used with the document. Use `setSchema()` to change. */
@@ -44,12 +41,6 @@ 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. */
@@ -117,12 +108,10 @@ 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' | null, options?: SchemaOptions): void;
+    setSchema(version: '1.1' | '1.2', options?: SchemaOptions): void;
     /** A plain JavaScript representation of the document `contents`. */
     toJS(opt?: ToJSOptions & {
         [ignored: string]: unknown;

package/dist/doc/Document.js

@@ -50,30 +50,6 @@ 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);
-        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))
@@ -118,10 +94,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 } = 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,
@@ -232,47 +207,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.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.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.Schema(Object.assign(opt, options));
-        else
-            throw new Error(`With a null YAML version, the { schema: Schema } option is required`);
+        this.schema = new Schema.Schema(_options);
     }
     // json & jsonArg are only used from toJSON()
     toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {

package/dist/doc/createNode.d.ts

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

package/dist/doc/createNode.js

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

package/dist/doc/directives.d.ts

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

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { LineCounter } from './parse/line-counter';
-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 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 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 { ErrorCode, YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
+export { YAMLError, YAMLParseError, YAMLWarning } from './errors.js';
 export { Alias } from './nodes/Alias.js';
-export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, Node, ParsedNode, Range } from './nodes/Node.js';
+export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq, Node, ParsedNode } from './nodes/Node.js';
 export { Pair } from './nodes/Pair.js';
 export { Scalar } from './nodes/Scalar.js';
 export { YAMLMap } from './nodes/YAMLMap.js';

package/dist/nodes/Alias.d.ts

@@ -1,17 +1,13 @@
-import type { Document } from '../doc/Document.js';
-import type { FlowScalar } from '../parse/cst.js';
+import type { Document } from '../doc/Document';
 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.js';
-import type { YAMLSeq } from './YAMLSeq.js';
+import type { YAMLMap } from './YAMLMap';
+import type { YAMLSeq } from './YAMLSeq';
 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,12 +15,6 @@ 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;
     /**
@@ -53,21 +47,21 @@ export declare abstract class Collection extends NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn(path: Iterable<unknown>): boolean;
+    deleteIn([key, ...rest]: 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(path: Iterable<unknown>, keepScalar?: boolean): unknown;
+    getIn([key, ...rest]: Iterable<unknown>, keepScalar?: boolean): unknown;
     hasAllNullValues(allowScalar?: boolean): boolean;
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn(path: Iterable<unknown>): boolean;
+    hasIn([key, ...rest]: 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(path: Iterable<unknown>, value: unknown): void;
+    setIn([key, ...rest]: Iterable<unknown>, value: unknown): void;
 }

package/dist/nodes/Collection.js

@@ -13,14 +13,19 @@ function collectionFromPath(schema, path, value) {
             v = a;
         }
         else {
-            v = new Map([[k, v]]);
+            const o = {};
+            Object.defineProperty(o, typeof k === 'symbol' ? k : String(k), {
+                value: v,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            v = o;
         }
     }
     return createNode.createNode(v, undefined, {
-        aliasDuplicateObjects: false,
-        keepUndefined: false,
-        onAnchor: () => {
-            throw new Error('This should not happen, please report a bug.');
+        onAnchor() {
+            throw new Error('Repeated objects are not supported here');
         },
         schema,
         sourceObjects: new Map()
@@ -39,20 +44,6 @@ class Collection extends Node.NodeBase {
             writable: true
         });
     }
-    /**
-     * Create a copy of this collection.
-     *
-     * @param schema - If defined, overwrites the original's schema
-     */
-    clone(schema) {
-        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-        if (schema)
-            copy.schema = schema;
-        copy.items = copy.items.map(it => Node.isNode(it) || Node.isPair(it) ? it.clone(schema) : it);
-        if (this.range)
-            copy.range = this.range.slice();
-        return copy;
-    }
     /**
      * Adds a value to the collection. For `!!map` and `!!omap` the value must
      * be a Pair instance or a `{ key, value }` object, which may not have a key
@@ -76,8 +67,7 @@ class Collection extends Node.NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn(path) {
-        const [key, ...rest] = path;
+    deleteIn([key, ...rest]) {
         if (rest.length === 0)
             return this.delete(key);
         const node = this.get(key, true);
@@ -91,8 +81,7 @@ class Collection extends Node.NodeBase {
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    getIn(path, keepScalar) {
-        const [key, ...rest] = path;
+    getIn([key, ...rest], keepScalar) {
         const node = this.get(key, true);
         if (rest.length === 0)
             return !keepScalar && Node.isScalar(node) ? node.value : node;
@@ -116,8 +105,7 @@ class Collection extends Node.NodeBase {
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn(path) {
-        const [key, ...rest] = path;
+    hasIn([key, ...rest]) {
         if (rest.length === 0)
             return this.has(key);
         const node = this.get(key, true);
@@ -127,8 +115,7 @@ class Collection extends Node.NodeBase {
      * Sets a value in this collection. For `!!set`, `value` needs to be a
      * boolean to add/remove the item from the set.
      */
-    setIn(path, value) {
-        const [key, ...rest] = path;
+    setIn([key, ...rest], value) {
         if (rest.length === 0) {
             this.set(key, value);
         }

package/dist/nodes/Node.d.ts

@@ -1,5 +1,4 @@
 import type { Document } from '../doc/Document.js';
-import { Token } from '../parse/cst.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import type { Alias } from './Alias.js';
 import type { Pair } from './Pair.js';
@@ -24,7 +23,7 @@ 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 hasAnchor: (node: unknown) => node is YAMLMap<unknown, unknown> | YAMLSeq<unknown> | Scalar<unknown>;
 export declare abstract class NodeBase {
     readonly [NODE_TYPE]: symbol;
     /** A comment on or immediately after this */
@@ -32,22 +31,16 @@ export declare abstract class NodeBase {
     /** A comment before this */
     commentBefore?: string | null;
     /**
-     * The `[start, value-end, node-end]` character offsets for the part of the
-     * source parsed into this node (undefined if not parsed). The `value-end`
-     * and `node-end` positions are themselves not included in their respective
-     * ranges.
+     * The [start, value-end, node-end] character offsets for the part of the
+     * source parsed into this node (undefined if not parsed).
      */
     range?: Range | null;
     /** A blank line before this node and its commentBefore */
     spaceBefore?: boolean;
-    /** The CST token that was composed into this node.  */
-    srcToken?: Token;
     /** A fully qualified tag, if required */
     tag?: string;
     /** A plain JS representation of this node */
     abstract toJSON(): any;
     abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
     constructor(type: symbol);
-    /** Create a copy of this node.  */
-    clone(): NodeBase;
 }

package/dist/nodes/Node.js

@@ -38,13 +38,6 @@ class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
     }
-    /** Create a copy of this node.  */
-    clone() {
-        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
-        if (this.range)
-            copy.range = this.range.slice();
-        return copy;
-    }
 }
 
 exports.ALIAS = ALIAS;

package/dist/nodes/Pair.d.ts

@@ -1,10 +1,8 @@
 import { CreateNodeContext } from '../doc/createNode.js';
-import type { CollectionItem } from '../parse/cst.js';
-import type { Schema } from '../schema/Schema.js';
-import type { StringifyContext } from '../stringify/stringify.js';
+import { StringifyContext } from '../stringify/stringify.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { NODE_TYPE } from './Node.js';
-import type { ToJSContext } from './toJS.js';
+import { 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 class Pair<K = unknown, V = unknown> {
     readonly [NODE_TYPE]: symbol;
@@ -12,10 +10,7 @@ export declare class Pair<K = unknown, V = unknown> {
     key: K;
     /** Always Node or null when parsed, but can be set to anything. */
     value: V | null;
-    /** The CST token that was composed into this pair.  */
-    srcToken?: CollectionItem;
     constructor(key: K, value?: V | null);
-    clone(schema?: Schema): Pair<K, V>;
     toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/dist/nodes/Pair.js

@@ -16,14 +16,6 @@ class Pair {
         this.key = key;
         this.value = value;
     }
-    clone(schema) {
-        let { key, value } = this;
-        if (Node.isNode(key))
-            key = key.clone(schema);
-        if (Node.isNode(value))
-            value = value.clone(schema);
-        return new Pair(key, value);
-    }
     toJSON(_, ctx) {
         const pair = ctx && ctx.mapAsMap ? new Map() : {};
         return addPairToJSMap.addPairToJSMap(ctx, pair, this);

package/dist/nodes/Scalar.d.ts

@@ -1,4 +1,3 @@
-import type { BlockScalar, FlowScalar } from '../parse/cst.js';
 import { NodeBase, Range } from './Node.js';
 import { ToJSContext } from './toJS.js';
 export declare const isScalarValue: (value: unknown) => boolean;
@@ -6,7 +5,6 @@ export declare namespace Scalar {
     interface Parsed extends Scalar {
         range: Range;
         source: string;
-        srcToken?: FlowScalar | BlockScalar;
     }
     type BLOCK_FOLDED = 'BLOCK_FOLDED';
     type BLOCK_LITERAL = 'BLOCK_LITERAL';

package/dist/nodes/YAMLMap.d.ts

@@ -1,4 +1,3 @@
-import type { BlockMap, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
@@ -10,7 +9,6 @@ export declare namespace YAMLMap {
     interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
         items: Pair<K, V>[];
         range: Range;
-        srcToken?: BlockMap | FlowCollection;
     }
 }
 export declare class YAMLMap<K = unknown, V = unknown> extends Collection {

package/dist/nodes/YAMLMap.js

@@ -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, {
-            blockItemPrefix: '',
+            blockItem: n => n.str,
             flowChars: { start: '{', end: '}' },
             itemIndent: ctx.indent || '',
             onChompKeep,

package/dist/nodes/YAMLSeq.d.ts

@@ -1,4 +1,3 @@
-import type { BlockSequence, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
@@ -9,7 +8,6 @@ export declare namespace YAMLSeq {
     interface Parsed<T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode> extends YAMLSeq<T> {
         items: T[];
         range: Range;
-        srcToken?: BlockSequence | FlowCollection;
     }
 }
 export declare class YAMLSeq<T = unknown> extends Collection {

package/dist/nodes/YAMLSeq.js

@@ -87,7 +87,7 @@ class YAMLSeq extends Collection.Collection {
         if (!ctx)
             return JSON.stringify(this);
         return stringifyCollection.stringifyCollection(this, ctx, {
-            blockItemPrefix: '- ',
+            blockItem: n => (n.comment ? n.str : `- ${n.str}`),
             flowChars: { start: '[', end: ']' },
             itemIndent: (ctx.indent || '') + '  ',
             onChompKeep,