@savvy-web/changesets 0.1.0

package/234.js

@@ -0,0 +1,337 @@
+import { lintRule } from "unified-lint-rule";
+import { SKIP, visit } from "unist-util-visit";
+import { external_mdast_util_to_string_toString } from "./689.js";
+import { isValidHeading, fromHeading, allHeadings } from "./60.js";
+const ContentStructureRule = lintRule("remark-lint:changeset-content-structure", (tree, file)=>{
+    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);
+    });
+    visit(tree, "code", (node)=>{
+        if (!node.lang) file.message("Code block is missing a language identifier", node);
+    });
+    visit(tree, "listItem", (node)=>{
+        const text = external_mdast_util_to_string_toString(node).trim();
+        if (!text) file.message("Empty list item", node);
+    });
+});
+const HeadingHierarchyRule = lintRule("remark-lint:changeset-heading-hierarchy", (tree, file)=>{
+    let prevDepth = 0;
+    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 = lintRule("remark-lint:changeset-required-sections", (tree, file)=>{
+    visit(tree, "heading", (node)=>{
+        if (2 !== node.depth) return;
+        const text = external_mdast_util_to_string_toString(node);
+        if (!isValidHeading(text)) file.message(`Unknown section "${text}". Valid sections: ${allHeadings().join(", ")}`, node);
+    });
+});
+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 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) 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 = 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];
+                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 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 = fromHeading(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 && "" === 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 = fromHeading(getHeadingText(a.heading))?.priority ?? UNKNOWN_PRIORITY;
+                const bPriority = fromHeading(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);
+        }
+    };
+export { ContentStructureRule, ContributorFootnotesPlugin, DeduplicateItemsPlugin, HeadingHierarchyRule, IssueLinkRefsPlugin, MergeSectionsPlugin, NormalizeFormatPlugin, ReorderSectionsPlugin, RequiredSectionsRule };

package/245.js

@@ -0,0 +1,5 @@
+export { Context, Data, Effect, Layer, Schema } from "effect";
+export { default as remark_gfm } from "remark-gfm";
+export { default as remark_parse } from "remark-parse";
+export { default as remark_stringify } from "remark-stringify";
+export { unified } from "unified";

package/273.js

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { unified, remark_gfm, remark_stringify, remark_parse } from "./245.js";
+import { MergeSectionsPlugin, DeduplicateItemsPlugin, IssueLinkRefsPlugin, ContentStructureRule, HeadingHierarchyRule, NormalizeFormatPlugin, ReorderSectionsPlugin, ContributorFootnotesPlugin, RequiredSectionsRule } from "./234.js";
+function stripFrontmatter(content) {
+    return content.replace(/^---\n[\s\S]*?\n---\n?/, "");
+}
+class ChangesetLinter {
+    static validateFile(filePath) {
+        const raw = readFileSync(filePath, "utf-8");
+        return ChangesetLinter.validateContent(raw, filePath);
+    }
+    static validateContent(content, filePath = "<input>") {
+        const body = stripFrontmatter(content);
+        const processor = unified().use(remark_parse).use(remark_stringify).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 readdirSync(dir).filter((f)=>f.endsWith(".md") && "README.md" !== f).flatMap((filename)=>ChangesetLinter.validateFile(join(dir, filename)));
+    }
+}
+class ChangelogTransformer {
+    static transformContent(content) {
+        const processor = unified().use(remark_parse).use(remark_gfm).use(MergeSectionsPlugin).use(ReorderSectionsPlugin).use(DeduplicateItemsPlugin).use(ContributorFootnotesPlugin).use(IssueLinkRefsPlugin).use(NormalizeFormatPlugin).use(remark_stringify);
+        const file = processor.processSync(content);
+        return String(file);
+    }
+    static transformFile(filePath) {
+        const content = readFileSync(filePath, "utf-8");
+        const result = ChangelogTransformer.transformContent(content);
+        writeFileSync(filePath, result, "utf-8");
+    }
+}
+export { ChangelogTransformer, ChangesetLinter, existsSync, join, mkdirSync, readFileSync, resolve, writeFileSync };

package/60.js

@@ -0,0 +1,137 @@
+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);
+}
+export { BREAKING_CHANGES, BUG_FIXES, BUILD_SYSTEM, CATEGORIES, CI, DEPENDENCIES, DOCUMENTATION, FEATURES, MAINTENANCE, OTHER, PERFORMANCE, REFACTORING, REVERTS, TESTS, allHeadings, fromHeading, isValidHeading, resolveCommitType };

package/689.js

@@ -0,0 +1 @@
+export { toString as external_mdast_util_to_string_toString } from "mdast-util-to-string";

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Savvy Web Strategy, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# @savvy-web/changesets
+
+[![npm version][npm-badge]][npm-url]
+[![License: MIT][license-badge]][license-url]
+
+Custom changelog formatter and markdown processing pipeline
+for the Silk Suite. Replaces the default
+`@changesets/cli/changelog` formatter with a three-layer
+architecture that validates changeset files, formats
+structured changelog entries, and post-processes the
+generated CHANGELOG.md.
+
+## Features
+
+- **Section-aware changesets** -- Use h2 headings in
+  changeset files to categorize changes (Features,
+  Bug Fixes, Breaking Changes, etc.)
+- **Three-layer pipeline** -- Pre-validation
+  (remark-lint), changelog formatting (Changesets API),
+  and post-processing (remark-transform)
+- **13 section categories** -- Consistent categorization
+  with priority-based ordering across all layers
+- **CLI tooling** -- `savvy-changesets` binary with init,
+  lint, transform, check, and version subcommands for CI
+  and local use
+- **GitHub integration** -- Automatic PR links, commit
+  references, and contributor attribution
+- **Remark plugins** -- Lint rules and transform plugins
+  via `@savvy-web/changesets/remark`
+- **markdownlint rules** -- Custom rules compatible with
+  markdownlint-cli2 and the VS Code extension via
+  `@savvy-web/changesets/markdownlint`
+
+## Installation
+
+```bash
+pnpm add @savvy-web/changesets
+```
+
+## Quick Start
+
+Bootstrap your repository:
+
+```bash
+savvy-changesets init
+```
+
+This creates `.changeset/config.json` with auto-detected
+GitHub repo settings. Or configure manually:
+
+```json
+{
+  "changelog": [
+    "@savvy-web/changesets/changelog",
+    { "repo": "owner/repo" }
+  ]
+}
+```
+
+Write section-aware changeset files:
+
+```markdown
+---
+"@my/package": minor
+---
+
+## Features
+
+Added a new authentication system with OAuth2 support.
+
+## Tests
+
+- Added unit tests for OAuth2 flow
+- Updated integration test fixtures
+```
+
+## markdownlint Integration
+
+Register the custom rules in your base config
+(e.g., `lib/configs/.markdownlint-cli2.jsonc`):
+
+```jsonc
+{
+  "customRules": [
+    "@savvy-web/changesets/markdownlint"
+  ],
+  "config": {
+    "changeset-heading-hierarchy": false,
+    "changeset-required-sections": false,
+    "changeset-content-structure": false
+  }
+}
+```
+
+Then enable the rules only for changeset files by
+creating `.changeset/.markdownlint.json`:
+
+```json
+{
+  "extends": "../lib/configs/.markdownlint-cli2.jsonc",
+  "default": false,
+  "changeset-heading-hierarchy": true,
+  "changeset-required-sections": true,
+  "changeset-content-structure": true,
+  "MD041": false
+}
+```
+
+## Documentation
+
+- [Section-Aware Pipeline](./docs/section-aware-pipeline.md) --
+  End-to-end walkthrough of how section-aware changesets
+  flow through the three-layer pipeline
+- [Full documentation](./docs/) -- CLI usage, API
+  reference, configuration, and architecture
+
+## License
+
+MIT
+
+[npm-badge]: https://img.shields.io/npm/v/@savvy-web/changesets
+[npm-url]: https://www.npmjs.com/package/@savvy-web/changesets
+[license-badge]: https://img.shields.io/badge/License-MIT-yellow.svg
+[license-url]: https://opensource.org/licenses/MIT