@savvy-web/changesets 0.1.0 → 0.1.1

package/cjs/index.cjs

@@ -0,0 +1,1302 @@
+"use strict";
+var __webpack_modules__ = {
+    "./src/categories/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Ar: ()=>MAINTENANCE,
+            CI: ()=>CI,
+            Fi: ()=>REFACTORING,
+            Gv: ()=>FEATURES,
+            JY: ()=>fromHeading,
+            KY: ()=>DEPENDENCIES,
+            Lr: ()=>isValidHeading,
+            N: ()=>BUILD_SYSTEM,
+            OH: ()=>resolveCommitType,
+            R6: ()=>CATEGORIES,
+            Rr: ()=>allHeadings,
+            Zs: ()=>OTHER,
+            cT: ()=>REVERTS,
+            iD: ()=>BREAKING_CHANGES,
+            l0: ()=>DOCUMENTATION,
+            mp: ()=>TESTS,
+            vZ: ()=>BUG_FIXES,
+            xe: ()=>PERFORMANCE
+        });
+        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());
+        }
+        function isValidHeading(heading) {
+            return headingToCategory.has(heading.toLowerCase());
+        }
+        function allHeadings() {
+            return CATEGORIES.map((cat)=>cat.heading);
+        }
+    },
+    "./src/changelog/index.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __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;
+    },
+    "./src/errors.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Gv: ()=>ChangesetValidationError,
+            OS: ()=>GitHubApiError,
+            TZ: ()=>GitHubApiErrorBase,
+            W4: ()=>ConfigurationErrorBase,
+            hL: ()=>ChangesetValidationErrorBase,
+            j1: ()=>ConfigurationError,
+            ww: ()=>MarkdownParseErrorBase,
+            zy: ()=>MarkdownParseError
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        const ChangesetValidationErrorBase = effect__rspack_import_0.Data.TaggedError("ChangesetValidationError");
+        class ChangesetValidationError extends ChangesetValidationErrorBase {
+            get message() {
+                const prefix = this.file ? `${this.file}: ` : "";
+                const detail = this.issues.map((i)=>`  - ${i.path}: ${i.message}`).join("\n");
+                return `${prefix}Changeset validation failed:\n${detail}`;
+            }
+        }
+        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);
+            }
+        }
+        const MarkdownParseErrorBase = effect__rspack_import_0.Data.TaggedError("MarkdownParseError");
+        class MarkdownParseError extends MarkdownParseErrorBase {
+            get message() {
+                const loc = this.line ? `:${this.line}${this.column ? `:${this.column}` : ""}` : "";
+                const src = this.source ? `${this.source}${loc}: ` : "";
+                return `${src}Markdown parse error: ${this.reason}`;
+            }
+        }
+        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__, {
+            OD: ()=>IssueNumberSchema,
+            Qo: ()=>UsernameSchema,
+            hY: ()=>UrlOrMarkdownLinkSchema,
+            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__, {
+            YL: ()=>ChangesetOptionsSchema,
+            jb: ()=>validateChangesetOptions,
+            s8: ()=>RepoSchema
+        });
+        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,
+            u: ()=>NonEmptyString
+        });
+        var effect__rspack_import_0 = __webpack_require__("effect");
+        const NonEmptyString = 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,
+            wP: ()=>GitHubServiceBase,
+            e_: ()=>makeGitHubTest,
+            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
+        });
+        function makeGitHubTest(responses) {
+            return external_effect_.Layer.succeed(GitHubService, {
+                getInfo: (params)=>{
+                    const info = responses.get(params.commit);
+                    if (info) return external_effect_.Effect.succeed(info);
+                    return external_effect_.Effect.fail(new errors.OS({
+                        operation: "getInfo",
+                        reason: `No mock response for commit ${params.commit}`
+                    }));
+                }
+            });
+        }
+    },
+    "./src/services/markdown.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Am: ()=>MarkdownLive,
+            M4: ()=>MarkdownServiceBase,
+            Rl: ()=>MarkdownService
+        });
+        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__, {
+        IssueNumberSchema: ()=>schemas_github.OD,
+        ChangelogServiceBase: ()=>ChangelogServiceBase,
+        UrlOrMarkdownLinkSchema: ()=>schemas_github.hY,
+        GitHubInfoSchema: ()=>schemas_github.lo,
+        GitHubServiceBase: ()=>github.wP,
+        GitHubApiErrorBase: ()=>errors.TZ,
+        ChangesetLinter: ()=>ChangesetLinter,
+        MarkdownServiceBase: ()=>markdown.M4,
+        ChangesetSchema: ()=>ChangesetSchema,
+        UsernameSchema: ()=>schemas_github.Qo,
+        ChangesetOptionsSchema: ()=>schemas_options.YL,
+        DependencyUpdateSchema: ()=>DependencyUpdateSchema,
+        VersionTypeSchema: ()=>VersionTypeSchema,
+        makeGitHubTest: ()=>github.e_,
+        ChangelogService: ()=>ChangelogService,
+        ChangesetSummarySchema: ()=>ChangesetSummarySchema,
+        MarkdownParseError: ()=>errors.zy,
+        PositiveInteger: ()=>primitives.e,
+        CommitHashSchema: ()=>CommitHashSchema,
+        ChangelogTransformer: ()=>ChangelogTransformer,
+        NonEmptyString: ()=>primitives.u,
+        ConfigurationError: ()=>errors.j1,
+        Categories: ()=>Categories,
+        Changelog: ()=>Changelog,
+        SectionCategorySchema: ()=>SectionCategorySchema,
+        DependencyTypeSchema: ()=>DependencyTypeSchema,
+        MarkdownService: ()=>markdown.Rl,
+        ChangesetValidationErrorBase: ()=>errors.hL,
+        ConfigurationErrorBase: ()=>errors.W4,
+        RepoSchema: ()=>schemas_options.s8,
+        GitHubApiError: ()=>errors.OS,
+        MarkdownParseErrorBase: ()=>errors.ww,
+        GitHubService: ()=>github.Xx,
+        GitHubLive: ()=>github.cH,
+        MarkdownLive: ()=>markdown.Am,
+        ChangesetValidationError: ()=>errors.Gv
+    });
+    var categories = __webpack_require__("./src/categories/index.ts");
+    class Categories {
+        static BREAKING_CHANGES = categories.iD;
+        static FEATURES = categories.Gv;
+        static BUG_FIXES = categories.vZ;
+        static PERFORMANCE = categories.xe;
+        static DOCUMENTATION = categories.l0;
+        static REFACTORING = categories.Fi;
+        static TESTS = categories.mp;
+        static BUILD_SYSTEM = categories.N;
+        static CI = categories.CI;
+        static DEPENDENCIES = categories.KY;
+        static MAINTENANCE = categories.Ar;
+        static REVERTS = categories.cT;
+        static OTHER = categories.Zs;
+        static ALL = categories.R6;
+        static fromCommitType(type, scope, breaking) {
+            return (0, categories.OH)(type, scope, breaking);
+        }
+        static fromHeading(heading) {
+            return (0, categories.JY)(heading);
+        }
+        static allHeadings() {
+            return (0, categories.Rr)();
+        }
+        static isValidHeading(heading) {
+            return (0, categories.Lr)(heading);
+        }
+    }
+    var changelog = __webpack_require__("./src/changelog/index.ts");
+    class Changelog {
+        static formatReleaseLine(changeset, versionType, options) {
+            return changelog["default"].getReleaseLine(changeset, versionType, options);
+        }
+        static formatDependencyReleaseLine(changesets, dependenciesUpdated, options) {
+            return changelog["default"].getDependencyReleaseLine(changesets, dependenciesUpdated, options);
+        }
+    }
+    const external_node_fs_namespaceObject = require("node:fs");
+    const external_node_path_namespaceObject = require("node:path");
+    var external_remark_parse_ = __webpack_require__("remark-parse");
+    var external_remark_parse_default = /*#__PURE__*/ __webpack_require__.n(external_remark_parse_);
+    var external_remark_stringify_ = __webpack_require__("remark-stringify");
+    var external_remark_stringify_default = /*#__PURE__*/ __webpack_require__.n(external_remark_stringify_);
+    var external_unified_ = __webpack_require__("unified");
+    var external_mdast_util_to_string_ = __webpack_require__("mdast-util-to-string");
+    const external_unified_lint_rule_namespaceObject = require("unified-lint-rule");
+    const external_unist_util_visit_namespaceObject = require("unist-util-visit");
+    const ContentStructureRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-content-structure", (tree, file)=>{
+        (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node, index, parent)=>{
+            if (2 !== node.depth || null == parent || null == index) return;
+            const next = parent.children[index + 1];
+            if (!next || "heading" === next.type && 2 === next.depth) file.message("Empty section: heading has no content before the next section or end of file", node);
+        });
+        (0, external_unist_util_visit_namespaceObject.visit)(tree, "code", (node)=>{
+            if (!node.lang) file.message("Code block is missing a language identifier", node);
+        });
+        (0, external_unist_util_visit_namespaceObject.visit)(tree, "listItem", (node)=>{
+            const text = (0, external_mdast_util_to_string_.toString)(node).trim();
+            if (!text) file.message("Empty list item", node);
+        });
+    });
+    const HeadingHierarchyRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-heading-hierarchy", (tree, file)=>{
+        let prevDepth = 0;
+        (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node)=>{
+            if (1 === node.depth) return void file.message("h1 headings are not allowed in changeset files", node);
+            if (prevDepth > 0 && node.depth > prevDepth + 1) file.message(`Heading level skipped: expected h${prevDepth + 1} or lower, found h${node.depth}`, node);
+            prevDepth = node.depth;
+        });
+    });
+    const RequiredSectionsRule = (0, external_unified_lint_rule_namespaceObject.lintRule)("remark-lint:changeset-required-sections", (tree, file)=>{
+        (0, external_unist_util_visit_namespaceObject.visit)(tree, "heading", (node)=>{
+            if (2 !== node.depth) return;
+            const text = (0, external_mdast_util_to_string_.toString)(node);
+            if (!(0, categories.Lr)(text)) file.message(`Unknown section "${text}". Valid sections: ${(0, categories.Rr)().join(", ")}`, node);
+        });
+    });
+    function stripFrontmatter(content) {
+        return content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+    }
+    class ChangesetLinter {
+        static validateFile(filePath) {
+            const raw = (0, external_node_fs_namespaceObject.readFileSync)(filePath, "utf-8");
+            return ChangesetLinter.validateContent(raw, filePath);
+        }
+        static validateContent(content, filePath = "<input>") {
+            const body = stripFrontmatter(content);
+            const processor = (0, external_unified_.unified)().use(external_remark_parse_default()).use(external_remark_stringify_default()).use(HeadingHierarchyRule).use(RequiredSectionsRule).use(ContentStructureRule);
+            const file = processor.processSync(body);
+            return file.messages.map((msg)=>({
+                    file: filePath,
+                    rule: msg.ruleId ?? msg.source ?? "unknown",
+                    line: msg.line ?? 1,
+                    column: msg.column ?? 1,
+                    message: msg.message
+                }));
+        }
+        static validate(dir) {
+            return (0, external_node_fs_namespaceObject.readdirSync)(dir).filter((f)=>f.endsWith(".md") && "README.md" !== f).flatMap((filename)=>ChangesetLinter.validateFile((0, external_node_path_namespaceObject.join)(dir, filename)));
+        }
+    }
+    var external_remark_gfm_ = __webpack_require__("remark-gfm");
+    var external_remark_gfm_default = /*#__PURE__*/ __webpack_require__.n(external_remark_gfm_);
+    function getVersionBlocks(tree) {
+        const blocks = [];
+        for(let i = 0; i < tree.children.length; i++){
+            const node = tree.children[i];
+            if ("heading" === node.type && 2 === node.depth) blocks.push({
+                headingIndex: i,
+                startIndex: i + 1,
+                endIndex: tree.children.length
+            });
+        }
+        for(let i = 0; i < blocks.length - 1; i++)blocks[i].endIndex = blocks[i + 1].headingIndex;
+        return blocks;
+    }
+    function getBlockSections(tree, block) {
+        const sections = [];
+        for(let i = block.startIndex; i < block.endIndex; i++){
+            const node = tree.children[i];
+            if ("heading" === node.type && 3 === node.depth) sections.push({
+                heading: node,
+                headingIndex: i,
+                contentNodes: []
+            });
+            else if (sections.length > 0) sections[sections.length - 1].contentNodes.push(node);
+        }
+        return sections;
+    }
+    function getHeadingText(heading) {
+        return (0, external_mdast_util_to_string_.toString)(heading);
+    }
+    const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
+    function extractLinkedAttribution(children) {
+        if (children.length < 3) return;
+        const last = children[children.length - 1];
+        const secondLast = children[children.length - 2];
+        const thirdLast = children[children.length - 3];
+        if ("text" !== last.type || "!" !== last.value) return;
+        if ("link" !== secondLast.type) return;
+        const linkNode = secondLast;
+        if (1 !== linkNode.children.length || "text" !== linkNode.children[0].type) return;
+        const linkText = linkNode.children[0].value;
+        if (!linkText.startsWith("@")) return;
+        const username = linkText.slice(1);
+        if ("text" !== thirdLast.type) return;
+        const textNode = thirdLast;
+        if (!/\s*Thanks $/.test(textNode.value)) return;
+        return {
+            contributor: {
+                username,
+                url: linkNode.url
+            },
+            removeFrom: children.length - 3
+        };
+    }
+    const ContributorFootnotesPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            for(let b = blocks.length - 1; b >= 0; b--){
+                const block = blocks[b];
+                const contributors = new Map();
+                for(let i = block.startIndex; i < block.endIndex; i++){
+                    const node = tree.children[i];
+                    if ("list" === node.type) (0, external_unist_util_visit_namespaceObject.visit)(node, "paragraph", (para)=>{
+                        const linked = extractLinkedAttribution(para.children);
+                        if (linked) {
+                            const key = linked.contributor.username.toLowerCase();
+                            if (!contributors.has(key)) contributors.set(key, linked.contributor);
+                            const textNode = para.children[linked.removeFrom];
+                            textNode.value = textNode.value.replace(/\s*Thanks $/, "");
+                            para.children.splice(linked.removeFrom + 1, 2);
+                            if ("" === textNode.value) para.children.splice(linked.removeFrom, 1);
+                            return;
+                        }
+                        const last = para.children[para.children.length - 1];
+                        if (last?.type === "text") {
+                            const textNode = last;
+                            const match = textNode.value.match(ATTRIBUTION_PLAIN_RE);
+                            if (match) {
+                                const username = match[1];
+                                const key = username.toLowerCase();
+                                if (!contributors.has(key)) contributors.set(key, {
+                                    username,
+                                    url: void 0
+                                });
+                                textNode.value = textNode.value.replace(ATTRIBUTION_PLAIN_RE, "");
+                            }
+                        }
+                    });
+                }
+                if (0 === contributors.size) continue;
+                const sorted = [
+                    ...contributors.values()
+                ].sort((a, b)=>a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
+                const phrasingChildren = [];
+                phrasingChildren.push({
+                    type: "text",
+                    value: "Thanks to "
+                });
+                for(let i = 0; i < sorted.length; i++){
+                    const contrib = sorted[i];
+                    if (i > 0 && sorted.length > 2) phrasingChildren.push({
+                        type: "text",
+                        value: ", "
+                    });
+                    if (i > 0 && i === sorted.length - 1) phrasingChildren.push({
+                        type: "text",
+                        value: 2 === sorted.length ? " and " : "and "
+                    });
+                    if (contrib.url) phrasingChildren.push({
+                        type: "link",
+                        url: contrib.url,
+                        children: [
+                            {
+                                type: "text",
+                                value: `@${contrib.username}`
+                            }
+                        ]
+                    });
+                    else phrasingChildren.push({
+                        type: "text",
+                        value: `@${contrib.username}`
+                    });
+                }
+                phrasingChildren.push({
+                    type: "text",
+                    value: " for their contributions!"
+                });
+                const paragraph = {
+                    type: "paragraph",
+                    children: phrasingChildren
+                };
+                tree.children.splice(block.endIndex, 0, paragraph);
+            }
+        };
+    const DeduplicateItemsPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            for (const block of blocks){
+                const sections = getBlockSections(tree, block);
+                for (const section of sections)for (const node of section.contentNodes){
+                    if ("list" !== node.type) continue;
+                    const list = node;
+                    const seen = new Set();
+                    list.children = list.children.filter((item)=>{
+                        const text = (0, external_mdast_util_to_string_.toString)(item);
+                        if (seen.has(text)) return false;
+                        seen.add(text);
+                        return true;
+                    });
+                }
+            }
+            tree.children = tree.children.filter((node)=>{
+                if ("list" === node.type) return node.children.length > 0;
+                return true;
+            });
+        };
+    const ISSUE_RE = /^#\d+$/;
+    const IssueLinkRefsPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            for(let b = blocks.length - 1; b >= 0; b--){
+                const block = blocks[b];
+                const definitions = new Map();
+                for(let i = block.startIndex; i < block.endIndex; i++){
+                    const node = tree.children[i];
+                    (0, external_unist_util_visit_namespaceObject.visit)(node, "link", (linkNode, index, parent)=>{
+                        if (!parent || void 0 === index) return;
+                        if (1 !== linkNode.children.length || "text" !== linkNode.children[0].type) return;
+                        const text = linkNode.children[0].value;
+                        if (!ISSUE_RE.test(text)) return;
+                        const label = text;
+                        if (!definitions.has(label)) definitions.set(label, {
+                            label,
+                            url: linkNode.url
+                        });
+                        const ref = {
+                            type: "linkReference",
+                            identifier: label,
+                            label,
+                            referenceType: "full",
+                            children: [
+                                {
+                                    type: "text",
+                                    value: label
+                                }
+                            ]
+                        };
+                        parent.children[index] = ref;
+                        return external_unist_util_visit_namespaceObject.SKIP;
+                    });
+                }
+                if (0 === definitions.size) continue;
+                const sorted = [
+                    ...definitions.values()
+                ].sort((a, b)=>{
+                    const aNum = Number.parseInt(a.label.slice(1), 10);
+                    const bNum = Number.parseInt(b.label.slice(1), 10);
+                    return aNum - bNum;
+                });
+                const defNodes = sorted.map((def)=>({
+                        type: "definition",
+                        identifier: def.label,
+                        label: def.label,
+                        url: def.url
+                    }));
+                tree.children.splice(block.endIndex, 0, ...defNodes);
+            }
+        };
+    const MergeSectionsPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            for(let b = blocks.length - 1; b >= 0; b--){
+                const sections = getBlockSections(tree, blocks[b]);
+                if (sections.length <= 1) continue;
+                const groups = new Map();
+                for(let s = 0; s < sections.length; s++){
+                    const text = getHeadingText(sections[s].heading);
+                    const category = (0, categories.JY)(text);
+                    const key = category ? category.heading.toLowerCase() : text.toLowerCase();
+                    const existing = groups.get(key);
+                    if (existing) existing.push(s);
+                    else groups.set(key, [
+                        s
+                    ]);
+                }
+                const indicesToRemove = [];
+                for (const indices of groups.values()){
+                    if (indices.length <= 1) continue;
+                    const target = sections[indices[0]];
+                    const targetEndIndex = target.headingIndex + 1 + target.contentNodes.length;
+                    const mergedContent = [];
+                    for(let d = 1; d < indices.length; d++){
+                        const dup = sections[indices[d]];
+                        mergedContent.push(...dup.contentNodes);
+                        indicesToRemove.push(dup.headingIndex);
+                        for(let c = 0; c < dup.contentNodes.length; c++)indicesToRemove.push(dup.headingIndex + 1 + c);
+                    }
+                    tree.children.splice(targetEndIndex, 0, ...mergedContent);
+                    const shift = mergedContent.length;
+                    for(let r = 0; r < indicesToRemove.length; r++)if (indicesToRemove[r] >= targetEndIndex) indicesToRemove[r] += shift;
+                }
+                indicesToRemove.sort((a, b)=>b - a);
+                for (const idx of indicesToRemove)tree.children.splice(idx, 1);
+            }
+        };
+    function isHeadingAtDepth(node, depths) {
+        return "heading" === node.type && depths.includes(node.depth);
+    }
+    const NormalizeFormatPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            const indicesToRemove = new Set();
+            for (const block of blocks)for(let i = block.startIndex; i < block.endIndex; i++){
+                const node = tree.children[i];
+                if ("list" === node.type && 0 === node.children.length) {
+                    indicesToRemove.add(i);
+                    continue;
+                }
+                if (!isHeadingAtDepth(node, [
+                    3
+                ])) continue;
+                let hasContent = false;
+                for(let j = i + 1; j < block.endIndex; j++){
+                    const next = tree.children[j];
+                    if ("paragraph" === next.type && "" === (0, external_mdast_util_to_string_.toString)(next).trim()) {
+                        indicesToRemove.add(j);
+                        continue;
+                    }
+                    if (isHeadingAtDepth(next, [
+                        2,
+                        3
+                    ])) break;
+                    hasContent = true;
+                    break;
+                }
+                if (!hasContent) indicesToRemove.add(i);
+            }
+            const sorted = [
+                ...indicesToRemove
+            ].sort((a, b)=>b - a);
+            for (const idx of sorted)tree.children.splice(idx, 1);
+        };
+    const UNKNOWN_PRIORITY = 999;
+    const ReorderSectionsPlugin = ()=>(tree)=>{
+            const blocks = getVersionBlocks(tree);
+            for(let b = blocks.length - 1; b >= 0; b--){
+                const block = blocks[b];
+                const sections = getBlockSections(tree, block);
+                if (sections.length <= 1) continue;
+                const preamble = [];
+                for(let i = block.startIndex; i < block.endIndex; i++)if (i < sections[0].headingIndex) preamble.push(tree.children[i]);
+                else break;
+                const sorted = [
+                    ...sections
+                ].sort((a, b)=>{
+                    const aPriority = (0, categories.JY)(getHeadingText(a.heading))?.priority ?? UNKNOWN_PRIORITY;
+                    const bPriority = (0, categories.JY)(getHeadingText(b.heading))?.priority ?? UNKNOWN_PRIORITY;
+                    return aPriority - bPriority;
+                });
+                const alreadySorted = sorted.every((s, i)=>s.headingIndex === sections[i].headingIndex);
+                if (alreadySorted) continue;
+                const newChildren = [
+                    ...preamble
+                ];
+                for (const section of sorted)newChildren.push(section.heading, ...section.contentNodes);
+                const blockLength = block.endIndex - block.startIndex;
+                tree.children.splice(block.startIndex, blockLength, ...newChildren);
+            }
+        };
+    class ChangelogTransformer {
+        static transformContent(content) {
+            const processor = (0, external_unified_.unified)().use(external_remark_parse_default()).use(external_remark_gfm_default()).use(MergeSectionsPlugin).use(ReorderSectionsPlugin).use(DeduplicateItemsPlugin).use(ContributorFootnotesPlugin).use(IssueLinkRefsPlugin).use(NormalizeFormatPlugin).use(external_remark_stringify_default());
+            const file = processor.processSync(content);
+            return String(file);
+        }
+        static transformFile(filePath) {
+            const content = (0, external_node_fs_namespaceObject.readFileSync)(filePath, "utf-8");
+            const result = ChangelogTransformer.transformContent(content);
+            (0, external_node_fs_namespaceObject.writeFileSync)(filePath, result, "utf-8");
+        }
+    }
+    var external_effect_ = __webpack_require__("effect");
+    const _tag = external_effect_.Context.Tag("ChangelogService");
+    const ChangelogServiceBase = _tag();
+    class ChangelogService extends ChangelogServiceBase {
+    }
+    var github = __webpack_require__("./src/services/github.ts");
+    var markdown = __webpack_require__("./src/services/markdown.ts");
+    var errors = __webpack_require__("./src/errors.ts");
+    const SectionCategorySchema = external_effect_.Schema.Struct({
+        heading: external_effect_.Schema.String,
+        priority: external_effect_.Schema.Number,
+        commitTypes: external_effect_.Schema.Array(external_effect_.Schema.String),
+        description: external_effect_.Schema.String
+    });
+    const CommitHashSchema = external_effect_.Schema.String.pipe(external_effect_.Schema.pattern(/^[a-f0-9]{7,}$/, {
+        message: ()=>"Commit hash must be at least 7 hexadecimal characters"
+    }));
+    const VersionTypeSchema = external_effect_.Schema.Literal("major", "minor", "patch", "none");
+    var primitives = __webpack_require__("./src/schemas/primitives.ts");
+    const ChangesetSummarySchema = external_effect_.Schema.String.pipe(external_effect_.Schema.minLength(1, {
+        message: ()=>"Changeset summary cannot be empty"
+    }), external_effect_.Schema.maxLength(1000, {
+        message: ()=>"Changeset summary is too long"
+    }));
+    const ChangesetSchema = external_effect_.Schema.Struct({
+        summary: ChangesetSummarySchema,
+        id: external_effect_.Schema.String,
+        commit: external_effect_.Schema.optional(CommitHashSchema)
+    });
+    const DependencyTypeSchema = external_effect_.Schema.Literal("dependencies", "devDependencies", "peerDependencies", "optionalDependencies");
+    const DependencyUpdateSchema = external_effect_.Schema.Struct({
+        name: primitives.u.annotations({
+            message: ()=>"Package name cannot be empty"
+        }),
+        type: DependencyTypeSchema,
+        oldVersion: external_effect_.Schema.String,
+        newVersion: external_effect_.Schema.String
+    });
+    var schemas_github = __webpack_require__("./src/schemas/github.ts");
+    var schemas_options = __webpack_require__("./src/schemas/options.ts");
+})();
+exports.Categories = __webpack_exports__.Categories;
+exports.Changelog = __webpack_exports__.Changelog;
+exports.ChangelogService = __webpack_exports__.ChangelogService;
+exports.ChangelogServiceBase = __webpack_exports__.ChangelogServiceBase;
+exports.ChangelogTransformer = __webpack_exports__.ChangelogTransformer;
+exports.ChangesetLinter = __webpack_exports__.ChangesetLinter;
+exports.ChangesetOptionsSchema = __webpack_exports__.ChangesetOptionsSchema;
+exports.ChangesetSchema = __webpack_exports__.ChangesetSchema;
+exports.ChangesetSummarySchema = __webpack_exports__.ChangesetSummarySchema;
+exports.ChangesetValidationError = __webpack_exports__.ChangesetValidationError;
+exports.ChangesetValidationErrorBase = __webpack_exports__.ChangesetValidationErrorBase;
+exports.CommitHashSchema = __webpack_exports__.CommitHashSchema;
+exports.ConfigurationError = __webpack_exports__.ConfigurationError;
+exports.ConfigurationErrorBase = __webpack_exports__.ConfigurationErrorBase;
+exports.DependencyTypeSchema = __webpack_exports__.DependencyTypeSchema;
+exports.DependencyUpdateSchema = __webpack_exports__.DependencyUpdateSchema;
+exports.GitHubApiError = __webpack_exports__.GitHubApiError;
+exports.GitHubApiErrorBase = __webpack_exports__.GitHubApiErrorBase;
+exports.GitHubInfoSchema = __webpack_exports__.GitHubInfoSchema;
+exports.GitHubLive = __webpack_exports__.GitHubLive;
+exports.GitHubService = __webpack_exports__.GitHubService;
+exports.GitHubServiceBase = __webpack_exports__.GitHubServiceBase;
+exports.IssueNumberSchema = __webpack_exports__.IssueNumberSchema;
+exports.MarkdownLive = __webpack_exports__.MarkdownLive;
+exports.MarkdownParseError = __webpack_exports__.MarkdownParseError;
+exports.MarkdownParseErrorBase = __webpack_exports__.MarkdownParseErrorBase;
+exports.MarkdownService = __webpack_exports__.MarkdownService;
+exports.MarkdownServiceBase = __webpack_exports__.MarkdownServiceBase;
+exports.NonEmptyString = __webpack_exports__.NonEmptyString;
+exports.PositiveInteger = __webpack_exports__.PositiveInteger;
+exports.RepoSchema = __webpack_exports__.RepoSchema;
+exports.SectionCategorySchema = __webpack_exports__.SectionCategorySchema;
+exports.UrlOrMarkdownLinkSchema = __webpack_exports__.UrlOrMarkdownLinkSchema;
+exports.UsernameSchema = __webpack_exports__.UsernameSchema;
+exports.VersionTypeSchema = __webpack_exports__.VersionTypeSchema;
+exports.makeGitHubTest = __webpack_exports__.makeGitHubTest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Categories",
+    "Changelog",
+    "ChangelogService",
+    "ChangelogServiceBase",
+    "ChangelogTransformer",
+    "ChangesetLinter",
+    "ChangesetOptionsSchema",
+    "ChangesetSchema",
+    "ChangesetSummarySchema",
+    "ChangesetValidationError",
+    "ChangesetValidationErrorBase",
+    "CommitHashSchema",
+    "ConfigurationError",
+    "ConfigurationErrorBase",
+    "DependencyTypeSchema",
+    "DependencyUpdateSchema",
+    "GitHubApiError",
+    "GitHubApiErrorBase",
+    "GitHubInfoSchema",
+    "GitHubLive",
+    "GitHubService",
+    "GitHubServiceBase",
+    "IssueNumberSchema",
+    "MarkdownLive",
+    "MarkdownParseError",
+    "MarkdownParseErrorBase",
+    "MarkdownService",
+    "MarkdownServiceBase",
+    "NonEmptyString",
+    "PositiveInteger",
+    "RepoSchema",
+    "SectionCategorySchema",
+    "UrlOrMarkdownLinkSchema",
+    "UsernameSchema",
+    "VersionTypeSchema",
+    "makeGitHubTest"
+].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;
+}