yaml 2.8.1 → 3.0.0-0

package/dist/index.d.ts

@@ -1,25 +1,335 @@
-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 type { asyncVisitor, asyncVisitorFn, visitor, visitorFn } from './visit';
-export { visit, visitAsync } from './visit';
+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";
+
+//#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)
+* ```
+*/
+declare class Composer<Value extends DocValue = DocValue, Strict extends boolean = true> {
+  private directives;
+  private doc;
+  private docs;
+  private options;
+  private atDirectives;
+  private prelude;
+  private errors;
+  private warnings;
+  constructor(options?: ParseOptions & DocumentOptions & SchemaOptions);
+  private onError;
+  private decorate;
+  /**
+  * Current stream status information.
+  *
+  * Mostly useful at the end of input for an empty stream.
+  */
+  streamInfo(): {
+    comment: string;
+    directives: Directives;
+    errors: YAMLParseError[];
+    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: 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.
+  */
+  end(forceDoc?: boolean, endOffset?: number): Document.Parsed<Value, Strict>[];
+}
+//#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
+*/
+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
+* }
+* ```
+*/
+declare class Parser {
+  private onNewLine?;
+  /** If true, space and sequence indicators count as indentation */
+  private atNewLine;
+  /** If true, next token is a scalar value */
+  private atScalar;
+  /** Current indentation level */
+  private indent;
+  /** Current offset since the start of parsing */
+  offset: number;
+  /** On the same line with a block map key */
+  private onKeyLine;
+  /** Top indicates the node that's currently being built */
+  stack: Token[];
+  /** The source of the current token, set in parse() */
+  private source;
+  /** The type of the current token, set in parse() */
+  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).
+  */
+  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: string): 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[];
+  private get sourceToken();
+  private step;
+  private peek;
+  private pop;
+  private stream;
+  private document;
+  private scalar;
+  private blockScalar;
+  private blockMap;
+  private blockSequence;
+  private flowCollection;
+  private flowScalar;
+  private startBlockValue;
+  private atIndentedComment;
+  private documentEnd;
+  private lineEnd;
+}
+//#endregion
+//#region src/public-api.d.ts
+interface EmptyStream extends Array<Document.Parsed>, ReturnType<Composer["streamInfo"]> {
+  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.
+*/
+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.
+*/
+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.
+*/
+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);
+  /**
+  * 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;
+  /**
+  * Returns the value matching `key`.
+  */
+  get(key: unknown): NodeOf<T> | undefined;
+  /**
+  * `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;
+  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> | {
+  Alias?: visitorFn<Alias>;
+  Collection?: visitorFn<YAMLMap | YAMLSeq>;
+  Map?: visitorFn<YAMLMap>;
+  Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+  Pair?: visitorFn<Pair>;
+  Scalar?: visitorFn<Scalar>;
+  Seq?: visitorFn<YAMLSeq>;
+  Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
+};
+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> | {
+  Alias?: asyncVisitorFn<Alias>;
+  Collection?: asyncVisitorFn<YAMLMap | YAMLSeq>;
+  Map?: asyncVisitorFn<YAMLMap>;
+  Node?: asyncVisitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
+  Pair?: asyncVisitorFn<Pair>;
+  Scalar?: asyncVisitorFn<Scalar>;
+  Seq?: asyncVisitorFn<YAMLSeq>;
+  Value?: asyncVisitorFn<Scalar | YAMLMap | YAMLSeq>;
+};
+/**
+* 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 */
+  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.
+*/
+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 */
+  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 };

package/dist/index.js

@@ -1,50 +1,5 @@
-'use strict';
+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";
 
-var composer = require('./compose/composer.js');
-var Document = require('./doc/Document.js');
-var Schema = require('./schema/Schema.js');
-var errors = require('./errors.js');
-var Alias = require('./nodes/Alias.js');
-var identity = require('./nodes/identity.js');
-var Pair = require('./nodes/Pair.js');
-var Scalar = require('./nodes/Scalar.js');
-var YAMLMap = require('./nodes/YAMLMap.js');
-var YAMLSeq = require('./nodes/YAMLSeq.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 publicApi = require('./public-api.js');
-var visit = require('./visit.js');
-
-
-
-exports.Composer = composer.Composer;
-exports.Document = Document.Document;
-exports.Schema = Schema.Schema;
-exports.YAMLError = errors.YAMLError;
-exports.YAMLParseError = errors.YAMLParseError;
-exports.YAMLWarning = errors.YAMLWarning;
-exports.Alias = Alias.Alias;
-exports.isAlias = identity.isAlias;
-exports.isCollection = identity.isCollection;
-exports.isDocument = identity.isDocument;
-exports.isMap = identity.isMap;
-exports.isNode = identity.isNode;
-exports.isPair = identity.isPair;
-exports.isScalar = identity.isScalar;
-exports.isSeq = identity.isSeq;
-exports.Pair = Pair.Pair;
-exports.Scalar = Scalar.Scalar;
-exports.YAMLMap = YAMLMap.YAMLMap;
-exports.YAMLSeq = YAMLSeq.YAMLSeq;
-exports.CST = cst;
-exports.Lexer = lexer.Lexer;
-exports.LineCounter = lineCounter.LineCounter;
-exports.Parser = parser.Parser;
-exports.parse = publicApi.parse;
-exports.parseAllDocuments = publicApi.parseAllDocuments;
-exports.parseDocument = publicApi.parseDocument;
-exports.stringify = publicApi.stringify;
-exports.visit = visit.visit;
-exports.visitAsync = visit.visitAsync;
+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 };