@kamilio/wire 0.1.8 → 0.1.10

package/node_modules/toolcraft/node_modules/yaml/dist/cli.mjs

@@ -0,0 +1,201 @@
+import { resolve } from 'path';
+import { parseArgs } from 'util';
+import { prettyToken } from './parse/cst.js';
+import { Lexer } from './parse/lexer.js';
+import { Parser } from './parse/parser.js';
+import { Composer } from './compose/composer.js';
+import { LineCounter } from './parse/line-counter.js';
+import { prettifyError } from './errors.js';
+import { visit } from './visit.js';
+
+const help = `\
+yaml: A command-line YAML processor and inspector
+
+Reads stdin and writes output to stdout and errors & warnings to stderr.
+
+Usage:
+  yaml          Process a YAML stream, outputting it as YAML
+  yaml cst      Parse the CST of a YAML stream
+  yaml lex      Parse the lexical tokens of a YAML stream
+  yaml valid    Validate a YAML stream, returning 0 on success
+
+Options:
+  --help, -h    Show this message.
+  --json, -j    Output JSON.
+  --indent 2    Output pretty-printed data, indented by the given number of spaces.
+  --merge, -m   Enable support for "<<" merge keys.
+
+Additional options for bare "yaml" command:
+  --doc, -d     Output pretty-printed JS Document objects.
+  --single, -1  Require the input to consist of a single YAML document.
+  --strict, -s  Stop on errors.
+  --visit, -v   Apply a visitor to each document (requires a path to import)
+  --yaml 1.1    Set the YAML version. (default: 1.2)`;
+class UserError extends Error {
+    constructor(code, message) {
+        super(`Error: ${message}`);
+        this.code = code;
+    }
+}
+UserError.ARGS = 2;
+UserError.SINGLE = 3;
+async function cli(stdin, done, argv) {
+    let args;
+    try {
+        args = parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: {
+                doc: { type: 'boolean', short: 'd' },
+                help: { type: 'boolean', short: 'h' },
+                indent: { type: 'string', short: 'i' },
+                merge: { type: 'boolean', short: 'm' },
+                json: { type: 'boolean', short: 'j' },
+                single: { type: 'boolean', short: '1' },
+                strict: { type: 'boolean', short: 's' },
+                visit: { type: 'string', short: 'v' },
+                yaml: { type: 'string', default: '1.2' }
+            }
+        });
+    }
+    catch (error) {
+        return done(new UserError(UserError.ARGS, error.message));
+    }
+    const { positionals: [mode], values: opt } = args;
+    let indent = Number(opt.indent);
+    stdin.setEncoding('utf-8');
+    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+    switch (opt.help || mode) {
+        /* istanbul ignore next */
+        case true: // --help
+            console.log(help);
+            break;
+        case 'lex': {
+            const lexer = new Lexer();
+            const data = [];
+            const add = (tok) => {
+                if (opt.json)
+                    data.push(tok);
+                else
+                    console.log(prettyToken(tok));
+            };
+            stdin.on('data', (chunk) => {
+                for (const tok of lexer.lex(chunk, true))
+                    add(tok);
+            });
+            stdin.on('end', () => {
+                for (const tok of lexer.lex('', false))
+                    add(tok);
+                if (opt.json)
+                    console.log(JSON.stringify(data, null, indent));
+                done();
+            });
+            break;
+        }
+        case 'cst': {
+            const parser = new Parser();
+            const data = [];
+            const add = (tok) => {
+                if (opt.json)
+                    data.push(tok);
+                else
+                    console.dir(tok, { depth: null });
+            };
+            stdin.on('data', (chunk) => {
+                for (const tok of parser.parse(chunk, true))
+                    add(tok);
+            });
+            stdin.on('end', () => {
+                for (const tok of parser.parse('', false))
+                    add(tok);
+                if (opt.json)
+                    console.log(JSON.stringify(data, null, indent));
+                done();
+            });
+            break;
+        }
+        case undefined:
+        case 'valid': {
+            const lineCounter = new LineCounter();
+            const parser = new Parser(lineCounter.addNewLine);
+            // @ts-expect-error Version is validated at runtime
+            const composer = new Composer({ version: opt.yaml, merge: opt.merge });
+            const visitor = opt.visit
+                ? (await import(resolve(opt.visit))).default
+                : null;
+            let source = '';
+            let hasDoc = false;
+            let reqDocEnd = false;
+            const data = [];
+            const add = (doc) => {
+                if (hasDoc && opt.single) {
+                    return done(new UserError(UserError.SINGLE, 'Input stream contains multiple documents'));
+                }
+                for (const error of doc.errors) {
+                    prettifyError(source, lineCounter)(error);
+                    if (opt.strict || mode === 'valid')
+                        return done(error);
+                    console.error(error);
+                }
+                for (const warning of doc.warnings) {
+                    prettifyError(source, lineCounter)(warning);
+                    console.error(warning);
+                }
+                if (visitor)
+                    visit(doc, visitor);
+                if (mode === 'valid')
+                    doc.toJS();
+                else if (opt.json)
+                    data.push(doc);
+                else if (opt.doc) {
+                    Object.defineProperties(doc, {
+                        options: { enumerable: false },
+                        schema: { enumerable: false }
+                    });
+                    console.dir(doc, { depth: null });
+                }
+                else {
+                    if (reqDocEnd)
+                        console.log('...');
+                    try {
+                        indent || (indent = 2);
+                        const str = doc.toString({ indent });
+                        console.log(str.endsWith('\n') ? str.slice(0, -1) : str);
+                    }
+                    catch (error) {
+                        done(error);
+                    }
+                }
+                hasDoc = true;
+                reqDocEnd = !doc.directives?.docEnd;
+            };
+            stdin.on('data', (chunk) => {
+                source += chunk;
+                for (const tok of parser.parse(chunk, true)) {
+                    for (const doc of composer.next(tok))
+                        add(doc);
+                }
+            });
+            stdin.on('end', () => {
+                for (const tok of parser.parse('', false)) {
+                    for (const doc of composer.next(tok))
+                        add(doc);
+                }
+                for (const doc of composer.end(false))
+                    add(doc);
+                if (opt.single && !hasDoc) {
+                    return done(new UserError(UserError.SINGLE, 'Input stream contained no documents'));
+                }
+                if (mode !== 'valid' && opt.json) {
+                    console.log(JSON.stringify(opt.single ? data[0] : data, null, indent));
+                }
+                done();
+            });
+            break;
+        }
+        default:
+            done(new UserError(UserError.ARGS, `Unknown command: ${JSON.stringify(mode)}`));
+    }
+}
+
+export { UserError, cli, help };

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-collection.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedNode } from '../nodes/Node';
+import type { BlockMap, BlockSequence, FlowCollection, SourceToken } from '../parse/cst';
+import type { ComposeContext, ComposeNode } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+interface Props {
+    anchor: SourceToken | null;
+    tag: SourceToken | null;
+    newlineAfterProp: SourceToken | null;
+}
+export declare function composeCollection(CN: ComposeNode, ctx: ComposeContext, token: BlockMap | BlockSequence | FlowCollection, props: Props, onError: ComposeErrorHandler): ParsedNode;
+export {};

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-collection.js

@@ -0,0 +1,90 @@
+'use strict';
+
+var identity = require('../nodes/identity.js');
+var Scalar = require('../nodes/Scalar.js');
+var YAMLMap = require('../nodes/YAMLMap.js');
+var YAMLSeq = require('../nodes/YAMLSeq.js');
+var resolveBlockMap = require('./resolve-block-map.js');
+var resolveBlockSeq = require('./resolve-block-seq.js');
+var resolveFlowCollection = require('./resolve-flow-collection.js');
+
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap.resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError, tag);
+    const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
+    if (tagName === '!' || tagName === Coll.tagName) {
+        coll.tag = Coll.tagName;
+        return coll;
+    }
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, props, onError) {
+    const tagToken = props.tag;
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    if (token.type === 'block-seq') {
+        const { anchor, newlineAfterProp: nl } = props;
+        const lastProp = anchor && tagToken
+            ? anchor.offset > tagToken.offset
+                ? anchor
+                : tagToken
+            : (anchor ?? tagToken);
+        if (lastProp && (!nl || nl.offset < lastProp.offset)) {
+            const message = 'Missing newline after block sequence props';
+            onError(lastProp, 'MISSING_CHAR', message);
+        }
+    }
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq')) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
+    if (!tag) {
+        const kt = ctx.schema.knownTags[tagName];
+        if (kt?.collection === expType) {
+            ctx.schema.tags.push(Object.assign({}, kt, { default: false }));
+            tag = kt;
+        }
+        else {
+            if (kt) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection ?? 'scalar'}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
+        }
+    }
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
+    const node = identity.isNode(res)
+        ? res
+        : new Scalar.Scalar(res);
+    node.range = coll.range;
+    node.tag = tagName;
+    if (tag?.format)
+        node.format = tag.format;
+    return node;
+}
+
+exports.composeCollection = composeCollection;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-doc.d.ts

@@ -0,0 +1,7 @@
+import type { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ParsedNode } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type * as CST from '../parse/cst';
+import type { ComposeErrorHandler } from './composer';
+export declare function composeDoc<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true>(options: ParseOptions & DocumentOptions & SchemaOptions, directives: Directives, { offset, start, value, end }: CST.Document, onError: ComposeErrorHandler): Document.Parsed<Contents, Strict>;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-doc.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var Document = require('../doc/Document.js');
+var composeNode = require('./compose-node.js');
+var resolveEnd = require('./resolve-end.js');
+var resolveProps = require('./resolve-props.js');
+
+function composeDoc(options, directives, { offset, start, value, end }, onError) {
+    const opts = Object.assign({ _directives: directives }, options);
+    const doc = new Document.Document(undefined, opts);
+    const ctx = {
+        atKey: false,
+        atRoot: true,
+        directives: doc.directives,
+        options: doc.options,
+        schema: doc.schema
+    };
+    const props = resolveProps.resolveProps(start, {
+        indicator: 'doc-start',
+        next: value ?? end?.[0],
+        offset,
+        onError,
+        parentIndent: 0,
+        startOnNewline: true
+    });
+    if (props.found) {
+        doc.directives.docStart = true;
+        if (value &&
+            (value.type === 'block-map' || value.type === 'block-seq') &&
+            !props.hasNewline)
+            onError(props.end, 'MISSING_CHAR', 'Block collection cannot start on same line with directives-end marker');
+    }
+    // @ts-expect-error If Contents is set, let's trust the user
+    doc.contents = value
+        ? composeNode.composeNode(ctx, value, props, onError)
+        : composeNode.composeEmptyNode(ctx, props.end, start, null, props, onError);
+    const contentEnd = doc.contents.range[2];
+    const re = resolveEnd.resolveEnd(end, contentEnd, false, onError);
+    if (re.comment)
+        doc.comment = re.comment;
+    doc.range = [offset, contentEnd, re.offset];
+    return doc;
+}
+
+exports.composeDoc = composeDoc;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-node.d.ts

@@ -0,0 +1,29 @@
+import type { Directives } from '../doc/directives';
+import type { ParsedNode } from '../nodes/Node';
+import type { ParseOptions } from '../options';
+import type { SourceToken, Token } from '../parse/cst';
+import type { Schema } from '../schema/Schema';
+import type { ComposeErrorHandler } from './composer';
+export interface ComposeContext {
+    atKey: boolean;
+    atRoot: boolean;
+    directives: Directives;
+    options: Readonly<Required<Omit<ParseOptions, 'lineCounter'>>>;
+    schema: Readonly<Schema>;
+}
+interface Props {
+    spaceBefore: boolean;
+    comment: string;
+    anchor: SourceToken | null;
+    tag: SourceToken | null;
+    newlineAfterProp: SourceToken | null;
+    end: number;
+}
+declare const CN: {
+    composeNode: typeof composeNode;
+    composeEmptyNode: typeof composeEmptyNode;
+};
+export type ComposeNode = typeof CN;
+export declare function composeNode(ctx: ComposeContext, token: Token, props: Props, onError: ComposeErrorHandler): ParsedNode;
+export declare function composeEmptyNode(ctx: ComposeContext, offset: number, before: Token[] | undefined, pos: number | null, { spaceBefore, comment, anchor, tag, end }: Props, onError: ComposeErrorHandler): import('../index').Scalar.Parsed;
+export {};

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-node.js

@@ -0,0 +1,112 @@
+'use strict';
+
+var Alias = require('../nodes/Alias.js');
+var identity = require('../nodes/identity.js');
+var composeCollection = require('./compose-collection.js');
+var composeScalar = require('./compose-scalar.js');
+var resolveEnd = require('./resolve-end.js');
+var utilEmptyScalarPosition = require('./util-empty-scalar-position.js');
+
+const CN = { composeNode, composeEmptyNode };
+function composeNode(ctx, token, props, onError) {
+    const atKey = ctx.atKey;
+    const { spaceBefore, comment, anchor, tag } = props;
+    let node;
+    let isSrcToken = true;
+    switch (token.type) {
+        case 'alias':
+            node = composeAlias(ctx, token, onError);
+            if (anchor || tag)
+                onError(token, 'ALIAS_PROPS', 'An alias node must not specify any properties');
+            break;
+        case 'scalar':
+        case 'single-quoted-scalar':
+        case 'double-quoted-scalar':
+        case 'block-scalar':
+            node = composeScalar.composeScalar(ctx, token, tag, onError);
+            if (anchor)
+                node.anchor = anchor.source.substring(1);
+            break;
+        case 'block-map':
+        case 'block-seq':
+        case 'flow-collection':
+            try {
+                node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+                if (anchor)
+                    node.anchor = anchor.source.substring(1);
+            }
+            catch (error) {
+                // Almost certainly here due to a stack overflow
+                const message = error instanceof Error ? error.message : String(error);
+                onError(token, 'RESOURCE_EXHAUSTION', message);
+            }
+            break;
+        default: {
+            const message = token.type === 'error'
+                ? token.message
+                : `Unsupported token (type: ${token.type})`;
+            onError(token, 'UNEXPECTED_TOKEN', message);
+            isSrcToken = false;
+        }
+    }
+    node ?? (node = composeEmptyNode(ctx, token.offset, undefined, null, props, onError));
+    if (anchor && node.anchor === '')
+        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    if (atKey &&
+        ctx.options.stringKeys &&
+        (!identity.isScalar(node) ||
+            typeof node.value !== 'string' ||
+            (node.tag && node.tag !== 'tag:yaml.org,2002:str'))) {
+        const msg = 'With stringKeys, all keys must be strings';
+        onError(tag ?? token, 'NON_STRING_KEY', msg);
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        if (token.type === 'scalar' && token.source === '')
+            node.comment = comment;
+        else
+            node.commentBefore = comment;
+    }
+    // @ts-expect-error Type checking misses meaning of isSrcToken
+    if (ctx.options.keepSourceTokens && isSrcToken)
+        node.srcToken = token;
+    return node;
+}
+function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+    const token = {
+        type: 'scalar',
+        offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
+        indent: -1,
+        source: ''
+    };
+    const node = composeScalar.composeScalar(ctx, token, tag, onError);
+    if (anchor) {
+        node.anchor = anchor.source.substring(1);
+        if (node.anchor === '')
+            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
+    }
+    if (spaceBefore)
+        node.spaceBefore = true;
+    if (comment) {
+        node.comment = comment;
+        node.range[2] = end;
+    }
+    return node;
+}
+function composeAlias({ options }, { offset, source, end }, onError) {
+    const alias = new Alias.Alias(source.substring(1));
+    if (alias.source === '')
+        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
+    if (alias.source.endsWith(':'))
+        onError(offset + source.length - 1, 'BAD_ALIAS', 'Alias ending in : is ambiguous', true);
+    const valueEnd = offset + source.length;
+    const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
+    alias.range = [offset, valueEnd, re.offset];
+    if (re.comment)
+        alias.comment = re.comment;
+    return alias;
+}
+
+exports.composeEmptyNode = composeEmptyNode;
+exports.composeNode = composeNode;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-scalar.d.ts

@@ -0,0 +1,5 @@
+import { Scalar } from '../nodes/Scalar';
+import type { BlockScalar, FlowScalar, SourceToken } from '../parse/cst';
+import type { ComposeContext } from './compose-node';
+import type { ComposeErrorHandler } from './composer';
+export declare function composeScalar(ctx: ComposeContext, token: FlowScalar | BlockScalar, tagToken: SourceToken | null, onError: ComposeErrorHandler): Scalar.Parsed;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/compose-scalar.js

@@ -0,0 +1,88 @@
+'use strict';
+
+var identity = require('../nodes/identity.js');
+var Scalar = require('../nodes/Scalar.js');
+var resolveBlockScalar = require('./resolve-block-scalar.js');
+var resolveFlowScalar = require('./resolve-flow-scalar.js');
+
+function composeScalar(ctx, token, tagToken, onError) {
+    const { value, type, comment, range } = token.type === 'block-scalar'
+        ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError)
+        : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+    const tagName = tagToken
+        ? ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg))
+        : null;
+    let tag;
+    if (ctx.options.stringKeys && ctx.atKey) {
+        tag = ctx.schema[identity.SCALAR];
+    }
+    else if (tagName)
+        tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+    else if (token.type === 'scalar')
+        tag = findScalarTagByTest(ctx, value, token, onError);
+    else
+        tag = ctx.schema[identity.SCALAR];
+    let scalar;
+    try {
+        const res = tag.resolve(value, msg => onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+        scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        onError(tagToken ?? token, 'TAG_RESOLVE_FAILED', msg);
+        scalar = new Scalar.Scalar(value);
+    }
+    scalar.range = range;
+    scalar.source = value;
+    if (type)
+        scalar.type = type;
+    if (tagName)
+        scalar.tag = tagName;
+    if (tag.format)
+        scalar.format = tag.format;
+    if (comment)
+        scalar.comment = comment;
+    return scalar;
+}
+function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+    if (tagName === '!')
+        return schema[identity.SCALAR]; // non-specific tag
+    const matchWithTest = [];
+    for (const tag of schema.tags) {
+        if (!tag.collection && tag.tag === tagName) {
+            if (tag.default && tag.test)
+                matchWithTest.push(tag);
+            else
+                return tag;
+        }
+    }
+    for (const tag of matchWithTest)
+        if (tag.test?.test(value))
+            return tag;
+    const kt = schema.knownTags[tagName];
+    if (kt && !kt.collection) {
+        // Ensure that the known tag is available for stringifying,
+        // but does not get used by default.
+        schema.tags.push(Object.assign({}, kt, { default: false, test: undefined }));
+        return kt;
+    }
+    onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
+    return schema[identity.SCALAR];
+}
+function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+    const tag = schema.tags.find(tag => (tag.default === true || (atKey && tag.default === 'key')) &&
+        tag.test?.test(value)) || schema[identity.SCALAR];
+    if (schema.compat) {
+        const compat = schema.compat.find(tag => tag.default && tag.test?.test(value)) ??
+            schema[identity.SCALAR];
+        if (tag.tag !== compat.tag) {
+            const ts = directives.tagString(tag.tag);
+            const cs = directives.tagString(compat.tag);
+            const msg = `Value may be parsed as either ${ts} or ${cs}`;
+            onError(token, 'TAG_RESOLVE_FAILED', msg, true);
+        }
+    }
+    return tag;
+}
+
+exports.composeScalar = composeScalar;

package/node_modules/toolcraft/node_modules/yaml/dist/compose/composer.d.ts

@@ -0,0 +1,63 @@
+import { Directives } from '../doc/directives';
+import { Document } from '../doc/Document';
+import type { ErrorCode } from '../errors';
+import { YAMLParseError, YAMLWarning } from '../errors';
+import type { ParsedNode, Range } from '../nodes/Node';
+import type { DocumentOptions, ParseOptions, SchemaOptions } from '../options';
+import type { Token } from '../parse/cst';
+type ErrorSource = number | [number, number] | Range | {
+    offset: number;
+    source?: string;
+};
+export type ComposeErrorHandler = (source: ErrorSource, code: ErrorCode, message: string, warning?: boolean) => void;
+/**
+ * Compose a stream of CST nodes into a stream of YAML Documents.
+ *
+ * ```ts
+ * import { Composer, Parser } from 'yaml'
+ *
+ * const src: string = ...
+ * const tokens = new Parser().parse(src)
+ * const docs = new Composer().compose(tokens)
+ * ```
+ */
+export declare class Composer<Contents extends ParsedNode = ParsedNode, Strict extends boolean = true> {
+    private directives;
+    private doc;
+    private options;
+    private atDirectives;
+    private prelude;
+    private errors;
+    private warnings;
+    constructor(options?: ParseOptions & DocumentOptions & SchemaOptions);
+    private onError;
+    private decorate;
+    /**
+     * Current stream status information.
+     *
+     * Mostly useful at the end of input for an empty stream.
+     */
+    streamInfo(): {
+        comment: string;
+        directives: Directives;
+        errors: YAMLParseError[];
+        warnings: YAMLWarning[];
+    };
+    /**
+     * Compose tokens into documents.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    compose(tokens: Iterable<Token>, forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
+    /** Advance the composer by one CST token. */
+    next(token: Token): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
+    /**
+     * Call at end of input to yield any remaining document.
+     *
+     * @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+     * @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+     */
+    end(forceDoc?: boolean, endOffset?: number): Generator<Document.Parsed<Contents, Strict>, void, unknown>;
+}
+export {};