yaml 2.8.2 → 3.0.0-0

package/dist/stringifyString-S_ITVLTO.d.ts

@@ -0,0 +1,1306 @@
+//#region src/parse/line-counter.d.ts
+/**
+* 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.
+*/
+declare class LineCounter {
+  lineStarts: number[];
+  /**
+  * Should be called in ascending order. Otherwise, call
+  * `lineCounter.lineStarts.sort()` before calling `linePos()`.
+  */
+  addNewLine: (offset: number) => 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.
+  */
+  linePos: (offset: number) => {
+    line: number;
+    col: number;
+  };
+}
+//#endregion
+//#region src/errors.d.ts
+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" | "NON_STRING_KEY" | "TAB_AS_INDENT" | "TAG_RESOLVE_FAILED" | "UNEXPECTED_TOKEN" | "BAD_COLLECTION_TYPE";
+type LinePos = {
+  line: number;
+  col: number;
+};
+declare class YAMLError extends Error {
+  name: "YAMLParseError" | "YAMLWarning";
+  code: ErrorCode;
+  message: string;
+  pos: [number, number];
+  linePos?: [LinePos] | [LinePos, LinePos];
+  constructor(name: YAMLError["name"], pos: [number, number], code: ErrorCode, message: string);
+}
+declare class YAMLParseError extends YAMLError {
+  constructor(pos: [number, number], code: ErrorCode, message: string);
+}
+declare class YAMLWarning extends YAMLError {
+  constructor(pos: [number, number], code: ErrorCode, message: string);
+}
+//#endregion
+//#region src/doc/applyReviver.d.ts
+type Reviver = (key: unknown, value: unknown) => unknown;
+//#endregion
+//#region src/log.d.ts
+type LogLevelId = "silent" | "error" | "warn" | "debug";
+declare function debug(logLevel: LogLevelId, ...messages: any[]): void;
+declare function warn(logLevel: LogLevelId, warning: string | Error): void;
+//#endregion
+//#region src/doc/NodeCreator.d.ts
+declare class NodeCreator {
+  #private;
+  keepUndefined: boolean;
+  replacer?: Replacer;
+  schema: Schema;
+  constructor(doc: Document<DocValue, boolean>, options?: CreateNodeOptions, replacer?: Replacer);
+  constructor(schema: Schema, options: CreateNodeOptions & {
+    aliasDuplicateObjects: false;
+  });
+  create(value: unknown, tagName?: string): Node;
+  createPair(key: unknown, value: unknown): Pair<NodeBase, NodeBase | null>;
+  /**
+  * With circular references, the source node is only resolved after all
+  * of its child nodes are. This is why anchors are set only after all of
+  * the nodes have been created.
+  */
+  setAnchors(): void;
+}
+//#endregion
+//#region src/nodes/toJS.d.ts
+interface AnchorData {
+  aliasCount: number;
+  count: number;
+  res: unknown;
+}
+interface ToJSContext {
+  anchors: Map<Node, AnchorData>;
+  /** Cached anchor and alias nodes in the order they occur in the document */
+  aliasResolveCache?: Node[];
+  doc: Document<DocValue, boolean>;
+  keep: boolean;
+  mapAsMap: boolean;
+  mapKeyWarned: boolean;
+  maxAliasCount: number;
+  onCreate?: (res: unknown) => void;
+}
+/**
+* Recursively convert any node or its contents to native JavaScript
+*
+* @param value - The input value
+* @param arg - If `value` defines a `toJSON()` method, use this
+*   as its first argument
+* @param ctx - Conversion context, originally set in Document#toJS(). If
+*   `{ keep: true }` is not set, output should be suitable for JSON
+*   stringification.
+*/
+declare function toJS(value: any, arg: string | null, ctx?: ToJSContext): any;
+//#endregion
+//#region src/nodes/Scalar.d.ts
+declare namespace Scalar {
+  type BLOCK_FOLDED = "BLOCK_FOLDED";
+  type BLOCK_LITERAL = "BLOCK_LITERAL";
+  type PLAIN = "PLAIN";
+  type QUOTE_DOUBLE = "QUOTE_DOUBLE";
+  type QUOTE_SINGLE = "QUOTE_SINGLE";
+  type Type = BLOCK_FOLDED | BLOCK_LITERAL | PLAIN | QUOTE_DOUBLE | QUOTE_SINGLE;
+}
+declare class Scalar<T = unknown> extends NodeBase {
+  static readonly BLOCK_FOLDED = "BLOCK_FOLDED";
+  static readonly BLOCK_LITERAL = "BLOCK_LITERAL";
+  static readonly PLAIN = "PLAIN";
+  static readonly QUOTE_DOUBLE = "QUOTE_DOUBLE";
+  static readonly QUOTE_SINGLE = "QUOTE_SINGLE";
+  value: T;
+  /** An optional anchor on this node. Used by alias nodes. */
+  anchor?: 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'
+  */
+  format?: string;
+  /** If `value` is a number, use this value when stringifying this node. */
+  minFractionDigits?: number;
+  /** Set during parsing to the source string value */
+  source?: string;
+  srcToken?: FlowScalar | BlockScalar;
+  /** The scalar style used for the node's string representation */
+  type?: Scalar.Type;
+  constructor(value: T);
+  toJSON(arg?: any, ctx?: ToJSContext): any;
+  toString(): string;
+}
+//#endregion
+//#region src/stringify/stringify.d.ts
+type StringifyContext = {
+  actualString?: boolean;
+  anchors: Set<string>;
+  doc: Document;
+  forceBlockIndent?: boolean;
+  implicitKey?: boolean;
+  indent: string;
+  indentStep: string;
+  indentAtStart?: number;
+  inFlow: boolean | null;
+  inStringifyKey?: boolean;
+  flowCollectionPadding: string;
+  noValues?: boolean;
+  options: Readonly<Required<Omit<ToStringOptions, "collectionStyle" | "indent">>>;
+  resolvedAliases?: Set<Alias>;
+};
+//#endregion
+//#region src/nodes/Collection.d.ts
+type Primitive = boolean | number | bigint | string | null;
+type NodeOf<T> = T extends Primitive ? Scalar<T> : T;
+declare abstract class Collection extends NodeBase {
+  schema: Schema | undefined;
+  items: (NodeBase | Pair)[];
+  /** An optional anchor on this node. Used by alias nodes. */
+  anchor?: string;
+  /**
+  * If true, stringify this and all child nodes using flow rather than
+  * block styles.
+  */
+  flow?: boolean;
+  constructor(schema?: Schema);
+  /**
+  * Create a copy of this collection.
+  *
+  * @param schema - If defined, overwrites the original's schema
+  */
+  clone(schema?: Schema): Collection;
+  /** Adds a value to the collection. */
+  abstract add(value: unknown): void;
+  /**
+  * Removes a value from the collection.
+  * @returns `true` if the item was found and removed.
+  */
+  abstract delete(key: unknown): boolean;
+  /**
+  * Returns item at `key`, or `undefined` if not found.
+  */
+  abstract get(key: unknown): NodeBase | Pair | undefined;
+  /**
+  * Checks if the collection includes a value with the key `key`.
+  */
+  abstract has(key: unknown): boolean;
+  /**
+  * Sets a value in this collection.
+  */
+  abstract set(key: unknown, value: unknown): void;
+  /**
+  * Adds a value to the collection.
+  *
+  * For `!!map` and `!!omap` the value must be a Pair instance.
+  */
+  addIn(path: unknown[], value: unknown): void;
+  /**
+  * Removes a value from the collection.
+  *
+  * @returns `true` if the item was found and removed.
+  */
+  deleteIn(path: unknown[]): boolean;
+  /**
+  * Returns item at `key`, or `undefined` if not found.
+  */
+  getIn(path: unknown[]): NodeBase | Pair | undefined;
+  /**
+  * Checks if the collection includes a value with the key `key`.
+  */
+  hasIn(path: unknown[]): boolean;
+  /**
+  * Sets a value in this collection.
+  */
+  setIn(path: unknown[], value: unknown): void;
+}
+//#endregion
+//#region src/nodes/YAMLMap.d.ts
+type MapLike = Map<any, any> | Set<any> | Record<string | number | symbol, any>;
+declare function findPair<K extends Primitive | NodeBase = Primitive | NodeBase, V extends Primitive | NodeBase = Primitive | NodeBase>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
+declare class YAMLMap<K extends Primitive | NodeBase = Primitive | NodeBase, V extends Primitive | NodeBase = Primitive | NodeBase> extends Collection {
+  static get tagName(): "tag:yaml.org,2002:map";
+  items: Pair<K, V>[];
+  srcToken?: BlockMap | FlowCollection;
+  /**
+  * A generic collection parsing method that can be extended
+  * to other node classes that inherit from YAMLMap
+  */
+  static from(nc: NodeCreator, obj: unknown): YAMLMap<any, any>;
+  /**
+  * Adds a key-value pair to the map.
+  *
+  * Using a key that is already in the collection overwrites the previous value.
+  */
+  add(pair: Pair<K, V>): void;
+  delete(key: unknown): boolean;
+  get(key: unknown): NodeOf<V> | undefined;
+  has(key: unknown): boolean;
+  set(key: unknown, value: unknown, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
+  /**
+  * @param ctx - Conversion context, originally set in Document#toJS()
+  * @param {Class} Type - If set, forces the returned collection type
+  * @returns Instance of Type, Map, or Object
+  */
+  toJSON<T extends MapLike = Map<any, any>>(_: unknown, ctx: ToJSContext | undefined, Type: {
+    new (): T;
+  }): T;
+  toJSON(_?: unknown, ctx?: ToJSContext): any;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/nodes/YAMLSeq.d.ts
+declare class YAMLSeq<T extends Primitive | NodeBase | Pair = Primitive | NodeBase | Pair> extends Collection {
+  static get tagName(): "tag:yaml.org,2002:seq";
+  items: NodeOf<T>[];
+  srcToken?: BlockSequence | FlowCollection;
+  add(value: T, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
+  /**
+  * Removes a value from the collection.
+  *
+  * Throws if `idx` is not a non-negative integer.
+  *
+  * @returns `true` if the item was found and removed.
+  */
+  delete(idx: number): boolean;
+  /**
+  * Returns item at `key`, or `undefined` if not found.
+  *
+  * Throws if `idx` is not a non-negative integer.
+  */
+  get(idx: number): NodeOf<T> | undefined;
+  /**
+  * Checks if the collection includes a value with the key `key`.
+  *
+  * Throws if `idx` is not a non-negative integer.
+  */
+  has(idx: number): boolean;
+  /**
+  * Sets a value in this collection. For `!!set`, `value` needs to be a
+  * boolean to add/remove the item from the set.
+  *
+  * Throws if `idx` is not a non-negative integer.
+  */
+  set(idx: number, value: T, options?: Omit<CreateNodeOptions, "aliasDuplicateObjects">): void;
+  toJSON(_?: unknown, ctx?: ToJSContext): unknown[];
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+  static from(nc: NodeCreator, obj: unknown): YAMLSeq;
+}
+//#endregion
+//#region src/schema/types.d.ts
+interface TagBase {
+  /**
+  * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
+  */
+  createNode?: (nc: NodeCreator, value: unknown) => Node;
+  /**
+  * If `true`, allows for values to be stringified without
+  * an explicit tag together with `test`.
+  * If `'key'`, this only applies if the value is used as a mapping key.
+  * For most cases, it's unlikely that you'll actually want to use this,
+  * even if you first think you do.
+  */
+  default?: boolean | "key";
+  /**
+  * If a tag has multiple forms that should be parsed and/or stringified
+  * differently, use `format` to identify them.
+  */
+  format?: string;
+  /**
+  * Used by `YAML.createNode` to detect your data type, e.g. using `typeof` or
+  * `instanceof`.
+  */
+  identify?: (value: unknown) => boolean;
+  /**
+  * The identifier for your data type, with which its stringified form will be
+  * prefixed. Should either be a !-prefixed local `!tag`, or a fully qualified
+  * `tag:domain,date:foo`.
+  */
+  tag: string;
+}
+interface ScalarTag extends TagBase {
+  collection?: never;
+  nodeClass?: never;
+  /**
+  * Turns a value into an AST node.
+  * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
+  */
+  resolve(value: string, onError: (message: string) => void, options: ParseOptions): unknown;
+  /**
+  * 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.
+  *
+  * @param item The node being stringified.
+  * @param ctx Contains the stringifying context variables.
+  * @param onComment Callback to signal that the stringifier includes the
+  *   item's comment in its output.
+  * @param onChompKeep Callback to signal that the output uses a block scalar
+  *   type with the `+` chomping indicator.
+  */
+  stringify?: (item: Scalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void) => string;
+  /**
+  * 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.
+  */
+  test?: RegExp;
+}
+interface CollectionTag extends TagBase {
+  stringify?: never;
+  test?: never;
+  /** The source collection type supported by this tag. */
+  collection: "map" | "seq";
+  /**
+  * 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.
+  */
+  nodeClass?: {
+    new (schema?: Schema): Node;
+    from?: (nc: NodeCreator, obj: unknown) => Node;
+  };
+  /**
+  * 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.
+  */
+  resolve?: (value: YAMLMap | YAMLSeq, onError: (message: string) => void, options: ParseOptions) => unknown;
+}
+//#endregion
+//#region src/schema/Schema.d.ts
+declare class Schema {
+  compat: Array<CollectionTag | ScalarTag> | null;
+  knownTags: Record<string, CollectionTag | ScalarTag>;
+  name: string;
+  sortMapEntries: ((a: Pair, b: Pair) => number) | null;
+  tags: Array<CollectionTag | ScalarTag>;
+  toStringOptions: Readonly<ToStringOptions> | null;
+  constructor({
+    compat,
+    customTags,
+    merge,
+    resolveKnownTags,
+    schema,
+    sortMapEntries,
+    toStringDefaults
+  }: SchemaOptions);
+  clone(): Schema;
+}
+//#endregion
+//#region src/nodes/addPairToJSMap.d.ts
+declare function addPairToJSMap(ctx: ToJSContext | undefined, map: MapLike, {
+  key,
+  value
+}: Pair): MapLike;
+//#endregion
+//#region src/nodes/Pair.d.ts
+declare class Pair<K extends Primitive | NodeBase = Primitive | NodeBase, V extends Primitive | NodeBase = Primitive | NodeBase> {
+  key: NodeOf<K>;
+  value: NodeOf<V> | null;
+  /** The CST token that was composed into this pair.  */
+  srcToken?: CollectionItem;
+  constructor(key: NodeOf<K>, value?: NodeOf<V> | null);
+  clone(schema?: Schema): Pair<K, V>;
+  toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
+  toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/schema/tags.d.ts
+declare const tagsByName: {
+  binary: ScalarTag;
+  bool: ScalarTag & {
+    test: RegExp;
+  };
+  float: ScalarTag;
+  floatExp: ScalarTag;
+  floatNaN: ScalarTag;
+  floatTime: ScalarTag;
+  int: ScalarTag;
+  intHex: ScalarTag;
+  intOct: ScalarTag;
+  intTime: ScalarTag;
+  map: CollectionTag;
+  merge: ScalarTag & {
+    identify(value: unknown): boolean;
+    test: RegExp;
+  };
+  null: ScalarTag & {
+    test: RegExp;
+  };
+  omap: CollectionTag;
+  pairs: CollectionTag;
+  seq: CollectionTag;
+  set: CollectionTag;
+  timestamp: ScalarTag & {
+    test: RegExp;
+  };
+};
+type TagId = keyof typeof tagsByName;
+type Tags = Array<ScalarTag | CollectionTag | TagId>;
+//#endregion
+//#region src/options.d.ts
+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;
+  /**
+  * Parse all mapping keys as strings. Treat all non-scalar keys as errors.
+  *
+  * Default: `false`
+  */
+  stringKeys?: 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 node values, and
+  * is expected to return a `boolean` indicating their equality.
+  *
+  * Default: `true`
+  */
+  uniqueKeys?: boolean | ((a: NodeBase, b: NodeBase) => boolean);
+};
+type DocumentOptions = {
+  /**
+  * 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 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 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 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 = {
+  /**
+  * 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;
+};
+//#endregion
+//#region src/nodes/Node.d.ts
+type Node = Alias | Scalar | YAMLSeq | YAMLMap;
+/** Utility type mapper */
+type NodeType<T> = T extends string | number | bigint | boolean | null | undefined ? Scalar<T> : T extends Date ? Scalar<string | Date> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends {
+  [key: string | number]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : Node;
+type Range = [start: number, valueEnd: number, nodeEnd: number];
+declare abstract class NodeBase {
+  /** A comment on or immediately after this */
+  comment?: string | null;
+  /** A comment before this */
+  commentBefore?: string | null;
+  /**
+  * The `[start, value-end, node-end]` character offsets for the part of the
+  * source parsed into this node (undefined if not parsed). The `value-end`
+  * and `node-end` positions are themselves not included in their respective
+  * ranges.
+  */
+  range?: Range | null;
+  /** A blank line before this node and its commentBefore */
+  spaceBefore?: boolean;
+  /** The CST token that was composed into this node.  */
+  srcToken?: Token;
+  /** A fully qualified tag, if required */
+  tag?: string;
+  /**
+  * Customize the way that a key-value pair is resolved.
+  * Used for YAML 1.1 !!merge << handling.
+  */
+  addToJSMap?: (ctx: ToJSContext | undefined, map: MapLike, value: unknown) => void;
+  /** A plain JS representation of this node */
+  abstract toJSON(): any;
+  abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+  /** Create a copy of this node.  */
+  clone(_schema?: Schema): NodeBase;
+  /** A plain JavaScript representation of this node. */
+  toJS(doc: Document, {
+    mapAsMap,
+    maxAliasCount,
+    onAnchor,
+    reviver
+  }?: ToJSOptions): any;
+}
+//#endregion
+//#region src/parse/cst-scalar.d.ts
+/**
+* If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
+* Otherwise, return `null`.
+*/
+declare function resolveAsScalar(token: FlowScalar | BlockScalar, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+  value: string;
+  type: Scalar.Type | null;
+  comment: string;
+  range: Range;
+};
+declare function resolveAsScalar(token: Token | null | undefined, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+  value: string;
+  type: Scalar.Type | null;
+  comment: string;
+  range: Range;
+} | null;
+/**
+* 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.
+*
+* @param value The string representation of the value, which will have its content properly indented.
+* @param context.end Comments and whitespace after the end of the value, or after the block scalar header. If undefined, a newline will be added.
+* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+* @param context.indent The indent level of the token.
+* @param context.inFlow Is this scalar within a flow collection? This may affect the resolved type of the token's value.
+* @param context.offset The offset position of the token.
+* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+*/
+declare function createScalarToken(value: string, context: {
+  end?: SourceToken[];
+  implicitKey?: boolean;
+  indent: number;
+  inFlow?: boolean;
+  offset?: number;
+  type?: Scalar.Type;
+}): BlockScalar | FlowScalar;
+/**
+* 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.
+*
+* @param token Any token. If it does not include an `indent` value, the value will be stringified as if it were an implicit key.
+* @param value The string representation of the value, which will have its content properly indented.
+* @param context.afterKey In most cases, values after a key should have an additional level of indentation.
+* @param context.implicitKey Being within an implicit key may affect the resolved type of the token's value.
+* @param context.inFlow Being within a flow collection may affect the resolved type of the token's value.
+* @param context.type The preferred type of the scalar token. If undefined, the previous type of the `token` will be used, defaulting to `'PLAIN'`.
+*/
+declare function setScalarValue(token: Token, value: string, context?: {
+  afterKey?: boolean;
+  implicitKey?: boolean;
+  inFlow?: boolean;
+  type?: Scalar.Type;
+}): void;
+//#endregion
+//#region src/parse/cst-stringify.d.ts
+/**
+* Stringify a CST document, token, or collection item
+*
+* Fair warning: This applies no validation whatsoever, and
+* simply concatenates the sources in their logical order.
+*/
+declare const stringify: (cst: Token | CollectionItem) => string;
+//#endregion
+//#region src/parse/cst-visit.d.ts
+type VisitPath = readonly ["key" | "value", number][];
+type Visitor = (item: CollectionItem, path: VisitPath) => number | symbol | Visitor | void;
+/**
+* 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.
+*/
+declare const visit: {
+  (cst: Document$1 | CollectionItem, visitor: Visitor): void; /** Terminate visit traversal completely */
+  BREAK: symbol; /** Do not visit the children of the current item */
+  SKIP: symbol; /** Remove the current item */
+  REMOVE: symbol; /** Find the item at `path` from `cst` as the root */
+  itemAtPath(cst: Document$1 | CollectionItem, path: VisitPath): CollectionItem | undefined;
+  /**
+  * Get the immediate parent collection of the item at `path` from `cst` as the root.
+  *
+  * Throws an error if the collection is not found, which should never happen if the item itself exists.
+  */
+  parentCollection(cst: Document$1 | CollectionItem, path: VisitPath): BlockMap | BlockSequence | FlowCollection;
+};
+declare namespace cst_d_exports {
+  export { BOM, BlockMap, BlockScalar, BlockSequence, CollectionItem, DOCUMENT, Directive, Document$1 as Document, DocumentEnd, ErrorToken, FLOW_END, FlowCollection, FlowScalar, SCALAR, SourceToken, Token, TokenType, VisitPath, Visitor, createScalarToken, isCollection, isScalar, prettyToken, resolveAsScalar, setScalarValue, stringify, tokenType, visit };
+}
+interface SourceToken {
+  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";
+  offset: number;
+  indent: number;
+  source: string;
+}
+interface ErrorToken {
+  type: "error";
+  offset: number;
+  source: string;
+  message: string;
+}
+interface Directive {
+  type: "directive";
+  offset: number;
+  source: string;
+}
+interface Document$1 {
+  type: "document";
+  offset: number;
+  start: SourceToken[];
+  value?: Token;
+  end?: SourceToken[];
+}
+interface DocumentEnd {
+  type: "doc-end";
+  offset: number;
+  source: string;
+  end?: SourceToken[];
+}
+interface FlowScalar {
+  type: "alias" | "scalar" | "single-quoted-scalar" | "double-quoted-scalar";
+  offset: number;
+  indent: number;
+  source: string;
+  end?: SourceToken[];
+}
+interface BlockScalar {
+  type: "block-scalar";
+  offset: number;
+  indent: number;
+  props: Token[];
+  source: string;
+}
+interface BlockMap {
+  type: "block-map";
+  offset: number;
+  indent: number;
+  items: Array<{
+    start: SourceToken[];
+    explicitKey?: true;
+    key?: never;
+    sep?: never;
+    value?: never;
+  } | {
+    start: SourceToken[];
+    explicitKey?: true;
+    key: Token | null;
+    sep: SourceToken[];
+    value?: Token;
+  }>;
+}
+interface BlockSequence {
+  type: "block-seq";
+  offset: number;
+  indent: number;
+  items: Array<{
+    start: SourceToken[];
+    key?: never;
+    sep?: never;
+    value?: Token;
+  }>;
+}
+type CollectionItem = {
+  start: SourceToken[];
+  key?: Token | null;
+  sep?: SourceToken[];
+  value?: Token;
+};
+interface FlowCollection {
+  type: "flow-collection";
+  offset: number;
+  indent: number;
+  start: SourceToken;
+  items: CollectionItem[];
+  end: SourceToken[];
+}
+type Token = SourceToken | ErrorToken | Directive | Document$1 | DocumentEnd | FlowScalar | BlockScalar | BlockMap | BlockSequence | FlowCollection;
+type TokenType = SourceToken["type"] | DocumentEnd["type"] | FlowScalar["type"];
+/** The byte order mark */
+declare const BOM = "";
+/** Start of doc-mode */
+declare const DOCUMENT = "";
+/** Unexpected end of flow-mode */
+declare const FLOW_END = "";
+/** Next token is a scalar value */
+declare const SCALAR = "";
+/** @returns `true` if `token` is a flow or block collection */
+declare const isCollection: (token: Token | null | undefined) => token is BlockMap | BlockSequence | FlowCollection;
+/** @returns `true` if `token` is a flow or block scalar; not an alias */
+declare const isScalar: (token: Token | null | undefined) => token is FlowScalar | BlockScalar;
+/** Get a printable representation of a lexer token */
+declare function prettyToken(token: string): string;
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+declare function tokenType(source: string): TokenType | null;
+//#endregion
+//#region src/nodes/Alias.d.ts
+declare class Alias extends NodeBase {
+  source: string;
+  anchor?: never;
+  srcToken?: FlowScalar & {
+    type: "alias";
+  };
+  constructor(source: string);
+  /**
+  * Resolve the value of this alias within `doc`, finding the last
+  * instance of the `source` anchor before this node.
+  */
+  resolve(doc: Document, ctx?: ToJSContext): Scalar | YAMLMap | YAMLSeq | undefined;
+  toJSON(_arg?: unknown, ctx?: ToJSContext): unknown;
+  toString(ctx?: StringifyContext, _onComment?: () => void, _onChompKeep?: () => void): string;
+}
+//#endregion
+//#region src/doc/Document.d.ts
+type DocValue = Scalar | YAMLSeq | YAMLMap;
+type Replacer = any[] | ((key: any, value: any) => unknown);
+declare namespace Document {
+  /** @ts-ignore The typing of directives fails in TS <= 4.2 */
+  interface Parsed<Value extends DocValue = DocValue, Strict extends boolean = true> extends Document<Value, Strict> {
+    directives: Directives;
+    range: Range;
+  }
+}
+declare class Document<Value extends DocValue = DocValue, Strict extends boolean = true> {
+  /** A comment before this Document */
+  commentBefore: string | null;
+  /** A comment immediately after this Document */
+  comment: string | null;
+  /** The document value. */
+  value: Value;
+  directives: Strict extends true ? Directives | undefined : Directives;
+  /** Errors encountered during parsing. */
+  errors: YAMLError[];
+  options: Required<Omit<ParseOptions & DocumentOptions, "_directives" | "lineCounter" | "version">>;
+  /**
+  * 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.
+  */
+  range?: Range;
+  /** The schema used with the document. Use `setSchema()` to change. */
+  schema: Schema;
+  /** Warnings encountered during parsing. */
+  warnings: YAMLWarning[];
+  /**
+  * @param value - The initial value for the document, which will be wrapped
+  *   in a Node container.
+  */
+  constructor(value?: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+  constructor(value: any, replacer: null | Replacer, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions);
+  /**
+  * Create a deep copy of this Document and its value.
+  *
+  * Custom Node values that inherit from `Object` still refer to their original instances.
+  */
+  clone(): Document<Value, Strict>;
+  /** Adds a value to the document. */
+  add(value: any): void;
+  /** Adds a value to the document. */
+  addIn(path: unknown[], value: unknown): void;
+  /**
+  * 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.
+  */
+  createAlias(node: Strict extends true ? DocValue : Node, name?: string): Alias;
+  /**
+  * Convert any value into a `Node` using the current schema, recursively
+  * turning objects into collections.
+  */
+  createNode<T = unknown>(value: T, options?: CreateNodeOptions): NodeType<T>;
+  createNode<T = unknown>(value: T, replacer: Replacer | CreateNodeOptions | null, options?: CreateNodeOptions): NodeType<T>;
+  /**
+  * Convert a key and a value into a `Pair` using the current schema,
+  * recursively wrapping all values as `Scalar` or `Collection` nodes.
+  */
+  createPair<K = unknown, V = unknown>(key: K, value: V, options?: CreateNodeOptions): Pair<K extends Primitive | NodeBase ? K : NodeBase, V extends Primitive | NodeBase ? V : NodeBase>;
+  /**
+  * Removes a value from the document.
+  * @returns `true` if the item was found and removed.
+  */
+  delete(key: any): boolean;
+  /**
+  * Removes a value from the document.
+  * @returns `true` if the item was found and removed.
+  */
+  deleteIn(path: unknown[]): boolean;
+  /**
+  * Returns item at `key`, or `undefined` if not found.
+  */
+  get(key: any): Strict extends true ? NodeBase | Pair | undefined : any;
+  /**
+  * Returns item at `path`, or `undefined` if not found.
+  */
+  getIn(path: unknown[]): Strict extends true ? NodeBase | Pair | null | undefined : any;
+  /**
+  * Checks if the document includes a value with the key `key`.
+  */
+  has(key: any): boolean;
+  /**
+  * Checks if the document includes a value at `path`.
+  */
+  hasIn(path: unknown[]): boolean;
+  /**
+  * Sets a value in this document. For `!!set`, `value` needs to be a
+  * boolean to add/remove the item from the set.
+  */
+  set(key: any, value: any): void;
+  /**
+  * Sets a value in this document. For `!!set`, `value` needs to be a
+  * boolean to add/remove the item from the set.
+  */
+  setIn(path: unknown[], value: unknown): 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.
+  */
+  setSchema(version: "1.1" | "1.2" | "next" | null, options?: SchemaOptions): void;
+  /** A plain JavaScript representation of the document `value`. */
+  toJS(opt?: ToJSOptions & {
+    [ignored: string]: unknown;
+  }): any;
+  /**
+  * A JSON representation of the document `value`.
+  *
+  * @param jsonArg Used by `JSON.stringify` to indicate the array index or
+  *   property name.
+  */
+  toJSON(jsonArg?: string | null, onAnchor?: ToJSOptions["onAnchor"]): any;
+  /** A YAML representation of the document. */
+  toString(options?: ToStringOptions): string;
+}
+//#endregion
+//#region src/doc/directives.d.ts
+declare class Directives {
+  static defaultYaml: Directives["yaml"];
+  static defaultTags: Directives["tags"];
+  yaml: {
+    version: "1.1" | "1.2" | "next";
+    explicit?: boolean;
+  };
+  tags: Record<string, string>;
+  /**
+  * The directives-end/doc-start marker `---`. If `null`, a marker may still be
+  * included in the document's stringified representation.
+  */
+  docStart: true | null;
+  /** The doc-end marker `...`.  */
+  docEnd: boolean;
+  /**
+  * Used when parsing YAML 1.1, where:
+  * > If the document specifies no directives, it is parsed using the same
+  * > settings as the previous document. If the document does specify any
+  * > directives, all directives of previous documents, if any, are ignored.
+  */
+  private atNextDocument?;
+  constructor(yaml?: Directives["yaml"], tags?: Directives["tags"]);
+  clone(): Directives;
+  /**
+  * During parsing, get a Directives instance for the current document and
+  * update the stream state according to the current version's spec.
+  */
+  atDocument(): Directives;
+  /**
+  * @param onError - May be called even if the action was successful
+  * @returns `true` on success
+  */
+  add(line: string, onError: (offset: number, message: string, warning?: boolean) => void): boolean;
+  /**
+  * Resolves a tag, matching handles to those defined in %TAG directives.
+  *
+  * @returns Resolved tag, which may also be the non-specific tag `'!'` or a
+  *   `'!local'` tag, or `null` if unresolvable.
+  */
+  tagName(source: string, onError: (message: string) => void): string | null;
+  /**
+  * Given a fully resolved tag, returns its printable string form,
+  * taking into account current tag prefixes and defaults.
+  */
+  tagString(tag: string): string;
+  toString(doc?: Document): string;
+}
+//#endregion
+//#region src/schema/common/map.d.ts
+declare const map: CollectionTag;
+//#endregion
+//#region src/schema/common/seq.d.ts
+declare const seq: CollectionTag;
+//#endregion
+//#region src/schema/common/string.d.ts
+declare const string: ScalarTag;
+//#endregion
+//#region src/stringify/foldFlowLines.d.ts
+/**
+* `'block'` prevents more-indented lines from being folded;
+* `'quoted'` allows for `\` escapes, including escaped newlines
+*/
+type FoldMode = "flow" | "block" | "quoted";
+interface FoldOptions {
+  /**
+  * Accounts for leading contents on the first line, defaulting to
+  * `indent.length`
+  */
+  indentAtStart?: number;
+  /** Default: `80` */
+  lineWidth?: number;
+  /**
+  * Allow highly indented lines to stretch the line width or indent content
+  * from the start.
+  *
+  * Default: `20`
+  */
+  minContentWidth?: number;
+  /** Called once if the text is folded */
+  onFold?: () => void;
+  /** Called once if any line of text exceeds lineWidth characters */
+  onOverflow?: () => void;
+}
+/**
+* Tries to keep input at up to `lineWidth` characters, splitting only on spaces
+* not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are
+* terminated with `\n` and started with `indent`.
+*/
+declare function foldFlowLines(text: string, indent: string, mode?: FoldMode, {
+  indentAtStart,
+  lineWidth,
+  minContentWidth,
+  onFold,
+  onOverflow
+}?: FoldOptions): string;
+//#endregion
+//#region src/stringify/stringifyNumber.d.ts
+declare function stringifyNumber({
+  format,
+  minFractionDigits,
+  tag,
+  value
+}: Scalar): string;
+//#endregion
+//#region src/stringify/stringifyString.d.ts
+interface StringifyScalar {
+  value: string;
+  comment?: string | null;
+  type?: string;
+}
+declare function stringifyString(item: Scalar | StringifyScalar, ctx: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+//#endregion
+export { YAMLSeq as A, LogLevelId as B, ToStringOptions as C, Schema as D, Pair as E, StringifyContext as F, YAMLError as G, warn as H, Scalar as I, LineCounter as J, YAMLParseError as K, ToJSContext as L, findPair as M, NodeOf as N, CollectionTag as O, Primitive as P, toJS as R, ToJSOptions as S, Tags as T, Reviver as U, debug as V, ErrorCode as W, Range as _, string as a, ParseOptions as b, Directives as c, Replacer as d, Alias as f, NodeBase as g, Node as h, foldFlowLines as i, YAMLMap as j, ScalarTag as k, DocValue as l, cst_d_exports as m, stringifyNumber as n, seq as o, Token as p, YAMLWarning as q, FoldOptions as r, map as s, stringifyString as t, Document as u, CreateNodeOptions as v, TagId as w, SchemaOptions as x, DocumentOptions as y, NodeCreator as z };