conventional-commits-parser 5.0.0 → 6.0.0

package/dist/CommitParser.js

@@ -0,0 +1,317 @@
+import { getParserRegexes } from './regex.js';
+import { trimNewLines, appendLine, getCommentFilter, gpgFilter, truncateToScissor } from './utils.js';
+import { defaultOptions } from './options.js';
+/**
+ * Helper to create commit object.
+ * @param initialData - Initial commit data.
+ * @returns Commit object with empty data.
+ */
+export function createCommitObject(initialData = {}) {
+    // @ts-expect-error: You can read properties from `Commit` without problems, but you can't assign object to this type. So here is helper for that.
+    return {
+        merge: null,
+        revert: null,
+        header: null,
+        body: null,
+        footer: null,
+        notes: [],
+        mentions: [],
+        references: [],
+        ...initialData
+    };
+}
+/**
+ * Commit message parser.
+ */
+export class CommitParser {
+    options;
+    regexes;
+    lines = [];
+    lineIndex = 0;
+    commit = createCommitObject();
+    constructor(options = {}) {
+        this.options = {
+            ...defaultOptions,
+            ...options
+        };
+        this.regexes = getParserRegexes(this.options);
+    }
+    currentLine() {
+        return this.lines[this.lineIndex];
+    }
+    nextLine() {
+        return this.lines[this.lineIndex++];
+    }
+    isLineAvailable() {
+        return this.lineIndex < this.lines.length;
+    }
+    parseReference(input, action) {
+        const { regexes } = this;
+        const matches = regexes.referenceParts.exec(input);
+        if (!matches) {
+            return null;
+        }
+        let [raw, repository = null, prefix, issue] = matches;
+        let owner = null;
+        if (repository) {
+            const slashIndex = repository.indexOf('/');
+            if (slashIndex !== -1) {
+                owner = repository.slice(0, slashIndex);
+                repository = repository.slice(slashIndex + 1);
+            }
+        }
+        return {
+            raw,
+            action,
+            owner,
+            repository,
+            prefix,
+            issue
+        };
+    }
+    parseReferences(input) {
+        const { regexes } = this;
+        const regex = input.match(regexes.references)
+            ? regexes.references
+            : /()(.+)/gi;
+        const references = [];
+        let matches;
+        let action;
+        let sentence;
+        let reference;
+        while (true) {
+            matches = regex.exec(input);
+            if (!matches) {
+                break;
+            }
+            action = matches[1] || null;
+            sentence = matches[2] || '';
+            while (true) {
+                reference = this.parseReference(sentence, action);
+                if (!reference) {
+                    break;
+                }
+                references.push(reference);
+            }
+        }
+        return references;
+    }
+    skipEmptyLines() {
+        let line = this.currentLine();
+        while (line !== undefined && !line.trim()) {
+            this.nextLine();
+            line = this.currentLine();
+        }
+    }
+    parseMerge() {
+        const { commit, options } = this;
+        const correspondence = options.mergeCorrespondence || [];
+        const merge = this.currentLine();
+        const matches = merge && options.mergePattern
+            ? merge.match(options.mergePattern)
+            : null;
+        if (matches) {
+            this.nextLine();
+            commit.merge = matches[0] || null;
+            correspondence.forEach((key, index) => {
+                commit[key] = matches[index + 1] || null;
+            });
+            return true;
+        }
+        return false;
+    }
+    parseHeader(isMergeCommit) {
+        if (isMergeCommit) {
+            this.skipEmptyLines();
+        }
+        const { commit, options } = this;
+        const correspondence = options.headerCorrespondence || [];
+        const header = this.nextLine();
+        let matches = null;
+        if (header) {
+            if (options.breakingHeaderPattern) {
+                matches = header.match(options.breakingHeaderPattern);
+            }
+            if (!matches && options.headerPattern) {
+                matches = header.match(options.headerPattern);
+            }
+        }
+        if (header) {
+            commit.header = header;
+        }
+        if (matches) {
+            correspondence.forEach((key, index) => {
+                commit[key] = matches[index + 1] || null;
+            });
+        }
+    }
+    parseMeta() {
+        const { options, commit } = this;
+        if (!options.fieldPattern || !this.isLineAvailable()) {
+            return false;
+        }
+        let matches;
+        let field = null;
+        let parsed = false;
+        while (this.isLineAvailable()) {
+            matches = this.currentLine().match(options.fieldPattern);
+            if (matches) {
+                field = matches[1] || null;
+                this.nextLine();
+                continue;
+            }
+            if (field) {
+                parsed = true;
+                commit[field] = appendLine(commit[field], this.currentLine());
+                this.nextLine();
+            }
+            else {
+                break;
+            }
+        }
+        return parsed;
+    }
+    parseNotes() {
+        const { regexes, commit } = this;
+        if (!this.isLineAvailable()) {
+            return false;
+        }
+        const matches = this.currentLine().match(regexes.notes);
+        let references = [];
+        if (matches) {
+            const note = {
+                title: matches[1],
+                text: matches[2]
+            };
+            commit.notes.push(note);
+            commit.footer = appendLine(commit.footer, this.currentLine());
+            this.nextLine();
+            while (this.isLineAvailable()) {
+                if (this.parseMeta()) {
+                    return true;
+                }
+                if (this.parseNotes()) {
+                    return true;
+                }
+                references = this.parseReferences(this.currentLine());
+                if (references.length) {
+                    commit.references.push(...references);
+                }
+                else {
+                    note.text = appendLine(note.text, this.currentLine());
+                }
+                commit.footer = appendLine(commit.footer, this.currentLine());
+                this.nextLine();
+                if (references.length) {
+                    break;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    parseBodyAndFooter(isBody) {
+        const { commit } = this;
+        if (!this.isLineAvailable()) {
+            return isBody;
+        }
+        const references = this.parseReferences(this.currentLine());
+        const isStillBody = !references.length && isBody;
+        if (isStillBody) {
+            commit.body = appendLine(commit.body, this.currentLine());
+        }
+        else {
+            commit.references.push(...references);
+            commit.footer = appendLine(commit.footer, this.currentLine());
+        }
+        this.nextLine();
+        return isStillBody;
+    }
+    parseBreakingHeader() {
+        const { commit, options } = this;
+        if (!options.breakingHeaderPattern || commit.notes.length || !commit.header) {
+            return;
+        }
+        const matches = commit.header.match(options.breakingHeaderPattern);
+        if (matches) {
+            commit.notes.push({
+                title: 'BREAKING CHANGE',
+                text: matches[3]
+            });
+        }
+    }
+    parseMentions(input) {
+        const { commit, regexes } = this;
+        let matches;
+        for (;;) {
+            matches = regexes.mentions.exec(input);
+            if (!matches) {
+                break;
+            }
+            commit.mentions.push(matches[1]);
+        }
+    }
+    parseRevert(input) {
+        const { commit, options } = this;
+        const correspondence = options.revertCorrespondence || [];
+        const matches = options.revertPattern
+            ? input.match(options.revertPattern)
+            : null;
+        if (matches) {
+            commit.revert = correspondence.reduce((meta, key, index) => {
+                meta[key] = matches[index + 1] || null;
+                return meta;
+            }, {});
+        }
+    }
+    cleanupCommit() {
+        const { commit } = this;
+        if (commit.body) {
+            commit.body = trimNewLines(commit.body);
+        }
+        if (commit.footer) {
+            commit.footer = trimNewLines(commit.footer);
+        }
+        commit.notes.forEach((note) => {
+            note.text = trimNewLines(note.text);
+        });
+    }
+    /**
+     * Parse commit message string into an object.
+     * @param input - Commit message string.
+     * @returns Commit object.
+     */
+    parse(input) {
+        if (!input.trim()) {
+            throw new TypeError('Expected a raw commit');
+        }
+        const commentFilter = getCommentFilter(this.options.commentChar);
+        const rawLines = trimNewLines(input).split(/\r?\n/);
+        const lines = truncateToScissor(rawLines).filter(line => commentFilter(line) && gpgFilter(line));
+        const commit = createCommitObject();
+        this.lines = lines;
+        this.lineIndex = 0;
+        this.commit = commit;
+        const isMergeCommit = this.parseMerge();
+        this.parseHeader(isMergeCommit);
+        if (commit.header) {
+            commit.references = this.parseReferences(commit.header);
+        }
+        let isBody = true;
+        while (this.isLineAvailable()) {
+            this.parseMeta();
+            if (this.parseNotes()) {
+                isBody = false;
+            }
+            if (!this.parseBodyAndFooter(isBody)) {
+                isBody = false;
+            }
+        }
+        this.parseBreakingHeader();
+        this.parseMentions(input);
+        this.parseRevert(input);
+        this.cleanupCommit();
+        return commit;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommitParser.js","sourceRoot":"","sources":["../src/CommitParser.ts"],"names":[],"mappings":"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"}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { pipeline } from 'stream/promises';
+import meow from 'meow';
+import { parseCommits } from '../index.js';
+import { parseOptions } from './options.js';
+import { readRawCommitsFromFiles, readRawCommitsFromLine, readRawCommitsFromStdin, stringify } from './utils.js';
+const DEFAULT_SEPARATOR = '\n\n\n';
+const cli = meow(`
+    Practice writing commit messages or parse messages from files.
+    If used without specifying a text file path, you will enter an interactive shell.
+    Otherwise the commit messages in the files are parsed and printed
+    By default, commits will be split by three newlines ('\\n\\n\\n') or you can specify a separator.
+
+    Usage
+      conventional-commits-parser [-s <commit-separator>]
+      conventional-commits-parser [-s <commit-separator>] <path> [<path> ...]
+      cat <path> | conventional-commits-parser [-s <commit-separator>]
+
+    Example
+      conventional-commits-parser
+      conventional-commits-parser log.txt
+      cat log.txt | conventional-commits-parser
+      conventional-commits-parser log2.txt -s '===' >> parsed.txt
+
+    Options
+      -s, --separator                   Commit separator
+      -p, --header-pattern              Regex to match header pattern
+      -c, --header-correspondence       Comma separated parts used to define what capturing group of 'headerPattern' captures what
+      -r, --reference-actions           Comma separated keywords that used to reference issues
+      -i, --issue-prefixes              Comma separated prefixes of an issue
+      --issue-prefixes-case-sensitive   Treat issue prefixes as case sensitive
+      -n, --note-keywords               Comma separated keywords for important notes
+      -f, --field-pattern               Regex to match other fields
+      --revert-pattern                  Regex to match revert pattern
+      --revert-correspondence           Comma separated fields used to define what the commit reverts
+      -v, --verbose                     Verbose output
+`, {
+    importMeta: import.meta,
+    flags: {
+        separator: {
+            shortFlag: 's',
+            type: 'string',
+            default: DEFAULT_SEPARATOR
+        },
+        headerPattern: {
+            shortFlag: 'p',
+            type: 'string'
+        },
+        headerCorrespondence: {
+            shortFlag: 'c',
+            type: 'string'
+        },
+        referenceActions: {
+            shortFlag: 'r',
+            type: 'string'
+        },
+        issuePrefixes: {
+            shortFlag: 'i',
+            type: 'string'
+        },
+        issuePrefixesCaseSensitive: {
+            type: 'boolean'
+        },
+        noteKeywords: {
+            shortFlag: 'n',
+            type: 'string'
+        },
+        fieldPattern: {
+            shortFlag: 'f',
+            type: 'string'
+        },
+        revertPattern: {
+            type: 'string'
+        },
+        revertCorrespondence: {
+            type: 'string'
+        },
+        verbose: {
+            shortFlag: 'v',
+            type: 'boolean'
+        }
+    }
+});
+const { separator } = cli.flags;
+const options = parseOptions(cli.flags);
+let inputStream;
+try {
+    if (cli.input.length) {
+        inputStream = readRawCommitsFromFiles(cli.input, separator);
+    }
+    else if (process.stdin.isTTY) {
+        inputStream = readRawCommitsFromLine(separator);
+    }
+    else {
+        inputStream = readRawCommitsFromStdin(separator);
+    }
+    await pipeline(inputStream, parseCommits(options), stringify, process.stdout);
+}
+catch (err) {
+    console.error(err);
+    process.exit(1);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY2xpL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFDQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDMUMsT0FBTyxJQUFJLE1BQU0sTUFBTSxDQUFBO0FBQ3ZCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxhQUFhLENBQUE7QUFDMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGNBQWMsQ0FBQTtBQUMzQyxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLHNCQUFzQixFQUN0Qix1QkFBdUIsRUFDdkIsU0FBUyxFQUNWLE1BQU0sWUFBWSxDQUFBO0FBRW5CLE1BQU0saUJBQWlCLEdBQUcsUUFBUSxDQUFBO0FBQ2xDLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Q0E2QmhCLEVBQUU7SUFDRCxVQUFVLEVBQUUsTUFBTSxDQUFDLElBQUk7SUFDdkIsS0FBSyxFQUFFO1FBQ0wsU0FBUyxFQUFFO1lBQ1QsU0FBUyxFQUFFLEdBQUc7WUFDZCxJQUFJLEVBQUUsUUFBUTtZQUNkLE9BQU8sRUFBRSxpQkFBaUI7U0FDM0I7UUFDRCxhQUFhLEVBQUU7WUFDYixTQUFTLEVBQUUsR0FBRztZQUNkLElBQUksRUFBRSxRQUFRO1NBQ2Y7UUFDRCxvQkFBb0IsRUFBRTtZQUNwQixTQUFTLEVBQUUsR0FBRztZQUNkLElBQUksRUFBRSxRQUFRO1NBQ2Y7UUFDRCxnQkFBZ0IsRUFBRTtZQUNoQixTQUFTLEVBQUUsR0FBRztZQUNkLElBQUksRUFBRSxRQUFRO1NBQ2Y7UUFDRCxhQUFhLEVBQUU7WUFDYixTQUFTLEVBQUUsR0FBRztZQUNkLElBQUksRUFBRSxRQUFRO1NBQ2Y7UUFDRCwwQkFBMEIsRUFBRTtZQUMxQixJQUFJLEVBQUUsU0FBUztTQUNoQjtRQUNELFlBQVksRUFBRTtZQUNaLFNBQVMsRUFBRSxHQUFHO1lBQ2QsSUFBSSxFQUFFLFFBQVE7U0FDZjtRQUNELFlBQVksRUFBRTtZQUNaLFNBQVMsRUFBRSxHQUFHO1lBQ2QsSUFBSSxFQUFFLFFBQVE7U0FDZjtRQUNELGFBQWEsRUFBRTtZQUNiLElBQUksRUFBRSxRQUFRO1NBQ2Y7UUFDRCxvQkFBb0IsRUFBRTtZQUNwQixJQUFJLEVBQUUsUUFBUTtTQUNmO1FBQ0QsT0FBTyxFQUFFO1lBQ1AsU0FBUyxFQUFFLEdBQUc7WUFDZCxJQUFJLEVBQUUsU0FBUztTQUNoQjtLQUNGO0NBQ0YsQ0FBQyxDQUFBO0FBQ0YsTUFBTSxFQUFFLFNBQVMsRUFBRSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUE7QUFDL0IsTUFBTSxPQUFPLEdBQUcsWUFBWSxDQUFDLEdBQUcsQ0FBQyxLQUFLLENBQUMsQ0FBQTtBQUN2QyxJQUFJLFdBQWtDLENBQUE7QUFFdEMsSUFBSTtJQUNGLElBQUksR0FBRyxDQUFDLEtBQUssQ0FBQyxNQUFNLEVBQUU7UUFDcEIsV0FBVyxHQUFHLHVCQUF1QixDQUFDLEdBQUcsQ0FBQyxLQUFLLEVBQUUsU0FBUyxDQUFDLENBQUE7S0FDNUQ7U0FDQyxJQUFJLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxFQUFFO1FBQ3ZCLFdBQVcsR0FBRyxzQkFBc0IsQ0FBQyxTQUFTLENBQUMsQ0FBQTtLQUNoRDtTQUFNO1FBQ0wsV0FBVyxHQUFHLHVCQUF1QixDQUFDLFNBQVMsQ0FBQyxDQUFBO0tBQ2pEO0lBRUgsTUFBTSxRQUFRLENBQ1osV0FBVyxFQUNYLFlBQVksQ0FBQyxPQUFPLENBQUMsRUFDckIsU0FBUyxFQUNULE9BQU8sQ0FBQyxNQUFNLENBQ2YsQ0FBQTtDQUNGO0FBQUMsT0FBTyxHQUFHLEVBQUU7SUFDWixPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFBO0lBQ2xCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUE7Q0FDaEIifQ==

package/dist/cli/options.d.ts

@@ -0,0 +1,3 @@
+import type { ParserStreamOptions } from '../types.js';
+export declare function parseOptions(options: Record<string, unknown>): ParserStreamOptions;
+//# sourceMappingURL=options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/cli/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAMtD,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,mBAAmB,CA4ClF"}

package/dist/cli/options.js

@@ -0,0 +1,40 @@
+function trim(str) {
+    return str.trim();
+}
+export function parseOptions(options) {
+    if (typeof options.headerPattern === 'string') {
+        options.headerPattern = new RegExp(options.headerPattern);
+    }
+    if (typeof options.headerCorrespondence === 'string') {
+        options.headerCorrespondence = options.headerCorrespondence.split(',').map(trim);
+    }
+    if (typeof options.referenceActions === 'string') {
+        options.referenceActions = options.referenceActions.split(',').map(trim);
+    }
+    if (typeof options.issuePrefixes === 'string') {
+        options.issuePrefixes = options.issuePrefixes.split(',').map(trim);
+    }
+    if (typeof options.noteKeywords === 'string') {
+        options.noteKeywords = options.noteKeywords.split(',').map(trim);
+    }
+    if (typeof options.fieldPattern === 'string') {
+        options.fieldPattern = new RegExp(options.fieldPattern);
+    }
+    if (typeof options.revertPattern === 'string') {
+        options.revertPattern = new RegExp(options.revertPattern);
+    }
+    if (typeof options.revertCorrespondence === 'string') {
+        options.revertCorrespondence = options.revertCorrespondence.split(',').map(trim);
+    }
+    if (typeof options.mergePattern === 'string') {
+        options.mergePattern = new RegExp(options.mergePattern);
+    }
+    if (options.verbose) {
+        options.warn = console.warn.bind(console);
+    }
+    else {
+        options.warn = true;
+    }
+    return options;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cli/utils.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Readable } from 'stream';
+export declare function splitStream(stream: Readable, separator: string): AsyncGenerator<string, void, undefined>;
+export declare function readRawCommitsFromFiles(files: string[], separator: string): AsyncGenerator<string, void, undefined>;
+export declare function readRawCommitsFromLine(separator: string): AsyncGenerator<string, void, unknown>;
+export declare function readRawCommitsFromStdin(separator: string): AsyncGenerator<string, void, undefined>;
+export declare function stringify(commits: AsyncIterable<Record<string, unknown>>): AsyncGenerator<string, void, unknown>;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/cli/utils.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAItC,wBAAuB,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,2CAmBrE;AAED,wBAAuB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,2CAQhF;AAED,wBAAuB,sBAAsB,CAAC,SAAS,EAAE,MAAM,yCAmB9D;AAED,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,2CAExD;AAMD,wBAAuB,SAAS,CAAC,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,yCAe/E"}

package/dist/cli/utils.js

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import readline from 'readline';
+export async function* splitStream(stream, separator) {
+    let chunk;
+    let payload;
+    let buffer = '';
+    for await (chunk of stream) {
+        buffer += chunk.toString();
+        if (buffer.includes(separator)) {
+            payload = buffer.split(separator);
+            buffer = payload.pop() || '';
+            yield* payload;
+        }
+    }
+    if (buffer) {
+        yield buffer;
+    }
+}
+export async function* readRawCommitsFromFiles(files, separator) {
+    for (const file of files) {
+        try {
+            yield* splitStream(fs.createReadStream(file), separator);
+        }
+        catch (err) {
+            console.warn(`Failed to read file ${file}:\n  ${err}`);
+        }
+    }
+}
+export async function* readRawCommitsFromLine(separator) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true
+    });
+    let line = '';
+    let commit = '';
+    for await (line of rl) {
+        commit += `${line}\n`;
+        if (!commit.includes(separator)) {
+            return;
+        }
+        yield commit;
+        commit = '';
+    }
+}
+export function readRawCommitsFromStdin(separator) {
+    return splitStream(process.stdin, separator);
+}
+const JSON_STREAM_OPEN = '[\n';
+const JSON_STREAM_SEPARATOR = '\n,\n';
+const JSON_STREAM_CLOSE = '\n]\n';
+export async function* stringify(commits) {
+    let jsonStreamOpened = false;
+    yield JSON_STREAM_OPEN;
+    for await (const commit of commits) {
+        if (jsonStreamOpened) {
+            yield JSON_STREAM_SEPARATOR;
+        }
+        yield JSON.stringify(commit);
+        jsonStreamOpened = true;
+    }
+    yield JSON_STREAM_CLOSE;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './CommitParser.js';
+export * from './stream.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAA;AAC1B,cAAc,mBAAmB,CAAA;AACjC,cAAc,aAAa,CAAA"}

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './CommitParser.js';
+export * from './stream.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUE7QUFDMUIsY0FBYyxtQkFBbUIsQ0FBQTtBQUNqQyxjQUFjLGFBQWEsQ0FBQSJ9

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+import type { ParserOptions } from './types.js';
+export declare const defaultOptions: ParserOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE/C,eAAO,MAAM,cAAc,EAAE,aAuB5B,CAAA"}

package/dist/options.js

@@ -0,0 +1,25 @@
+export const defaultOptions = {
+    noteKeywords: ['BREAKING CHANGE', 'BREAKING-CHANGE'],
+    issuePrefixes: ['#'],
+    referenceActions: [
+        'close',
+        'closes',
+        'closed',
+        'fix',
+        'fixes',
+        'fixed',
+        'resolve',
+        'resolves',
+        'resolved'
+    ],
+    headerPattern: /^(\w*)(?:\(([\w$.\-*/ ]*)\))?: (.*)$/,
+    headerCorrespondence: [
+        'type',
+        'scope',
+        'subject'
+    ],
+    revertPattern: /^Revert\s"([\s\S]*)"\s*This reverts commit (\w*)\./,
+    revertCorrespondence: ['header', 'hash'],
+    fieldPattern: /^-(.*?)-$/
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBa0I7SUFDM0MsWUFBWSxFQUFFLENBQUMsaUJBQWlCLEVBQUUsaUJBQWlCLENBQUM7SUFDcEQsYUFBYSxFQUFFLENBQUMsR0FBRyxDQUFDO0lBQ3BCLGdCQUFnQixFQUFFO1FBQ2hCLE9BQU87UUFDUCxRQUFRO1FBQ1IsUUFBUTtRQUNSLEtBQUs7UUFDTCxPQUFPO1FBQ1AsT0FBTztRQUNQLFNBQVM7UUFDVCxVQUFVO1FBQ1YsVUFBVTtLQUNYO0lBQ0QsYUFBYSxFQUFFLHNDQUFzQztJQUNyRCxvQkFBb0IsRUFBRTtRQUNwQixNQUFNO1FBQ04sT0FBTztRQUNQLFNBQVM7S0FDVjtJQUNELGFBQWEsRUFBRSxvREFBb0Q7SUFDbkUsb0JBQW9CLEVBQUUsQ0FBQyxRQUFRLEVBQUUsTUFBTSxDQUFDO0lBQ3hDLFlBQVksRUFBRSxXQUFXO0NBQzFCLENBQUEifQ==

package/dist/regex.d.ts

@@ -0,0 +1,8 @@
+import type { ParserOptions, ParserRegexes } from './types.js';
+/**
+ * Make the regexes used to parse a commit.
+ * @param options
+ * @returns Regexes.
+ */
+export declare function getParserRegexes(options?: Pick<ParserOptions, 'noteKeywords' | 'notesPattern' | 'issuePrefixes' | 'issuePrefixesCaseSensitive' | 'referenceActions'>): ParserRegexes;
+//# sourceMappingURL=regex.d.ts.map

package/dist/regex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.d.ts","sourceRoot":"","sources":["../src/regex.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,aAAa,EACd,MAAM,YAAY,CAAA;AAsDnB;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,IAAI,CAAC,aAAa,EAAE,cAAc,GAAG,cAAc,GAAG,eAAe,GAAG,4BAA4B,GAAG,kBAAkB,CAAM,GACvI,aAAa,CAWf"}