yaml 2.0.0-4 → 2.0.0-8

package/dist/doc/Document.js

@@ -6,10 +6,10 @@ var Node = require('../nodes/Node.js');
 var Pair = require('../nodes/Pair.js');
 var toJS = require('../nodes/toJS.js');
 var options = require('../options.js');
-var addComment = require('../stringify/addComment.js');
+var Schema = require('../schema/Schema.js');
 var stringify = require('../stringify/stringify.js');
-var Anchors = require('./Anchors.js');
-var Schema = require('./Schema.js');
+var stringifyDocument = require('../stringify/stringifyDocument.js');
+var anchors = require('./anchors.js');
 var applyReviver = require('./applyReviver.js');
 var createNode = require('./createNode.js');
 var directives = require('./directives.js');
@@ -25,7 +25,7 @@ class Document {
         /** Warnings encountered during parsing. */
         this.warnings = [];
         Object.defineProperty(this, Node.NODE_TYPE, { value: Node.DOC });
-        let _replacer = undefined;
+        let _replacer = null;
         if (typeof replacer === 'function' || Array.isArray(replacer)) {
             _replacer = replacer;
         }
@@ -35,7 +35,6 @@ class Document {
         }
         const opt = Object.assign({}, options.defaultOptions, options$1);
         this.options = opt;
-        this.anchors = new Anchors.Anchors(this.options.anchorPrefix);
         let { version } = opt;
         if (options$1 === null || options$1 === void 0 ? void 0 : options$1.directives) {
             this.directives = options$1.directives.atDocument();
@@ -45,10 +44,34 @@ class Document {
         else
             this.directives = new directives.Directives({ version });
         this.setSchema(version, options$1);
-        this.contents =
-            value === undefined
-                ? null
-                : this.createNode(value, { replacer: _replacer });
+        if (value === undefined)
+            this.contents = null;
+        else {
+            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) {
@@ -61,48 +84,54 @@ class Document {
             this.contents.addIn(path, value);
     }
     /**
-     * Convert any value into a `Node` using the current schema, recursively
-     * turning objects into collections.
+     * Create a new `Alias` node, ensuring that the target `node` has the required anchor.
+     *
+     * If `node` already has an anchor, `name` is ignored.
+     * Otherwise, the `node.anchor` value will be set to `name`,
+     * or if an anchor with that name is already present in the document,
+     * `name` will be used as a prefix for a new unique anchor.
+     * If `name` is undefined, the generated anchor will use 'a' as a prefix.
      */
-    createNode(value, { flow, keepUndefined, onTagObj, replacer, tag } = {}) {
-        if (typeof replacer === 'function')
+    createAlias(node, name) {
+        if (!node.anchor) {
+            const prev = anchors.anchorNames(this);
+            node.anchor =
+                !name || prev.has(name) ? anchors.findNewAnchor(name || 'a', prev) : name;
+        }
+        return new Alias.Alias(node.anchor);
+    }
+    createNode(value, replacer, options) {
+        let _replacer = undefined;
+        if (typeof replacer === 'function') {
             value = replacer.call({ '': value }, '', value);
+            _replacer = replacer;
+        }
         else if (Array.isArray(replacer)) {
             const keyToStr = (v) => typeof v === 'number' || v instanceof String || v instanceof Number;
             const asStr = replacer.filter(keyToStr).map(String);
             if (asStr.length > 0)
                 replacer = replacer.concat(asStr);
+            _replacer = replacer;
+        }
+        else if (options === undefined && replacer) {
+            options = replacer;
+            replacer = undefined;
         }
-        if (typeof keepUndefined !== 'boolean')
-            keepUndefined = !!this.options.keepUndefined;
-        const aliasNodes = [];
+        const { aliasDuplicateObjects, anchorPrefix, flow, keepUndefined, onTagObj, tag } = options || {};
+        const { onAnchor, setAnchors, sourceObjects } = anchors.createNodeAnchors(this, anchorPrefix || 'a');
         const ctx = {
-            keepUndefined,
-            onAlias(source) {
-                // These get fixed later in createNode()
-                const alias = new Alias.Alias(source);
-                aliasNodes.push(alias);
-                return alias;
-            },
+            aliasDuplicateObjects: aliasDuplicateObjects !== null && aliasDuplicateObjects !== void 0 ? aliasDuplicateObjects : true,
+            keepUndefined: keepUndefined !== null && keepUndefined !== void 0 ? keepUndefined : false,
+            onAnchor,
             onTagObj,
-            prevObjects: new Map(),
-            replacer,
-            schema: this.schema
+            replacer: _replacer,
+            schema: this.schema,
+            sourceObjects
         };
         const node = createNode.createNode(value, tag, ctx);
-        for (const alias of aliasNodes) {
-            // 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.
-            alias.source = alias.source.node;
-            let name = this.anchors.getName(alias.source);
-            if (!name) {
-                name = this.anchors.newName();
-                this.anchors.map[name] = alias.source;
-            }
-        }
         if (flow && Node.isCollection(node))
             node.flow = true;
+        setAnchors();
         return node;
     }
     /**
@@ -110,8 +139,8 @@ class Document {
      * recursively wrapping all values as `Scalar` or `Collection` nodes.
      */
     createPair(key, value, options = {}) {
-        const k = this.createNode(key, options);
-        const v = this.createNode(value, options);
+        const k = this.createNode(key, null, options);
+        const v = this.createNode(value, null, options);
         return new Pair.Pair(k, v);
     }
     /**
@@ -225,10 +254,8 @@ class Document {
     }
     // json & jsonArg are only used from toJSON()
     toJS({ json, jsonArg, mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
-        const anchorNodes = Object.values(this.anchors.map).map(node => [node, { alias: [], aliasCount: 0, count: 1 }]);
-        const anchors = anchorNodes.length > 0 ? new Map(anchorNodes) : null;
         const ctx = {
-            anchors,
+            anchors: new Map(),
             doc: this,
             keep: !json,
             mapAsMap: mapAsMap === true,
@@ -237,8 +264,8 @@ class Document {
             stringify: stringify.stringify
         };
         const res = toJS.toJS(this.contents, jsonArg || '', ctx);
-        if (typeof onAnchor === 'function' && anchors)
-            for (const { count, res } of anchors.values())
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
                 onAnchor(res, count);
         return typeof reviver === 'function'
             ? applyReviver.applyReviver(reviver, { '': res }, '', res)
@@ -262,59 +289,7 @@ class Document {
             const s = JSON.stringify(options.indent);
             throw new Error(`"indent" option must be a positive integer, not ${s}`);
         }
-        const lines = [];
-        let hasDirectives = options.directives === true;
-        if (options.directives !== false) {
-            const dir = this.directives.toString(this);
-            if (dir) {
-                lines.push(dir);
-                hasDirectives = true;
-            }
-            else if (this.directives.marker)
-                hasDirectives = true;
-        }
-        if (hasDirectives)
-            lines.push('---');
-        if (this.commentBefore) {
-            if (lines.length !== 1)
-                lines.unshift('');
-            lines.unshift(this.commentBefore.replace(/^/gm, '#'));
-        }
-        const ctx = stringify.createStringifyContext(this, options);
-        let chompKeep = false;
-        let contentComment = null;
-        if (this.contents) {
-            if (Node.isNode(this.contents)) {
-                if (this.contents.spaceBefore && hasDirectives)
-                    lines.push('');
-                if (this.contents.commentBefore)
-                    lines.push(this.contents.commentBefore.replace(/^/gm, '#'));
-                // top-level block scalars need to be indented if followed by a comment
-                ctx.forceBlockIndent = !!this.comment;
-                contentComment = this.contents.comment;
-            }
-            const onChompKeep = contentComment ? undefined : () => (chompKeep = true);
-            let body = stringify.stringify(this.contents, ctx, () => (contentComment = null), onChompKeep);
-            if (contentComment)
-                body = addComment.addComment(body, '', contentComment);
-            if ((body[0] === '|' || body[0] === '>') &&
-                lines[lines.length - 1] === '---') {
-                // Top-level block scalars with a preceding doc marker ought to use the
-                // same line for their header.
-                lines[lines.length - 1] = `--- ${body}`;
-            }
-            else
-                lines.push(body);
-        }
-        else {
-            lines.push(stringify.stringify(this.contents, ctx));
-        }
-        if (this.comment) {
-            if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '')
-                lines.push('');
-            lines.push(this.comment.replace(/^/gm, '#'));
-        }
-        return lines.join('\n') + '\n';
+        return stringifyDocument.stringifyDocument(this, options);
     }
 }
 function assertCollection(contents) {

package/dist/doc/anchors.d.ts

@@ -0,0 +1,24 @@
+import { Node } from '../nodes/Node.js';
+import type { Document } from './Document.js';
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+export declare function anchorIsValid(anchor: string): true;
+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;
+    /**
+     * 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;
+    sourceObjects: Map<unknown, {
+        anchor: string | null;
+        node: Node | null;
+    }>;
+};

package/dist/doc/anchors.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var visit = require('../visit.js');
+
+/**
+ * Verify that the input string is a valid anchor.
+ *
+ * Will throw on errors.
+ */
+function anchorIsValid(anchor) {
+    if (/[\x00-\x19\s,[\]{}]/.test(anchor)) {
+        const sa = JSON.stringify(anchor);
+        const msg = `Anchor must not contain whitespace or control characters: ${sa}`;
+        throw new Error(msg);
+    }
+    return true;
+}
+function anchorNames(root) {
+    const anchors = new Set();
+    visit.visit(root, {
+        Value(_key, node) {
+            if (node.anchor)
+                anchors.add(node.anchor);
+        }
+    });
+    return anchors;
+}
+/** Find a new anchor name with the given `prefix` and a one-indexed suffix. */
+function findNewAnchor(prefix, exclude) {
+    for (let i = 1; true; ++i) {
+        const name = `${prefix}${i}`;
+        if (!exclude.has(name))
+            return name;
+    }
+}
+function createNodeAnchors(doc, prefix) {
+    const aliasObjects = [];
+    const sourceObjects = new Map();
+    let prevAnchors = null;
+    return {
+        onAnchor(source) {
+            aliasObjects.push(source);
+            if (!prevAnchors)
+                prevAnchors = anchorNames(doc);
+            const anchor = findNewAnchor(prefix, prevAnchors);
+            prevAnchors.add(anchor);
+            return anchor;
+        },
+        /**
+         * 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() {
+            for (const source of aliasObjects) {
+                const ref = sourceObjects.get(source);
+                if (typeof ref === 'object' &&
+                    ref.anchor &&
+                    (Node.isScalar(ref.node) || Node.isCollection(ref.node))) {
+                    ref.node.anchor = ref.anchor;
+                }
+                else {
+                    const error = new Error('Failed to resolve repeated object (this should not happen)');
+                    error.source = source;
+                    throw error;
+                }
+            }
+        },
+        sourceObjects
+    };
+}
+
+exports.anchorIsValid = anchorIsValid;
+exports.anchorNames = anchorNames;
+exports.createNodeAnchors = createNodeAnchors;
+exports.findNewAnchor = findNewAnchor;

package/dist/doc/createNode.d.ts

@@ -1,17 +1,16 @@
-import type { Alias } from '../nodes/Alias.js';
 import { Node } from '../nodes/Node.js';
-import type { TagObj } from '../tags/types.js';
+import type { Schema } from '../schema/Schema.js';
+import type { CollectionTag, ScalarTag } from '../schema/types.js';
 import type { Replacer } from './Document.js';
-import type { Schema } from './Schema.js';
-export interface CreateNodeAliasRef {
-    node: Node | undefined;
-    value: unknown;
-}
 export interface CreateNodeContext {
-    keepUndefined?: boolean;
-    onAlias(source: CreateNodeAliasRef): Alias;
-    onTagObj?: (tagObj: TagObj) => void;
-    prevObjects: Map<unknown, CreateNodeAliasRef>;
+    aliasDuplicateObjects: boolean;
+    keepUndefined: boolean;
+    onAnchor(source: unknown): string;
+    onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
+    sourceObjects: Map<unknown, {
+        anchor: string | null;
+        node: Node | null;
+    }>;
     replacer?: Replacer;
     schema: Schema;
 }

package/dist/doc/createNode.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var Alias = require('../nodes/Alias.js');
 var Node = require('../nodes/Node.js');
 var Scalar = require('../nodes/Scalar.js');
 
@@ -16,10 +17,12 @@ 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)) {
-        const map = (_b = (_a = ctx.schema.map).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
+        const map = (_b = (_a = ctx.schema[Node.MAP]).createNode) === null || _b === void 0 ? void 0 : _b.call(_a, ctx.schema, null, ctx);
         map.items.push(value);
         return map;
     }
@@ -31,39 +34,52 @@ function createNode(value, tagName, ctx) {
         // https://tc39.es/ecma262/#sec-serializejsonproperty
         value = value.valueOf();
     }
-    const { onAlias, onTagObj, prevObjects } = ctx;
-    const { map, seq, tags } = ctx.schema;
+    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 (aliasDuplicateObjects && value && typeof value === 'object') {
+        ref = sourceObjects.get(value);
+        if (ref) {
+            if (!ref.anchor)
+                ref.anchor = onAnchor(value);
+            return new Alias.Alias(ref.anchor);
+        }
+        else {
+            ref = { anchor: null, node: null };
+            sourceObjects.set(value, ref);
+        }
+    }
     if (tagName && tagName.startsWith('!!'))
         tagName = defaultTagPrefix + tagName.slice(2);
-    let tagObj = findTagObject(value, tagName, tags);
+    let tagObj = findTagObject(value, tagName, schema.tags);
     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 ? map : Symbol.iterator in Object(value) ? seq : map;
+            value instanceof Map
+                ? schema[Node.MAP]
+                : Symbol.iterator in Object(value)
+                    ? schema[Node.SEQ]
+                    : schema[Node.MAP];
     }
     if (onTagObj) {
         onTagObj(tagObj);
         delete ctx.onTagObj;
     }
-    // Detect duplicate references to the same object & use Alias nodes for all
-    // after first. The `ref` wrapper allows for circular references to resolve.
-    const ref = { value: undefined, node: undefined };
-    if (value && typeof value === 'object') {
-        const prev = prevObjects.get(value);
-        if (prev)
-            return onAlias(prev);
-        ref.value = value;
-        prevObjects.set(value, ref);
-    }
     const node = (tagObj === null || tagObj === void 0 ? void 0 : tagObj.createNode)
         ? tagObj.createNode(ctx.schema, value, ctx)
         : new Scalar.Scalar(value);
     if (tagName)
         node.tag = tagName;
-    ref.node = node;
+    if (ref)
+        ref.node = node;
     return node;
 }
 

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,18 +1,21 @@
 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 LinePos = {
+    line: number;
+    col: number;
+};
 export declare class YAMLError extends Error {
     name: 'YAMLParseError' | 'YAMLWarning';
+    code: ErrorCode;
     message: string;
-    offset: number;
-    linePos?: {
-        line: number;
-        col: number;
-    };
-    constructor(name: YAMLError['name'], offset: number, message: string);
+    pos: [number, number];
+    linePos?: [LinePos] | [LinePos, LinePos];
+    constructor(name: YAMLError['name'], pos: [number, number], code: ErrorCode, message: string);
 }
 export declare class YAMLParseError extends YAMLError {
-    constructor(offset: number, message: string);
+    constructor(pos: [number, number], code: ErrorCode, message: string);
 }
 export declare class YAMLWarning extends YAMLError {
-    constructor(offset: number, message: string);
+    constructor(pos: [number, number], code: ErrorCode, message: string);
 }
 export declare const prettifyError: (src: string, lc: LineCounter) => (error: YAMLError) => void;

package/dist/errors.js

@@ -1,30 +1,29 @@
 'use strict';
 
 class YAMLError extends Error {
-    constructor(name, offset, message) {
-        if (!message)
-            throw new Error(`Invalid arguments for new ${name}`);
+    constructor(name, pos, code, message) {
         super();
         this.name = name;
+        this.code = code;
         this.message = message;
-        this.offset = offset;
+        this.pos = pos;
     }
 }
 class YAMLParseError extends YAMLError {
-    constructor(offset, message) {
-        super('YAMLParseError', offset, message);
+    constructor(pos, code, message) {
+        super('YAMLParseError', pos, code, message);
     }
 }
 class YAMLWarning extends YAMLError {
-    constructor(offset, message) {
-        super('YAMLWarning', offset, message);
+    constructor(pos, code, message) {
+        super('YAMLWarning', pos, code, message);
     }
 }
 const prettifyError = (src, lc) => (error) => {
-    if (error.offset === -1)
+    if (error.pos[0] === -1)
         return;
-    error.linePos = lc.linePos(error.offset);
-    const { line, col } = error.linePos;
+    error.linePos = error.pos.map(pos => lc.linePos(pos));
+    const { line, col } = error.linePos[0];
     error.message += ` at line ${line}, column ${col}`;
     let ci = col - 1;
     let lineStr = src
@@ -47,7 +46,12 @@ const prettifyError = (src, lc) => (error) => {
         lineStr = prev + lineStr;
     }
     if (/[^ ]/.test(lineStr)) {
-        const pointer = ' '.repeat(ci) + '^';
+        let count = 1;
+        const end = error.linePos[1];
+        if (end && end.line === line && end.col > col) {
+            count = Math.min(end.col - col, 80 - ci);
+        }
+        const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;
     }
 };

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { Composer } from './compose/composer.js';
 export { Document } from './doc/Document.js';
-export { Schema } from './doc/Schema.js';
+export { Schema } from './schema/Schema.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 } from './nodes/Node.js';
@@ -8,10 +8,12 @@ export { Pair } from './nodes/Pair.js';
 export { Scalar } from './nodes/Scalar.js';
 export { YAMLMap } from './nodes/YAMLMap.js';
 export { YAMLSeq } from './nodes/YAMLSeq.js';
-export { CreateNodeOptions, defaultOptions, Options, SchemaOptions, ToJSOptions, ToStringOptions } from './options.js';
+export { CreateNodeOptions, defaultOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from './options.js';
+export * as CST from './parse/cst.js';
 export { Lexer } from './parse/lexer.js';
 export { LineCounter } from './parse/line-counter.js';
 export { Parser } from './parse/parser.js';
-export * as tokens from './parse/tokens.js';
 export { EmptyStream, parse, parseAllDocuments, parseDocument, stringify } from './public-api.js';
+export type { TagId, Tags } from './schema/tags';
+export type { CollectionTag, ScalarTag } from './schema/types';
 export { visit, visitor, visitorFn } from './visit.js';

package/dist/index.js

@@ -2,7 +2,7 @@
 
 var composer = require('./compose/composer.js');
 var Document = require('./doc/Document.js');
-var Schema = require('./doc/Schema.js');
+var Schema = require('./schema/Schema.js');
 var errors = require('./errors.js');
 var Alias = require('./nodes/Alias.js');
 var Node = require('./nodes/Node.js');
@@ -11,10 +11,10 @@ var Scalar = require('./nodes/Scalar.js');
 var YAMLMap = require('./nodes/YAMLMap.js');
 var YAMLSeq = require('./nodes/YAMLSeq.js');
 var options = require('./options.js');
+var cst = require('./parse/cst.js');
 var lexer = require('./parse/lexer.js');
 var lineCounter = require('./parse/line-counter.js');
 var parser = require('./parse/parser.js');
-var tokens = require('./parse/tokens.js');
 var publicApi = require('./public-api.js');
 var visit = require('./visit.js');
 
@@ -40,10 +40,10 @@ exports.Scalar = Scalar.Scalar;
 exports.YAMLMap = YAMLMap.YAMLMap;
 exports.YAMLSeq = YAMLSeq.YAMLSeq;
 exports.defaultOptions = options.defaultOptions;
+exports.CST = cst;
 exports.Lexer = lexer.Lexer;
 exports.LineCounter = lineCounter.LineCounter;
 exports.Parser = parser.Parser;
-exports.tokens = tokens;
 exports.parse = publicApi.parse;
 exports.parseAllDocuments = publicApi.parseAllDocuments;
 exports.parseDocument = publicApi.parseDocument;

package/dist/nodes/Alias.d.ts

@@ -1,14 +1,24 @@
-import { StringifyContext } from '../stringify/stringify.js';
-import { Node, NodeBase } from './Node.js';
-import { ToJSContext } from './toJS.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';
+import type { YAMLSeq } from './YAMLSeq';
 export declare namespace Alias {
     interface Parsed extends Alias {
-        range: [number, number];
+        range: Range;
     }
 }
-export declare class Alias<T extends Node = Node> extends NodeBase {
-    source: T;
-    constructor(source: T);
-    toJSON(arg?: unknown, ctx?: ToJSContext): any;
-    toString({ anchors, doc, implicitKey, inStringifyKey }: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
+export declare class Alias extends NodeBase {
+    source: string;
+    anchor?: never;
+    constructor(source: string);
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined;
+    toJSON(_arg?: unknown, ctx?: ToJSContext): unknown;
+    toString(ctx?: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
 }