kenaz 0.3.3 → 0.3.6

package/core/k-cli/node_modules/yaml/dist/cli.mjs

@@ -1,201 +0,0 @@
-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/core/k-cli/node_modules/yaml/dist/compose/compose-collection.d.ts

@@ -1,11 +0,0 @@
-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/core/k-cli/node_modules/yaml/dist/compose/compose-collection.js

@@ -1,90 +0,0 @@
-'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/core/k-cli/node_modules/yaml/dist/compose/compose-doc.d.ts

@@ -1,7 +0,0 @@
-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/core/k-cli/node_modules/yaml/dist/compose/compose-doc.js

@@ -1,45 +0,0 @@
-'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/core/k-cli/node_modules/yaml/dist/compose/compose-node.d.ts

@@ -1,29 +0,0 @@
-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/core/k-cli/node_modules/yaml/dist/compose/compose-node.js

@@ -1,112 +0,0 @@
-'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/core/k-cli/node_modules/yaml/dist/compose/compose-scalar.d.ts

@@ -1,5 +0,0 @@
-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/core/k-cli/node_modules/yaml/dist/compose/compose-scalar.js

@@ -1,88 +0,0 @@
-'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/core/k-cli/node_modules/yaml/dist/compose/composer.d.ts

@@ -1,63 +0,0 @@
-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 {};