yaml 2.6.0 → 2.7.0

package/README.md

@@ -55,24 +55,29 @@ The first has the simplest API and "just works", the second gets you all the bel
 
 A [command-line tool](https://eemeli.org/yaml/#command-line-tool) is also included.
 
+### Parse & Stringify
+
 ```js
 import { parse, stringify } from 'yaml'
-// or
-import YAML from 'yaml'
-// or
-const YAML = require('yaml')
 ```
 
-### Parse & Stringify
-
 - [`parse(str, reviver?, options?): value`](https://eemeli.org/yaml/#yaml-parse)
 - [`stringify(value, replacer?, options?): string`](https://eemeli.org/yaml/#yaml-stringify)
 
 ### Documents
 
+<!-- prettier-ignore -->
+```js
+import {
+  Document,
+  isDocument,
+  parseAllDocuments,
+  parseDocument
+} from 'yaml'
+```
+
 - [`Document`](https://eemeli.org/yaml/#documents)
   - [`constructor(value, replacer?, options?)`](https://eemeli.org/yaml/#creating-documents)
-  - [`#anchors`](https://eemeli.org/yaml/#working-with-anchors)
   - [`#contents`](https://eemeli.org/yaml/#content-nodes)
   - [`#directives`](https://eemeli.org/yaml/#stream-directives)
   - [`#errors`](https://eemeli.org/yaml/#errors)
@@ -83,6 +88,15 @@ const YAML = require('yaml')
 
 ### Content Nodes
 
+<!-- prettier-ignore -->
+```js
+import {
+  isAlias, isCollection, isMap, isNode,
+  isPair, isScalar, isSeq, Scalar,
+  visit, visitAsync, YAMLMap, YAMLSeq
+} from 'yaml'
+```
+
 - [`isAlias(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
 - [`isCollection(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
 - [`isMap(foo): boolean`](https://eemeli.org/yaml/#identifying-node-types)
@@ -93,13 +107,18 @@ const YAML = require('yaml')
 - [`new Scalar(value)`](https://eemeli.org/yaml/#scalar-values)
 - [`new YAMLMap()`](https://eemeli.org/yaml/#collections)
 - [`new YAMLSeq()`](https://eemeli.org/yaml/#collections)
-- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#working-with-anchors)
+- [`doc.createAlias(node, name?): Alias`](https://eemeli.org/yaml/#creating-nodes)
 - [`doc.createNode(value, options?): Node`](https://eemeli.org/yaml/#creating-nodes)
 - [`doc.createPair(key, value): Pair`](https://eemeli.org/yaml/#creating-nodes)
 - [`visit(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
+- [`visitAsync(node, visitor)`](https://eemeli.org/yaml/#finding-and-modifying-nodes)
 
 ### Parsing YAML
 
+```js
+import { Composer, Lexer, Parser } from 'yaml'
+```
+
 - [`new Lexer().lex(src)`](https://eemeli.org/yaml/#lexer)
 - [`new Parser(onNewLine?).parse(src)`](https://eemeli.org/yaml/#parser)
 - [`new Composer(options?).compose(tokens)`](https://eemeli.org/yaml/#composer)

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

@@ -55,7 +55,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (atNewline) {
                     if (comment)
                         comment += token.source;
-                    else
+                    else if (!found || indicator !== 'seq-item-ind')
                         spaceBefore = true;
                 }
                 else

package/browser/dist/log.js

@@ -4,10 +4,7 @@ function debug(logLevel, ...messages) {
 }
 function warn(logLevel, warning) {
     if (logLevel === 'debug' || logLevel === 'warn') {
-        if (typeof process !== 'undefined' && process.emitWarning)
-            process.emitWarning(warning);
-        else
-            console.warn(warning);
+        console.warn(warning);
     }
 }
 

package/browser/dist/schema/json/schema.js

@@ -27,7 +27,7 @@ const jsonScalars = [
         identify: value => typeof value === 'boolean',
         default: true,
         tag: 'tag:yaml.org,2002:bool',
-        test: /^true|false$/,
+        test: /^true$|^false$/,
         resolve: str => str === 'true',
         stringify: stringifyJSON
     },

package/browser/dist/schema/yaml-1.1/binary.js

@@ -14,10 +14,7 @@ const binary = {
      *   document.querySelector('#photo').src = URL.createObjectURL(blob)
      */
     resolve(src, onError) {
-        if (typeof Buffer === 'function') {
-            return Buffer.from(src, 'base64');
-        }
-        else if (typeof atob === 'function') {
+        if (typeof atob === 'function') {
             // On IE 11, atob() can't handle newlines
             const str = atob(src.replace(/[\n\r]/g, ''));
             const buffer = new Uint8Array(str.length);
@@ -33,13 +30,7 @@ const binary = {
     stringify({ comment, type, value }, ctx, onComment, onChompKeep) {
         const buf = value; // checked earlier by binary.identify()
         let str;
-        if (typeof Buffer === 'function') {
-            str =
-                buf instanceof Buffer
-                    ? buf.toString('base64')
-                    : Buffer.from(buf.buffer).toString('base64');
-        }
-        else if (typeof btoa === 'function') {
+        if (typeof btoa === 'function') {
             let s = '';
             for (let i = 0; i < buf.length; ++i)
                 s += String.fromCharCode(buf[i]);

package/browser/dist/schema/yaml-1.1/timestamp.js

@@ -95,7 +95,7 @@ const timestamp = {
         }
         return new Date(date);
     },
-    stringify: ({ value }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '')
+    stringify: ({ value }) => value.toISOString().replace(/(T00:00:00)?\.000Z$/, '')
 };
 
 export { floatTime, intTime, timestamp };

package/browser/dist/stringify/stringifyString.js

@@ -219,23 +219,32 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
         start = start.replace(/\n+/g, `$&${indent}`);
     }
     const indentSize = indent ? '2' : '1'; // root is at -1
-    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
+    // Leading | or > is added later
+    let header = (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
         header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
         if (onComment)
             onComment();
     }
-    if (literal) {
-        value = value.replace(/\n+/g, `$&${indent}`);
-        return `${header}\n${indent}${start}${value}${end}`;
+    if (!literal) {
+        const foldedValue = value
+            .replace(/\n+/g, '\n$&')
+            .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
+            //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
+            .replace(/\n+/g, `$&${indent}`);
+        let literalFallback = false;
+        const foldOptions = getFoldOptions(ctx, true);
+        if (blockQuote !== 'folded' && type !== Scalar.BLOCK_FOLDED) {
+            foldOptions.onOverflow = () => {
+                literalFallback = true;
+            };
+        }
+        const body = foldFlowLines(`${start}${foldedValue}${end}`, indent, FOLD_BLOCK, foldOptions);
+        if (!literalFallback)
+            return `>${header}\n${indent}${body}`;
     }
-    value = value
-        .replace(/\n+/g, '\n$&')
-        .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
-        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
-        .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines(`${start}${value}${end}`, indent, FOLD_BLOCK, getFoldOptions(ctx, true));
-    return `${header}\n${indent}${body}`;
+    value = value.replace(/\n+/g, `$&${indent}`);
+    return `|${header}\n${indent}${start}${value}${end}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
     const { type, value } = item;

package/browser/dist/util.js

@@ -1,8 +1,8 @@
 export { createNode } from './doc/createNode.js';
 export { debug, warn } from './log.js';
 export { createPair } from './nodes/Pair.js';
-export { findPair } from './nodes/YAMLMap.js';
 export { toJS } from './nodes/toJS.js';
+export { findPair } from './nodes/YAMLMap.js';
 export { map as mapTag } from './schema/common/map.js';
 export { seq as seqTag } from './schema/common/seq.js';
 export { string as stringTag } from './schema/common/string.js';

package/dist/compose/compose-collection.d.ts

@@ -1,7 +1,7 @@
-import type { ParsedNode } from '../nodes/Node.js';
-import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { ParsedNode } from '../nodes/Node';
+import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 interface Props {
     anchor: SourceToken | null;
     tag: SourceToken | null;

package/dist/compose/compose-doc.d.ts

@@ -1,7 +1,7 @@
-import type { Directives } from '../doc/directives.js';
-import { Document } from '../doc/Document.js';
-import type { ParsedNode } from '../nodes/Node.js';
-import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
-import type * as CST from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ParsedNode } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type * as CST from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function composeDoc<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true>(options: ParseOptions & DocumentOptions & SchemaOptions, directives: Directives, { offset, start, value, end }: CST.Document, onError: ComposeErrorHandler): Document.Parsed<Contents, Strict>;

package/dist/compose/compose-node.d.ts

@@ -1,9 +1,9 @@
-import type { Directives } from '../doc/directives.js';
-import type { ParsedNode } from '../nodes/Node.js';
-import type { ParseOptions } from '../options.js';
-import type { SourceToken, Token } from '../parse/cst.js';
-import type { Schema } from '../schema/Schema.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Directives } from '../doc/directives';
+import type { ParsedNode } from '../nodes/Node';
+import type { ParseOptions } from '../options';
+import type { SourceToken, Token } from '../parse/cst';
+import type { Schema } from '../schema/Schema';
+import type { ComposeErrorHandler } from './composer';
 export interface ComposeContext {
     atKey: boolean;
     atRoot: boolean;
@@ -25,5 +25,5 @@ declare const CN: {
 };
 export type ComposeNode = typeof CN;
 export declare function composeNode(ctx: ComposeContext, token: Token, props: Props, onError: ComposeErrorHandler): ParsedNode;
-export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag, end }: Props, onError: ComposeErrorHandler): import("../index.js").Scalar.Parsed;
+export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag, end }: Props, onError: ComposeErrorHandler): import('../index').Scalar.Parsed;
 export {};

package/dist/compose/compose-scalar.d.ts

@@ -1,5 +1,5 @@
-import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst.js';
-import type { ComposeContext } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import { Scalar } from '../nodes/Scalar';
+import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst';
+import type { ComposeContext } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 export declare function composeScalar(ctx: ComposeContext, token: FlowScalar | BlockScalar, tagToken: SourceToken | null, onError: ComposeErrorHandler): Scalar.Parsed;

package/dist/compose/composer.d.ts

@@ -1,9 +1,10 @@
-import { Directives } from '../doc/directives.js';
-import { Document } from '../doc/Document.js';
-import { ErrorCode, YAMLParseError, YAMLWarning } from '../errors.js';
-import type { ParsedNode, Range } from '../nodes/Node.js';
-import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options.js';
-import type { Token } from '../parse/cst.js';
+import { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ErrorCode } from '../errors';
+import { YAMLParseError, YAMLWarning } from '../errors';
+import type { ParsedNode, Range } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type { Token } from '../parse/cst';
 type ErrorSource = number | [number, number] | Range | {
     offset: number;
     source?: string;

package/dist/compose/composer.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var node_process = require('node:process');
 var directives = require('../doc/directives.js');
 var Document = require('../doc/Document.js');
 var errors = require('../errors.js');
@@ -133,7 +134,7 @@ class Composer {
     }
     /** Advance the composer by one CST token. */
     *next(token) {
-        if (process.env.LOG_STREAM)
+        if (node_process.env.LOG_STREAM)
             console.dir(token, { depth: null });
         switch (token.type) {
             case 'directive':

package/dist/compose/resolve-block-map.d.ts

@@ -1,6 +1,6 @@
-import { YAMLMap } from '../nodes/YAMLMap.js';
-import type { BlockMap } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import { YAMLMap } from '../nodes/YAMLMap';
+import type { BlockMap } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed;

package/dist/compose/resolve-block-scalar.d.ts

@@ -1,8 +1,8 @@
-import { Range } from '../nodes/Node.js';
-import { Scalar } from '../nodes/Scalar.js';
-import type { BlockScalar } from '../parse/cst.js';
-import type { ComposeContext } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Range } from '../nodes/Node';
+import { Scalar } from '../nodes/Scalar';
+import type { BlockScalar } from '../parse/cst';
+import type { ComposeContext } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveBlockScalar(ctx: ComposeContext, scalar: BlockScalar, onError: ComposeErrorHandler): {
     value: string;
     type: Scalar.BLOCK_FOLDED | Scalar.BLOCK_LITERAL | null;

package/dist/compose/resolve-block-seq.d.ts

@@ -1,6 +1,6 @@
-import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { BlockSequence } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
+import { YAMLSeq } from '../nodes/YAMLSeq';
+import type { BlockSequence } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLSeq.Parsed;

package/dist/compose/resolve-end.d.ts

@@ -1,5 +1,5 @@
-import type { SourceToken } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { SourceToken } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveEnd(end: SourceToken[] | undefined, offset: number, reqSpace: boolean, onError: ComposeErrorHandler): {
     comment: string;
     offset: number;

package/dist/compose/resolve-flow-collection.d.ts

@@ -1,7 +1,7 @@
-import { YAMLMap } from '../nodes/YAMLMap.js';
-import { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { FlowCollection } from '../parse/cst.js';
-import { CollectionTag } from '../schema/types.js';
-import type { ComposeContext, ComposeNode } from './compose-node.js';
-import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null> | YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+import { YAMLMap } from '../nodes/YAMLMap';
+import { YAMLSeq } from '../nodes/YAMLSeq';
+import type { FlowCollection } from '../parse/cst';
+import type { CollectionTag } from '../schema/types';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<import('../index').ParsedNode, import('../index').ParsedNode | null> | YAMLSeq.Parsed<import('../index').ParsedNode>;

package/dist/compose/resolve-flow-scalar.d.ts

@@ -1,7 +1,7 @@
-import { Range } from '../nodes/Node.js';
-import { Scalar } from '../nodes/Scalar.js';
-import type { FlowScalar } from '../parse/cst.js';
-import type { ComposeErrorHandler } from './composer.js';
+import type { Range } from '../nodes/Node';
+import { Scalar } from '../nodes/Scalar';
+import type { FlowScalar } from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
 export declare function resolveFlowScalar(scalar: FlowScalar, strict: boolean, onError: ComposeErrorHandler): {
     value: string;
     type: Scalar.PLAIN | Scalar.QUOTE_DOUBLE | Scalar.QUOTE_SINGLE | null;

package/dist/compose/resolve-props.d.ts

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

package/dist/compose/resolve-props.js

@@ -57,7 +57,7 @@ function resolveProps(tokens, { flow, indicator, next, offset, onError, parentIn
                 if (atNewline) {
                     if (comment)
                         comment += token.source;
-                    else
+                    else if (!found || indicator !== 'seq-item-ind')
                         spaceBefore = true;
                 }
                 else

package/dist/compose/util-contains-newline.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/cst.js';
+import type { Token } from '../parse/cst';
 export declare function containsNewline(key: Token | null | undefined): boolean | null;

package/dist/compose/util-empty-scalar-position.d.ts

@@ -1,2 +1,2 @@
-import type { Token } from '../parse/cst.js';
+import type { Token } from '../parse/cst';
 export declare function emptyScalarPosition(offset: number, before: Token[] | undefined, pos: number | null): number;

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

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

package/dist/compose/util-map-includes.d.ts

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

package/dist/doc/Document.d.ts

@@ -1,14 +1,14 @@
-import type { YAMLError, YAMLWarning } from '../errors.js';
-import { Alias } from '../nodes/Alias.js';
-import { NODE_TYPE } from '../nodes/identity.js';
-import type { Node, NodeType, ParsedNode, Range } from '../nodes/Node.js';
-import { Pair } from '../nodes/Pair.js';
-import type { Scalar } from '../nodes/Scalar.js';
-import type { YAMLMap } from '../nodes/YAMLMap.js';
-import type { YAMLSeq } from '../nodes/YAMLSeq.js';
-import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options.js';
-import { Schema } from '../schema/Schema.js';
-import { Directives } from './directives.js';
+import type { YAMLError, YAMLWarning } from '../errors';
+import { Alias } from '../nodes/Alias';
+import { NODE_TYPE } from '../nodes/identity';
+import type { Node, NodeType, ParsedNode, Range } from '../nodes/Node';
+import { Pair } from '../nodes/Pair';
+import type { Scalar } from '../nodes/Scalar';
+import type { YAMLMap } from '../nodes/YAMLMap';
+import type { YAMLSeq } from '../nodes/YAMLSeq';
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from '../options';
+import { Schema } from '../schema/Schema';
+import { Directives } from './directives';
 export type Replacer = any[] | ((key: any, value: any) => unknown);
 export declare namespace Document {
     /** @ts-ignore The typing of directives fails in TS <= 4.2 */

package/dist/doc/anchors.d.ts

@@ -1,5 +1,5 @@
-import type { Node } from '../nodes/Node.js';
-import type { Document } from './Document.js';
+import type { Node } from '../nodes/Node';
+import type { Document } from './Document';
 /**
  * Verify that the input string is a valid anchor.
  *

package/dist/doc/createNode.d.ts

@@ -1,7 +1,7 @@
-import type { Node } from '../nodes/Node.js';
-import type { Schema } from '../schema/Schema.js';
-import type { CollectionTag, ScalarTag } from '../schema/types.js';
-import type { Replacer } from './Document.js';
+import type { Node } from '../nodes/Node';
+import type { Schema } from '../schema/Schema';
+import type { CollectionTag, ScalarTag } from '../schema/types';
+import type { Replacer } from './Document';
 export interface CreateNodeContext {
     aliasDuplicateObjects: boolean;
     keepUndefined: boolean;

package/dist/doc/directives.d.ts

@@ -1,4 +1,4 @@
-import type { Document } from './Document.js';
+import type { Document } from './Document';
 export declare class Directives {
     static defaultYaml: Directives['yaml'];
     static defaultTags: Directives['tags'];

package/dist/index.d.ts

@@ -1,22 +1,25 @@
-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 { Alias } from './nodes/Alias.js';
-export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq } from './nodes/identity.js';
-export { 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';
-export { YAMLSeq } from './nodes/YAMLSeq.js';
-export type { CreateNodeOptions, 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 { EmptyStream, parse, parseAllDocuments, parseDocument, stringify } from './public-api.js';
+export { Composer } from './compose/composer';
+export { Document } from './doc/Document';
+export { Schema } from './schema/Schema';
+export type { ErrorCode } from './errors';
+export { YAMLError, YAMLParseError, YAMLWarning } from './errors';
+export { Alias } from './nodes/Alias';
+export { isAlias, isCollection, isDocument, isMap, isNode, isPair, isScalar, isSeq } from './nodes/identity';
+export type { Node, ParsedNode, Range } from './nodes/Node';
+export { Pair } from './nodes/Pair';
+export { Scalar } from './nodes/Scalar';
+export { YAMLMap } from './nodes/YAMLMap';
+export { YAMLSeq } from './nodes/YAMLSeq';
+export type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from './options';
+export * as CST from './parse/cst';
+export { Lexer } from './parse/lexer';
+export { LineCounter } from './parse/line-counter';
+export { Parser } from './parse/parser';
+export type { EmptyStream } from './public-api';
+export { parse, parseAllDocuments, parseDocument, stringify } from './public-api';
 export type { TagId, Tags } from './schema/tags';
 export type { CollectionTag, ScalarTag } from './schema/types';
 export type { YAMLOMap } from './schema/yaml-1.1/omap';
 export type { YAMLSet } from './schema/yaml-1.1/set';
-export { asyncVisitor, asyncVisitorFn, visit, visitAsync, visitor, visitorFn } from './visit.js';
+export type { asyncVisitor, asyncVisitorFn, visitor, visitorFn } from './visit';
+export { visit, visitAsync } from './visit';

package/dist/log.js

@@ -1,13 +1,15 @@
 'use strict';
 
+var node_process = require('node:process');
+
 function debug(logLevel, ...messages) {
     if (logLevel === 'debug')
         console.log(...messages);
 }
 function warn(logLevel, warning) {
     if (logLevel === 'debug' || logLevel === 'warn') {
-        if (typeof process !== 'undefined' && process.emitWarning)
-            process.emitWarning(warning);
+        if (typeof node_process.emitWarning === 'function')
+            node_process.emitWarning(warning);
         else
             console.warn(warning);
     }

package/dist/nodes/Alias.d.ts

@@ -1,11 +1,12 @@
-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 { Document } from '../doc/Document';
+import type { FlowScalar } from '../parse/cst';
+import type { StringifyContext } from '../stringify/stringify';
+import type { Range } from './Node';
+import { NodeBase } from './Node';
 import type { Scalar } from './Scalar';
-import { ToJSContext } from './toJS.js';
-import type { YAMLMap } from './YAMLMap.js';
-import type { YAMLSeq } from './YAMLSeq.js';
+import type { ToJSContext } from './toJS';
+import type { YAMLMap } from './YAMLMap';
+import type { YAMLSeq } from './YAMLSeq';
 export declare namespace Alias {
     interface Parsed extends Alias {
         range: Range;
@@ -23,6 +24,6 @@ export declare class Alias extends NodeBase {
      * instance of the `source` anchor before this node.
      */
     resolve(doc: Document): Scalar | YAMLMap | YAMLSeq | undefined;
-    toJSON(_arg?: unknown, ctx?: ToJSContext): {} | null;
+    toJSON(_arg?: unknown, ctx?: ToJSContext): unknown;
     toString(ctx?: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
 }

package/dist/nodes/Collection.d.ts

@@ -1,7 +1,7 @@
-import type { Schema } from '../schema/Schema.js';
-import { NODE_TYPE } from './identity.js';
-import { NodeBase } from './Node.js';
-export declare function collectionFromPath(schema: Schema, path: unknown[], value: unknown): import("./Node.js").Node;
+import type { Schema } from '../schema/Schema';
+import { NODE_TYPE } from './identity';
+import { NodeBase } from './Node';
+export declare function collectionFromPath(schema: Schema, path: unknown[], value: unknown): import('./Node').Node;
 export declare const isEmptyPath: (path: Iterable<unknown> | null | undefined) => path is null | undefined;
 export declare abstract class Collection extends NodeBase {
     schema: Schema | undefined;

package/dist/nodes/Node.d.ts

@@ -1,13 +1,13 @@
-import type { Document } from '../doc/Document.js';
-import type { ToJSOptions } from '../options.js';
-import { Token } from '../parse/cst.js';
-import type { StringifyContext } from '../stringify/stringify.js';
-import type { Alias } from './Alias.js';
-import { NODE_TYPE } from './identity.js';
-import type { Scalar } from './Scalar.js';
-import { ToJSContext } from './toJS.js';
-import type { MapLike, YAMLMap } from './YAMLMap.js';
-import type { YAMLSeq } from './YAMLSeq.js';
+import type { Document } from '../doc/Document';
+import type { ToJSOptions } from '../options';
+import type { Token } from '../parse/cst';
+import type { StringifyContext } from '../stringify/stringify';
+import type { Alias } from './Alias';
+import { NODE_TYPE } from './identity';
+import type { Scalar } from './Scalar';
+import type { ToJSContext } from './toJS';
+import type { MapLike, YAMLMap } from './YAMLMap';
+import type { YAMLSeq } from './YAMLSeq';
 export type Node<T = unknown> = Alias | Scalar<T> | YAMLMap<unknown, T> | YAMLSeq<T>;
 /** Utility type mapper */
 export type NodeType<T> = T extends string | number | bigint | boolean | null | undefined ? Scalar<T> : T extends Date ? Scalar<string | Date> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends {