@savvy-web/changesets 0.1.0 → 0.1.1

package/cjs/changelog.cjs

@@ -0,0 +1,670 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/categories/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            JY: ()=>fromHeading,
+            OH: ()=>resolveCommitType
+        });
+        const BREAKING_CHANGES = {
+            heading: "Breaking Changes",
+            priority: 1,
+            commitTypes: [],
+            description: "Backward-incompatible changes"
+        };
+        const FEATURES = {
+            heading: "Features",
+            priority: 2,
+            commitTypes: [
+                "feat"
+            ],
+            description: "New functionality"
+        };
+        const BUG_FIXES = {
+            heading: "Bug Fixes",
+            priority: 3,
+            commitTypes: [
+                "fix"
+            ],
+            description: "Bug corrections"
+        };
+        const PERFORMANCE = {
+            heading: "Performance",
+            priority: 4,
+            commitTypes: [
+                "perf"
+            ],
+            description: "Performance improvements"
+        };
+        const DOCUMENTATION = {
+            heading: "Documentation",
+            priority: 5,
+            commitTypes: [
+                "docs"
+            ],
+            description: "Documentation changes"
+        };
+        const REFACTORING = {
+            heading: "Refactoring",
+            priority: 6,
+            commitTypes: [
+                "refactor"
+            ],
+            description: "Code restructuring"
+        };
+        const TESTS = {
+            heading: "Tests",
+            priority: 7,
+            commitTypes: [
+                "test"
+            ],
+            description: "Test additions or modifications"
+        };
+        const BUILD_SYSTEM = {
+            heading: "Build System",
+            priority: 8,
+            commitTypes: [
+                "build"
+            ],
+            description: "Build configuration changes"
+        };
+        const CI = {
+            heading: "CI",
+            priority: 9,
+            commitTypes: [
+                "ci"
+            ],
+            description: "Continuous integration changes"
+        };
+        const DEPENDENCIES = {
+            heading: "Dependencies",
+            priority: 10,
+            commitTypes: [
+                "deps"
+            ],
+            description: "Dependency updates"
+        };
+        const MAINTENANCE = {
+            heading: "Maintenance",
+            priority: 11,
+            commitTypes: [
+                "chore",
+                "style"
+            ],
+            description: "General maintenance"
+        };
+        const REVERTS = {
+            heading: "Reverts",
+            priority: 12,
+            commitTypes: [
+                "revert"
+            ],
+            description: "Reverted changes"
+        };
+        const OTHER = {
+            heading: "Other",
+            priority: 13,
+            commitTypes: [],
+            description: "Uncategorized changes"
+        };
+        const CATEGORIES = [
+            BREAKING_CHANGES,
+            FEATURES,
+            BUG_FIXES,
+            PERFORMANCE,
+            DOCUMENTATION,
+            REFACTORING,
+            TESTS,
+            BUILD_SYSTEM,
+            CI,
+            DEPENDENCIES,
+            MAINTENANCE,
+            REVERTS,
+            OTHER
+        ];
+        const headingToCategory = new Map(CATEGORIES.map((cat)=>[
+                cat.heading.toLowerCase(),
+                cat
+            ]));
+        const commitTypeToCategory = new Map();
+        for (const cat of CATEGORIES)for (const commitType of cat.commitTypes)commitTypeToCategory.set(commitType, cat);
+        function resolveCommitType(type, scope, breaking) {
+            if (breaking) return BREAKING_CHANGES;
+            if ("chore" === type && "deps" === scope) return DEPENDENCIES;
+            return commitTypeToCategory.get(type) ?? OTHER;
+        }
+        function fromHeading(heading) {
+            return headingToCategory.get(heading.toLowerCase());
+        }
+    },
+    "./src/errors.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            OS: ()=>GitHubApiError,
+            j1: ()=>ConfigurationError
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        effect__rspack_import_0.Data.TaggedError("ChangesetValidationError");
+        const GitHubApiErrorBase = effect__rspack_import_0.Data.TaggedError("GitHubApiError");
+        class GitHubApiError extends GitHubApiErrorBase {
+            get message() {
+                const status = this.statusCode ? ` (${this.statusCode})` : "";
+                return `GitHub API error during ${this.operation}${status}: ${this.reason}`;
+            }
+            get isRateLimited() {
+                return 403 === this.statusCode || 429 === this.statusCode;
+            }
+            get isRetryable() {
+                return void 0 !== this.statusCode && (this.statusCode >= 500 || this.isRateLimited);
+            }
+        }
+        effect__rspack_import_0.Data.TaggedError("MarkdownParseError");
+        const ConfigurationErrorBase = effect__rspack_import_0.Data.TaggedError("ConfigurationError");
+        class ConfigurationError extends ConfigurationErrorBase {
+            get message() {
+                return `Configuration error (${this.field}): ${this.reason}`;
+            }
+        }
+    },
+    "./src/schemas/github.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            lo: ()=>GitHubInfoSchema
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        var _utils_markdown_link_js__rspack_import_2 = __webpack_require__("./src/utils/markdown-link.ts");
+        var _primitives_js__rspack_import_1 = __webpack_require__("./src/schemas/primitives.ts");
+        function isValidUrl(value) {
+            try {
+                new URL(value);
+                return true;
+            } catch  {
+                return false;
+            }
+        }
+        const UsernameSchema = effect__rspack_import_0.Schema.String.pipe(effect__rspack_import_0.Schema.pattern(/^[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?$/, {
+            message: ()=>"Invalid GitHub username format"
+        }));
+        const IssueNumberSchema = _primitives_js__rspack_import_1.e.annotations({
+            title: "IssueNumber",
+            description: "GitHub issue or pull request number"
+        });
+        const UrlOrMarkdownLinkSchema = effect__rspack_import_0.Schema.String.pipe(effect__rspack_import_0.Schema.filter((value)=>{
+            if (isValidUrl(value)) return true;
+            const match = _utils_markdown_link_js__rspack_import_2.o.exec(value);
+            return match?.[2] ? isValidUrl(match[2]) : false;
+        }, {
+            message: ()=>"Invalid URL or markdown link format"
+        }));
+        const GitHubInfoSchema = effect__rspack_import_0.Schema.Struct({
+            user: effect__rspack_import_0.Schema.optional(UsernameSchema),
+            pull: effect__rspack_import_0.Schema.optional(IssueNumberSchema),
+            links: effect__rspack_import_0.Schema.Struct({
+                commit: UrlOrMarkdownLinkSchema,
+                pull: effect__rspack_import_0.Schema.optional(UrlOrMarkdownLinkSchema),
+                user: effect__rspack_import_0.Schema.optional(UrlOrMarkdownLinkSchema)
+            })
+        });
+    },
+    "./src/schemas/options.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            jb: ()=>validateChangesetOptions
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        var _errors_js__rspack_import_1 = __webpack_require__("./src/errors.ts");
+        const REPO_PATTERN = /^[a-zA-Z0-9._-]+\/[a-zA-Z0-9._-]+$/;
+        const RepoSchema = effect__rspack_import_0.Schema.String.pipe(effect__rspack_import_0.Schema.pattern(REPO_PATTERN, {
+            message: ()=>'Repository must be in format "owner/repository" (e.g., "microsoft/vscode")'
+        }));
+        const ChangesetOptionsSchema = effect__rspack_import_0.Schema.Struct({
+            repo: RepoSchema,
+            commitLinks: effect__rspack_import_0.Schema.optional(effect__rspack_import_0.Schema.Boolean),
+            prLinks: effect__rspack_import_0.Schema.optional(effect__rspack_import_0.Schema.Boolean),
+            issueLinks: effect__rspack_import_0.Schema.optional(effect__rspack_import_0.Schema.Boolean),
+            issuePrefixes: effect__rspack_import_0.Schema.optional(effect__rspack_import_0.Schema.Array(effect__rspack_import_0.Schema.String))
+        });
+        function validateChangesetOptions(input) {
+            if (null == input) return effect__rspack_import_0.Effect.fail(new _errors_js__rspack_import_1.j1({
+                field: "options",
+                reason: 'Configuration is required. Add options to your changesets config:\n"changelog": ["@savvy-web/changesets", { "repo": "owner/repository" }]'
+            }));
+            if ("object" != typeof input) return effect__rspack_import_0.Effect.fail(new _errors_js__rspack_import_1.j1({
+                field: "options",
+                reason: "Configuration must be an object"
+            }));
+            const obj = input;
+            if (!("repo" in obj) || void 0 === obj.repo) return effect__rspack_import_0.Effect.fail(new _errors_js__rspack_import_1.j1({
+                field: "repo",
+                reason: 'Repository name is required. Add the "repo" option to your changesets config:\n"changelog": ["@savvy-web/changesets", { "repo": "owner/repository" }]'
+            }));
+            if ("string" == typeof obj.repo && !REPO_PATTERN.test(obj.repo)) return effect__rspack_import_0.Effect.fail(new _errors_js__rspack_import_1.j1({
+                field: "repo",
+                reason: `Invalid repository format: "${obj.repo}". Expected format is "owner/repository" (e.g., "microsoft/vscode")`
+            }));
+            return effect__rspack_import_0.Schema.decodeUnknown(ChangesetOptionsSchema)(input).pipe(effect__rspack_import_0.Effect.mapError((parseError)=>new _errors_js__rspack_import_1.j1({
+                    field: "options",
+                    reason: String(parseError)
+                })));
+        }
+    },
+    "./src/schemas/primitives.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            e: ()=>PositiveInteger
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        effect__rspack_import_0.Schema.String.pipe(effect__rspack_import_0.Schema.minLength(1));
+        const PositiveInteger = effect__rspack_import_0.Schema.Number.pipe(effect__rspack_import_0.Schema.int(), effect__rspack_import_0.Schema.positive());
+    },
+    "./src/services/github.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Xx: ()=>GitHubService,
+            cH: ()=>GitHubLive
+        });
+        var external_effect_ = __webpack_require__("effect");
+        var errors = __webpack_require__("./src/errors.ts");
+        const get_github_info_namespaceObject = require("@changesets/get-github-info");
+        function getGitHubInfo(params) {
+            return external_effect_.Effect.tryPromise({
+                try: ()=>(0, get_github_info_namespaceObject.getInfo)({
+                        commit: params.commit,
+                        repo: params.repo
+                    }),
+                catch: (error)=>new errors.OS({
+                        operation: "getInfo",
+                        reason: error instanceof Error ? error.message : String(error)
+                    })
+            });
+        }
+        const _tag = external_effect_.Context.Tag("GitHubService");
+        const GitHubServiceBase = _tag();
+        class GitHubService extends GitHubServiceBase {
+        }
+        const GitHubLive = external_effect_.Layer.succeed(GitHubService, {
+            getInfo: getGitHubInfo
+        });
+    },
+    "./src/services/markdown.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Am: ()=>MarkdownLive
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        var _utils_remark_pipeline_js__rspack_import_1 = __webpack_require__("./src/utils/remark-pipeline.ts");
+        const _tag = effect__rspack_import_0.Context.Tag("MarkdownService");
+        const MarkdownServiceBase = _tag();
+        class MarkdownService extends MarkdownServiceBase {
+        }
+        const MarkdownLive = effect__rspack_import_0.Layer.succeed(MarkdownService, {
+            parse: (content)=>effect__rspack_import_0.Effect.sync(()=>(0, _utils_remark_pipeline_js__rspack_import_1.Dd)(content)),
+            stringify: (tree)=>effect__rspack_import_0.Effect.sync(()=>(0, _utils_remark_pipeline_js__rspack_import_1.FH)(tree))
+        });
+    },
+    "./src/utils/markdown-link.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            W: ()=>extractUrlFromMarkdown,
+            o: ()=>MARKDOWN_LINK_PATTERN
+        });
+        const MARKDOWN_LINK_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/;
+        function extractUrlFromMarkdown(linkOrUrl) {
+            const match = MARKDOWN_LINK_PATTERN.exec(linkOrUrl);
+            return match ? match[2] : linkOrUrl;
+        }
+    },
+    "./src/utils/remark-pipeline.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Dd: ()=>parseMarkdown,
+            FH: ()=>stringifyMarkdown
+        });
+        var remark_gfm__rspack_import_0 = __webpack_require__("remark-gfm");
+        var remark_gfm__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(remark_gfm__rspack_import_0);
+        var remark_parse__rspack_import_1 = __webpack_require__("remark-parse");
+        var remark_parse__rspack_import_1_default = /*#__PURE__*/ __webpack_require__.n(remark_parse__rspack_import_1);
+        var remark_stringify__rspack_import_2 = __webpack_require__("remark-stringify");
+        var remark_stringify__rspack_import_2_default = /*#__PURE__*/ __webpack_require__.n(remark_stringify__rspack_import_2);
+        var unified__rspack_import_3 = __webpack_require__("unified");
+        function createRemarkProcessor() {
+            return (0, unified__rspack_import_3.unified)().use(remark_parse__rspack_import_1_default()).use(remark_gfm__rspack_import_0_default()).use(remark_stringify__rspack_import_2_default());
+        }
+        function parseMarkdown(content) {
+            const processor = createRemarkProcessor();
+            return processor.parse(content);
+        }
+        function stringifyMarkdown(tree) {
+            const processor = createRemarkProcessor();
+            return processor.stringify(tree);
+        }
+    },
+    effect (module) {
+        module.exports = require("effect");
+    },
+    "mdast-util-to-string" (module) {
+        module.exports = require("mdast-util-to-string");
+    },
+    "remark-gfm" (module) {
+        module.exports = require("remark-gfm");
+    },
+    "remark-parse" (module) {
+        module.exports = require("remark-parse");
+    },
+    "remark-stringify" (module) {
+        module.exports = require("remark-stringify");
+    },
+    unified (module) {
+        module.exports = require("unified");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>changelog
+    });
+    var external_effect_ = __webpack_require__("effect");
+    var schemas_options = __webpack_require__("./src/schemas/options.ts");
+    var services_github = __webpack_require__("./src/services/github.ts");
+    var markdown = __webpack_require__("./src/services/markdown.ts");
+    function logWarning(message, ...args) {
+        if ("u" > typeof process && "true" === process.env.GITHUB_ACTIONS) {
+            const text = args.length > 0 ? `${message} ${args.join(" ")}` : message;
+            console.warn(`::warning::${text}`);
+        } else console.warn(message, ...args);
+    }
+    function getDependencyReleaseLine(changesets, dependenciesUpdated, options) {
+        return external_effect_.Effect.gen(function*() {
+            if (0 === dependenciesUpdated.length) return "";
+            const github = yield* services_github.Xx;
+            let apiFailures = 0;
+            const totalWithCommit = changesets.filter((cs)=>cs.commit).length;
+            const commitLinks = yield* external_effect_.Effect.forEach(changesets, (cs)=>{
+                const commit = cs.commit;
+                if (!commit) return external_effect_.Effect.succeed(null);
+                return github.getInfo({
+                    commit,
+                    repo: options.repo
+                }).pipe(external_effect_.Effect.map((info)=>info.links.commit), external_effect_.Effect.catchAll((error)=>{
+                    apiFailures++;
+                    logWarning(`Failed to fetch GitHub info for commit ${commit}:`, String(error));
+                    return external_effect_.Effect.succeed(`[\`${commit.substring(0, 7)}\`](https://github.com/${options.repo}/commit/${commit})`);
+                }));
+            }, {
+                concurrency: 10
+            });
+            if (apiFailures > 0) {
+                const successRate = ((totalWithCommit - apiFailures) / totalWithCommit * 100).toFixed(1);
+                logWarning(`GitHub API calls completed with ${apiFailures}/${totalWithCommit} failures (${successRate}% success rate)`);
+            }
+            const validLinks = commitLinks.filter(Boolean);
+            const changesetLink = validLinks.length > 0 ? `- Updated dependencies [${validLinks.join(", ")}]:` : "- Updated dependencies:";
+            const updatedDependenciesList = dependenciesUpdated.map((dep)=>`  - ${dep.name}@${dep.newVersion}`);
+            return [
+                changesetLink,
+                ...updatedDependenciesList
+            ].join("\n");
+        });
+    }
+    var categories = __webpack_require__("./src/categories/index.ts");
+    var schemas_github = __webpack_require__("./src/schemas/github.ts");
+    const CONVENTIONAL_COMMIT_PATTERN = /^(\w+)(?:\(([^)]+)\))?(!)?\s*:\s*(.+)/;
+    function parseCommitMessage(message) {
+        const match = CONVENTIONAL_COMMIT_PATTERN.exec(message);
+        if (match) {
+            const [, type, scope, bang, description] = match;
+            const lines = message.split("\n");
+            const body = lines.slice(1).join("\n").trim();
+            const result = {
+                type,
+                description: description.trim()
+            };
+            if (scope) result.scope = scope;
+            if ("!" === bang) result.breaking = true;
+            if (body) result.body = body;
+            return result;
+        }
+        return {
+            description: message
+        };
+    }
+    const CLOSES_ISSUE_PATTERN = /closes?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+    const FIXES_ISSUE_PATTERN = /fix(?:es)?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+    const REFS_ISSUE_PATTERN = /refs?:?\s*#?(\d+(?:, *#?\d+)*)/i;
+    const ISSUE_NUMBER_SPLIT_PATTERN = /, */;
+    function extractIssueNumbers(pattern, message) {
+        const safeMessage = message.slice(0, 10000);
+        const match = pattern.exec(safeMessage);
+        if (!match?.[1]) return [];
+        return match[1].split(ISSUE_NUMBER_SPLIT_PATTERN).map((num)=>num.replace("#", "").trim());
+    }
+    function parseIssueReferences(commitMessage) {
+        return {
+            closes: extractIssueNumbers(CLOSES_ISSUE_PATTERN, commitMessage),
+            fixes: extractIssueNumbers(FIXES_ISSUE_PATTERN, commitMessage),
+            refs: extractIssueNumbers(REFS_ISSUE_PATTERN, commitMessage)
+        };
+    }
+    var external_mdast_util_to_string_ = __webpack_require__("mdast-util-to-string");
+    var remark_pipeline = __webpack_require__("./src/utils/remark-pipeline.ts");
+    function parseChangesetSections(summary) {
+        const tree = (0, remark_pipeline.Dd)(summary);
+        const h2Indices = [];
+        for(let i = 0; i < tree.children.length; i++){
+            const node = tree.children[i];
+            if ("heading" === node.type && 2 === node.depth) h2Indices.push(i);
+        }
+        if (0 === h2Indices.length) return {
+            preamble: summary.trim(),
+            sections: []
+        };
+        const result = {
+            sections: []
+        };
+        if (h2Indices[0] > 0) {
+            const preambleNodes = tree.children.slice(0, h2Indices[0]);
+            result.preamble = stringifyAstSlice(preambleNodes);
+        }
+        for(let i = 0; i < h2Indices.length; i++){
+            const headingIndex = h2Indices[i];
+            const headingNode = tree.children[headingIndex];
+            const headingText = (0, external_mdast_util_to_string_.toString)(headingNode);
+            const nextIndex = i + 1 < h2Indices.length ? h2Indices[i + 1] : tree.children.length;
+            const contentNodes = tree.children.slice(headingIndex + 1, nextIndex);
+            const content = stringifyAstSlice(contentNodes);
+            const category = (0, categories.JY)(headingText);
+            if (category) result.sections.push({
+                category,
+                heading: headingText,
+                content
+            });
+        }
+        return result;
+    }
+    function stringifyAstSlice(nodes) {
+        if (0 === nodes.length) return "";
+        const root = {
+            type: "root",
+            children: nodes
+        };
+        return (0, remark_pipeline.FH)(root).trim();
+    }
+    var markdown_link = __webpack_require__("./src/utils/markdown-link.ts");
+    const ISSUE_CATEGORIES = [
+        {
+            key: "closes",
+            label: "Closes"
+        },
+        {
+            key: "fixes",
+            label: "Fixes"
+        },
+        {
+            key: "refs",
+            label: "Refs"
+        }
+    ];
+    function formatChangelogEntry(entry, options) {
+        const parts = [];
+        if (entry.commit) {
+            const shortHash = entry.commit.substring(0, 7);
+            parts.push(`[\`${shortHash}\`](https://github.com/${options.repo}/commit/${entry.commit})`);
+        }
+        parts.push(entry.summary.trim());
+        const issueLinks = [];
+        for (const { key, label } of ISSUE_CATEGORIES){
+            const numbers = entry.issues[key];
+            if (numbers.length > 0) {
+                const links = numbers.map((num)=>`[#${num}](https://github.com/${options.repo}/issues/${num})`);
+                issueLinks.push(`${label}: ${links.join(", ")}`);
+            }
+        }
+        if (issueLinks.length > 0) parts.push(`\n\n${issueLinks.join(". ")}`);
+        return parts.join(" ");
+    }
+    function formatPRAndUserAttribution(pr, user, links) {
+        let prReference = "";
+        if (pr) if (links?.pull) {
+            const pullUrl = (0, markdown_link.W)(links.pull);
+            prReference = ` [#${String(pr)}](${pullUrl})`;
+        } else prReference = ` (#${String(pr)})`;
+        if (user) {
+            if (links?.user) {
+                const userUrl = (0, markdown_link.W)(links.user);
+                return `${prReference} Thanks [@${user}](${userUrl})!`;
+            }
+            return `${prReference} Thanks @${user}!`;
+        }
+        return prReference;
+    }
+    function getReleaseLine(changeset, versionType, options) {
+        return external_effect_.Effect.gen(function*() {
+            let commitInfo = null;
+            if (changeset.commit) {
+                const github = yield* services_github.Xx;
+                commitInfo = yield* github.getInfo({
+                    commit: changeset.commit,
+                    repo: options.repo
+                }).pipe(external_effect_.Effect.flatMap((raw)=>external_effect_.Schema.decodeUnknown(schemas_github.lo)(raw).pipe(external_effect_.Effect.map(()=>raw), external_effect_.Effect.catchAll(()=>external_effect_.Effect.succeed(raw)))), external_effect_.Effect.catchAll((error)=>{
+                    logWarning("Could not fetch GitHub info for commit:", changeset.commit ?? "", String(error));
+                    return external_effect_.Effect.succeed(null);
+                }));
+            }
+            const parsed = parseChangesetSections(changeset.summary);
+            const firstLine = changeset.summary.split("\n")[0];
+            const commitMsg = parseCommitMessage(firstLine);
+            const bodyText = changeset.summary.split("\n").slice(1).join("\n");
+            const issueRefs = parseIssueReferences(bodyText);
+            const attribution = commitInfo ? formatPRAndUserAttribution(commitInfo.pull ?? void 0, commitInfo.user ?? void 0, commitInfo.links) : "";
+            if (parsed.sections.length > 0) {
+                const lines = [];
+                if (parsed.preamble) {
+                    lines.push(parsed.preamble);
+                    lines.push("");
+                }
+                for (const section of parsed.sections){
+                    lines.push(`### ${section.category.heading}`);
+                    lines.push("");
+                    const commitPrefix = changeset.commit ? `[\`${changeset.commit.substring(0, 7)}\`](https://github.com/${options.repo}/commit/${changeset.commit}) ` : "";
+                    if (section.content) {
+                        const contentLines = section.content.split("\n");
+                        const firstContentLine = contentLines[0];
+                        if (firstContentLine.startsWith("- ") || firstContentLine.startsWith("* ")) {
+                            lines.push(`${firstContentLine.substring(0, 2)}${commitPrefix}${firstContentLine.substring(2)}`);
+                            lines.push(...contentLines.slice(1));
+                        } else lines.push(`- ${commitPrefix}${section.content}`);
+                    }
+                    lines.push("");
+                }
+                const result = lines.join("\n").trimEnd();
+                return `${result}${attribution}`;
+            }
+            const commitType = commitMsg.type ?? versionType;
+            const category = (0, categories.OH)(commitType, commitMsg.scope, commitMsg.breaking);
+            const entryInput = {
+                type: category.heading,
+                summary: changeset.summary,
+                issues: issueRefs,
+                ...changeset.commit ? {
+                    commit: changeset.commit
+                } : {}
+            };
+            const entry = formatChangelogEntry(entryInput, {
+                repo: options.repo
+            });
+            return `- ${entry}${attribution}`;
+        });
+    }
+    const MainLayer = external_effect_.Layer.mergeAll(services_github.cH, markdown.Am);
+    const changelogFunctions = {
+        getReleaseLine: async (changeset, versionType, options)=>{
+            const program = external_effect_.Effect.gen(function*() {
+                const opts = yield* (0, schemas_options.jb)(options);
+                return yield* getReleaseLine(changeset, versionType, opts);
+            });
+            return external_effect_.Effect.runPromise(program.pipe(external_effect_.Effect.provide(MainLayer)));
+        },
+        getDependencyReleaseLine: async (changesets, dependenciesUpdated, options)=>{
+            const program = external_effect_.Effect.gen(function*() {
+                const opts = yield* (0, schemas_options.jb)(options);
+                return yield* getDependencyReleaseLine(changesets, dependenciesUpdated, opts);
+            });
+            return external_effect_.Effect.runPromise(program.pipe(external_effect_.Effect.provide(MainLayer)));
+        }
+    };
+    const changelog = changelogFunctions;
+})();
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});
+
+
+if (module.exports && module.exports.__esModule && 'default' in module.exports) {
+  var _def = module.exports.default;
+  if (_def !== null && _def !== undefined && (typeof _def === 'object' || typeof _def === 'function')) {
+    var _keys = Object.keys(module.exports);
+    for (var _i = 0; _i < _keys.length; _i++) {
+      var _key = _keys[_i];
+      if (_key !== 'default' && _key !== '__esModule' && !(_key in _def)) {
+        _def[_key] = module.exports[_key];
+      }
+    }
+  }
+  module.exports = _def;
+}