yaml

  • Version 2.4.5
  • Published
  • 675 kB
  • No dependencies
  • ISC license

Install

npm i yaml
yarn add yaml
pnpm add yaml

Overview

JavaScript parser and stringifier for YAML

Index

Functions

Classes

Interfaces

Type Aliases

Namespaces

Functions

function isAlias

isAlias: (node: any) => node is Alias;

    function isCollection

    isCollection: <K = unknown, V = unknown>(
    node: any
    ) => node is YAMLMap<K, V> | YAMLSeq<V>;

      function isDocument

      isDocument: <T extends Node<unknown> = Node<unknown>>(
      node: any
      ) => node is Document<T, true>;

        function isMap

        isMap: <K = unknown, V = unknown>(node: any) => node is YAMLMap<K, V>;

          function isNode

          isNode: <T = unknown>(node: any) => node is Node<T>;

            function isPair

            isPair: <K = unknown, V = unknown>(node: any) => node is Pair<K, V>;

              function isScalar

              isScalar: <T = unknown>(node: any) => node is Scalar<T>;

                function isSeq

                isSeq: <T = unknown>(node: any) => node is YAMLSeq<T>;

                  function parse

                  parse: {
                  (
                  src: string,
                  options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions
                  ): any;
                  (
                  src: string,
                  reviver: Reviver,
                  options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions
                  ): any;
                  };
                  • 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.

                    Parameter str

                    A string with YAML formatting.

                    Parameter 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.

                  function parseAllDocuments

                  parseAllDocuments: <
                  Contents extends Node<unknown> = ParsedNode,
                  Strict extends boolean = true
                  >(
                  source: string,
                  options?: ParseOptions & DocumentOptions & SchemaOptions
                  ) =>
                  | Array<
                  Contents extends ParsedNode
                  ? Document.Parsed<Contents, Strict>
                  : Document<Contents, Strict>
                  >
                  | EmptyStream;
                  • 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.

                  function parseDocument

                  parseDocument: <
                  Contents extends Node<unknown> = ParsedNode,
                  Strict extends boolean = true
                  >(
                  source: string,
                  options?: ParseOptions & DocumentOptions & SchemaOptions
                  ) => Contents extends ParsedNode
                  ? Document.Parsed<Contents, Strict>
                  : Document<Contents, Strict>;
                  • Parse an input string into a single YAML.Document

                  function stringify

                  stringify: {
                  (
                  value: any,
                  options?: DocumentOptions &
                  SchemaOptions &
                  ParseOptions &
                  CreateNodeOptions &
                  ToStringOptions
                  ): string;
                  (
                  value: any,
                  replacer?: Replacer,
                  options?:
                  | string
                  | number
                  | (DocumentOptions &
                  SchemaOptions &
                  ParseOptions &
                  CreateNodeOptions &
                  ToStringOptions)
                  ): string;
                  };
                  • Stringify a value as a YAML document.

                    Parameter 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.

                  function visit

                  visit: typeof visit;
                  • 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.

                  function visitAsync

                  visitAsync: typeof visitAsync;
                  • 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 - 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.

                  Classes

                  class Alias

                  class Alias extends NodeBase {}

                    constructor

                    constructor(source: string);

                      property anchor

                      anchor?: never;

                        property source

                        source: string;

                          method resolve

                          resolve: (doc: Document) => Scalar | YAMLMap | YAMLSeq | undefined;
                          • Resolve the value of this alias within doc, finding the last instance of the source anchor before this node.

                          method toJSON

                          toJSON: (_arg?: unknown, ctx?: ToJSContext) => {} | null;

                            method toString

                            toString: (
                            ctx?: StringifyContext,
                            _onComment?: () => void,
                            _onChompKeep?: () => void
                            ) => string;

                              class Composer

                              class Composer<
                              Contents extends ParsedNode = ParsedNode,
                              Strict extends boolean = true
                              > {}
                              • Compose a stream of CST nodes into a stream of YAML Documents.

                                import { Composer, Parser } from 'yaml'
                                const src: string = ...
                                const tokens = new Parser().parse(src)
                                const docs = new Composer().compose(tokens)

                              constructor

                              constructor(options?: ParseOptions & DocumentOptions & SchemaOptions);

                                method compose

                                compose: (
                                tokens: Iterable<Token>,
                                forceDoc?: boolean,
                                endOffset?: number
                                ) => Generator<Document.Parsed<Contents, Strict>, void, unknown>;
                                • Compose tokens into documents.

                                  Parameter 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.

                                  Parameter endOffset

                                  Should be set if forceDoc is also set, to set the document range end and to indicate errors correctly.

                                method end

                                end: (
                                forceDoc?: boolean,
                                endOffset?: number
                                ) => Generator<Document.Parsed<Contents, Strict>, void, unknown>;
                                • Call at end of input to yield any remaining document.

                                  Parameter 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.

                                  Parameter endOffset

                                  Should be set if forceDoc is also set, to set the document range end and to indicate errors correctly.

                                method next

                                next: (
                                token: Token
                                ) => Generator<Document.Parsed<Contents, Strict>, void, unknown>;
                                • Advance the composer by one CST token.

                                method streamInfo

                                streamInfo: () => {
                                comment: string;
                                directives: Directives;
                                errors: YAMLParseError[];
                                warnings: YAMLWarning[];
                                };
                                • Current stream status information.

                                  Mostly useful at the end of input for an empty stream.

                                class Document

                                class Document<Contents extends Node = Node, Strict extends boolean = true> {}

                                  constructor

                                  constructor(
                                  value?: any,
                                  options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions
                                  );
                                  • Parameter value

                                    The initial value for the document, which will be wrapped in a Node container.

                                  constructor

                                  constructor(
                                  value: any,
                                  replacer: Replacer,
                                  options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions
                                  );

                                    property [NODE_TYPE]

                                    readonly [NODE_TYPE]: Symbol;

                                      property comment

                                      comment: string;
                                      • A comment immediately after this Document

                                      property commentBefore

                                      commentBefore: string;
                                      • A comment before this Document

                                      property contents

                                      contents: Node<unknown>;
                                      • The document contents.

                                      property directives

                                      directives: Directives;

                                        property errors

                                        errors: YAMLError[];
                                        • Errors encountered during parsing.

                                        property options

                                        options: Required<
                                        Omit<
                                        ParseOptions & DocumentOptions,
                                        '_directives' | 'lineCounter' | 'version'
                                        >
                                        >;

                                          property range

                                          range?: Range;
                                          • The [start, value-end, node-end] character offsets for the part of the source parsed into this document (undefined if not parsed). The value-end and node-end positions are themselves not included in their respective ranges.

                                          property schema

                                          schema: Schema;
                                          • The schema used with the document. Use setSchema() to change.

                                          property warnings

                                          warnings: YAMLWarning[];
                                          • Warnings encountered during parsing.

                                          method add

                                          add: (value: any) => void;
                                          • Adds a value to the document.

                                          method addIn

                                          addIn: (path: Iterable<unknown>, value: unknown) => void;
                                          • Adds a value to the document.

                                          method clone

                                          clone: () => Document<Contents, Strict>;
                                          • Create a deep copy of this Document and its contents.

                                            Custom Node values that inherit from Object still refer to their original instances.

                                          method createAlias

                                          createAlias: (
                                          node: Strict extends true ? Scalar | YAMLMap | YAMLSeq : Node,
                                          name?: string
                                          ) => Alias;
                                          • 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.

                                          method createNode

                                          createNode: {
                                          <T = unknown>(value: T, options?: CreateNodeOptions): NodeType<T>;
                                          <T = unknown>(
                                          value: T,
                                          replacer: CreateNodeOptions | Replacer,
                                          options?: CreateNodeOptions
                                          ): NodeType<T>;
                                          };
                                          • Convert any value into a Node using the current schema, recursively turning objects into collections.

                                          method createPair

                                          createPair: <
                                          K extends Node<unknown> = Node<unknown>,
                                          V extends Node<unknown> = Node<unknown>
                                          >(
                                          key: unknown,
                                          value: unknown,
                                          options?: CreateNodeOptions
                                          ) => Pair<K, V>;
                                          • Convert a key and a value into a Pair using the current schema, recursively wrapping all values as Scalar or Collection nodes.

                                          method delete

                                          delete: (key: unknown) => boolean;
                                          • Removes a value from the document.

                                            Returns

                                            true if the item was found and removed.

                                          method deleteIn

                                          deleteIn: (path: Iterable<unknown> | null) => boolean;
                                          • Removes a value from the document.

                                            Returns

                                            true if the item was found and removed.

                                          method get

                                          get: (key: unknown, keepScalar?: boolean) => Strict extends true ? unknown : any;
                                          • Returns item at key, or undefined if not found. By default unwraps scalar values from their surrounding node; to disable set keepScalar to true (collections are always returned intact).

                                          method getIn

                                          getIn: (
                                          path: Iterable<unknown> | null,
                                          keepScalar?: boolean
                                          ) => Strict extends true ? unknown : any;
                                          • Returns item at path, or undefined if not found. By default unwraps scalar values from their surrounding node; to disable set keepScalar to true (collections are always returned intact).

                                          method has

                                          has: (key: unknown) => boolean;
                                          • Checks if the document includes a value with the key key.

                                          method hasIn

                                          hasIn: (path: Iterable<unknown> | null) => boolean;
                                          • Checks if the document includes a value at path.

                                          method set

                                          set: (key: any, value: unknown) => void;
                                          • Sets a value in this document. For !!set, value needs to be a boolean to add/remove the item from the set.

                                          method setIn

                                          setIn: (path: Iterable<unknown> | null, value: unknown) => void;
                                          • Sets a value in this document. For !!set, value needs to be a boolean to add/remove the item from the set.

                                          method setSchema

                                          setSchema: (
                                          version: '1.1' | '1.2' | 'next' | null,
                                          options?: SchemaOptions
                                          ) => void;
                                          • Change the YAML version and schema used by the document. A null version disables support for directives, explicit tags, anchors, and aliases. It also requires the schema option to be given as a Schema instance value.

                                            Overrides all previously set schema options.

                                          method toJS

                                          toJS: (opt?: ToJSOptions & { [ignored: string]: unknown }) => any;
                                          • A plain JavaScript representation of the document contents.

                                          method toJSON

                                          toJSON: (jsonArg?: string | null, onAnchor?: ToJSOptions['onAnchor']) => any;
                                          • A JSON representation of the document contents.

                                            Parameter jsonArg

                                            Used by JSON.stringify to indicate the array index or property name.

                                          method toString

                                          toString: (options?: ToStringOptions) => string;
                                          • A YAML representation of the document.

                                          class Lexer

                                          class Lexer {}
                                          • Splits an input string into lexical tokens, i.e. smaller strings that are easily identifiable by tokens.tokenType().

                                            Lexing starts always in a "stream" context. Incomplete input may be buffered until a complete token can be emitted.

                                            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

                                          method lex

                                          lex: (source: string, incomplete?: boolean) => Generator<string, void, unknown>;
                                          • Generate YAML tokens from the source string. If incomplete, a part of the last line may be left as a buffer for the next call.

                                            Returns

                                            A generator of lexical tokens

                                          class LineCounter

                                          class LineCounter {}
                                          • Tracks newlines during parsing in order to provide an efficient API for determining the one-indexed { line, col } position for any offset within the input.

                                          property addNewLine

                                          addNewLine: (offset: number) => number;
                                          • Should be called in ascending order. Otherwise, call lineCounter.lineStarts.sort() before calling linePos().

                                          property linePos

                                          linePos: (offset: number) => { line: number; col: number };
                                          • Performs a binary search and returns the 1-indexed { line, col } position of offset. If line === 0, addNewLine has never been called or offset is before the first known newline.

                                          property lineStarts

                                          lineStarts: number[];

                                            class Pair

                                            class Pair<K = unknown, V = unknown> {}

                                              constructor

                                              constructor(key: {}, value?: {});

                                                property [NODE_TYPE]

                                                readonly [NODE_TYPE]: Symbol;

                                                  property key

                                                  key: {};
                                                  • Always Node or null when parsed, but can be set to anything.

                                                  property srcToken

                                                  srcToken?: CollectionItem;
                                                  • The CST token that was composed into this pair.

                                                  property value

                                                  value: {};
                                                  • Always Node or null when parsed, but can be set to anything.

                                                  method clone

                                                  clone: (schema?: Schema) => Pair<K, V>;

                                                    method toJSON

                                                    toJSON: (_?: unknown, ctx?: ToJSContext) => ReturnType<typeof addPairToJSMap>;

                                                      method toString

                                                      toString: (
                                                      ctx?: StringifyContext,
                                                      onComment?: () => void,
                                                      onChompKeep?: () => void
                                                      ) => string;

                                                        class Parser

                                                        class Parser {}
                                                        • A YAML concrete syntax tree (CST) parser

                                                          const src: string = ...
                                                          for (const token of new Parser().parse(src)) {
                                                          // token: Token
                                                          }

                                                          To use the parser with a user-provided lexer:

                                                          function* parse(source: string, lexer: Lexer) {
                                                          const parser = new Parser()
                                                          for (const lexeme of lexer.lex(source))
                                                          yield* parser.next(lexeme)
                                                          yield* parser.end()
                                                          }
                                                          const src: string = ...
                                                          const lexer = new Lexer()
                                                          for (const token of parse(src, lexer)) {
                                                          // token: Token
                                                          }

                                                        constructor

                                                        constructor(onNewLine?: (offset: number) => void);
                                                        • Parameter onNewLine

                                                          If defined, called separately with the start position of each new line (in parse(), including the start of input).

                                                        property offset

                                                        offset: number;
                                                        • Current offset since the start of parsing

                                                        property stack

                                                        stack: Token[];
                                                        • Top indicates the node that's currently being built

                                                        method end

                                                        end: () => Generator<Token, void, unknown>;
                                                        • Call at end of input to push out any remaining constructions

                                                        method next

                                                        next: (source: string) => Generator<Token, void, unknown>;
                                                        • Advance the parser by the source of one lexical token.

                                                        method parse

                                                        parse: (source: string, incomplete?: boolean) => Generator<Token, void, unknown>;
                                                        • Parse source as a YAML stream. If incomplete, a part of the last line may be left as a buffer for the next call.

                                                          Errors are not thrown, but yielded as { type: 'error', message } tokens.

                                                          Returns

                                                          A generator of tokens representing each directive, document, and other structure.

                                                        class Scalar

                                                        class Scalar<T = unknown> extends NodeBase {}

                                                          constructor

                                                          constructor(value: {});

                                                            property anchor

                                                            anchor?: string;
                                                            • An optional anchor on this node. Used by alias nodes.

                                                            property BLOCK_FOLDED

                                                            static readonly BLOCK_FOLDED: string;

                                                              property BLOCK_LITERAL

                                                              static readonly BLOCK_LITERAL: string;

                                                                property format

                                                                format?: string;
                                                                • By default (undefined), numbers use decimal notation. The YAML 1.2 core schema only supports 'HEX' and 'OCT'. The YAML 1.1 schema also supports 'BIN' and 'TIME'

                                                                property minFractionDigits

                                                                minFractionDigits?: number;
                                                                • If value is a number, use this value when stringifying this node.

                                                                property PLAIN

                                                                static readonly PLAIN: string;

                                                                  property QUOTE_DOUBLE

                                                                  static readonly QUOTE_DOUBLE: string;

                                                                    property QUOTE_SINGLE

                                                                    static readonly QUOTE_SINGLE: string;

                                                                      property source

                                                                      source?: string;
                                                                      • Set during parsing to the source string value

                                                                      property type

                                                                      type?: Scalar.Type;
                                                                      • The scalar style used for the node's string representation

                                                                      property value

                                                                      value: {};

                                                                        method toJSON

                                                                        toJSON: (arg?: any, ctx?: ToJSContext) => any;

                                                                          method toString

                                                                          toString: () => string;

                                                                            class Schema

                                                                            class Schema {}

                                                                              constructor

                                                                              constructor({
                                                                              compat,
                                                                              customTags,
                                                                              merge,
                                                                              resolveKnownTags,
                                                                              schema,
                                                                              sortMapEntries,
                                                                              toStringDefaults,
                                                                              }: SchemaOptions);

                                                                                property [MAP]

                                                                                readonly [MAP]: CollectionTag;

                                                                                  property [SCALAR]

                                                                                  readonly [SCALAR]: ScalarTag;

                                                                                    property [SEQ]

                                                                                    readonly [SEQ]: CollectionTag;

                                                                                      property compat

                                                                                      compat: (CollectionTag | ScalarTag)[];

                                                                                        property knownTags

                                                                                        knownTags: Record<string, CollectionTag | ScalarTag>;

                                                                                          property merge

                                                                                          merge: boolean;

                                                                                            property name

                                                                                            name: string;

                                                                                              property sortMapEntries

                                                                                              sortMapEntries: (a: Pair, b: Pair) => number;

                                                                                                property tags

                                                                                                tags: (CollectionTag | ScalarTag)[];

                                                                                                  property toStringOptions

                                                                                                  toStringOptions: Readonly<ToStringOptions>;

                                                                                                    method clone

                                                                                                    clone: () => Schema;

                                                                                                      class YAMLError

                                                                                                      class YAMLError extends Error {}

                                                                                                        constructor

                                                                                                        constructor(
                                                                                                        name: 'YAMLParseError' | 'YAMLWarning',
                                                                                                        pos: [number, number],
                                                                                                        code: ErrorCode,
                                                                                                        message: string
                                                                                                        );

                                                                                                          property code

                                                                                                          code: ErrorCode;

                                                                                                            property linePos

                                                                                                            linePos?: [LinePos] | [LinePos, LinePos];

                                                                                                              property message

                                                                                                              message: string;

                                                                                                                property name

                                                                                                                name: 'YAMLParseError' | 'YAMLWarning';

                                                                                                                  property pos

                                                                                                                  pos: [number, number];

                                                                                                                    class YAMLMap

                                                                                                                    class YAMLMap<K = unknown, V = unknown> extends Collection {}

                                                                                                                      constructor

                                                                                                                      constructor(schema?: Schema);

                                                                                                                        property items

                                                                                                                        items: Pair<K, V>[];

                                                                                                                          property tagName

                                                                                                                          static readonly tagName: string;

                                                                                                                            method add

                                                                                                                            add: (pair: Pair<K, V> | { key: K; value: V }, overwrite?: boolean) => void;
                                                                                                                            • Adds a value to the collection.

                                                                                                                              Parameter overwrite

                                                                                                                              If not set true, using a key that is already in the collection will throw. Otherwise, overwrites the previous value.

                                                                                                                            method delete

                                                                                                                            delete: (key: unknown) => boolean;

                                                                                                                              method from

                                                                                                                              static from: (
                                                                                                                              schema: Schema,
                                                                                                                              obj: unknown,
                                                                                                                              ctx: CreateNodeContext
                                                                                                                              ) => YAMLMap<unknown, unknown>;
                                                                                                                              • A generic collection parsing method that can be extended to other node classes that inherit from YAMLMap

                                                                                                                              method get

                                                                                                                              get: {
                                                                                                                              (key: unknown, keepScalar: true): Scalar<V> | undefined;
                                                                                                                              (key: unknown, keepScalar?: false): V;
                                                                                                                              (key: unknown, keepScalar?: boolean): V | Scalar<V>;
                                                                                                                              };

                                                                                                                                method has

                                                                                                                                has: (key: unknown) => boolean;

                                                                                                                                  method set

                                                                                                                                  set: (key: K, value: V) => void;

                                                                                                                                    method toJSON

                                                                                                                                    toJSON: <T extends MapLike = Map<unknown, unknown>>(
                                                                                                                                    _?: unknown,
                                                                                                                                    ctx?: ToJSContext,
                                                                                                                                    Type?: { new (): T }
                                                                                                                                    ) => any;
                                                                                                                                    • Parameter ctx

                                                                                                                                      Conversion context, originally set in Document#toJS()

                                                                                                                                      Parameter Type

                                                                                                                                      If set, forces the returned collection type

                                                                                                                                      Returns

                                                                                                                                      Instance of Type, Map, or Object

                                                                                                                                    method toString

                                                                                                                                    toString: (
                                                                                                                                    ctx?: StringifyContext,
                                                                                                                                    onComment?: () => void,
                                                                                                                                    onChompKeep?: () => void
                                                                                                                                    ) => string;

                                                                                                                                      class YAMLOMap

                                                                                                                                      class YAMLOMap extends YAMLSeq {}

                                                                                                                                        constructor

                                                                                                                                        constructor();

                                                                                                                                          property add

                                                                                                                                          add: (
                                                                                                                                          pair: import('../../index.js').Pair<any, any> | { key: any; value: any },
                                                                                                                                          overwrite?: boolean | undefined
                                                                                                                                          ) => void;

                                                                                                                                            property delete

                                                                                                                                            delete: (key: unknown) => boolean;

                                                                                                                                              property get

                                                                                                                                              get: {
                                                                                                                                              (key: unknown, keepScalar: true):
                                                                                                                                              | import('../../index.js').Scalar<any>
                                                                                                                                              | undefined;
                                                                                                                                              (key: unknown, keepScalar?: false | undefined): any;
                                                                                                                                              (key: unknown, keepScalar?: boolean | undefined): any;
                                                                                                                                              };

                                                                                                                                                property has

                                                                                                                                                has: (key: unknown) => boolean;

                                                                                                                                                  property set

                                                                                                                                                  set: (key: any, value: any) => void;

                                                                                                                                                    property tag

                                                                                                                                                    static tag: string;

                                                                                                                                                      method from

                                                                                                                                                      static from: (
                                                                                                                                                      schema: Schema,
                                                                                                                                                      iterable: unknown,
                                                                                                                                                      ctx: CreateNodeContext
                                                                                                                                                      ) => YAMLOMap;

                                                                                                                                                        method toJSON

                                                                                                                                                        toJSON: (_?: unknown, ctx?: ToJSContext) => unknown[];
                                                                                                                                                        • If ctx is given, the return type is actually Map<unknown, unknown>, but TypeScript won't allow widening the signature of a child method.

                                                                                                                                                        class YAMLParseError

                                                                                                                                                        class YAMLParseError extends YAMLError {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(pos: [number, number], code: ErrorCode, message: string);

                                                                                                                                                            class YAMLSeq

                                                                                                                                                            class YAMLSeq<T = unknown> extends Collection {}

                                                                                                                                                              constructor

                                                                                                                                                              constructor(schema?: Schema);

                                                                                                                                                                property items

                                                                                                                                                                items: T[];

                                                                                                                                                                  property tagName

                                                                                                                                                                  static readonly tagName: string;

                                                                                                                                                                    method add

                                                                                                                                                                    add: (value: T) => void;

                                                                                                                                                                      method delete

                                                                                                                                                                      delete: (key: unknown) => boolean;
                                                                                                                                                                      • Removes a value from the collection.

                                                                                                                                                                        key must contain a representation of an integer for this to succeed. It may be wrapped in a Scalar.

                                                                                                                                                                        Returns

                                                                                                                                                                        true if the item was found and removed.

                                                                                                                                                                      method from

                                                                                                                                                                      static from: (
                                                                                                                                                                      schema: Schema,
                                                                                                                                                                      obj: unknown,
                                                                                                                                                                      ctx: CreateNodeContext
                                                                                                                                                                      ) => YAMLSeq<unknown>;

                                                                                                                                                                        method get

                                                                                                                                                                        get: {
                                                                                                                                                                        (key: unknown, keepScalar: true): Scalar<T> | undefined;
                                                                                                                                                                        (key: unknown, keepScalar?: false): T;
                                                                                                                                                                        (key: unknown, keepScalar?: boolean): T | Scalar<T>;
                                                                                                                                                                        };
                                                                                                                                                                        • Returns item at key, or undefined if not found. By default unwraps scalar values from their surrounding node; to disable set keepScalar to true (collections are always returned intact).

                                                                                                                                                                          key must contain a representation of an integer for this to succeed. It may be wrapped in a Scalar.

                                                                                                                                                                        method has

                                                                                                                                                                        has: (key: unknown) => boolean;
                                                                                                                                                                        • Checks if the collection includes a value with the key key.

                                                                                                                                                                          key must contain a representation of an integer for this to succeed. It may be wrapped in a Scalar.

                                                                                                                                                                        method set

                                                                                                                                                                        set: (key: unknown, value: T) => void;
                                                                                                                                                                        • Sets a value in this collection. For !!set, value needs to be a boolean to add/remove the item from the set.

                                                                                                                                                                          If key does not contain a representation of an integer, this will throw. It may be wrapped in a Scalar.

                                                                                                                                                                        method toJSON

                                                                                                                                                                        toJSON: (_?: unknown, ctx?: ToJSContext) => unknown[];

                                                                                                                                                                          method toString

                                                                                                                                                                          toString: (
                                                                                                                                                                          ctx?: StringifyContext,
                                                                                                                                                                          onComment?: () => void,
                                                                                                                                                                          onChompKeep?: () => void
                                                                                                                                                                          ) => string;

                                                                                                                                                                            class YAMLSet

                                                                                                                                                                            class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null> {}

                                                                                                                                                                              constructor

                                                                                                                                                                              constructor(schema?: Schema);

                                                                                                                                                                                property tag

                                                                                                                                                                                static tag: string;

                                                                                                                                                                                  method add

                                                                                                                                                                                  add: (
                                                                                                                                                                                  key:
                                                                                                                                                                                  | T
                                                                                                                                                                                  | Pair<T, Scalar<null> | null>
                                                                                                                                                                                  | { key: T; value: Scalar<null> | null }
                                                                                                                                                                                  ) => void;

                                                                                                                                                                                    method from

                                                                                                                                                                                    static from: (
                                                                                                                                                                                    schema: Schema,
                                                                                                                                                                                    iterable: unknown,
                                                                                                                                                                                    ctx: CreateNodeContext
                                                                                                                                                                                    ) => YAMLSet<unknown>;

                                                                                                                                                                                      method get

                                                                                                                                                                                      get: (key: unknown, keepPair?: boolean) => any;
                                                                                                                                                                                      • If keepPair is true, returns the Pair matching key. Otherwise, returns the value of that Pair's key.

                                                                                                                                                                                      method set

                                                                                                                                                                                      set: { (key: T, value: boolean): void; (key: T, value: null): void };
                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                        Will throw; value must be boolean

                                                                                                                                                                                      method toJSON

                                                                                                                                                                                      toJSON: (_?: unknown, ctx?: ToJSContext) => any;

                                                                                                                                                                                        method toString

                                                                                                                                                                                        toString: (
                                                                                                                                                                                        ctx?: StringifyContext,
                                                                                                                                                                                        onComment?: () => void,
                                                                                                                                                                                        onChompKeep?: () => void
                                                                                                                                                                                        ) => string;

                                                                                                                                                                                          class YAMLWarning

                                                                                                                                                                                          class YAMLWarning extends YAMLError {}

                                                                                                                                                                                            constructor

                                                                                                                                                                                            constructor(pos: [number, number], code: ErrorCode, message: string);

                                                                                                                                                                                              Interfaces

                                                                                                                                                                                              interface CollectionTag

                                                                                                                                                                                              interface CollectionTag extends TagBase {}

                                                                                                                                                                                                property collection

                                                                                                                                                                                                collection: 'map' | 'seq';
                                                                                                                                                                                                • The source collection type supported by this tag.

                                                                                                                                                                                                property nodeClass

                                                                                                                                                                                                nodeClass?: {
                                                                                                                                                                                                new (schema?: Schema): Node;
                                                                                                                                                                                                from?: (schema: Schema, obj: unknown, ctx: CreateNodeContext) => Node;
                                                                                                                                                                                                };
                                                                                                                                                                                                • The Node child class that implements this tag. If set, used to select this tag when stringifying.

                                                                                                                                                                                                  If the class provides a static from method, then that will be used if the tag object doesn't have a createNode method.

                                                                                                                                                                                                property resolve

                                                                                                                                                                                                resolve?: (
                                                                                                                                                                                                value: YAMLMap.Parsed | YAMLSeq.Parsed,
                                                                                                                                                                                                onError: (message: string) => void,
                                                                                                                                                                                                options: ParseOptions
                                                                                                                                                                                                ) => unknown;
                                                                                                                                                                                                • Turns a value into an AST node. If returning a non-Node value, the output will be wrapped as a Scalar.

                                                                                                                                                                                                  Note: this is required if nodeClass is not provided.

                                                                                                                                                                                                property stringify

                                                                                                                                                                                                stringify?: never;

                                                                                                                                                                                                  property test

                                                                                                                                                                                                  test?: never;

                                                                                                                                                                                                    interface EmptyStream

                                                                                                                                                                                                    interface EmptyStream
                                                                                                                                                                                                    extends Array<Document.Parsed>,
                                                                                                                                                                                                    ReturnType<Composer['streamInfo']> {}

                                                                                                                                                                                                      property empty

                                                                                                                                                                                                      empty: true;

                                                                                                                                                                                                        interface ScalarTag

                                                                                                                                                                                                        interface ScalarTag extends TagBase {}

                                                                                                                                                                                                          property collection

                                                                                                                                                                                                          collection?: never;

                                                                                                                                                                                                            property nodeClass

                                                                                                                                                                                                            nodeClass?: never;

                                                                                                                                                                                                              property stringify

                                                                                                                                                                                                              stringify?: (
                                                                                                                                                                                                              item: Scalar,
                                                                                                                                                                                                              ctx: StringifyContext,
                                                                                                                                                                                                              onComment?: () => void,
                                                                                                                                                                                                              onChompKeep?: () => void
                                                                                                                                                                                                              ) => string;
                                                                                                                                                                                                              • Optional function stringifying a Scalar node. If your data includes a suitable .toString() method, you can probably leave this undefined and use the default stringifier.

                                                                                                                                                                                                                Parameter item

                                                                                                                                                                                                                The node being stringified.

                                                                                                                                                                                                                Parameter ctx

                                                                                                                                                                                                                Contains the stringifying context variables.

                                                                                                                                                                                                                Parameter onComment

                                                                                                                                                                                                                Callback to signal that the stringifier includes the item's comment in its output.

                                                                                                                                                                                                                Parameter onChompKeep

                                                                                                                                                                                                                Callback to signal that the output uses a block scalar type with the + chomping indicator.

                                                                                                                                                                                                              property test

                                                                                                                                                                                                              test?: RegExp;
                                                                                                                                                                                                              • Together with default allows for values to be stringified without an explicit tag and detected using a regular expression. For most cases, it's unlikely that you'll actually want to use these, even if you first think you do.

                                                                                                                                                                                                              method resolve

                                                                                                                                                                                                              resolve: (
                                                                                                                                                                                                              value: string,
                                                                                                                                                                                                              onError: (message: string) => void,
                                                                                                                                                                                                              options: ParseOptions
                                                                                                                                                                                                              ) => unknown;
                                                                                                                                                                                                              • Turns a value into an AST node. If returning a non-Node value, the output will be wrapped as a Scalar.

                                                                                                                                                                                                              Type Aliases

                                                                                                                                                                                                              type asyncVisitor

                                                                                                                                                                                                              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>;
                                                                                                                                                                                                              };

                                                                                                                                                                                                                type asyncVisitorFn

                                                                                                                                                                                                                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 CreateNodeOptions

                                                                                                                                                                                                                  type CreateNodeOptions = {
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * During node construction, use anchors and aliases to keep strictly equal
                                                                                                                                                                                                                  * non-null objects as equivalent in YAML.
                                                                                                                                                                                                                  *
                                                                                                                                                                                                                  * Default: `true`
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  aliasDuplicateObjects?: boolean;
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * Default prefix for anchors.
                                                                                                                                                                                                                  *
                                                                                                                                                                                                                  * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  anchorPrefix?: string;
                                                                                                                                                                                                                  /** Force the top-level collection node to use flow style. */
                                                                                                                                                                                                                  flow?: boolean;
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * Keep `undefined` object values when creating mappings, rather than
                                                                                                                                                                                                                  * discarding them.
                                                                                                                                                                                                                  *
                                                                                                                                                                                                                  * Default: `false`
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  keepUndefined?: boolean | null;
                                                                                                                                                                                                                  onTagObj?: (tagObj: ScalarTag | CollectionTag) => void;
                                                                                                                                                                                                                  /**
                                                                                                                                                                                                                  * Specify the top-level collection type, e.g. `"!!omap"`. Note that this
                                                                                                                                                                                                                  * requires the corresponding tag to be available in this document's schema.
                                                                                                                                                                                                                  */
                                                                                                                                                                                                                  tag?: string;
                                                                                                                                                                                                                  };

                                                                                                                                                                                                                    type DocumentOptions

                                                                                                                                                                                                                    type DocumentOptions = {
                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                    * @internal
                                                                                                                                                                                                                    * Used internally by Composer. If set and includes an explicit version,
                                                                                                                                                                                                                    * that overrides the `version` option.
                                                                                                                                                                                                                    */
                                                                                                                                                                                                                    _directives?: Directives;
                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                    * Control the logging level during parsing
                                                                                                                                                                                                                    *
                                                                                                                                                                                                                    * Default: `'warn'`
                                                                                                                                                                                                                    */
                                                                                                                                                                                                                    logLevel?: LogLevelId;
                                                                                                                                                                                                                    /**
                                                                                                                                                                                                                    * The YAML version used by documents without a `%YAML` directive.
                                                                                                                                                                                                                    *
                                                                                                                                                                                                                    * Default: `"1.2"`
                                                                                                                                                                                                                    */
                                                                                                                                                                                                                    version?: '1.1' | '1.2' | 'next';
                                                                                                                                                                                                                    };

                                                                                                                                                                                                                      type ErrorCode

                                                                                                                                                                                                                      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'
                                                                                                                                                                                                                      | 'BAD_COLLECTION_TYPE';

                                                                                                                                                                                                                        type Node

                                                                                                                                                                                                                        type Node<T = unknown> = Alias | Scalar<T> | YAMLMap<unknown, T> | YAMLSeq<T>;

                                                                                                                                                                                                                          type ParsedNode

                                                                                                                                                                                                                          type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;

                                                                                                                                                                                                                            type ParseOptions

                                                                                                                                                                                                                            type ParseOptions = {
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Whether integers should be parsed into BigInt rather than number values.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Default: `false`
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            intAsBigInt?: boolean;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Include a `srcToken` value on each parsed `Node`, containing the CST token
                                                                                                                                                                                                                            * that was composed into this node.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Default: `false`
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            keepSourceTokens?: boolean;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)`
                                                                                                                                                                                                                            * to provide the `{ line, col }` positions within the input.
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            lineCounter?: LineCounter;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Include line/col position & node type directly in parse errors.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Default: `true`
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            prettyErrors?: boolean;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * Detect and report errors that are required by the YAML 1.2 spec,
                                                                                                                                                                                                                            * but are caused by unambiguous content.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Default: `true`
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            strict?: boolean;
                                                                                                                                                                                                                            /**
                                                                                                                                                                                                                            * YAML requires map keys to be unique. By default, this is checked by
                                                                                                                                                                                                                            * comparing scalar values with `===`; deep equality is not checked for
                                                                                                                                                                                                                            * aliases or collections. If merge keys are enabled by the schema,
                                                                                                                                                                                                                            * multiple `<<` keys are allowed.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Set `false` to disable, or provide your own comparator function to
                                                                                                                                                                                                                            * customise. The comparator will be passed two `ParsedNode` values, and
                                                                                                                                                                                                                            * is expected to return a `boolean` indicating their equality.
                                                                                                                                                                                                                            *
                                                                                                                                                                                                                            * Default: `true`
                                                                                                                                                                                                                            */
                                                                                                                                                                                                                            uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean);
                                                                                                                                                                                                                            };

                                                                                                                                                                                                                              type Range

                                                                                                                                                                                                                              type Range = [number, number, number];

                                                                                                                                                                                                                                type SchemaOptions

                                                                                                                                                                                                                                type SchemaOptions = {
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * When parsing, warn about compatibility issues with the given schema.
                                                                                                                                                                                                                                * When stringifying, use scalar styles that are parsed correctly
                                                                                                                                                                                                                                * by the `compat` schema as well as the actual schema.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * Default: `null`
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                compat?: string | Tags | null;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * Array of additional tags to include in the schema, or a function that may
                                                                                                                                                                                                                                * modify the schema's base tag array.
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                customTags?: Tags | ((tags: Tags) => Tags) | null;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * Enable support for `<<` merge keys.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * Default: `false` for YAML 1.2, `true` for earlier versions
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                merge?: boolean;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * When using the `'core'` schema, support parsing values with these
                                                                                                                                                                                                                                * explicit YAML 1.1 tags:
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * `!!binary`, `!!omap`, `!!pairs`, `!!set`, `!!timestamp`.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * Default `true`
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                resolveKnownTags?: boolean;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * The base schema to use.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * The core library has built-in support for the following:
                                                                                                                                                                                                                                * - `'failsafe'`: A minimal schema that parses all scalars as strings
                                                                                                                                                                                                                                * - `'core'`: The YAML 1.2 core schema
                                                                                                                                                                                                                                * - `'json'`: The YAML 1.2 JSON schema, with minimal rules for JSON compatibility
                                                                                                                                                                                                                                * - `'yaml-1.1'`: The YAML 1.1 schema
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * If using another (custom) schema, the `customTags` array needs to
                                                                                                                                                                                                                                * fully define the schema's tags.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * Default: `'core'` for YAML 1.2, `'yaml-1.1'` for earlier versions
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                schema?: string | Schema;
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * When adding to or stringifying a map, sort the entries.
                                                                                                                                                                                                                                * If `true`, sort by comparing key values with `<`.
                                                                                                                                                                                                                                * Does not affect item order when parsing.
                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                * Default: `false`
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                * Override default values for `toString()` options.
                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                toStringDefaults?: ToStringOptions;
                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                  type TagId

                                                                                                                                                                                                                                  type TagId = keyof typeof tagsByName;

                                                                                                                                                                                                                                    type Tags

                                                                                                                                                                                                                                    type Tags = Array<ScalarTag | CollectionTag | TagId>;

                                                                                                                                                                                                                                      type ToJSOptions

                                                                                                                                                                                                                                      type ToJSOptions = {
                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                      * Use Map rather than Object to represent mappings.
                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                      * Default: `false`
                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                      mapAsMap?: boolean;
                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                      * Prevent exponential entity expansion attacks by limiting data aliasing count;
                                                                                                                                                                                                                                      * set to `-1` to disable checks; `0` disallows all alias nodes.
                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                      * Default: `100`
                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                      maxAliasCount?: number;
                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                      * If defined, called with the resolved `value` and reference `count` for
                                                                                                                                                                                                                                      * each anchor in the document.
                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                      onAnchor?: (value: unknown, count: number) => void;
                                                                                                                                                                                                                                      /**
                                                                                                                                                                                                                                      * Optional function that may filter or modify the output JS value
                                                                                                                                                                                                                                      *
                                                                                                                                                                                                                                      * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#using_the_reviver_parameter
                                                                                                                                                                                                                                      */
                                                                                                                                                                                                                                      reviver?: Reviver;
                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                        type ToStringOptions

                                                                                                                                                                                                                                        type ToStringOptions = {
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Use block quote styles for scalar values where applicable.
                                                                                                                                                                                                                                        * Set to `false` to disable block quotes completely.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `true`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        blockQuote?: boolean | 'folded' | 'literal';
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Enforce `'block'` or `'flow'` style on maps and sequences.
                                                                                                                                                                                                                                        * Empty collections will always be stringified as `{}` or `[]`.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'any'`, allowing each node to set its style separately
                                                                                                                                                                                                                                        * with its `flow: boolean` (default `false`) property.
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        collectionStyle?: 'any' | 'block' | 'flow';
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Comment stringifier.
                                                                                                                                                                                                                                        * Output should be valid for the current schema.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * By default, empty comment lines are left empty,
                                                                                                                                                                                                                                        * lines consisting of a single space are replaced by `#`,
                                                                                                                                                                                                                                        * and all other lines are prefixed with a `#`.
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        commentString?: (comment: string) => string;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * The default type of string literal used to stringify implicit key values.
                                                                                                                                                                                                                                        * Output may use other types if required to fully represent the value.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * If `null`, the value of `defaultStringType` is used.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `null`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        defaultKeyType?: Scalar.Type | null;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * The default type of string literal used to stringify values in general.
                                                                                                                                                                                                                                        * Output may use other types if required to fully represent the value.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'PLAIN'`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        defaultStringType?: Scalar.Type;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Include directives in the output.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * - If `true`, at least the document-start marker `---` is always included.
                                                                                                                                                                                                                                        * This does not force the `%YAML` directive to be included. To do that,
                                                                                                                                                                                                                                        * set `doc.directives.yaml.explicit = true`.
                                                                                                                                                                                                                                        * - If `false`, no directives or marker is ever included. If using the `%TAG`
                                                                                                                                                                                                                                        * directive, you are expected to include it manually in the stream before
                                                                                                                                                                                                                                        * its use.
                                                                                                                                                                                                                                        * - If `null`, directives and marker may be included if required.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `null`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        directives?: boolean | null;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Restrict double-quoted strings to use JSON-compatible syntax.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `false`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        doubleQuotedAsJSON?: boolean;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Minimum length for double-quoted strings to use multiple lines to
                                                                                                                                                                                                                                        * represent the value. Ignored if `doubleQuotedAsJSON` is set.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `40`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        doubleQuotedMinMultiLineLength?: number;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * String representation for `false`.
                                                                                                                                                                                                                                        * With the core schema, use `'false'`, `'False'`, or `'FALSE'`.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'false'`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        falseStr?: string;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * When true, a single space of padding will be added inside the delimiters
                                                                                                                                                                                                                                        * of non-empty single-line flow collections.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `true`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        flowCollectionPadding?: boolean;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * The number of spaces to use when indenting code.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `2`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        indent?: number;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Whether block sequences should be indented.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `true`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        indentSeq?: boolean;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Maximum line width (set to `0` to disable folding).
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * This is a soft limit, as only double-quoted semantics allow for inserting
                                                                                                                                                                                                                                        * a line break in the middle of a word, as well as being influenced by the
                                                                                                                                                                                                                                        * `minContentWidth` option.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `80`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        lineWidth?: number;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Minimum line width for highly-indented content (set to `0` to disable).
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `20`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        minContentWidth?: number;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * String representation for `null`.
                                                                                                                                                                                                                                        * With the core schema, use `'null'`, `'Null'`, `'NULL'`, `'~'`, or an empty
                                                                                                                                                                                                                                        * string `''`.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'null'`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        nullStr?: string;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Require keys to be scalars and to use implicit rather than explicit notation.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `false`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        simpleKeys?: boolean;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * Use 'single quote' rather than "double quote" where applicable.
                                                                                                                                                                                                                                        * Set to `false` to disable single quotes completely.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `null`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        singleQuote?: boolean | null;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * String representation for `true`.
                                                                                                                                                                                                                                        * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'true'`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        trueStr?: string;
                                                                                                                                                                                                                                        /**
                                                                                                                                                                                                                                        * The anchor used by an alias must be defined before the alias node. As it's
                                                                                                                                                                                                                                        * possible for the document to be modified manually, the order may be
                                                                                                                                                                                                                                        * verified during stringification.
                                                                                                                                                                                                                                        *
                                                                                                                                                                                                                                        * Default: `'true'`
                                                                                                                                                                                                                                        */
                                                                                                                                                                                                                                        verifyAliasOrder?: boolean;
                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                          type visitor

                                                                                                                                                                                                                                          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 visitorFn

                                                                                                                                                                                                                                            type visitorFn<T> = (
                                                                                                                                                                                                                                            key: number | 'key' | 'value' | null,
                                                                                                                                                                                                                                            node: T,
                                                                                                                                                                                                                                            path: readonly (Document | Node | Pair)[]
                                                                                                                                                                                                                                            ) => void | symbol | number | Node | Pair;

                                                                                                                                                                                                                                              Namespaces

                                                                                                                                                                                                                                              namespace Alias

                                                                                                                                                                                                                                              namespace Alias {}

                                                                                                                                                                                                                                                interface Parsed

                                                                                                                                                                                                                                                interface Parsed extends Alias {}

                                                                                                                                                                                                                                                  property range

                                                                                                                                                                                                                                                  range: Range;

                                                                                                                                                                                                                                                    property srcToken

                                                                                                                                                                                                                                                    srcToken?: FlowScalar & {
                                                                                                                                                                                                                                                    type: 'alias';
                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                      namespace CST

                                                                                                                                                                                                                                                      module 'dist/parse/cst.d.ts' {}
                                                                                                                                                                                                                                                      • The byte order mark

                                                                                                                                                                                                                                                      variable BOM

                                                                                                                                                                                                                                                      const BOM: string;
                                                                                                                                                                                                                                                      • The byte order mark

                                                                                                                                                                                                                                                      variable DOCUMENT

                                                                                                                                                                                                                                                      const DOCUMENT: string;
                                                                                                                                                                                                                                                      • Start of doc-mode

                                                                                                                                                                                                                                                      variable FLOW_END

                                                                                                                                                                                                                                                      const FLOW_END: string;
                                                                                                                                                                                                                                                      • Unexpected end of flow-mode

                                                                                                                                                                                                                                                      variable SCALAR

                                                                                                                                                                                                                                                      const SCALAR: string;
                                                                                                                                                                                                                                                      • Next token is a scalar value

                                                                                                                                                                                                                                                      function createScalarToken

                                                                                                                                                                                                                                                      createScalarToken: (
                                                                                                                                                                                                                                                      value: string,
                                                                                                                                                                                                                                                      context: {
                                                                                                                                                                                                                                                      end?: SourceToken[];
                                                                                                                                                                                                                                                      implicitKey?: boolean;
                                                                                                                                                                                                                                                      indent: number;
                                                                                                                                                                                                                                                      inFlow?: boolean;
                                                                                                                                                                                                                                                      offset?: number;
                                                                                                                                                                                                                                                      type?: Scalar.Type;
                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                      ) => BlockScalar | FlowScalar;
                                                                                                                                                                                                                                                      • Create a new scalar token with value

                                                                                                                                                                                                                                                        Values that represent an actual string but may be parsed as a different type should use a type other than 'PLAIN', as this function does not support any schema operations and won't check for such conflicts.

                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                        The string representation of the value, which will have its content properly indented.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.implicitKey Being within an implicit key may affect the resolved type of the token's value.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.indent The indent level of the token.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.offset The offset position of the token.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.type The preferred type of the scalar token. If undefined, the previous type of the token will be used, defaulting to 'PLAIN'.

                                                                                                                                                                                                                                                      function isCollection

                                                                                                                                                                                                                                                      isCollection: (
                                                                                                                                                                                                                                                      token: Token | null | undefined
                                                                                                                                                                                                                                                      ) => token is BlockMap | BlockSequence | FlowCollection;
                                                                                                                                                                                                                                                      • Returns

                                                                                                                                                                                                                                                        true if token is a flow or block collection

                                                                                                                                                                                                                                                      function isScalar

                                                                                                                                                                                                                                                      isScalar: (token: Token | null | undefined) => token is FlowScalar | BlockScalar;
                                                                                                                                                                                                                                                      • Returns

                                                                                                                                                                                                                                                        true if token is a flow or block scalar; not an alias

                                                                                                                                                                                                                                                      function prettyToken

                                                                                                                                                                                                                                                      prettyToken: (token: string) => string;
                                                                                                                                                                                                                                                      • Get a printable representation of a lexer token

                                                                                                                                                                                                                                                      function resolveAsScalar

                                                                                                                                                                                                                                                      resolveAsScalar: {
                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                      token: FlowScalar | BlockScalar,
                                                                                                                                                                                                                                                      strict?: boolean,
                                                                                                                                                                                                                                                      onError?: (offset: number, code: ErrorCode, message: string) => void
                                                                                                                                                                                                                                                      ): { value: string; type: Scalar.Type | null; comment: string; range: Range };
                                                                                                                                                                                                                                                      (
                                                                                                                                                                                                                                                      token: Token,
                                                                                                                                                                                                                                                      strict?: boolean,
                                                                                                                                                                                                                                                      onError?: (offset: number, code: ErrorCode, message: string) => void
                                                                                                                                                                                                                                                      ): { value: string; type: Scalar.Type; comment: string; range: Range };
                                                                                                                                                                                                                                                      };
                                                                                                                                                                                                                                                      • If token is a CST flow or block scalar, determine its string value and a few other attributes. Otherwise, return null.

                                                                                                                                                                                                                                                      function setScalarValue

                                                                                                                                                                                                                                                      setScalarValue: (
                                                                                                                                                                                                                                                      token: Token,
                                                                                                                                                                                                                                                      value: string,
                                                                                                                                                                                                                                                      context?: {
                                                                                                                                                                                                                                                      afterKey?: boolean;
                                                                                                                                                                                                                                                      implicitKey?: boolean;
                                                                                                                                                                                                                                                      inFlow?: boolean;
                                                                                                                                                                                                                                                      type?: Scalar.Type;
                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                      ) => void;
                                                                                                                                                                                                                                                      • Set the value of token to the given string value, overwriting any previous contents and type that it may have.

                                                                                                                                                                                                                                                        Best efforts are made to retain any comments previously associated with the token, though all contents within a collection's items will be overwritten.

                                                                                                                                                                                                                                                        Values that represent an actual string but may be parsed as a different type should use a type other than 'PLAIN', as this function does not support any schema operations and won't check for such conflicts.

                                                                                                                                                                                                                                                        Parameter token

                                                                                                                                                                                                                                                        Any token. If it does not include an indent value, the value will be stringified as if it were an implicit key.

                                                                                                                                                                                                                                                        Parameter value

                                                                                                                                                                                                                                                        The string representation of the value, which will have its content properly indented.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.afterKey In most cases, values after a key should have an additional level of indentation.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.implicitKey Being within an implicit key may affect the resolved type of the token's value.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.inFlow Being within a flow collection may affect the resolved type of the token's value.

                                                                                                                                                                                                                                                        Parameter

                                                                                                                                                                                                                                                        context.type The preferred type of the scalar token. If undefined, the previous type of the token will be used, defaulting to 'PLAIN'.

                                                                                                                                                                                                                                                      function stringify

                                                                                                                                                                                                                                                      stringify: (cst: Token | CollectionItem) => string;
                                                                                                                                                                                                                                                      • Stringify a CST document, token, or collection item

                                                                                                                                                                                                                                                        Fair warning: This applies no validation whatsoever, and simply concatenates the sources in their logical order.

                                                                                                                                                                                                                                                      function tokenType

                                                                                                                                                                                                                                                      tokenType: (source: string) => TokenType | null;
                                                                                                                                                                                                                                                      • Identify the type of a lexer token. May return null for unknown tokens.

                                                                                                                                                                                                                                                      function visit

                                                                                                                                                                                                                                                      visit: typeof visit;
                                                                                                                                                                                                                                                      • Apply a visitor to a CST document or item.

                                                                                                                                                                                                                                                        Walks through the tree (depth-first) starting from the root, calling a visitor function with two arguments when entering each item: - item: The current item, which included the following members: - start: SourceToken[] – Source tokens before the key or value, possibly including its anchor or tag. - key?: Token | null – Set for pair values. May then be null, if the key before the : separator is empty. - sep?: SourceToken[] – Source tokens between the key and the value, which should include the : map value indicator if value is set. - value?: Token – The value of a sequence item, or of a map pair. - path: The steps from the root to the current node, as an array of ['key' | 'value', number] tuples.

                                                                                                                                                                                                                                                        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 token, continue with next sibling - visit.BREAK: Terminate traversal completely - visit.REMOVE: Remove the current item, then continue with the next one - number: Set the index of the next step. This is useful especially if the index of the current token has changed. - function: Define the next visitor for this item. After the original visitor is called on item entry, next visitors are called after handling a non-empty key and when exiting the item.

                                                                                                                                                                                                                                                      interface BlockMap

                                                                                                                                                                                                                                                      interface BlockMap {}

                                                                                                                                                                                                                                                        property indent

                                                                                                                                                                                                                                                        indent: number;

                                                                                                                                                                                                                                                          property items

                                                                                                                                                                                                                                                          items: Array<
                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                          start: SourceToken[];
                                                                                                                                                                                                                                                          explicitKey?: true;
                                                                                                                                                                                                                                                          key?: never;
                                                                                                                                                                                                                                                          sep?: never;
                                                                                                                                                                                                                                                          value?: never;
                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                          | {
                                                                                                                                                                                                                                                          start: SourceToken[];
                                                                                                                                                                                                                                                          explicitKey?: true;
                                                                                                                                                                                                                                                          key: Token | null;
                                                                                                                                                                                                                                                          sep: SourceToken[];
                                                                                                                                                                                                                                                          value?: Token;
                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                            property offset

                                                                                                                                                                                                                                                            offset: number;

                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                              type: 'block-map';

                                                                                                                                                                                                                                                                interface BlockScalar

                                                                                                                                                                                                                                                                interface BlockScalar {}

                                                                                                                                                                                                                                                                  property indent

                                                                                                                                                                                                                                                                  indent: number;

                                                                                                                                                                                                                                                                    property offset

                                                                                                                                                                                                                                                                    offset: number;

                                                                                                                                                                                                                                                                      property props

                                                                                                                                                                                                                                                                      props: Token[];

                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                        source: string;

                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                          type: 'block-scalar';

                                                                                                                                                                                                                                                                            interface BlockSequence

                                                                                                                                                                                                                                                                            interface BlockSequence {}

                                                                                                                                                                                                                                                                              property indent

                                                                                                                                                                                                                                                                              indent: number;

                                                                                                                                                                                                                                                                                property items

                                                                                                                                                                                                                                                                                items: Array<{
                                                                                                                                                                                                                                                                                start: SourceToken[];
                                                                                                                                                                                                                                                                                key?: never;
                                                                                                                                                                                                                                                                                sep?: never;
                                                                                                                                                                                                                                                                                value?: Token;
                                                                                                                                                                                                                                                                                }>;

                                                                                                                                                                                                                                                                                  property offset

                                                                                                                                                                                                                                                                                  offset: number;

                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                    type: 'block-seq';

                                                                                                                                                                                                                                                                                      interface Directive

                                                                                                                                                                                                                                                                                      interface Directive {}

                                                                                                                                                                                                                                                                                        property offset

                                                                                                                                                                                                                                                                                        offset: number;

                                                                                                                                                                                                                                                                                          property source

                                                                                                                                                                                                                                                                                          source: string;

                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                            type: 'directive';

                                                                                                                                                                                                                                                                                              interface Document

                                                                                                                                                                                                                                                                                              interface Document {}

                                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                                end?: SourceToken[];

                                                                                                                                                                                                                                                                                                  property offset

                                                                                                                                                                                                                                                                                                  offset: number;

                                                                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                                                                    start: SourceToken[];

                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                      type: 'document';

                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                        value?: Token;

                                                                                                                                                                                                                                                                                                          interface DocumentEnd

                                                                                                                                                                                                                                                                                                          interface DocumentEnd {}

                                                                                                                                                                                                                                                                                                            property end

                                                                                                                                                                                                                                                                                                            end?: SourceToken[];

                                                                                                                                                                                                                                                                                                              property offset

                                                                                                                                                                                                                                                                                                              offset: number;

                                                                                                                                                                                                                                                                                                                property source

                                                                                                                                                                                                                                                                                                                source: string;

                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                  type: 'doc-end';

                                                                                                                                                                                                                                                                                                                    interface ErrorToken

                                                                                                                                                                                                                                                                                                                    interface ErrorToken {}

                                                                                                                                                                                                                                                                                                                      property message

                                                                                                                                                                                                                                                                                                                      message: string;

                                                                                                                                                                                                                                                                                                                        property offset

                                                                                                                                                                                                                                                                                                                        offset: number;

                                                                                                                                                                                                                                                                                                                          property source

                                                                                                                                                                                                                                                                                                                          source: string;

                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                            type: 'error';

                                                                                                                                                                                                                                                                                                                              interface FlowCollection

                                                                                                                                                                                                                                                                                                                              interface FlowCollection {}

                                                                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                                                                end: SourceToken[];

                                                                                                                                                                                                                                                                                                                                  property indent

                                                                                                                                                                                                                                                                                                                                  indent: number;

                                                                                                                                                                                                                                                                                                                                    property items

                                                                                                                                                                                                                                                                                                                                    items: CollectionItem[];

                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                      offset: number;

                                                                                                                                                                                                                                                                                                                                        property start

                                                                                                                                                                                                                                                                                                                                        start: SourceToken;

                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                          type: 'flow-collection';

                                                                                                                                                                                                                                                                                                                                            interface FlowScalar

                                                                                                                                                                                                                                                                                                                                            interface FlowScalar {}

                                                                                                                                                                                                                                                                                                                                              property end

                                                                                                                                                                                                                                                                                                                                              end?: SourceToken[];

                                                                                                                                                                                                                                                                                                                                                property indent

                                                                                                                                                                                                                                                                                                                                                indent: number;

                                                                                                                                                                                                                                                                                                                                                  property offset

                                                                                                                                                                                                                                                                                                                                                  offset: number;

                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                      type: 'alias' | 'scalar' | 'single-quoted-scalar' | 'double-quoted-scalar';

                                                                                                                                                                                                                                                                                                                                                        interface SourceToken

                                                                                                                                                                                                                                                                                                                                                        interface SourceToken {}

                                                                                                                                                                                                                                                                                                                                                          property indent

                                                                                                                                                                                                                                                                                                                                                          indent: number;

                                                                                                                                                                                                                                                                                                                                                            property offset

                                                                                                                                                                                                                                                                                                                                                            offset: number;

                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                              source: string;

                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                type:
                                                                                                                                                                                                                                                                                                                                                                | 'byte-order-mark'
                                                                                                                                                                                                                                                                                                                                                                | 'doc-mode'
                                                                                                                                                                                                                                                                                                                                                                | 'doc-start'
                                                                                                                                                                                                                                                                                                                                                                | 'space'
                                                                                                                                                                                                                                                                                                                                                                | 'comment'
                                                                                                                                                                                                                                                                                                                                                                | 'newline'
                                                                                                                                                                                                                                                                                                                                                                | 'directive-line'
                                                                                                                                                                                                                                                                                                                                                                | 'anchor'
                                                                                                                                                                                                                                                                                                                                                                | 'tag'
                                                                                                                                                                                                                                                                                                                                                                | 'seq-item-ind'
                                                                                                                                                                                                                                                                                                                                                                | 'explicit-key-ind'
                                                                                                                                                                                                                                                                                                                                                                | 'map-value-ind'
                                                                                                                                                                                                                                                                                                                                                                | 'flow-map-start'
                                                                                                                                                                                                                                                                                                                                                                | 'flow-map-end'
                                                                                                                                                                                                                                                                                                                                                                | 'flow-seq-start'
                                                                                                                                                                                                                                                                                                                                                                | 'flow-seq-end'
                                                                                                                                                                                                                                                                                                                                                                | 'flow-error-end'
                                                                                                                                                                                                                                                                                                                                                                | 'comma'
                                                                                                                                                                                                                                                                                                                                                                | 'block-scalar-header';

                                                                                                                                                                                                                                                                                                                                                                  type CollectionItem

                                                                                                                                                                                                                                                                                                                                                                  type CollectionItem = {
                                                                                                                                                                                                                                                                                                                                                                  start: SourceToken[];
                                                                                                                                                                                                                                                                                                                                                                  key?: Token | null;
                                                                                                                                                                                                                                                                                                                                                                  sep?: SourceToken[];
                                                                                                                                                                                                                                                                                                                                                                  value?: Token;
                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                    type Token

                                                                                                                                                                                                                                                                                                                                                                    type Token =
                                                                                                                                                                                                                                                                                                                                                                    | SourceToken
                                                                                                                                                                                                                                                                                                                                                                    | ErrorToken
                                                                                                                                                                                                                                                                                                                                                                    | Directive
                                                                                                                                                                                                                                                                                                                                                                    | Document
                                                                                                                                                                                                                                                                                                                                                                    | DocumentEnd
                                                                                                                                                                                                                                                                                                                                                                    | FlowScalar
                                                                                                                                                                                                                                                                                                                                                                    | BlockScalar
                                                                                                                                                                                                                                                                                                                                                                    | BlockMap
                                                                                                                                                                                                                                                                                                                                                                    | BlockSequence
                                                                                                                                                                                                                                                                                                                                                                    | FlowCollection;

                                                                                                                                                                                                                                                                                                                                                                      type TokenType

                                                                                                                                                                                                                                                                                                                                                                      type TokenType = SourceToken['type'] | DocumentEnd['type'] | FlowScalar['type'];

                                                                                                                                                                                                                                                                                                                                                                        type Visitor

                                                                                                                                                                                                                                                                                                                                                                        type Visitor = (
                                                                                                                                                                                                                                                                                                                                                                        item: CollectionItem,
                                                                                                                                                                                                                                                                                                                                                                        path: VisitPath
                                                                                                                                                                                                                                                                                                                                                                        ) => number | symbol | Visitor | void;

                                                                                                                                                                                                                                                                                                                                                                          type VisitPath

                                                                                                                                                                                                                                                                                                                                                                          type VisitPath = readonly ['key' | 'value', number][];

                                                                                                                                                                                                                                                                                                                                                                            namespace CST.visit

                                                                                                                                                                                                                                                                                                                                                                            namespace CST.visit {}

                                                                                                                                                                                                                                                                                                                                                                              variable BREAK

                                                                                                                                                                                                                                                                                                                                                                              var BREAK: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                variable REMOVE

                                                                                                                                                                                                                                                                                                                                                                                var REMOVE: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                  variable SKIP

                                                                                                                                                                                                                                                                                                                                                                                  var SKIP: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                    function itemAtPath

                                                                                                                                                                                                                                                                                                                                                                                    itemAtPath: (
                                                                                                                                                                                                                                                                                                                                                                                    cst: Document | CollectionItem,
                                                                                                                                                                                                                                                                                                                                                                                    path: VisitPath
                                                                                                                                                                                                                                                                                                                                                                                    ) => CollectionItem | undefined;

                                                                                                                                                                                                                                                                                                                                                                                      function parentCollection

                                                                                                                                                                                                                                                                                                                                                                                      parentCollection: (
                                                                                                                                                                                                                                                                                                                                                                                      cst: Document | CollectionItem,
                                                                                                                                                                                                                                                                                                                                                                                      path: VisitPath
                                                                                                                                                                                                                                                                                                                                                                                      ) =>
                                                                                                                                                                                                                                                                                                                                                                                      | import('./cst.js').BlockMap
                                                                                                                                                                                                                                                                                                                                                                                      | import('./cst.js').BlockSequence
                                                                                                                                                                                                                                                                                                                                                                                      | import('./cst.js').FlowCollection;

                                                                                                                                                                                                                                                                                                                                                                                        namespace Document

                                                                                                                                                                                                                                                                                                                                                                                        namespace Document {}

                                                                                                                                                                                                                                                                                                                                                                                          interface Parsed

                                                                                                                                                                                                                                                                                                                                                                                          interface Parsed<
                                                                                                                                                                                                                                                                                                                                                                                          Contents extends ParsedNode = ParsedNode,
                                                                                                                                                                                                                                                                                                                                                                                          Strict extends boolean = true
                                                                                                                                                                                                                                                                                                                                                                                          > extends Document<Contents, Strict> {}
                                                                                                                                                                                                                                                                                                                                                                                          • @ts-ignore The typing of directives fails in TS <= 4.2

                                                                                                                                                                                                                                                                                                                                                                                          property directives

                                                                                                                                                                                                                                                                                                                                                                                          directives: Directives;

                                                                                                                                                                                                                                                                                                                                                                                            property range

                                                                                                                                                                                                                                                                                                                                                                                            range: Range;

                                                                                                                                                                                                                                                                                                                                                                                              namespace Scalar

                                                                                                                                                                                                                                                                                                                                                                                              namespace Scalar {}

                                                                                                                                                                                                                                                                                                                                                                                                interface Parsed

                                                                                                                                                                                                                                                                                                                                                                                                interface Parsed extends Scalar {}

                                                                                                                                                                                                                                                                                                                                                                                                  property range

                                                                                                                                                                                                                                                                                                                                                                                                  range: Range;

                                                                                                                                                                                                                                                                                                                                                                                                    property source

                                                                                                                                                                                                                                                                                                                                                                                                    source: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property srcToken

                                                                                                                                                                                                                                                                                                                                                                                                      srcToken?: FlowScalar | BlockScalar;

                                                                                                                                                                                                                                                                                                                                                                                                        type BLOCK_FOLDED

                                                                                                                                                                                                                                                                                                                                                                                                        type BLOCK_FOLDED = 'BLOCK_FOLDED';

                                                                                                                                                                                                                                                                                                                                                                                                          type BLOCK_LITERAL

                                                                                                                                                                                                                                                                                                                                                                                                          type BLOCK_LITERAL = 'BLOCK_LITERAL';

                                                                                                                                                                                                                                                                                                                                                                                                            type PLAIN

                                                                                                                                                                                                                                                                                                                                                                                                            type PLAIN = 'PLAIN';

                                                                                                                                                                                                                                                                                                                                                                                                              type QUOTE_DOUBLE

                                                                                                                                                                                                                                                                                                                                                                                                              type QUOTE_DOUBLE = 'QUOTE_DOUBLE';

                                                                                                                                                                                                                                                                                                                                                                                                                type QUOTE_SINGLE

                                                                                                                                                                                                                                                                                                                                                                                                                type QUOTE_SINGLE = 'QUOTE_SINGLE';

                                                                                                                                                                                                                                                                                                                                                                                                                  type Type

                                                                                                                                                                                                                                                                                                                                                                                                                  type Type = BLOCK_FOLDED | BLOCK_LITERAL | PLAIN | QUOTE_DOUBLE | QUOTE_SINGLE;

                                                                                                                                                                                                                                                                                                                                                                                                                    namespace visit

                                                                                                                                                                                                                                                                                                                                                                                                                    namespace visit {}

                                                                                                                                                                                                                                                                                                                                                                                                                      variable BREAK

                                                                                                                                                                                                                                                                                                                                                                                                                      var BREAK: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                        variable REMOVE

                                                                                                                                                                                                                                                                                                                                                                                                                        var REMOVE: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                          variable SKIP

                                                                                                                                                                                                                                                                                                                                                                                                                          var SKIP: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                            namespace visitAsync

                                                                                                                                                                                                                                                                                                                                                                                                                            namespace visitAsync {}

                                                                                                                                                                                                                                                                                                                                                                                                                              variable BREAK

                                                                                                                                                                                                                                                                                                                                                                                                                              var BREAK: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                variable REMOVE

                                                                                                                                                                                                                                                                                                                                                                                                                                var REMOVE: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                  variable SKIP

                                                                                                                                                                                                                                                                                                                                                                                                                                  var SKIP: Symbol;

                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace YAMLMap

                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace YAMLMap {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Parsed

                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Parsed<
                                                                                                                                                                                                                                                                                                                                                                                                                                      K extends ParsedNode = ParsedNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                      V extends ParsedNode | null = ParsedNode | null
                                                                                                                                                                                                                                                                                                                                                                                                                                      > extends YAMLMap<K, V> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                        property items

                                                                                                                                                                                                                                                                                                                                                                                                                                        items: Pair<K, V>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          property range

                                                                                                                                                                                                                                                                                                                                                                                                                                          range: Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property srcToken

                                                                                                                                                                                                                                                                                                                                                                                                                                            srcToken?: BlockMap | FlowCollection;

                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace YAMLSeq

                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace YAMLSeq {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Parsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Parsed<
                                                                                                                                                                                                                                                                                                                                                                                                                                                T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                > extends YAMLSeq<T> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property items

                                                                                                                                                                                                                                                                                                                                                                                                                                                  items: T[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                    range: Range;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property srcToken

                                                                                                                                                                                                                                                                                                                                                                                                                                                      srcToken?: BlockSequence | FlowCollection;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (26)

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                        No dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (23)

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                        No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

                                                                                                                                                                                                                                                                                                                                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/yaml.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/yaml)
                                                                                                                                                                                                                                                                                                                                                                                                                                                        • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                          <a href="https://www.jsdocs.io/package/yaml"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>