yaml 3.0.0-0 → 3.0.0-2

package/dist/index.d.ts

@@ -1,17 +1,16 @@
-import { A as YAMLSeq, C as ToStringOptions, D as Schema, E as Pair, F as StringifyContext, G as YAMLError, I as Scalar, J as LineCounter, K as YAMLParseError, L as ToJSContext, N as NodeOf, O as CollectionTag, P as Primitive, S as ToJSOptions, T as Tags, U as Reviver, W as ErrorCode, _ as Range, b as ParseOptions, c as Directives, d as Replacer, f as Alias, g as NodeBase, h as Node, j as YAMLMap, k as ScalarTag, l as DocValue, m as cst_d_exports, p as Token, q as YAMLWarning, u as Document, v as CreateNodeOptions, w as TagId, x as SchemaOptions, y as DocumentOptions, z as NodeCreator } from "./stringifyString-S_ITVLTO.js";
-
+import { A as CollectionTag, C as DocumentOptions, D as ToStringOptions, E as ToJSOptions, F as Scalar, G as YAMLParseError, H as Reviver, K as YAMLWarning, L as ToJSContext, M as Pair, N as KeyArg, O as TagId, P as YAMLMap, R as StringifyContext, S as CreateNodeOptions, T as SchemaOptions, U as ErrorCode, W as YAMLError, a as Alias, c as Node, d as Range, f as YAMLSet, i as Replacer, j as ScalarTag, k as Tags, l as NodeBase, n as DocValue, o as Token, q as LineCounter, r as Document, s as cst_d_exports, t as Directives, u as Primitive, w as ParseOptions, x as Schema, y as YAMLSeq } from "./directives-CGITitH5.js";
 //#region src/compose/composer.d.ts
 /**
-* Compose a stream of CST nodes into a stream of YAML Documents.
-*
-* ```ts
-* import { Composer, Parser } from 'yaml'
-*
-* const src: string = ...
-* const tokens = new Parser().parse(src)
-* const docs = new Composer().compose(tokens)
-* ```
-*/
+ * Compose a stream of CST nodes into a stream of YAML Documents.
+ *
+ * ```ts
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
+ * ```
+ */
 declare class Composer<Value extends DocValue = DocValue, Strict extends boolean = true> {
   private directives;
   private doc;
@@ -25,10 +24,10 @@ declare class Composer<Value extends DocValue = DocValue, Strict extends boolean
   private onError;
   private decorate;
   /**
-  * Current stream status information.
-  *
-  * Mostly useful at the end of input for an empty stream.
-  */
+   * Current stream status information.
+   *
+   * Mostly useful at the end of input for an empty stream.
+   */
   streamInfo(): {
     comment: string;
     directives: Directives;
@@ -36,66 +35,72 @@ declare class Composer<Value extends DocValue = DocValue, Strict extends boolean
     warnings: YAMLWarning[];
   };
   /**
-  * Compose tokens into documents.
-  *
-  * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
-  * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
-  */
+   * Compose tokens into documents.
+   *
+   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+   */
   compose(tokens: Iterable<Token>, forceDoc?: boolean, endOffset?: number): Document.Parsed<Value, Strict>[];
   /** Advance the composer by one CST token. */
   next(token: Token): void;
   /**
-  * Call at end of input to handle any remaining document.
-  *
-  * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
-  * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
-  */
+   * Call at end of input to handle any remaining document.
+   *
+   * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+   * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+   */
   end(forceDoc?: boolean, endOffset?: number): Document.Parsed<Value, Strict>[];
 }
 //#endregion
+//#region src/nodes/identity.d.ts
+/** Type predicate for collections */
+declare const isCollection: (node: unknown) => node is YAMLMap | YAMLSeq | YAMLSet;
+/** Type predicate for `Node` values */
+declare const isNode: (node: unknown) => node is Node;
+//#endregion
 //#region src/parse/lexer.d.ts
 /**
-* Splits an input `source` string into lexical YAML tokens,
-* i.e. smaller strings that are easily identifiable by `tokens.tokenType()`.
-*
-* Lexing starts always in a "stream" context.
-*
-* In addition to slices of the original input, the following control characters
-* may also be emitted:
-*
-* - `\x02` (Start of Text): A document starts with the next token
-* - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
-* - `\x1f` (Unit Separator): Next token is a scalar value
-* - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
-*/
+ * Splits an input `source` string into lexical YAML tokens,
+ * i.e. smaller strings that are easily identifiable by `tokens.tokenType()`.
+ *
+ * Lexing starts always in a "stream" context.
+ *
+ * In addition to slices of the original input, the following control characters
+ * may also be emitted:
+ *
+ * - `\x02` (Start of Text): A document starts with the next token
+ * - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+ * - `\x1f` (Unit Separator): Next token is a scalar value
+ * - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+ */
 declare function lex(source: string): string[];
 //#endregion
 //#region src/parse/parser.d.ts
 /**
-* A YAML concrete syntax tree (CST) parser
-*
-* ```ts
-* const src: string = ...
-* for (const token of new Parser().parse(src)) {
-*   // token: Token
-* }
-* ```
-*
-* To use the parser with a user-provided lexer:
-*
-* ```ts
-* function parse(source: string, lexTokens: string[]) {
-*   const parser = new Parser()
-*   for (const lexeme of lexTokens) parser.next(lexeme)
-*   return parser.end()
-* }
-*
-* const src: string = ...
-* for (const token of parse(src, lex(src))) {
-*   // token: Token
-* }
-* ```
-*/
+ * A YAML concrete syntax tree (CST) parser
+ *
+ * ```ts
+ * const src: string = ...
+ * for (const token of new Parser().parse(src)) {
+ *   // token: Token
+ * }
+ * ```
+ *
+ * To use the parser with a user-provided lexer:
+ *
+ * ```ts
+ * function parse(source: string, lexTokens: string[]) {
+ *   const parser = new Parser()
+ *   for (const lexeme of lexTokens) parser.next(lexeme)
+ *   return parser.end()
+ * }
+ *
+ * const src: string = ...
+ * for (const token of parse(src, lex(src))) {
+ *   // token: Token
+ * }
+ * ```
+ */
 declare class Parser {
   private onNewLine?;
   /** If true, space and sequence indicators count as indentation */
@@ -116,21 +121,21 @@ declare class Parser {
   private type;
   tokens: Token[];
   /**
-  * @param onNewLine - If defined, called separately with the start position of
-  *   each new line (in `parse()`, including the start of input).
-  */
+   * @param onNewLine - If defined, called separately with the start position of
+   *   each new line (in `parse()`, including the start of input).
+   */
   constructor(onNewLine?: (offset: number) => void);
   /**
-  * Parse `source` as a YAML stream.
-  *
-  * Errors are not thrown, but included in the result as `{ type: 'error', message }` tokens.
-  *
-  * @returns Tokens representing each directive, document, and other structure.
-  */
+   * Parse `source` as a YAML stream.
+   *
+   * Errors are not thrown, but included in the result as `{ type: 'error', message }` tokens.
+   *
+   * @returns Tokens representing each directive, document, and other structure.
+   */
   parse(source: string): Token[];
   /**
-  * Advance the parser by the `source` of one lexical token.
-  */
+   * Advance the parser by the `source` of one lexical token.
+   */
   next(source: string): void;
   /** Call at end of input to account for any remaining constructions */
   end(): Token[];
@@ -157,179 +162,164 @@ interface EmptyStream extends Array<Document.Parsed>, ReturnType<Composer["strea
   empty: true;
 }
 /**
-* Parse the input as a stream of YAML documents.
-*
-* Documents should be separated from each other by `...` or `---` marker lines.
-*
-* @returns If an empty `docs` array is returned, it will be of type
-*   EmptyStream and contain additional stream information. In
-*   TypeScript, you should use `'empty' in docs` as a type guard for it.
-*/
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ *
+ * @returns If an empty `docs` array is returned, it will be of type
+ *   EmptyStream and contain additional stream information. In
+ *   TypeScript, you should use `'empty' in docs` as a type guard for it.
+ */
 declare function parseAllDocuments<Value extends DocValue = DocValue, Strict extends boolean = true>(source: string, options?: ParseOptions & DocumentOptions & SchemaOptions): Document.Parsed<Value, Strict>[] | EmptyStream;
 /** Parse an input string into a single YAML.Document */
 declare function parseDocument<Value extends DocValue = DocValue, Strict extends boolean = true>(source: string, options?: ParseOptions & DocumentOptions & SchemaOptions): Document.Parsed<Value, Strict>;
 /**
-* Parse an input string into JavaScript.
-*
-* Only supports input consisting of a single YAML document; for multi-document
-* support you should use `YAML.parseAllDocuments`. May throw on error, and may
-* log warnings using `console.warn`.
-*
-* @param str - A string with YAML formatting.
-* @param reviver - A reviver function, as in `JSON.parse()`
-* @returns The value will match the type of the root value of the parsed YAML
-*   document, so Maps become objects, Sequences arrays, and scalars result in
-*   nulls, booleans, numbers and strings.
-*/
+ * Parse an input string into JavaScript.
+ *
+ * Only supports input consisting of a single YAML document; for multi-document
+ * support you should use `YAML.parseAllDocuments`. May throw on error, and may
+ * log warnings using `console.warn`.
+ *
+ * @param str - A string with YAML formatting.
+ * @param reviver - A reviver function, as in `JSON.parse()`
+ * @returns The value will match the type of the root value of the parsed YAML
+ *   document, so Maps become objects, Sequences arrays, and scalars result in
+ *   nulls, booleans, numbers and strings.
+ */
 declare function parse(src: string, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
 declare function parse(src: string, reviver: Reviver, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
 /**
-* Stringify a value as a YAML document.
-*
-* @param replacer - A replacer array or function, as in `JSON.stringify()`
-* @returns Will always include `\n` as the last character, as is expected of YAML documents.
-*/
+ * Stringify a value as a YAML document.
+ *
+ * @param replacer - A replacer array or function, as in `JSON.stringify()`
+ * @returns Will always include `\n` as the last character, as is expected of YAML documents.
+ */
 declare function stringify(value: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions): string;
 declare function stringify(value: any, replacer?: Replacer | null, options?: string | number | (DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions)): string;
 //#endregion
 //#region src/schema/yaml-1.1/omap.d.ts
-declare class YAMLOMap<K extends Primitive | NodeBase = Primitive | NodeBase, V extends Primitive | NodeBase = Primitive | NodeBase> extends YAMLSeq<Pair<K, V>> {
-  static tag: string;
-  constructor(schema?: Schema);
-  add: typeof YAMLMap.prototype.add;
-  delete: typeof YAMLMap.prototype.delete;
-  get: typeof YAMLMap.prototype.get;
-  has: typeof YAMLMap.prototype.has;
-  set: typeof YAMLMap.prototype.set;
-  /**
-  * If `ctx` is given, the return type is actually `Map<unknown, unknown>`,
-  * but TypeScript won't allow widening the signature of a child method.
-  */
-  toJSON(_?: unknown, ctx?: ToJSContext): unknown[];
-  static from(nc: NodeCreator, iterable: unknown): YAMLOMap;
-}
-//#endregion
-//#region src/schema/yaml-1.1/set.d.ts
-declare class YAMLSet<T extends Primitive | NodeBase = Primitive | NodeBase> extends YAMLMap<T, T> {
-  static tag: string;
-  constructor(schema?: Schema);
+declare class YAMLOMap<K extends Primitive | Node = Primitive | Node, V extends Primitive | Node = Primitive | Node> extends YAMLSeq<Pair<K, V>> {
+  constructor(schema: Schema, elements?: Array<Pair<K, V>>);
   /**
-  * Add a value to the set.
-  *
-  * If `value` is a Pair, its `.value` must be null and `options` is ignored.
-  *
-  * If the set already includes a matching value, no value is added.
-  */
-  add(value: unknown, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
+   * Append new pairs to the omap, and return its new length.
+   */
+  push(...pairs: Pair<K, V>[]): number;
   /**
-  * Returns the value matching `key`.
-  */
-  get(key: unknown): NodeOf<T> | undefined;
+   * Set a pair in this omap.
+   *
+   * Throws if `idx` is not an integer.
+   */
+  set(idx: number, pair: Pair<K, V>): void;
   /**
-  * `value` needs to be true/false to add/remove the item from the set.
-  */
-  set(key: unknown, value: boolean, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
-  toJSON(_?: unknown, ctx?: ToJSContext): any;
+   * The returned value actually has type `Map<unknown, unknown>`,
+   * but TypeScript won't allow widening the signature of a child method.
+   */
+  toJS(doc: Document<DocValue, boolean>, ctx?: ToJSContext): never[];
   toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
-  static from(nc: NodeCreator, iterable: unknown): YAMLSet;
 }
 //#endregion
 //#region src/visit.d.ts
 type visitorFn<T> = (key: number | "key" | "value" | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair;
-type visitor = visitorFn<unknown> | {
+type visitor = visitorFn<Node | Pair | null> | {
   Alias?: visitorFn<Alias>;
-  Collection?: visitorFn<YAMLMap | YAMLSeq>;
-  Map?: visitorFn<YAMLMap>;
-  Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+  Collection?: visitorFn<YAMLMap | YAMLSeq | YAMLSet>;
+  Map?: visitorFn<YAMLMap | YAMLSet>;
+  Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq | YAMLSet>;
   Pair?: visitorFn<Pair>;
   Scalar?: visitorFn<Scalar>;
   Seq?: visitorFn<YAMLSeq>;
-  Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
+  Value?: visitorFn<Scalar | YAMLMap | YAMLSeq | YAMLSet>;
 };
 type asyncVisitorFn<T> = (key: number | "key" | "value" | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair | Promise<void | symbol | number | Node | Pair>;
-type asyncVisitor = asyncVisitorFn<unknown> | {
+type asyncVisitor = asyncVisitorFn<Node | Pair | null> | {
   Alias?: asyncVisitorFn<Alias>;
-  Collection?: asyncVisitorFn<YAMLMap | YAMLSeq>;
-  Map?: asyncVisitorFn<YAMLMap>;
-  Node?: asyncVisitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+  Collection?: asyncVisitorFn<YAMLMap | YAMLSeq | YAMLSet>;
+  Map?: asyncVisitorFn<YAMLMap | YAMLSet>;
+  Node?: asyncVisitorFn<Alias | Scalar | YAMLMap | YAMLSeq | YAMLSet>;
   Pair?: asyncVisitorFn<Pair>;
   Scalar?: asyncVisitorFn<Scalar>;
   Seq?: asyncVisitorFn<YAMLSeq>;
-  Value?: asyncVisitorFn<Scalar | YAMLMap | YAMLSeq>;
+  Value?: asyncVisitorFn<Scalar | YAMLMap | YAMLSeq | YAMLSet>;
 };
 /**
-* Apply a visitor to an AST node or document.
-*
-* Walks through the tree (depth-first) starting from `node`, calling a
-* `visitor` function with three arguments:
-*   - `key`: For sequence values and map `Pair`, the node's index in the
-*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
-*     `null` for the root node.
-*   - `node`: The current node.
-*   - `path`: The ancestry of the current node.
-*
-* The return value of the visitor may be used to control the traversal:
-*   - `undefined` (default): Do nothing and continue
-*   - `visit.SKIP`: Do not visit the children of this node, continue with next
-*     sibling
-*   - `visit.BREAK`: Terminate traversal completely
-*   - `visit.REMOVE`: Remove the current node, then continue with the next one
-*   - `Node`: Replace the current node, then continue by visiting it
-*   - `number`: While iterating the items of a sequence or map, set the index
-*     of the next step. This is useful especially if the index of the current
-*     node has changed.
-*
-* If `visitor` is a single function, it will be called with all values
-* encountered in the tree, including e.g. `null` values. Alternatively,
-* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
-* `Alias` and `Scalar` node. To define the same visitor function for more than
-* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
-* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
-* specific defined one will be used for each node.
-*/
+ * Apply a visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visit.SKIP`: Do not visit the children of this node, continue with next
+ *     sibling
+ *   - `visit.BREAK`: Terminate traversal completely
+ *   - `visit.REMOVE`: Remove the current node, then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
 declare const visit: {
-  (node: Node | Document | null, visitor: visitor): void; /** Terminate visit traversal completely */
-  BREAK: symbol; /** Do not visit the children of the current node */
-  SKIP: symbol; /** Remove the current node */
+  (node: Node | Document | null, visitor: visitor): void;
+  /** Terminate visit traversal completely */
+  BREAK: symbol;
+  /** Do not visit the children of the current node */
+  SKIP: symbol;
+  /** Remove the current node */
   REMOVE: symbol;
 };
 /**
-* Apply an async visitor to an AST node or document.
-*
-* Walks through the tree (depth-first) starting from `node`, calling a
-* `visitor` function with three arguments:
-*   - `key`: For sequence values and map `Pair`, the node's index in the
-*     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
-*     `null` for the root node.
-*   - `node`: The current node.
-*   - `path`: The ancestry of the current node.
-*
-* The return value of the visitor may be used to control the traversal:
-*   - `Promise`: Must resolve to one of the following values
-*   - `undefined` (default): Do nothing and continue
-*   - `visitAsync.SKIP`: Do not visit the children of this node,
-*     continue with next sibling
-*   - `visitAsync.BREAK`: Terminate traversal completely
-*   - `visitAsync.REMOVE`: Remove the current node,
-*     then continue with the next one
-*   - `Node`: Replace the current node, then continue by visiting it
-*   - `number`: While iterating the items of a sequence or map, set the index
-*     of the next step. This is useful especially if the index of the current
-*     node has changed.
-*
-* If `visitor` is a single function, it will be called with all values
-* encountered in the tree, including e.g. `null` values. Alternatively,
-* separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
-* `Alias` and `Scalar` node. To define the same visitor function for more than
-* one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
-* and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
-* specific defined one will be used for each node.
-*/
+ * Apply an async visitor to an AST node or document.
+ *
+ * Walks through the tree (depth-first) starting from `node`, calling a
+ * `visitor` function with three arguments:
+ *   - `key`: For sequence values and map `Pair`, the node's index in the
+ *     collection. Within a `Pair`, `'key'` or `'value'`, correspondingly.
+ *     `null` for the root node.
+ *   - `node`: The current node.
+ *   - `path`: The ancestry of the current node.
+ *
+ * The return value of the visitor may be used to control the traversal:
+ *   - `Promise`: Must resolve to one of the following values
+ *   - `undefined` (default): Do nothing and continue
+ *   - `visitAsync.SKIP`: Do not visit the children of this node,
+ *     continue with next sibling
+ *   - `visitAsync.BREAK`: Terminate traversal completely
+ *   - `visitAsync.REMOVE`: Remove the current node,
+ *     then continue with the next one
+ *   - `Node`: Replace the current node, then continue by visiting it
+ *   - `number`: While iterating the items of a sequence or map, set the index
+ *     of the next step. This is useful especially if the index of the current
+ *     node has changed.
+ *
+ * If `visitor` is a single function, it will be called with all values
+ * encountered in the tree, including e.g. `null` values. Alternatively,
+ * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
+ */
 declare const visitAsync: {
-  (node: Node | Document | null, visitor: asyncVisitor): Promise<void>; /** Terminate visit traversal completely */
-  BREAK: symbol; /** Do not visit the children of the current node */
-  SKIP: symbol; /** Remove the current node */
+  (node: Node | Document | null, visitor: asyncVisitor): Promise<void>;
+  /** Terminate visit traversal completely */
+  BREAK: symbol;
+  /** Do not visit the children of the current node */
+  SKIP: symbol;
+  /** Remove the current node */
   REMOVE: symbol;
 };
 //#endregion
-export { Alias, cst_d_exports as CST, type CollectionTag, Composer, type CreateNodeOptions, type DocValue, Document, type DocumentOptions, type EmptyStream, type ErrorCode, LineCounter, type Node, Pair, type ParseOptions, Parser, type Range, Scalar, type ScalarTag, Schema, type SchemaOptions, type TagId, type Tags, type ToJSOptions, type ToStringOptions, YAMLError, YAMLMap, type YAMLOMap, YAMLParseError, YAMLSeq, type YAMLSet, YAMLWarning, type asyncVisitor, type asyncVisitorFn, lex, parse, parseAllDocuments, parseDocument, stringify, visit, visitAsync, type visitor, type visitorFn };
+export { Alias, cst_d_exports as CST, type CollectionTag, Composer, type CreateNodeOptions, type DocValue, Document, type DocumentOptions, type EmptyStream, type ErrorCode, type KeyArg, LineCounter, type Node, type NodeBase, Pair, type ParseOptions, Parser, type Range, Scalar, type ScalarTag, Schema, type SchemaOptions, type TagId, type Tags, type ToJSOptions, type ToStringOptions, YAMLError, YAMLMap, type YAMLOMap, YAMLParseError, YAMLSeq, YAMLSet, YAMLWarning, type asyncVisitor, type asyncVisitorFn, isCollection, isNode, lex, parse, parseAllDocuments, parseDocument, stringify, visit, visitAsync, type visitor, type visitorFn };

package/dist/index.js

@@ -1,5 +1,4 @@
-import { a as Schema, b as Scalar, f as Alias, g as YAMLSeq, i as Document, n as visit, p as Pair, r as visitAsync, u as YAMLMap } from "./directives-CG6n4xSM.js";
-import { a as cst_exports, c as YAMLParseError, i as lex, l as YAMLWarning, n as Composer, r as Parser, s as YAMLError, t as LineCounter } from "./line-counter-TFl552k_.js";
-import { i as stringify, n as parseAllDocuments, r as parseDocument, t as parse } from "./public-api-BE74JyVm.js";
-
-export { Alias, cst_exports as CST, Composer, Document, LineCounter, Pair, Parser, Scalar, Schema, YAMLError, YAMLMap, YAMLParseError, YAMLSeq, YAMLWarning, lex, parse, parseAllDocuments, parseDocument, stringify, visit, visitAsync };
+import { S as Scalar, _ as YAMLMap, a as Schema, f as Pair, g as YAMLSeq, h as YAMLSet, i as Document, m as isNode, n as visit, p as isCollection, r as visitAsync, u as Alias } from "./directives-DqP9ea45.js";
+import { a as cst_exports, c as YAMLParseError, i as lex, l as YAMLWarning, n as Composer, r as Parser, s as YAMLError, t as LineCounter } from "./line-counter-B2FjSv3E.js";
+import { i as stringify, n as parseAllDocuments, r as parseDocument, t as parse } from "./public-api-uicovB0N.js";
+export { Alias, cst_exports as CST, Composer, Document, LineCounter, Pair, Parser, Scalar, Schema, YAMLError, YAMLMap, YAMLParseError, YAMLSeq, YAMLSet, YAMLWarning, isCollection, isNode, lex, parse, parseAllDocuments, parseDocument, stringify, visit, visitAsync };