conventional-changelog 7.0.0 → 7.0.2

package/dist/ConventionalChangelog.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Readable } from 'stream';
+import type { ParserStreamOptions, Commit } from 'conventional-commits-parser';
+import { type GetSemverTagsParams, type GetCommitsParams, ConventionalGitClient, packagePrefix } from '@conventional-changelog/git-client';
+import { type Options as WriterOptions, type Context, type Details } from 'conventional-changelog-writer';
+import { type UnknownPresetCreatorParams, type PresetParams } from 'conventional-changelog-preset-loader';
+import type { HostedGitInfo, PackageTransform, Options, Preset } from './types.js';
+export { packagePrefix };
+/**
+ * Conventional changelog generator
+ */
+export declare class ConventionalChangelog {
+    private readonly gitClient;
+    private params;
+    constructor(cwdOrGitClient?: string | ConventionalGitClient);
+    private composeParams;
+    private finalizeContext;
+    private finalizeWriterOptions;
+    private getSemverTags;
+    private getCommits;
+    private transformCommits;
+    private getPackageJson;
+    /**
+     * Load configs from a preset
+     * @param preset
+     * @returns this
+     */
+    loadPreset<PresetCreatorParams extends UnknownPresetCreatorParams = UnknownPresetCreatorParams>(preset: PresetParams<PresetCreatorParams>): this;
+    /**
+     * Set the config directly
+     * @param config - Config object
+     * @returns this
+     */
+    config(config: Preset | Promise<Preset>): this;
+    /**
+     * Find package.json and read it
+     * @param transform - Optional transform function
+     * @returns this
+     */
+    readPackage(transform?: PackageTransform): this;
+    /**
+     * Read package.json from a specified path
+     * @param path - Path to package.json
+     * @param transform - Optional transform function
+     * @returns this
+     */
+    readPackage(path?: string, transform?: PackageTransform): this;
+    /**
+     * Set package.json data
+     * @param pkg - Package.json data
+     * @returns this
+     */
+    package(pkg: Record<string, unknown>): this;
+    /**
+     * Read repository info from the current git repository
+     * @returns this
+     */
+    readRepository(): this;
+    /**
+     * Set repository info
+     * @param infoOrGitUrl - Hosted git info or git url
+     * @returns this
+     */
+    repository(infoOrGitUrl: string | Partial<HostedGitInfo>): this;
+    /**
+     * Set conventional-changelog options
+     * @param options - Generator options
+     * @returns this
+     */
+    options(options: Options): this;
+    /**
+     * Set writer context data
+     * @param context - Writer context data
+     * @returns this
+     */
+    context(context: Context): this;
+    /**
+     * Set params to get semver tags
+     * @param params - Params to get the last semver tag
+     * @returns this
+     */
+    tags(params: GetSemverTagsParams): this;
+    /**
+     * Set params to get commits
+     * @param params - Params to get commits since last release
+     * @param parserOptions - Parser options
+     * @returns this
+     */
+    commits(params: GetCommitsParams, parserOptions?: ParserStreamOptions): this;
+    /**
+     * Set writer options
+     * @param params - Writer options
+     * @returns this
+     */
+    writer(params: WriterOptions): this;
+    /**
+     * Generate changelog
+     * @param includeDetails - Generate data objects instead of strings
+     * @returns Changelog generator
+     */
+    write(includeDetails?: false): AsyncGenerator<string, void>;
+    /**
+     * Generate changelog data objects
+     * @param includeDetails - Generate data objects instead of strings
+     */
+    write(includeDetails: true): AsyncGenerator<Details<Commit>, void>;
+    /**
+     * Generate changelog
+     * @param includeDetails - Generate data objects instead of strings
+     * @returns Changelog generator
+     */
+    write(includeDetails?: boolean): AsyncGenerator<string | Details<Commit>, void>;
+    /**
+     * Generate changelog to stream
+     * @param includeDetails - Generate data objects instead of strings
+     * @returns Changelog stream
+     */
+    writeStream(includeDetails?: boolean): Readable;
+}
+//# sourceMappingURL=ConventionalChangelog.d.ts.map

package/dist/ConventionalChangelog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConventionalChangelog.d.ts","sourceRoot":"","sources":["../src/ConventionalChangelog.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AACjC,OAAO,KAAK,EACV,mBAAmB,EACnB,MAAM,EACP,MAAM,6BAA6B,CAAA;AACpC,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,qBAAqB,EACrB,aAAa,EACd,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EACL,KAAK,OAAO,IAAI,aAAa,EAC7B,KAAK,OAAO,EACZ,KAAK,OAAO,EAIb,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,KAAK,0BAA0B,EAC/B,KAAK,YAAY,EAElB,MAAM,sCAAsC,CAAA;AAI7C,OAAO,KAAK,EACV,aAAa,EAGb,gBAAgB,EAEhB,OAAO,EAEP,MAAM,EACP,MAAM,YAAY,CAAA;AAUnB,OAAO,EAAE,aAAa,EAAE,CAAA;AAExB;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAuB;IACjD,OAAO,CAAC,MAAM,CAAiB;gBAEnB,cAAc,GAAE,MAAM,GAAG,qBAAqC;IAmB1E,OAAO,CAAC,aAAa;YAkCP,eAAe;YAiCf,qBAAqB;YA0FrB,aAAa;YAYZ,UAAU;YAiFV,gBAAgB;YAcjB,cAAc;IA8C5B;;;;OAIG;IACH,UAAU,CAAC,mBAAmB,SAAS,0BAA0B,GAAG,0BAA0B,EAC5F,MAAM,EAAE,YAAY,CAAC,mBAAmB,CAAC;IAe3C;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAMvC;;;;OAIG;IACH,WAAW,CAAC,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAC/C;;;;;OAKG;IACH,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,gBAAgB,GAAG,IAAI;IAa9D;;;;OAIG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAQpC;;;OAGG;IACH,cAAc;IAUd;;;;OAIG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAYxD;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO;IAQxB;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO;IAQxB;;;;OAIG;IACH,IAAI,CAAC,MAAM,EAAE,mBAAmB;IAQhC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,CAAC,EAAE,mBAAmB;IASrE;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,aAAa;IAQ5B;;;;OAIG;IACH,KAAK,CAAC,cAAc,CAAC,EAAE,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,IAAI,CAAC;IAC3D;;;OAGG;IACH,KAAK,CAAC,cAAc,EAAE,IAAI,GAAG,cAAc,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC;IAClE;;;;OAIG;IACH,KAAK,CAAC,cAAc,CAAC,EAAE,OAAO,GAAG,cAAc,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC;IA4B/E;;;;OAIG;IACH,WAAW,CAAC,cAAc,CAAC,EAAE,OAAO;CAGrC"}

package/dist/ConventionalChangelog.js

@@ -0,0 +1,429 @@
+import fs from 'fs/promises';
+import { Readable } from 'stream';
+import { ConventionalGitClient, packagePrefix } from '@conventional-changelog/git-client';
+import { transformCommit, formatDate, writeChangelog } from 'conventional-changelog-writer';
+import { loadPreset } from 'conventional-changelog-preset-loader';
+import normalizePackageData from 'normalize-package-data';
+import { findPackage } from 'fd-package-json';
+import { parseHostedGitUrl } from './hostedGitInfo.js';
+import { getHostOptions, guessNextTag, isUnreleasedVersion, versionTagRegex, defaultCommitTransform, bindLogNamespace } from './utils.js';
+export { packagePrefix };
+/**
+ * Conventional changelog generator
+ */
+export class ConventionalChangelog {
+    gitClient;
+    params;
+    constructor(cwdOrGitClient = process.cwd()) {
+        this.gitClient = typeof cwdOrGitClient === 'string'
+            ? new ConventionalGitClient(cwdOrGitClient)
+            : cwdOrGitClient;
+        this.params = Promise.resolve({
+            options: {
+                append: false,
+                releaseCount: 1,
+                formatDate,
+                transformCommit: defaultCommitTransform
+            },
+            commits: {
+                format: '%B%n-hash-%n%H%n-gitTags-%n%d%n-committerDate-%n%ci',
+                merges: false
+            }
+        });
+    }
+    composeParams(params) {
+        this.params = Promise.all([params, this.params]).then(([params, prevParams]) => ({
+            options: {
+                ...prevParams.options,
+                ...params.options
+            },
+            context: {
+                ...prevParams.context,
+                ...params.context
+            },
+            tags: {
+                ...prevParams.tags,
+                ...params.tags
+            },
+            commits: {
+                ...prevParams.commits,
+                ...params.commits
+            },
+            parser: {
+                ...prevParams.parser,
+                ...params.parser
+            },
+            writer: {
+                ...prevParams.writer,
+                ...params.writer
+            },
+            repository: {
+                ...prevParams.repository,
+                ...params.repository
+            },
+            package: prevParams.package || params.package
+        }));
+    }
+    async finalizeContext(semverTags, hostOptions) {
+        const { options, package: pkg, repository, context } = await this.params;
+        const finalContext = {
+            packageData: pkg,
+            version: pkg?.version,
+            gitSemverTags: semverTags,
+            ...context
+        };
+        if (repository) {
+            finalContext.repoUrl = finalContext.repoUrl || repository.url;
+            finalContext.host = finalContext.host || repository.host;
+            finalContext.owner = finalContext.owner || repository.owner;
+            finalContext.repository = finalContext.repository || repository.project;
+        }
+        if (hostOptions) {
+            finalContext.issue = finalContext.issue || hostOptions.issue;
+            finalContext.commit = finalContext.commit || hostOptions.commit;
+        }
+        if (isUnreleasedVersion(semverTags, finalContext.version) && options.outputUnreleased) {
+            finalContext.version = 'Unreleased';
+        }
+        return finalContext;
+    }
+    async finalizeWriterOptions(semverTags, version) {
+        const { options, tags, writer } = await this.params;
+        let doFlush = options.outputUnreleased;
+        if (isUnreleasedVersion(semverTags, version) && !doFlush) {
+            doFlush = false;
+        }
+        else if (typeof doFlush !== 'boolean') {
+            doFlush = true;
+        }
+        const finalOptions = {
+            finalizeContext(context, _writerOpts, _filteredCommits, keyCommit, originalCommits) {
+                const [firstCommit] = originalCommits;
+                const lastCommit = originalCommits[originalCommits.length - 1];
+                const firstCommitHash = firstCommit ? firstCommit.hash : null;
+                const lastCommitHash = lastCommit ? lastCommit.hash : null;
+                if ((!context.currentTag || !context.previousTag) && keyCommit) {
+                    const matches = keyCommit.gitTags?.match(versionTagRegex);
+                    const { currentTag } = context;
+                    context.currentTag = currentTag || matches?.[1]; // currentTag || matches ? matches[1] : null
+                    const index = context.currentTag
+                        ? semverTags.indexOf(context.currentTag)
+                        : -1;
+                    // if `keyCommit.gitTags` is not a semver
+                    if (index === -1) {
+                        context.currentTag = currentTag || null;
+                    }
+                    else {
+                        const previousTag = semverTags[index + 1];
+                        context.previousTag = previousTag;
+                        if (!previousTag) {
+                            if (options.append) {
+                                context.previousTag = context.previousTag || firstCommitHash;
+                            }
+                            else {
+                                context.previousTag = context.previousTag || lastCommitHash;
+                            }
+                        }
+                    }
+                }
+                else {
+                    context.previousTag = context.previousTag || semverTags[0];
+                    if (context.version === 'Unreleased') {
+                        if (options.append) {
+                            context.currentTag = context.currentTag || lastCommitHash;
+                        }
+                        else {
+                            context.currentTag = context.currentTag || firstCommitHash;
+                        }
+                    }
+                    else if (!context.currentTag) {
+                        if (tags?.prefix) {
+                            context.currentTag = tags.prefix + (context.version || '');
+                        }
+                        else {
+                            context.currentTag = guessNextTag(semverTags[0], context.version);
+                        }
+                    }
+                }
+                if (typeof context.linkCompare !== 'boolean' && context.previousTag && context.currentTag) {
+                    context.linkCompare = true;
+                }
+                return context;
+            },
+            reverse: options.append,
+            doFlush,
+            ...writer
+        };
+        if (!finalOptions.debug && options.debug) {
+            finalOptions.debug = bindLogNamespace('writer', options.debug);
+        }
+        return finalOptions;
+    }
+    async getSemverTags() {
+        const { gitClient } = this;
+        const { tags: params } = await this.params;
+        const tags = [];
+        for await (const tag of gitClient.getSemverTags(params)) {
+            tags.push(tag);
+        }
+        return tags;
+    }
+    async *getCommits(semverTags, hostOptions) {
+        const { gitClient } = this;
+        const { options, commits, parser } = await this.params;
+        const { reset, releaseCount } = options;
+        const params = {
+            from: reset
+                ? undefined
+                : releaseCount
+                    ? semverTags[releaseCount - 1]
+                    : undefined,
+            ...commits
+        };
+        const parserParams = {
+            ...parser
+        };
+        if (!parserParams.warn && options.warn) {
+            parserParams.warn = bindLogNamespace('parser', options.warn);
+        }
+        if (options.append) {
+            params.reverse = true;
+        }
+        if (hostOptions?.referenceActions && !parserParams.referenceActions?.length) {
+            parserParams.referenceActions = hostOptions.referenceActions;
+        }
+        if (hostOptions?.issuePrefixes && !parserParams.issuePrefixes?.length) {
+            parserParams.issuePrefixes = hostOptions.issuePrefixes;
+        }
+        try {
+            await gitClient.verify('HEAD');
+            let reverseTags = semverTags.slice().reverse();
+            reverseTags.push('HEAD');
+            if (params.from) {
+                if (reverseTags.includes(params.from)) {
+                    reverseTags = reverseTags.slice(reverseTags.indexOf(params.from));
+                }
+                else {
+                    reverseTags = [params.from, 'HEAD'];
+                }
+            }
+            else {
+                reverseTags.unshift('');
+            }
+            const streams = [];
+            for (let i = 1, len = reverseTags.length; i < len; i++) {
+                streams.push(gitClient.getCommits({
+                    ...params,
+                    from: reverseTags[i - 1],
+                    to: reverseTags[i]
+                }, parserParams));
+            }
+            if (!params.reverse) {
+                streams.reverse();
+            }
+            for (const stream of streams) {
+                yield* stream;
+            }
+        }
+        catch (err) {
+            yield* gitClient.getCommits(params, parserParams);
+        }
+    }
+    async *transformCommits(commits) {
+        const params = await this.params;
+        const { transformCommit: transform } = params.options;
+        let transformed;
+        for await (const commit of commits) {
+            transformed = await transformCommit(commit, transform, params);
+            if (transformed) {
+                yield transformed;
+            }
+        }
+    }
+    async getPackageJson(pkgPath, transform) {
+        const { gitClient } = this;
+        let pkg;
+        if (pkgPath) {
+            pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
+        }
+        else {
+            pkg = (await findPackage(gitClient.cwd) || {});
+        }
+        normalizePackageData(pkg);
+        if (!pkg.repository?.url) {
+            try {
+                const repoUrl = await gitClient.getConfig('remote.origin.url');
+                if (repoUrl) {
+                    pkg.repository = {
+                        ...pkg.repository,
+                        url: repoUrl
+                    };
+                }
+            }
+            catch (err) {
+                // Do nothing
+            }
+        }
+        if (transform) {
+            pkg = transform(pkg);
+        }
+        const result = {
+            package: pkg
+        };
+        const repositoryURL = (pkg.repository?.url || pkg.repository);
+        if (repositoryURL) {
+            result.repository = parseHostedGitUrl(repositoryURL);
+        }
+        return result;
+    }
+    /**
+     * Load configs from a preset
+     * @param preset
+     * @returns this
+     */
+    loadPreset(preset) {
+        const config = loadPreset(preset).then((config) => {
+            if (!config) {
+                throw Error('Preset is not loaded or have incorrect exports');
+            }
+            return config;
+        });
+        this.composeParams(config);
+        return this;
+    }
+    /**
+     * Set the config directly
+     * @param config - Config object
+     * @returns this
+     */
+    config(config) {
+        this.composeParams(config);
+        return this;
+    }
+    readPackage(pathOrTransform, maybeTransform) {
+        const [pkgPath, transform] = typeof pathOrTransform === 'string'
+            ? [pathOrTransform, maybeTransform]
+            : [undefined, pathOrTransform];
+        this.composeParams(this.getPackageJson(pkgPath, transform));
+        return this;
+    }
+    /**
+     * Set package.json data
+     * @param pkg - Package.json data
+     * @returns this
+     */
+    package(pkg) {
+        this.composeParams({
+            package: pkg
+        });
+        return this;
+    }
+    /**
+     * Read repository info from the current git repository
+     * @returns this
+     */
+    readRepository() {
+        this.composeParams(this.gitClient.getConfig('remote.origin.url').then(repository => ({
+            repository: parseHostedGitUrl(repository)
+        })));
+        return this;
+    }
+    /**
+     * Set repository info
+     * @param infoOrGitUrl - Hosted git info or git url
+     * @returns this
+     */
+    repository(infoOrGitUrl) {
+        const info = typeof infoOrGitUrl === 'string'
+            ? parseHostedGitUrl(infoOrGitUrl)
+            : infoOrGitUrl;
+        this.composeParams({
+            repository: info
+        });
+        return this;
+    }
+    /**
+     * Set conventional-changelog options
+     * @param options - Generator options
+     * @returns this
+     */
+    options(options) {
+        this.composeParams({
+            options
+        });
+        return this;
+    }
+    /**
+     * Set writer context data
+     * @param context - Writer context data
+     * @returns this
+     */
+    context(context) {
+        this.composeParams({
+            context
+        });
+        return this;
+    }
+    /**
+     * Set params to get semver tags
+     * @param params - Params to get the last semver tag
+     * @returns this
+     */
+    tags(params) {
+        this.composeParams({
+            tags: params
+        });
+        return this;
+    }
+    /**
+     * Set params to get commits
+     * @param params - Params to get commits since last release
+     * @param parserOptions - Parser options
+     * @returns this
+     */
+    commits(params, parserOptions) {
+        this.composeParams({
+            commits: params,
+            parser: parserOptions
+        });
+        return this;
+    }
+    /**
+     * Set writer options
+     * @param params - Writer options
+     * @returns this
+     */
+    writer(params) {
+        this.composeParams({
+            writer: params
+        });
+        return this;
+    }
+    async *write(includeDetails) {
+        const { gitClient } = this;
+        const { options, repository, context } = await this.params;
+        const hostOptions = getHostOptions(repository, context);
+        if (!gitClient.debug && options.debug) {
+            gitClient.debug = bindLogNamespace('git-client', options.debug);
+        }
+        if (!hostOptions && options.warn) {
+            options.warn('core', `Host is not supported: ${context?.host || repository?.host}`);
+        }
+        const semverTags = await this.getSemverTags();
+        const finalContext = await this.finalizeContext(semverTags, hostOptions);
+        const writerOptions = await this.finalizeWriterOptions(semverTags, finalContext.version);
+        const commits = this.getCommits(semverTags, hostOptions);
+        const transformedCommits = this.transformCommits(commits);
+        const changelogWriter = writeChangelog(finalContext, writerOptions, includeDetails);
+        yield* changelogWriter(transformedCommits);
+    }
+    /**
+     * Generate changelog to stream
+     * @param includeDetails - Generate data objects instead of strings
+     * @returns Changelog stream
+     */
+    writeStream(includeDetails) {
+        return Readable.from(this.write(includeDetails));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ConventionalChangelog.js","sourceRoot":"","sources":["../src/ConventionalChangelog.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,aAAa,CAAA;AAC5B,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAKjC,OAAO,EAGL,qBAAqB,EACrB,aAAa,EACd,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAIL,eAAe,EACf,UAAU,EACV,cAAc,EACf,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAGL,UAAU,EACX,MAAM,sCAAsC,CAAA;AAC7C,OAAO,oBAAoB,MAAM,wBAAwB,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAWtD,OAAO,EACL,cAAc,EACd,YAAY,EACZ,mBAAmB,EACnB,eAAe,EACf,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,aAAa,EAAE,CAAA;AAExB;;GAEG;AACH,MAAM,OAAO,qBAAqB;IACf,SAAS,CAAuB;IACzC,MAAM,CAAiB;IAE/B,YAAY,iBAAiD,OAAO,CAAC,GAAG,EAAE;QACxE,IAAI,CAAC,SAAS,GAAG,OAAO,cAAc,KAAK,QAAQ;YACjD,CAAC,CAAC,IAAI,qBAAqB,CAAC,cAAc,CAAC;YAC3C,CAAC,CAAC,cAAc,CAAA;QAElB,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;YAC5B,OAAO,EAAE;gBACP,MAAM,EAAE,KAAK;gBACb,YAAY,EAAE,CAAC;gBACf,UAAU;gBACV,eAAe,EAAE,sBAAsB;aACxC;YACD,OAAO,EAAE;gBACP,MAAM,EAAE,qDAAqD;gBAC7D,MAAM,EAAE,KAAK;aACd;SACF,CAAC,CAAA;IACJ,CAAC;IAEO,aAAa,CAAC,MAAkD;QACtE,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC;YAC/E,OAAO,EAAE;gBACP,GAAG,UAAU,CAAC,OAAO;gBACrB,GAAG,MAAM,CAAC,OAAO;aAClB;YACD,OAAO,EAAE;gBACP,GAAG,UAAU,CAAC,OAAO;gBACrB,GAAG,MAAM,CAAC,OAAO;aAClB;YACD,IAAI,EAAE;gBACJ,GAAG,UAAU,CAAC,IAAI;gBAClB,GAAG,MAAM,CAAC,IAAI;aACf;YACD,OAAO,EAAE;gBACP,GAAG,UAAU,CAAC,OAAO;gBACrB,GAAG,MAAM,CAAC,OAAO;aAClB;YACD,MAAM,EAAE;gBACN,GAAG,UAAU,CAAC,MAAM;gBACpB,GAAG,MAAM,CAAC,MAAM;aACjB;YACD,MAAM,EAAE;gBACN,GAAG,UAAU,CAAC,MAAM;gBACpB,GAAG,MAAM,CAAC,MAAM;aACjB;YACD,UAAU,EAAE;gBACV,GAAG,UAAU,CAAC,UAAU;gBACxB,GAAG,MAAM,CAAC,UAAU;aACrB;YACD,OAAO,EAAE,UAAU,CAAC,OAAO,IAAI,MAAM,CAAC,OAAO;SAC9C,CAAC,CAAC,CAAA;IACL,CAAC;IAEO,KAAK,CAAC,eAAe,CAAC,UAAoB,EAAE,WAA+B;QACjF,MAAM,EACJ,OAAO,EACP,OAAO,EAAE,GAAG,EACZ,UAAU,EACV,OAAO,EACR,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QACrB,MAAM,YAAY,GAAG;YACnB,WAAW,EAAE,GAAG;YAChB,OAAO,EAAE,GAAG,EAAE,OAAO;YACrB,aAAa,EAAE,UAAU;YACzB,GAAG,OAAO;SACX,CAAA;QAED,IAAI,UAAU,EAAE;YACd,YAAY,CAAC,OAAO,GAAG,YAAY,CAAC,OAAO,IAAI,UAAU,CAAC,GAAG,CAAA;YAC7D,YAAY,CAAC,IAAI,GAAG,YAAY,CAAC,IAAI,IAAI,UAAU,CAAC,IAAI,CAAA;YACxD,YAAY,CAAC,KAAK,GAAG,YAAY,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAA;YAC3D,YAAY,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,IAAI,UAAU,CAAC,OAAO,CAAA;SACxE;QAED,IAAI,WAAW,EAAE;YACf,YAAY,CAAC,KAAK,GAAG,YAAY,CAAC,KAAK,IAAI,WAAW,CAAC,KAAK,CAAA;YAC5D,YAAY,CAAC,MAAM,GAAG,YAAY,CAAC,MAAM,IAAI,WAAW,CAAC,MAAM,CAAA;SAChE;QAED,IAAI,mBAAmB,CAAC,UAAU,EAAE,YAAY,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC,gBAAgB,EAAE;YACrF,YAAY,CAAC,OAAO,GAAG,YAAY,CAAA;SACpC;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;IAEO,KAAK,CAAC,qBAAqB,CAAC,UAAoB,EAAE,OAA2B;QACnF,MAAM,EACJ,OAAO,EACP,IAAI,EACJ,MAAM,EACP,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QACrB,IAAI,OAAO,GAAG,OAAO,CAAC,gBAAgB,CAAA;QAEtC,IAAI,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE;YACxD,OAAO,GAAG,KAAK,CAAA;SAChB;aACC,IAAI,OAAO,OAAO,KAAK,SAAS,EAAE;YAChC,OAAO,GAAG,IAAI,CAAA;SACf;QAEH,MAAM,YAAY,GAAkB;YAClC,eAAe,CACb,OAAyB,EACzB,WAAW,EACX,gBAAgB,EAChB,SAAiB,EACjB,eAAe;gBAEf,MAAM,CAAC,WAAW,CAAC,GAAG,eAAe,CAAA;gBACrC,MAAM,UAAU,GAAG,eAAe,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;gBAC9D,MAAM,eAAe,GAAG,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;gBAC7D,MAAM,cAAc,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAA;gBAE1D,IAAI,CAAC,CAAC,OAAO,CAAC,UAAU,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,SAAS,EAAE;oBAC9D,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;oBACzD,MAAM,EAAE,UAAU,EAAE,GAAG,OAAO,CAAA;oBAE9B,OAAO,CAAC,UAAU,GAAG,UAAU,IAAI,OAAO,EAAE,CAAC,CAAC,CAAC,CAAA,CAAC,4CAA4C;oBAE5F,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU;wBAC9B,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC;wBACxC,CAAC,CAAC,CAAC,CAAC,CAAA;oBAEN,yCAAyC;oBACzC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;wBAChB,OAAO,CAAC,UAAU,GAAG,UAAU,IAAI,IAAI,CAAA;qBACxC;yBAAM;wBACL,MAAM,WAAW,GAAG,UAAU,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;wBAEzC,OAAO,CAAC,WAAW,GAAG,WAAW,CAAA;wBAEjC,IAAI,CAAC,WAAW,EAAE;4BAChB,IAAI,OAAO,CAAC,MAAM,EAAE;gCAClB,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,eAAe,CAAA;6BAC7D;iCAAM;gCACL,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,cAAc,CAAA;6BAC5D;yBACF;qBACF;iBACF;qBAAM;oBACL,OAAO,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,UAAU,CAAC,CAAC,CAAC,CAAA;oBAE1D,IAAI,OAAO,CAAC,OAAO,KAAK,YAAY,EAAE;wBACpC,IAAI,OAAO,CAAC,MAAM,EAAE;4BAClB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,cAAc,CAAA;yBAC1D;6BAAM;4BACL,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,eAAe,CAAA;yBAC3D;qBACF;yBAAM,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE;wBAC9B,IAAI,IAAI,EAAE,MAAM,EAAE;4BAChB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,OAAO,CAAC,OAAO,IAAI,EAAE,CAAC,CAAA;yBAC3D;6BAAM;4BACL,OAAO,CAAC,UAAU,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;yBAClE;qBACF;iBACF;gBAED,IAAI,OAAO,OAAO,CAAC,WAAW,KAAK,SAAS,IAAI,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,UAAU,EAAE;oBACzF,OAAO,CAAC,WAAW,GAAG,IAAI,CAAA;iBAC3B;gBAED,OAAO,OAAO,CAAA;YAChB,CAAC;YACD,OAAO,EAAE,OAAO,CAAC,MAAM;YACvB,OAAO;YACP,GAAG,MAAM;SACV,CAAA;QAED,IAAI,CAAC,YAAY,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE;YACxC,YAAY,CAAC,KAAK,GAAG,gBAAgB,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;SAC/D;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;IAEO,KAAK,CAAC,aAAa;QACzB,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;QAC1B,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QAC1C,MAAM,IAAI,GAAG,EAAE,CAAA;QAEf,IAAI,KAAK,EAAE,MAAM,GAAG,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE;YACvD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;SACf;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAEO,KAAK,CAAA,CAAE,UAAU,CACvB,UAAoB,EACpB,WAA+B;QAE/B,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;QAC1B,MAAM,EACJ,OAAO,EACP,OAAO,EACP,MAAM,EACP,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QACrB,MAAM,EACJ,KAAK,EACL,YAAY,EACb,GAAG,OAAO,CAAA;QACX,MAAM,MAAM,GAAG;YACb,IAAI,EAAE,KAAK;gBACT,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,YAAY;oBACZ,CAAC,CAAC,UAAU,CAAC,YAAY,GAAG,CAAC,CAAC;oBAC9B,CAAC,CAAC,SAAS;YACf,GAAG,OAAO;SACX,CAAA;QACD,MAAM,YAAY,GAAG;YACnB,GAAG,MAAM;SACV,CAAA;QAED,IAAI,CAAC,YAAY,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,EAAE;YACtC,YAAY,CAAC,IAAI,GAAG,gBAAgB,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;SAC7D;QAED,IAAI,OAAO,CAAC,MAAM,EAAE;YAClB,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;SACtB;QAED,IAAI,WAAW,EAAE,gBAAgB,IAAI,CAAC,YAAY,CAAC,gBAAgB,EAAE,MAAM,EAAE;YAC3E,YAAY,CAAC,gBAAgB,GAAG,WAAW,CAAC,gBAAgB,CAAA;SAC7D;QAED,IAAI,WAAW,EAAE,aAAa,IAAI,CAAC,YAAY,CAAC,aAAa,EAAE,MAAM,EAAE;YACrE,YAAY,CAAC,aAAa,GAAG,WAAW,CAAC,aAAa,CAAA;SACvD;QAED,IAAI;YACF,MAAM,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;YAE9B,IAAI,WAAW,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC,OAAO,EAAE,CAAA;YAE9C,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YAExB,IAAI,MAAM,CAAC,IAAI,EAAE;gBACf,IAAI,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;oBACrC,WAAW,GAAG,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;iBAClE;qBAAM;oBACL,WAAW,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;iBACpC;aACF;iBAAM;gBACL,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;aACxB;YAED,MAAM,OAAO,GAAG,EAAE,CAAA;YAElB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE;gBACtD,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC;oBAChC,GAAG,MAAM;oBACT,IAAI,EAAE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC;oBACxB,EAAE,EAAE,WAAW,CAAC,CAAC,CAAC;iBACnB,EAAE,YAAY,CAAC,CAAC,CAAA;aAClB;YAED,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;gBACnB,OAAO,CAAC,OAAO,EAAE,CAAA;aAClB;YAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;gBAC5B,KAAK,CAAC,CAAC,MAAM,CAAA;aACd;SACF;QAAC,OAAO,GAAG,EAAE;YACZ,KAAK,CAAC,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE,YAAY,CAAC,CAAA;SAClD;IACH,CAAC;IAEO,KAAK,CAAA,CAAE,gBAAgB,CAAC,OAA8B;QAC5D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QAChC,MAAM,EAAE,eAAe,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC,OAAO,CAAA;QACrD,IAAI,WAAW,CAAA;QAEf,IAAI,KAAK,EAAE,MAAM,MAAM,IAAI,OAAO,EAAE;YAClC,WAAW,GAAG,MAAM,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAA;YAE9D,IAAI,WAAW,EAAE;gBACf,MAAM,WAAW,CAAA;aAClB;SACF;IACH,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,OAAgB,EAAE,SAA4B;QACzE,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;QAC1B,IAAI,GAAY,CAAA;QAEhB,IAAI,OAAO,EAAE;YACX,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAY,CAAA;SACjE;aAAM;YACL,GAAG,GAAG,CAAC,MAAM,WAAW,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,CAAY,CAAA;SAC1D;QAED,oBAAoB,CAAC,GAAG,CAAC,CAAA;QAEzB,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,EAAE;YACxB,IAAI;gBACF,MAAM,OAAO,GAAG,MAAM,SAAS,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAA;gBAE9D,IAAI,OAAO,EAAE;oBACX,GAAG,CAAC,UAAU,GAAG;wBACf,GAAG,GAAG,CAAC,UAAW;wBAClB,GAAG,EAAE,OAAO;qBACb,CAAA;iBACF;aACF;YAAC,OAAO,GAAG,EAAE;gBACZ,aAAa;aACd;SACF;QAED,IAAI,SAAS,EAAE;YACb,GAAG,GAAG,SAAS,CAAC,GAAG,CAAC,CAAA;SACrB;QAED,MAAM,MAAM,GAGR;YACF,OAAO,EAAE,GAAG;SACb,CAAA;QACD,MAAM,aAAa,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,GAAG,IAAI,GAAG,CAAC,UAAU,CAAW,CAAA;QAEvE,IAAI,aAAa,EAAE;YACjB,MAAM,CAAC,UAAU,GAAG,iBAAiB,CAAC,aAAa,CAAC,CAAA;SACrD;QAED,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;OAIG;IACH,UAAU,CACR,MAAyC;QAEzC,MAAM,MAAM,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAChD,IAAI,CAAC,MAAM,EAAE;gBACX,MAAM,KAAK,CAAC,gDAAgD,CAAC,CAAA;aAC9D;YAED,OAAO,MAAM,CAAA;QACf,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;QAE1B,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAgC;QACrC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;QAE1B,OAAO,IAAI,CAAA;IACb,CAAC;IAeD,WAAW,CAAC,eAA2C,EAAE,cAAiC;QACxF,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,OAAO,eAAe,KAAK,QAAQ;YAC9D,CAAC,CAAC,CAAC,eAAe,EAAE,cAAc,CAAC;YACnC,CAAC,CAAC,CAAC,SAAS,EAAE,eAAe,CAAC,CAAA;QAEhC,IAAI,CAAC,aAAa,CAChB,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CACxC,CAAA;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,GAA4B;QAClC,IAAI,CAAC,aAAa,CAAC;YACjB,OAAO,EAAE,GAAc;SACxB,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;OAGG;IACH,cAAc;QACZ,IAAI,CAAC,aAAa,CAChB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YAChE,UAAU,EAAE,iBAAiB,CAAC,UAAU,CAAC;SAC1C,CAAC,CAAC,CACJ,CAAA;QAED,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,YAA6C;QACtD,MAAM,IAAI,GAAG,OAAO,YAAY,KAAK,QAAQ;YAC3C,CAAC,CAAC,iBAAiB,CAAC,YAAY,CAAC;YACjC,CAAC,CAAC,YAAY,CAAA;QAEhB,IAAI,CAAC,aAAa,CAAC;YACjB,UAAU,EAAE,IAAI;SACjB,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAgB;QACtB,IAAI,CAAC,aAAa,CAAC;YACjB,OAAO;SACR,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAgB;QACtB,IAAI,CAAC,aAAa,CAAC;YACjB,OAAO;SACR,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,MAA2B;QAC9B,IAAI,CAAC,aAAa,CAAC;YACjB,IAAI,EAAE,MAAM;SACb,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;;OAKG;IACH,OAAO,CAAC,MAAwB,EAAE,aAAmC;QACnE,IAAI,CAAC,aAAa,CAAC;YACjB,OAAO,EAAE,MAAM;YACf,MAAM,EAAE,aAAa;SACtB,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,MAAqB;QAC1B,IAAI,CAAC,aAAa,CAAC;YACjB,MAAM,EAAE,MAAM;SACf,CAAC,CAAA;QAEF,OAAO,IAAI,CAAA;IACb,CAAC;IAmBD,KAAK,CAAA,CAAE,KAAK,CAAC,cAAwB;QACnC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,CAAA;QAC1B,MAAM,EACJ,OAAO,EACP,UAAU,EACV,OAAO,EACR,GAAG,MAAM,IAAI,CAAC,MAAM,CAAA;QACrB,MAAM,WAAW,GAAG,cAAc,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;QAEvD,IAAI,CAAC,SAAS,CAAC,KAAK,IAAI,OAAO,CAAC,KAAK,EAAE;YACrC,SAAS,CAAC,KAAK,GAAG,gBAAgB,CAAC,YAAY,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;SAChE;QAED,IAAI,CAAC,WAAW,IAAI,OAAO,CAAC,IAAI,EAAE;YAChC,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,0BAA0B,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;SACpF;QAED,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAA;QAC7C,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,UAAU,EAAE,WAAW,CAAC,CAAA;QACxE,MAAM,aAAa,GAAG,MAAM,IAAI,CAAC,qBAAqB,CAAC,UAAU,EAAE,YAAY,CAAC,OAAO,CAAC,CAAA;QACxF,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,WAAW,CAAC,CAAA;QACxD,MAAM,kBAAkB,GAAG,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,CAAA;QACzD,MAAM,eAAe,GAAG,cAAc,CAAC,YAAY,EAAE,aAAa,EAAE,cAAc,CAAC,CAAA;QAEnF,KAAK,CAAC,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAA;IAC5C,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,cAAwB;QAClC,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,CAAA;IAClD,CAAC;CACF"}

package/dist/cli/cli.d.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+import { type ConventionalChangelog } from '../index.js';
+export interface Flags {
+    infile?: string;
+    outfile?: string;
+    stdout?: boolean;
+    preset?: string;
+    pkg?: string;
+    append?: boolean;
+    releaseCount?: number;
+    skipUnstable?: boolean;
+    outputUnreleased?: boolean;
+    verbose?: boolean;
+    config?: string;
+    context?: string;
+    firstRelease?: boolean;
+    lernaPackage?: string;
+    tagPrefix?: string;
+}
+export declare const flags: {
+    readonly infile: {
+        readonly shortFlag: "i";
+        readonly default: "CHANGELOG.md";
+        readonly type: "string";
+    };
+    readonly outfile: {
+        readonly shortFlag: "o";
+        readonly type: "string";
+    };
+    readonly stdout: {
+        readonly type: "boolean";
+    };
+    readonly preset: {
+        readonly shortFlag: "p";
+        readonly type: "string";
+    };
+    readonly pkg: {
+        readonly shortFlag: "k";
+        readonly type: "string";
+    };
+    readonly append: {
+        readonly shortFlag: "a";
+        readonly type: "boolean";
+    };
+    readonly releaseCount: {
+        readonly shortFlag: "r";
+        readonly type: "number";
+    };
+    readonly skipUnstable: {
+        readonly type: "boolean";
+    };
+    readonly outputUnreleased: {
+        readonly shortFlag: "u";
+        readonly type: "boolean";
+    };
+    readonly verbose: {
+        readonly shortFlag: "v";
+        readonly type: "boolean";
+    };
+    readonly config: {
+        readonly shortFlag: "n";
+        readonly type: "string";
+    };
+    readonly context: {
+        readonly shortFlag: "c";
+        readonly type: "string";
+    };
+    readonly firstRelease: {
+        readonly shortFlag: "f";
+        readonly type: "boolean";
+    };
+    readonly lernaPackage: {
+        readonly shortFlag: "l";
+        readonly type: "string";
+    };
+    readonly tagPrefix: {
+        readonly shortFlag: "t";
+        readonly type: "string";
+    };
+};
+export declare function runProgram(generator: ConventionalChangelog, flags: Flags): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":";AAMA,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,aAAa,CAAA;AAWpB,MAAM,WAAW,KAAK;IACpB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4DR,CAAA;AAEV,wBAAsB,UAAU,CAC9B,SAAS,EAAE,qBAAqB,EAChC,KAAK,EAAE,KAAK,iBA+Hb"}