@poveste/vendors 0.14.0 → 0.15.0

package/dist/client/node_modules/chokidar/index.d.ts

@@ -0,0 +1,217 @@
+/*! chokidar - MIT License (c) 2012 Paul Miller (paulmillr.com) */
+import { EventEmitter } from 'node:events';
+import { Stats } from 'node:fs';
+import { type EntryInfo, type ReaddirpOptions, ReaddirpStream } from 'readdirp';
+import { EVENTS as EV, type EventName, NodeFsHandler, type Path, type WatchHandlers } from './handler.js';
+export type AWF = {
+    stabilityThreshold: number;
+    pollInterval: number;
+};
+type BasicOpts = {
+    persistent: boolean;
+    ignoreInitial: boolean;
+    followSymlinks: boolean;
+    cwd?: string;
+    usePolling: boolean;
+    interval: number;
+    binaryInterval: number;
+    alwaysStat?: boolean;
+    depth?: number;
+    ignorePermissionErrors: boolean;
+    atomic: boolean | number;
+};
+export type Throttler = {
+    timeoutObject: NodeJS.Timeout;
+    clear: () => void;
+    count: number;
+};
+export type ChokidarOptions = Partial<BasicOpts & {
+    ignored: Matcher | Matcher[];
+    awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+export type FSWInstanceOptions = BasicOpts & {
+    ignored: Matcher[];
+    awaitWriteFinish: false | AWF;
+};
+export type ThrottleType = 'readdir' | 'watch' | 'add' | 'remove' | 'change';
+export type EmitArgs = [path: Path, stats?: Stats];
+export type EmitErrorArgs = [error: Error, stats?: Stats];
+export type EmitArgsWithName = [event: EventName, ...EmitArgs];
+export type MatchFunction = (val: string, stats?: Stats) => boolean;
+export interface MatcherObject {
+    path: string;
+    recursive?: boolean;
+}
+export type Matcher = string | RegExp | MatchFunction | MatcherObject;
+/**
+ * Directory entry.
+ */
+declare class DirEntry {
+    path: Path;
+    _removeWatcher: (dir: string, base: string) => void;
+    items: Set<Path>;
+    constructor(dir: Path, removeWatcher: (dir: string, base: string) => void);
+    add(item: string): void;
+    remove(item: string): Promise<void>;
+    has(item: string): boolean | undefined;
+    getChildren(): string[];
+    dispose(): void;
+}
+export declare class WatchHelper {
+    fsw: FSWatcher;
+    path: string;
+    watchPath: string;
+    fullWatchPath: string;
+    dirParts: string[][];
+    followSymlinks: boolean;
+    statMethod: 'stat' | 'lstat';
+    constructor(path: string, follow: boolean, fsw: FSWatcher);
+    entryPath(entry: EntryInfo): Path;
+    filterPath(entry: EntryInfo): boolean;
+    filterDir(entry: EntryInfo): boolean;
+}
+export interface FSWatcherEventMap {
+    [EV.READY]: [];
+    [EV.RAW]: Parameters<WatchHandlers['rawEmitter']>;
+    [EV.ERROR]: Parameters<WatchHandlers['errHandler']>;
+    [EV.ALL]: [event: EventName, ...EmitArgs];
+    [EV.ADD]: EmitArgs;
+    [EV.CHANGE]: EmitArgs;
+    [EV.ADD_DIR]: EmitArgs;
+    [EV.UNLINK]: EmitArgs;
+    [EV.UNLINK_DIR]: EmitArgs;
+}
+/**
+ * Watches files & directories for changes. Emitted events:
+ * `add`, `addDir`, `change`, `unlink`, `unlinkDir`, `all`, `error`
+ *
+ *     new FSWatcher()
+ *       .add(directories)
+ *       .on('add', path => log('File', path, 'was added'))
+ */
+export declare class FSWatcher extends EventEmitter<FSWatcherEventMap> {
+    closed: boolean;
+    options: FSWInstanceOptions;
+    _closers: Map<string, Array<any>>;
+    _ignoredPaths: Set<Matcher>;
+    _throttled: Map<ThrottleType, Map<any, any>>;
+    _streams: Set<ReaddirpStream>;
+    _symlinkPaths: Map<Path, string | boolean>;
+    _watched: Map<string, DirEntry>;
+    _pendingWrites: Map<string, any>;
+    _pendingUnlinks: Map<string, EmitArgsWithName>;
+    _readyCount: number;
+    _emitReady: () => void;
+    _closePromise?: Promise<void>;
+    _userIgnored?: MatchFunction;
+    _readyEmitted: boolean;
+    _emitRaw: WatchHandlers['rawEmitter'];
+    _boundRemove: (dir: string, item: string) => void;
+    _nodeFsHandler: NodeFsHandler;
+    constructor(_opts?: ChokidarOptions);
+    _addIgnoredPath(matcher: Matcher): void;
+    _removeIgnoredPath(matcher: Matcher): void;
+    /**
+     * Adds paths to be watched on an existing FSWatcher instance.
+     * @param paths_ file or file list. Other arguments are unused
+     */
+    add(paths_: Path | Path[], _origAdd?: string, _internal?: boolean): FSWatcher;
+    /**
+     * Close watchers or start ignoring events from specified paths.
+     */
+    unwatch(paths_: Path | Path[]): FSWatcher;
+    /**
+     * Close watchers and remove all listeners from watched paths.
+     */
+    close(): Promise<void>;
+    /**
+     * Expose list of watched paths
+     * @returns for chaining
+     */
+    getWatched(): Record<string, string[]>;
+    emitWithAll(event: EventName, args: EmitArgs): void;
+    /**
+     * Normalize and emit events.
+     * Calling _emit DOES NOT MEAN emit() would be called!
+     * @param event Type of event
+     * @param path File or directory path
+     * @param stats arguments to be passed with event
+     * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _emit(event: EventName, path: Path, stats?: Stats): Promise<this | undefined>;
+    /**
+     * Common handler for errors
+     * @returns The error if defined, otherwise the value of the FSWatcher instance's `closed` flag
+     */
+    _handleError(error: Error): Error | boolean;
+    /**
+     * Helper utility for throttling
+     * @param actionType type being throttled
+     * @param path being acted upon
+     * @param timeout duration of time to suppress duplicate actions
+     * @returns tracking object or false if action should be suppressed
+     */
+    _throttle(actionType: ThrottleType, path: Path, timeout: number): Throttler | false;
+    _incrReadyCount(): number;
+    /**
+     * Awaits write operation to finish.
+     * Polls a newly created file for size variations. When files size does not change for 'threshold' milliseconds calls callback.
+     * @param path being acted upon
+     * @param threshold Time in milliseconds a file size must be fixed before acknowledging write OP is finished
+     * @param event
+     * @param awfEmit Callback to be called when ready for event to be emitted.
+     */
+    _awaitWriteFinish(path: Path, threshold: number, event: EventName, awfEmit: (err?: Error, stat?: Stats) => void): void;
+    /**
+     * Determines whether user has asked to ignore this path.
+     */
+    _isIgnored(path: Path, stats?: Stats): boolean;
+    _isntIgnored(path: Path, stat?: Stats): boolean;
+    /**
+     * Provides a set of common helpers and properties relating to symlink handling.
+     * @param path file or directory pattern being watched
+     */
+    _getWatchHelpers(path: Path): WatchHelper;
+    /**
+     * Provides directory tracking objects
+     * @param directory path of the directory
+     */
+    _getWatchedDir(directory: string): DirEntry;
+    /**
+     * Check for read permissions: https://stackoverflow.com/a/11781404/1358405
+     */
+    _hasReadPermissions(stats: Stats): boolean;
+    /**
+     * Handles emitting unlink events for
+     * files and directories, and via recursion, for
+     * files and directories within directories that are unlinked
+     * @param directory within which the following item is located
+     * @param item      base path of item/directory
+     */
+    _remove(directory: string, item: string, isDirectory?: boolean): void;
+    /**
+     * Closes all watchers for a path
+     */
+    _closePath(path: Path): void;
+    /**
+     * Closes only file-specific watchers
+     */
+    _closeFile(path: Path): void;
+    _addPathCloser(path: Path, closer: () => void): void;
+    _readdirp(root: Path, opts?: Partial<ReaddirpOptions>): ReaddirpStream | undefined;
+}
+/**
+ * Instantiates watcher with paths to be tracked.
+ * @param paths file / directory paths
+ * @param options opts, such as `atomic`, `awaitWriteFinish`, `ignored`, and others
+ * @returns an instance of FSWatcher for chaining.
+ * @example
+ * const watcher = watch('.').on('all', (event, path) => { console.log(event, path); });
+ * watch('.', { atomic: true, awaitWriteFinish: true, ignored: (f, stats) => stats?.isFile() && !f.endsWith('.js') })
+ */
+export declare function watch(paths: string | string[], options?: ChokidarOptions): FSWatcher;
+declare const _default: {
+    watch: typeof watch;
+    FSWatcher: typeof FSWatcher;
+};
+export default _default;

package/dist/client/node_modules/chokidar/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "chokidar",
+  "description": "Minimal and efficient cross-platform file watching library",
+  "version": "5.0.0",
+  "type": "module",
+  "homepage": "https://github.com/paulmillr/chokidar",
+  "author": "Paul Miller (https://paulmillr.com)",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "handler.js",
+    "handler.d.ts"
+  ],
+  "main": "./index.js",
+  "exports": {
+    ".": {
+      "default": "./index.js"
+    },
+    "./handler.js": {
+      "default": "./handler.js"
+    }
+  },
+  "dependencies": {
+    "readdirp": "^5.0.0"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.4.5",
+    "@types/node": "24.10.1",
+    "prettier": "3.5.2",
+    "tinyspy": "3.0.2",
+    "typescript": "5.9.2",
+    "upath": "2.0.1"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">= 20.19.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/paulmillr/chokidar.git"
+  },
+  "bugs": {
+    "url": "https://github.com/paulmillr/chokidar/issues"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "lint": "prettier --check src",
+    "format": "prettier --write src",
+    "test": "node index.test.js",
+    "test:bun1": "bun index.test.js"
+  },
+  "keywords": [
+    "fs",
+    "watch",
+    "watchFile",
+    "watcher",
+    "watching",
+    "file",
+    "fsevents"
+  ],
+  "funding": "https://paulmillr.com/funding/"
+}

package/dist/client/node_modules/confbox/dist/_chunks/_format.d.mts

@@ -0,0 +1,25 @@
+//#region src/_format.d.ts
+interface FormatOptions {
+  /**
+   * A String or Number object that's used to insert white space into the output JSON string for readability purposes.
+   *
+   * When provided, identation won't be auto detected anymore.
+   */
+  indent?: string | number;
+  /**
+   * Set to `false` to skip indentation preservation.
+   */
+  preserveIndentation?: boolean;
+  /**
+   * Set to `false` to skip whitespace preservation.
+   */
+  preserveWhitespace?: boolean;
+  /**
+   * The number of characters to sample from the start of the text.
+   *
+   * Default: 1024
+   */
+  sampleSize?: number;
+}
+//#endregion
+export { FormatOptions as t };

package/dist/client/node_modules/confbox/dist/index.d.mts

@@ -0,0 +1,34 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+import { JSON5ParseOptions, JSON5StringifyOptions, parseJSON5, stringifyJSON5 } from "./json5.mjs";
+import { JSONCParseError, JSONCParseOptions, parseJSONC, stringifyJSONC } from "./jsonc.mjs";
+import { YAMLParseOptions, YAMLStringifyOptions, parseYAML, stringifyYAML } from "./yaml.mjs";
+import { parseTOML, stringifyTOML } from "./toml.mjs";
+import { INIParseOptions, INIStringifyOptions, parseINI, stringifyINI } from "./ini.mjs";
+
+//#region src/json.d.ts
+/**
+ * Converts a [JSON](https://www.json.org/json-en.html) string into an object.
+ *
+ * Indentation status is auto-detected and preserved when stringifying back using `stringifyJSON`
+ */
+declare function parseJSON<T = unknown>(text: string, options?: JSONParseOptions): T;
+/**
+ * Converts a JavaScript value to a [JSON](https://www.json.org/json-en.html) string.
+ *
+ * Indentation status is auto detected and preserved when using value from parseJSON.
+ */
+declare function stringifyJSON(value: any, options?: JSONStringifyOptions): string;
+interface JSONParseOptions extends FormatOptions {
+  /**
+   * A function that transforms the results. This function is called for each member of the object.
+   */
+  reviver?: (this: any, key: string, value: any) => any;
+}
+interface JSONStringifyOptions extends FormatOptions {
+  /**
+   * A function that transforms the results. This function is called for each member of the object.
+   */
+  replacer?: (this: any, key: string, value: any) => any;
+}
+//#endregion
+export { type INIParseOptions, type INIStringifyOptions, type JSON5ParseOptions, type JSON5StringifyOptions, type JSONCParseError, type JSONCParseOptions, type JSONParseOptions, type JSONStringifyOptions, type YAMLParseOptions, type YAMLStringifyOptions, parseINI, parseJSON, parseJSON5, parseJSONC, parseTOML, parseYAML, stringifyINI, stringifyJSON, stringifyJSON5, stringifyJSONC, stringifyTOML, stringifyYAML };

package/dist/client/node_modules/confbox/dist/ini.d.mts

@@ -0,0 +1,62 @@
+//#region src/ini.d.ts
+/**
+ * Converts an [INI](https://www.ini.org/ini-en.html) string into an object.
+ *
+ * **Note:** Style and indentation are not preserved currently.
+ */
+declare function parseINI<T = unknown>(text: string, options?: INIParseOptions): T;
+/**
+ * Converts a JavaScript value to an [INI](https://www.ini.org/ini-en.html) string.
+ *
+ * **Note:** Style and indentation are not preserved currently.
+ */
+declare function stringifyINI(value: any, options?: INIStringifyOptions): string;
+interface INIParseOptions {
+  /**
+   *  Whether to append `[]` to array keys.
+   *
+   *  Some parsers treat duplicate names by themselves as arrays.
+   */
+  bracketedArray?: boolean;
+}
+interface INIStringifyOptions {
+  /**
+   *  Whether to insert spaces before & after `=` character.
+   *  Enabled by default.
+   */
+  whitespace?: boolean;
+  /**
+   *  Whether to align the `=` character for each section.
+   */
+  align?: boolean;
+  /**
+   *  Identifier to use for global items
+   *  and to prepend to all other sections.
+   */
+  section?: string;
+  /**
+   *  Whether to sort all sections & their keys alphabetically.
+   */
+  sort?: boolean;
+  /**
+   *  Whether to insert a newline after each section header.
+   */
+  newline?: boolean;
+  /**
+   *  Which platforms line-endings should be used.
+   *
+   *  win32 -> CR+LF
+   *  other -> LF
+   *
+   *  Default is the current platform
+   */
+  platform?: string;
+  /**
+   *  Whether to append `[]` to array keys.
+   *
+   *  Some parsers treat duplicate names by themselves as arrays
+   */
+  bracketedArray?: boolean;
+}
+//#endregion
+export { INIParseOptions, INIStringifyOptions, parseINI, stringifyINI };

package/dist/client/node_modules/confbox/dist/json5.d.mts

@@ -0,0 +1,59 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/json5.d.ts
+/**
+ * Converts a [JSON5](https://json5.org/) string into an object.
+ *
+ * @template T The type of the return value.
+ * @param text The string to parse as JSON5.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the JSON5 string.
+ */
+declare function parseJSON5<T = unknown>(text: string, options?: JSON5ParseOptions): T;
+/**
+ * Converts a JavaScript value to a [JSON5](https://json5.org/) string.
+ *
+ * @param value
+ * @param options
+ * @returns The JSON string converted from the JavaScript value.
+ */
+declare function stringifyJSON5(value: any, options?: JSON5StringifyOptions): string;
+interface JSON5ParseOptions extends FormatOptions {
+  /**
+   * A function that alters the behavior of the parsing process, or an array of
+   * String and Number objects that serve as a allowlist for selecting/filtering
+   * the properties of the value object to be included in the resulting
+   * JavaScript object. If this value is null or not provided, all properties of
+   * the object are included in the resulting JavaScript object.
+   */
+  reviver?: (this: any, key: string, value: any) => any;
+}
+interface JSON5StringifyOptions extends FormatOptions {
+  /**
+   * A function that alters the behavior of the stringification process, or an
+   * array of String and Number objects that serve as a allowlist for
+   * selecting/filtering the properties of the value object to be included in
+   * the JSON5 string. If this value is null or not provided, all properties
+   * of the object are included in the resulting JSON5 string.
+   */
+  replacer?: ((this: any, key: string, value: any) => any) | null;
+  /**
+   * A String or Number object that's used to insert white space into the
+   * output JSON5 string for readability purposes. If this is a Number, it
+   * indicates the number of space characters to use as white space; this
+   * number is capped at 10 (if it is greater, the value is just 10). Values
+   * less than 1 indicate that no space should be used. If this is a String,
+   * the string (or the first 10 characters of the string, if it's longer than
+   * that) is used as white space. If this parameter is not provided (or is
+   * null), no white space is used. If white space is used, trailing commas
+   * will be used in objects and arrays.
+   */
+  space?: string | number | null;
+  /**
+   * A String representing the quote character to use when serializing
+   * strings.
+   */
+  quote?: string | null;
+}
+//#endregion
+export { JSON5ParseOptions, JSON5StringifyOptions, parseJSON5, stringifyJSON5 };

package/dist/client/node_modules/confbox/dist/jsonc.d.mts

@@ -0,0 +1,41 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/jsonc.d.ts
+/**
+ *
+ * Converts a [JSONC](https://github.com/microsoft/node-jsonc-parser) string into an object.
+ *
+ * @NOTE On invalid input, the parser tries to be as fault tolerant as possible, but still return a result.
+ *
+ * @NOTE Comments and trailing commas are not preserved after parsing.
+ *
+ * @template T The type of the return value.
+ * @param text The string to parse as JSONC.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the JSONC string.
+ */
+declare function parseJSONC<T = unknown>(text: string, options?: JSONCParseOptions): T;
+/**
+ * Converts a JavaScript value to a [JSONC](https://github.com/microsoft/node-jsonc-parser) string.
+ *
+ * @NOTE Comments and trailing commas are not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The JSON string converted from the JavaScript value.
+ */
+declare function stringifyJSONC(value: any, options?: JSONCStringifyOptions): string;
+interface JSONCParseOptions extends FormatOptions {
+  disallowComments?: boolean;
+  allowTrailingComma?: boolean;
+  allowEmptyContent?: boolean;
+  errors?: JSONCParseError[];
+}
+interface JSONCStringifyOptions extends FormatOptions {}
+interface JSONCParseError {
+  error: number;
+  offset: number;
+  length: number;
+}
+//#endregion
+export { JSONCParseError, JSONCParseOptions, JSONCStringifyOptions, parseJSONC, stringifyJSONC };

package/dist/client/node_modules/confbox/dist/toml.d.mts

@@ -0,0 +1,23 @@
+//#region src/toml.d.ts
+/**
+ * Converts a [TOML](https://toml.io/) string into an object.
+ *
+ * @NOTE Comments and indentation is not preserved after parsing.
+ *
+ * @template T The type of the return value.
+ * @param text The TOML string to parse.
+ * @returns The JavaScript value converted from the TOML string.
+ */
+declare function parseTOML<T = unknown>(text: string): T;
+/**
+ * Converts a JavaScript value to a [TOML](https://toml.io/) string.
+ *
+ * @NOTE Comments and indentation is not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The YAML string converted from the JavaScript value.
+ */
+declare function stringifyTOML(value: any): string;
+//#endregion
+export { parseTOML, stringifyTOML };

package/dist/client/node_modules/confbox/dist/yaml.d.mts

@@ -0,0 +1,96 @@
+import { t as FormatOptions } from "./_chunks/_format.mjs";
+
+//#region src/yaml.d.ts
+/**
+ * Converts a [YAML](https://yaml.org/) string into an object.
+ *
+ * @NOTE This function does **not** understand multi-document sources, it throws exception on those.
+ *
+ * @NOTE Comments are not preserved after parsing.
+ *
+ * @NOTE This function does **not** support schema-specific tag resolution restrictions.
+ * So, the JSON schema is not as strictly defined in the YAML specification.
+ * It allows numbers in any notation, use `Null` and `NULL` as `null`, etc.
+ * The core schema also has no such restrictions. It allows binary notation for integers.
+ *
+ * @template T The type of the return value.
+ * @param text The YAML string to parse.
+ * @param options Parsing options.
+ * @returns The JavaScript value converted from the YAML string.
+ */
+declare function parseYAML<T = unknown>(text: string, options?: YAMLParseOptions): T;
+/**
+ * Converts a JavaScript value to a [YAML](https://yaml.org/) string.
+ *
+ * @NOTE Comments are not preserved in the output.
+ *
+ * @param value
+ * @param options
+ * @returns The YAML string converted from the JavaScript value.
+ */
+declare function stringifyYAML(value: any, options?: YAMLStringifyOptions): string;
+interface YAMLParseOptions extends FormatOptions {
+  /** string to be used as a file path in error/warning messages. */
+  filename?: string | undefined;
+  /** function to call on warning messages. */
+  onWarning?(this: null, e: YAMLException): void;
+  /** specifies a schema to use. */
+  schema?: any | undefined;
+  /** compatibility with JSON.parse behaviour. */
+  json?: boolean | undefined;
+  /** listener for parse events */
+  listener?(this: any, eventType: any, state: any): void;
+}
+interface YAMLStringifyOptions extends FormatOptions {
+  /** indentation width to use (in spaces). */
+  indent?: number | undefined;
+  /** when true, will not add an indentation level to array elements */
+  noArrayIndent?: boolean | undefined;
+  /** do not throw on invalid types (like function in the safe schema) and skip pairs and single values with such types. */
+  skipInvalid?: boolean | undefined;
+  /** specifies level of nesting, when to switch from block to flow style for collections. -1 means block style everwhere */
+  flowLevel?: number | undefined;
+  /** Each tag may have own set of styles.    - "tag" => "style" map. */
+  styles?: {
+    [x: string]: any;
+  } | undefined;
+  /** specifies a schema to use. */
+  schema?: any | undefined;
+  /** if true, sort keys when dumping YAML. If a function, use the function to sort the keys. (default: false) */
+  sortKeys?: boolean | ((a: any, b: any) => number) | undefined;
+  /** set max line width. (default: 80) */
+  lineWidth?: number | undefined;
+  /** if true, don't convert duplicate objects into references (default: false) */
+  noRefs?: boolean | undefined;
+  /** if true don't try to be compatible with older yaml versions. Currently: don't quote "yes", "no" and so on, as required for YAML 1.1 (default: false) */
+  noCompatMode?: boolean | undefined;
+  /**
+   * if true flow sequences will be condensed, omitting the space between `key: value` or `a, b`. Eg. `'[a,b]'` or `{a:{b:c}}`.
+   * Can be useful when using yaml for pretty URL query params as spaces are %-encoded. (default: false).
+   */
+  condenseFlow?: boolean | undefined;
+  /** strings will be quoted using this quoting style. If you specify single quotes, double quotes will still be used for non-printable characters. (default: `'`) */
+  quotingType?: "'" | '"' | undefined;
+  /** if true, all non-key strings will be quoted even if they normally don't need to. (default: false) */
+  forceQuotes?: boolean | undefined;
+  /** callback `function (key, value)` called recursively on each key/value in source object (see `replacer` docs for `JSON.stringify`). */
+  replacer?: ((key: string, value: any) => any) | undefined;
+}
+interface Mark {
+  buffer: string;
+  column: number;
+  line: number;
+  name: string;
+  position: number;
+  snippet: string;
+}
+declare class YAMLException extends Error {
+  constructor(reason?: string, mark?: Mark);
+  toString(compact?: boolean): string;
+  name: string;
+  reason: string;
+  message: string;
+  mark: Mark;
+}
+//#endregion
+export { YAMLParseOptions, YAMLStringifyOptions, parseYAML, stringifyYAML };