svelte-docsmith 0.8.0 → 0.9.0

package/dist/buildtime/changelog.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse a Changesets-generated `CHANGELOG.md` into structured releases.
+ *
+ * The shape Changesets writes is stable:
+ *
+ *     # package-name
+ *
+ *     ## 0.8.0
+ *
+ *     ### Minor Changes
+ *
+ *     - 4a1b3d4: Add an announcement bar. …
+ *
+ *       A second paragraph, indented two spaces.
+ *
+ * Parsing that rather than asking authors to write release notes twice means
+ * the changelog can never fall behind what actually shipped.
+ */
+import type { ChangelogRelease } from '../core/changelog.js';
+export declare function parseChangelog(markdown: string): ChangelogRelease[];

package/dist/buildtime/changelog.js

@@ -0,0 +1,74 @@
+/** `- <7-or-more hex chars>: ` prefix that Changesets puts on each entry. */
+const COMMIT_PREFIX = /^([-*])\s+[0-9a-f]{7,40}:\s*/;
+/** Strip the leading `- ` (and any commit hash) from an entry's first line. */
+function stripBullet(line) {
+    const withoutHash = line.replace(COMMIT_PREFIX, '');
+    if (withoutHash !== line)
+        return withoutHash;
+    return line.replace(/^[-*]\s+/, '');
+}
+/**
+ * De-indent an entry's continuation lines. Changesets indents them by two
+ * spaces to keep them inside the list item; leaving that in would render them
+ * as code blocks.
+ */
+function dedent(lines) {
+    return lines
+        .map((line) => (line.startsWith('  ') ? line.slice(2) : line))
+        .join('\n')
+        .trim();
+}
+export function parseChangelog(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const releases = [];
+    let release;
+    let group;
+    let entry;
+    const flushEntry = () => {
+        if (entry && group) {
+            const text = dedent(entry);
+            if (text)
+                group.items.push(text);
+        }
+        entry = undefined;
+    };
+    const flushGroup = () => {
+        flushEntry();
+        if (group && release && group.items.length > 0)
+            release.groups.push(group);
+        group = undefined;
+    };
+    const flushRelease = () => {
+        flushGroup();
+        if (release)
+            releases.push(release);
+        release = undefined;
+    };
+    for (const line of lines) {
+        const version = /^##\s+(?!#)(.+?)\s*$/.exec(line);
+        if (version) {
+            flushRelease();
+            release = { version: version[1].trim(), groups: [] };
+            continue;
+        }
+        const heading = /^###\s+(.+?)\s*$/.exec(line);
+        if (heading && release) {
+            flushGroup();
+            group = { kind: heading[1].trim(), items: [] };
+            continue;
+        }
+        if (!group)
+            continue;
+        // A new bullet at column zero starts an entry; anything else continues the
+        // current one, which is how multi-paragraph changesets survive intact.
+        if (/^[-*]\s+/.test(line)) {
+            flushEntry();
+            entry = [stripBullet(line)];
+        }
+        else if (entry) {
+            entry.push(line);
+        }
+    }
+    flushRelease();
+    return releases;
+}

package/dist/buildtime/fence-meta.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Parse the metadata that follows a code fence's language:
+ *
+ * ```ts title="vite.config.ts" showLineNumbers startLine=12
+ *
+ * mdsvex hands this string to the highlighter as its third argument, so no
+ * extra plumbing is needed to read it. Unknown entries are ignored rather than
+ * rejected, so a fence never fails a build over an unrecognised flag.
+ */
+export type FenceMeta = {
+    /** Filename or caption shown above the block. */
+    title?: string;
+    /** Whether to number the lines. `undefined` means "use the global default". */
+    lineNumbers?: boolean;
+    /** First line's number, for a snippet lifted out of a larger file. */
+    startLine?: number;
+};
+export declare function parseFenceMeta(meta?: string | null): FenceMeta;
+/** Whether a fence opts into Twoslash: ```ts twoslash */
+export declare function hasTwoslash(meta?: string | null): boolean;

package/dist/buildtime/fence-meta.js

@@ -0,0 +1,48 @@
+/**
+ * Parse the metadata that follows a code fence's language:
+ *
+ * ```ts title="vite.config.ts" showLineNumbers startLine=12
+ *
+ * mdsvex hands this string to the highlighter as its third argument, so no
+ * extra plumbing is needed to read it. Unknown entries are ignored rather than
+ * rejected, so a fence never fails a build over an unrecognised flag.
+ */
+/** `title="a b"`, `title='a b'`, or `title=a` (unquoted values stop at a space). */
+const KEY_VALUE = /(\w+)=(?:"([^"]*)"|'([^']*)'|(\S+))/g;
+export function parseFenceMeta(meta) {
+    const result = {};
+    if (!meta)
+        return result;
+    for (const match of meta.matchAll(KEY_VALUE)) {
+        const key = match[1];
+        const value = match[2] ?? match[3] ?? match[4] ?? '';
+        if (key === 'title')
+            result.title = value;
+        else if (key === 'startLine') {
+            const parsed = Number.parseInt(value, 10);
+            // A non-numeric or nonsensical startLine is ignored: numbering from an
+            // accidental NaN is worse than numbering from 1.
+            if (Number.isFinite(parsed) && parsed > 0)
+                result.startLine = parsed;
+        }
+        else if (key === 'showLineNumbers' || key === 'lineNumbers') {
+            result.lineNumbers = value !== 'false';
+        }
+    }
+    // Bare flags, e.g. ```ts showLineNumbers
+    const bare = meta.replace(KEY_VALUE, ' ').split(/\s+/).filter(Boolean);
+    if (bare.includes('showLineNumbers') || bare.includes('lineNumbers'))
+        result.lineNumbers = true;
+    if (bare.includes('noLineNumbers'))
+        result.lineNumbers = false;
+    // Numbering from a given line is meaningless without a gutter to show it in.
+    if (result.startLine !== undefined && result.lineNumbers === undefined)
+        result.lineNumbers = true;
+    return result;
+}
+/** Whether a fence opts into Twoslash: ```ts twoslash */
+export function hasTwoslash(meta) {
+    if (!meta)
+        return false;
+    return meta.replace(KEY_VALUE, ' ').split(/\s+/).includes('twoslash');
+}

package/dist/buildtime/markdown-layout.svelte.d.ts

@@ -1,4 +1,7 @@
 export declare const pre: import("svelte").Component<{
+    title?: string;
+    lineNumbers?: boolean;
+    startLine?: number;
     children: Snippet;
 }, {}, "">;
 export declare const code: import("svelte").Component<{

package/dist/buildtime/preprocess.d.ts

@@ -22,6 +22,19 @@ export interface DocsmithPreprocessOptions {
     remarkPlugins?: MdsvexOptions['remarkPlugins'];
     /** Extra rehype plugins, appended after docsmith's own (slug, sectionize). */
     rehypePlugins?: MdsvexOptions['rehypePlugins'];
+    /**
+     * Number every code block by default. Per-fence `showLineNumbers` /
+     * `noLineNumbers` override it either way. Default: `false`.
+     */
+    lineNumbers?: boolean;
+    /**
+     * Enable Twoslash on fences that ask for it with ```ts twoslash, adding real
+     * hover types from the TypeScript compiler. Requires the optional peer
+     * dependencies `@shikijs/twoslash`, `twoslash-svelte`, and `typescript`.
+     * A snippet that fails to typecheck falls back to a plain highlight with a
+     * build warning rather than failing the build. Default: `false`.
+     */
+    twoslash?: boolean;
 }
 /**
  * Build the svelte-docsmith preprocessor: mdsvex with Shiki highlighting (via

package/dist/buildtime/preprocess.js

@@ -6,11 +6,13 @@
  * doesn't care where it's registered). It must never import component code.
  */
 import rehypeSectionize from '@hbsnow/rehype-sectionize';
-import { transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight } from '@shikijs/transformers';
+import { transformerNotationDiff, transformerNotationErrorLevel, transformerNotationFocus, transformerNotationHighlight, transformerNotationWordHighlight, transformerMetaHighlight } from '@shikijs/transformers';
 import { escapeSvelte, mdsvex } from 'mdsvex';
 import { fileURLToPath } from 'node:url';
 import rehypeSlug from 'rehype-slug';
 import { DEFAULT_LANGS, DEFAULT_THEMES, lazyHighlighter } from './highlight.js';
+import { parseFenceMeta, hasTwoslash } from './fence-meta.js';
+import { twoslashTransformer, twoslashFailure } from './twoslash.js';
 /**
  * Build the svelte-docsmith preprocessor: mdsvex with Shiki highlighting (via
  * the raw-code `highlight` hook, the correct mdsvex integration point), heading
@@ -31,25 +33,75 @@ export function docsmith(options = {}) {
         extensions: options.extensions ?? ['.md'],
         layout,
         highlight: {
-            highlighter: async (code, lang) => {
+            // mdsvex passes the fence's trailing metadata as the third argument,
+            // which is where `title=` and the line-number flags come from.
+            highlighter: async (code, lang, meta) => {
+                const fence = parseFenceMeta(meta);
+                // A ```mermaid fence renders as a diagram, not highlighted code. The
+                // component is dynamic-imported so `mermaid` (an optional peer dep) is
+                // only pulled into pages that actually use it; JSON.stringify safely
+                // carries the multi-line source into the attribute.
+                if (lang === 'mermaid') {
+                    // The pending branch renders server-side, reserving the diagram's
+                    // space at first paint so it doesn't shift the page in on load.
+                    // The client component reuses the same skeleton class until the
+                    // diagram is ready, so the two never disagree on height.
+                    return (`{#await import('svelte-docsmith/mermaid')}` +
+                        `<div class="docsmith-mermaid-skeleton not-prose" aria-hidden="true"></div>` +
+                        `{:then { default: Mermaid }}` +
+                        `<Mermaid code={${JSON.stringify(code)}} />` +
+                        `{/await}`);
+                }
                 const highlighter = await getHighlighter();
                 const language = lang && highlighter.getLoadedLanguages().includes(lang) ? lang : 'text';
-                // Shiki highlights the raw code; escapeSvelte makes the result safe
-                // to embed in a Svelte component.
-                const html = escapeSvelte(highlighter.codeToHtml(code, {
+                // Comment-driven annotations authors write inside the fence:
+                // line highlight, diff (++/--), focus, error/warning, and
+                // word highlight. Each strips its own marker comment.
+                const notation = [
+                    // Line ranges from the fence meta (```svelte {4,7-9}). The only way
+                    // to highlight a line in markup: Shiki's comment markers are not
+                    // recognised inside a Svelte template region, where an HTML comment
+                    // is stripped without applying anything.
+                    transformerMetaHighlight(),
+                    transformerNotationHighlight(),
+                    transformerNotationDiff(),
+                    transformerNotationFocus(),
+                    transformerNotationErrorLevel(),
+                    transformerNotationWordHighlight()
+                ];
+                const render = (extra = []) => highlighter.codeToHtml(code, {
                     lang: language,
                     themes,
-                    // Comment-driven annotations authors write inside the fence:
-                    // line highlight, diff (++/--), focus, error/warning, and
-                    // word highlight. Each strips its own marker comment.
-                    transformers: [
-                        transformerNotationHighlight(),
-                        transformerNotationDiff(),
-                        transformerNotationFocus(),
-                        transformerNotationErrorLevel(),
-                        transformerNotationWordHighlight()
-                    ]
-                }));
+                    // transformerMetaHighlight reads the raw fence meta from here.
+                    meta: { __raw: meta ?? '' },
+                    transformers: [...extra, ...notation]
+                });
+                let rendered;
+                if (options.twoslash && hasTwoslash(meta)) {
+                    const loaded = await twoslashTransformer();
+                    if ('error' in loaded) {
+                        console.warn(`[svelte-docsmith] ${loaded.error}`);
+                        rendered = render();
+                    }
+                    else {
+                        try {
+                            rendered = render([loaded.transformer]);
+                        }
+                        catch (error) {
+                            // One snippet that doesn't typecheck must not take the site
+                            // down; fall back to a plain highlight and say which it was.
+                            console.warn(`[svelte-docsmith] twoslash could not annotate a ${language} block: ` +
+                                twoslashFailure(error));
+                            rendered = render();
+                        }
+                    }
+                }
+                else {
+                    rendered = render();
+                }
+                // escapeSvelte makes the highlighted result safe to embed in a
+                // Svelte component.
+                const html = escapeSvelte(rendered);
                 // Without a layout there is no `Components.pre` to render through —
                 // keep Shiki's own <pre> as-is.
                 if (layout === undefined)
@@ -60,7 +112,15 @@ export function docsmith(options = {}) {
                     .replace(/^<pre[^>]*>/, '')
                     .replace(/<\/pre>\s*$/, '')
                     .trim();
-                return `<Components.pre>{@html \`${inner}\`}</Components.pre>`;
+                const showNumbers = fence.lineNumbers ?? options.lineNumbers ?? false;
+                const attrs = [
+                    fence.title ? `title=${JSON.stringify(fence.title)}` : '',
+                    showNumbers ? 'lineNumbers' : '',
+                    showNumbers && fence.startLine !== undefined ? `startLine={${fence.startLine}}` : ''
+                ]
+                    .filter(Boolean)
+                    .join(' ');
+                return `<Components.pre${attrs ? ' ' + attrs : ''}>{@html \`${inner}\`}</Components.pre>`;
             }
         },
         remarkPlugins: options.remarkPlugins,

package/dist/buildtime/twoslash.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Twoslash support for code fences that opt in with ```ts twoslash.
+ *
+ * Twoslash runs the snippet through the TypeScript compiler and annotates it
+ * with the real inferred types, which is what makes a hover show `string`
+ * rather than a guess. The cost is that it **throws** on anything that does not
+ * typecheck: a missing import, a type error, an incomplete fragment.
+ *
+ * That strictness is the point, but it must not be able to take a whole site
+ * down. {@link highlightWithTwoslash} therefore falls back to an ordinary
+ * highlight and warns, naming the file, rather than failing the build over one
+ * bad snippet.
+ *
+ * The packages are optional peer dependencies, loaded only when a fence asks
+ * for them, so sites that never use Twoslash pay nothing for it.
+ */
+import type { ShikiTransformer } from 'shiki';
+type Loaded = {
+    transformer: ShikiTransformer;
+} | {
+    error: string;
+};
+export declare function twoslashTransformer(): Promise<Loaded>;
+/** One-line reason a snippet could not be annotated, for the build warning. */
+export declare function twoslashFailure(error: unknown): string;
+export {};

package/dist/buildtime/twoslash.js

@@ -0,0 +1,40 @@
+let cached;
+/**
+ * Build the Twoslash transformer once per process. `langs` must include
+ * `svelte`, or Svelte fences are silently passed through unannotated: the
+ * transformer's default allowlist is TypeScript only.
+ */
+async function loadTransformer() {
+    try {
+        const [{ transformerTwoslash }, { createTwoslasher }] = await Promise.all([
+            import('@shikijs/twoslash'),
+            import('twoslash-svelte')
+        ]);
+        return {
+            transformer: transformerTwoslash({
+                // The fence's meta is parsed by docsmith, which decides per block
+                // whether to include this transformer at all.
+                explicitTrigger: false,
+                langs: ['ts', 'tsx', 'js', 'svelte'],
+                twoslasher: createTwoslasher()
+            })
+        };
+    }
+    catch {
+        return {
+            error: "'twoslash' requires its optional peer dependencies. " +
+                'Install them with: npm i -D @shikijs/twoslash twoslash-svelte typescript'
+        };
+    }
+}
+export function twoslashTransformer() {
+    cached ??= loadTransformer();
+    return cached;
+}
+/** One-line reason a snippet could not be annotated, for the build warning. */
+export function twoslashFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    // Twoslash errors are multi-line with a code frame; the first line carries
+    // the actual diagnostic.
+    return message.split('\n').find((line) => line.trim()) ?? 'unknown error';
+}

package/dist/buildtime/vite/git.d.ts

@@ -1,2 +1,9 @@
 /** Last git commit date (strict ISO) for a file, or undefined outside a repo. */
 export declare function lastCommitDate(file: string): string | undefined;
+/**
+ * Release dates keyed by version, read from the commit that introduced each
+ * `## <version>` heading in a changelog. Changesets does not write dates, and a
+ * tag lookup misses versions released before tagging was set up, so the file's
+ * own history is the most reliable source available.
+ */
+export declare function changelogDates(file: string): Map<string, string>;

package/dist/buildtime/vite/git.js

@@ -9,3 +9,35 @@ export function lastCommitDate(file) {
     const date = res.status === 0 ? res.stdout.trim() : '';
     return date || undefined;
 }
+/**
+ * Release dates keyed by version, read from the commit that introduced each
+ * `## <version>` heading in a changelog. Changesets does not write dates, and a
+ * tag lookup misses versions released before tagging was set up, so the file's
+ * own history is the most reliable source available.
+ */
+export function changelogDates(file) {
+    const dates = new Map();
+    // `-L` would be per-line; instead walk the file's commits newest-first and
+    // record the first commit in which each version heading appears.
+    const log = spawnSync('git', ['log', '--format=%H %cI', '--reverse', '--follow', '--', path.basename(file)], { cwd: path.dirname(file), encoding: 'utf-8' });
+    if (log.status !== 0)
+        return dates;
+    for (const line of log.stdout.trim().split('\n').filter(Boolean)) {
+        const [hash, date] = line.split(' ');
+        if (!hash || !date)
+            continue;
+        const show = spawnSync('git', ['show', `${hash}:./${path.basename(file)}`], {
+            cwd: path.dirname(file),
+            encoding: 'utf-8'
+        });
+        if (show.status !== 0)
+            continue;
+        for (const match of show.stdout.matchAll(/^##\s+(?!#)(.+?)\s*$/gm)) {
+            const version = match[1].trim();
+            // First commit containing this heading wins, which is its release.
+            if (!dates.has(version))
+                dates.set(version, date);
+        }
+    }
+    return dates;
+}

package/dist/buildtime/vite/index.d.ts

@@ -1,5 +1,6 @@
 import type { Plugin } from 'vite';
 export { collectDocs, collectLlmsDocs, collectSearchDocs } from './collect.js';
+export { collectReleases } from './releases.js';
 export interface DocsmithViteOptions {
     /** Directory scanned for doc pages. Default: `'src/routes/docs'`. */
     content?: string;
@@ -13,6 +14,18 @@ export interface DocsmithViteOptions {
         light: string;
         dark: string;
     };
+    /**
+     * Path to the `CHANGELOG.md` that feeds the generated
+     * `svelte-docsmith/changelog` index. Default: `'CHANGELOG.md'` in the app
+     * directory; point it at the package whose releases you publish. Set `false`
+     * to skip the changelog entirely.
+     */
+    changelog?: string | false;
+    /**
+     * Route the changelog is served at, used to build feed links and to find
+     * hand-written per-release pages. Default: `'/changelog'`.
+     */
+    changelogPath?: string;
 }
 /**
  * The svelte-docsmith Vite plugin. Add it to `plugins` in `vite.config.ts`:

package/dist/buildtime/vite/index.js

@@ -21,7 +21,9 @@ import path from 'node:path';
 import { DEFAULT_THEMES, lazyHighlighter } from '../highlight.js';
 import { isPageFile, listPageFiles } from './pages.js';
 import { collectDocs, collectLlmsDocs, collectSearchDocs } from './collect.js';
+import { collectReleases } from './releases.js';
 export { collectDocs, collectLlmsDocs, collectSearchDocs } from './collect.js';
+export { collectReleases } from './releases.js';
 /**
  * The svelte-docsmith Vite plugin. Add it to `plugins` in `vite.config.ts`:
  *
@@ -40,9 +42,14 @@ const SEARCH_SPECIFIER = 'svelte-docsmith/search';
 const VIRTUAL_SEARCH_ID = '\0svelte-docsmith:search';
 const LLMS_SPECIFIER = 'svelte-docsmith/llms';
 const VIRTUAL_LLMS_ID = '\0svelte-docsmith:llms';
+const CHANGELOG_SPECIFIER = 'svelte-docsmith/changelog';
+const VIRTUAL_CHANGELOG_ID = '\0svelte-docsmith:changelog';
 function contentIndexPlugin(options) {
     const contentDir = path.resolve(options.content ?? 'src/routes/docs');
     const routesDir = path.resolve(options.routes ?? 'src/routes');
+    const changelogFile = options.changelog === false ? undefined : path.resolve(options.changelog ?? 'CHANGELOG.md');
+    const changelogRoute = options.changelogPath ?? '/changelog';
+    const changelogOverrides = path.join(routesDir, changelogRoute.replace(/^\//, ''));
     return {
         name: 'docsmith-content',
         enforce: 'pre',
@@ -53,6 +60,8 @@ function contentIndexPlugin(options) {
                 return VIRTUAL_SEARCH_ID;
             if (id === LLMS_SPECIFIER)
                 return VIRTUAL_LLMS_ID;
+            if (id === CHANGELOG_SPECIFIER)
+                return VIRTUAL_CHANGELOG_ID;
         },
         load(id) {
             // Watch each page file (not the directory) so editing frontmatter or
@@ -77,6 +86,13 @@ function contentIndexPlugin(options) {
                 const docs = collectLlmsDocs(contentDir, routesDir);
                 return `export const docs = ${JSON.stringify(docs)};\n`;
             }
+            if (id === VIRTUAL_CHANGELOG_ID) {
+                if (!changelogFile)
+                    return `export const releases = [];\n`;
+                this.addWatchFile(changelogFile);
+                const releases = collectReleases(changelogFile, changelogOverrides, changelogRoute);
+                return `export const releases = ${JSON.stringify(releases)};\n`;
+            }
         },
         configureServer(server) {
             server.watcher.add(contentDir);

package/dist/buildtime/vite/releases.d.ts

@@ -0,0 +1,12 @@
+import type { ChangelogRelease } from '../../core/changelog.js';
+/**
+ * Read a Changesets `CHANGELOG.md` into releases, dated from git history, and
+ * linked to a hand-written page where one exists.
+ *
+ * `overridesDir` is scanned for directories named after a version
+ * (`src/routes/changelog/0.9.0/`), so a release worth a proper write-up can
+ * have one while the rest stay generated.
+ */
+export declare function collectReleases(changelogFile: string, overridesDir?: string, routePath?: string): ChangelogRelease[];
+/** Default location of a monorepo package's changelog, relative to the app. */
+export declare function defaultChangelogPath(cwd?: string): string;

package/dist/buildtime/vite/releases.js

@@ -0,0 +1,57 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { marked } from 'marked';
+import { parseChangelog } from '../changelog.js';
+import { changelogDates } from './git.js';
+/**
+ * Render an entry's markdown to HTML at build time. Changesets entries use
+ * inline code, emphasis, links and nested lists, so shipping the raw markdown
+ * would mean every consuming site needed a runtime renderer.
+ */
+function renderItem(markdown) {
+    return marked.parse(markdown, { async: false, gfm: true }).trim();
+}
+/**
+ * Read a Changesets `CHANGELOG.md` into releases, dated from git history, and
+ * linked to a hand-written page where one exists.
+ *
+ * `overridesDir` is scanned for directories named after a version
+ * (`src/routes/changelog/0.9.0/`), so a release worth a proper write-up can
+ * have one while the rest stay generated.
+ */
+export function collectReleases(changelogFile, overridesDir, routePath = '/changelog') {
+    if (!fs.existsSync(changelogFile))
+        return [];
+    const releases = parseChangelog(fs.readFileSync(changelogFile, 'utf-8'));
+    const dates = changelogDates(changelogFile);
+    const overrides = new Set();
+    if (overridesDir && fs.existsSync(overridesDir)) {
+        for (const entry of fs.readdirSync(overridesDir, { withFileTypes: true })) {
+            if (entry.isDirectory())
+                overrides.add(entry.name);
+        }
+    }
+    return releases.map((release) => {
+        // Directory names can't contain the dots a version has on every platform,
+        // so `0.9.0` may be written as `0-9-0`.
+        const slug = release.version.replace(/\./g, '-');
+        const override = overrides.has(release.version)
+            ? release.version
+            : overrides.has(slug)
+                ? slug
+                : undefined;
+        return {
+            ...release,
+            groups: release.groups.map((group) => ({
+                ...group,
+                items: group.items.map(renderItem)
+            })),
+            ...(dates.get(release.version) ? { date: dates.get(release.version) } : {}),
+            ...(override ? { path: `${routePath}/${override}` } : {})
+        };
+    });
+}
+/** Default location of a monorepo package's changelog, relative to the app. */
+export function defaultChangelogPath(cwd = process.cwd()) {
+    return path.resolve(cwd, 'CHANGELOG.md');
+}