@aureuma/svelta 0.1.0 → 0.2.0

package/packages/{blogkit → core}/dist/server/blog.js

@@ -78,7 +78,7 @@ function normalizeCategory(label) {
 }
 function parseISODate(date) {
     // Prefer stable UTC parsing for YYYY-MM-DD.
-    if (/^\\d{4}-\\d{2}-\\d{2}$/.test(date)) {
+    if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
         const d = new Date(`${date}T00:00:00Z`);
         if (!Number.isNaN(d.getTime()))
             return d;
@@ -100,6 +100,11 @@ const fmtShort = new Intl.DateTimeFormat('en-US', {
     year: 'numeric',
     timeZone: 'UTC'
 });
+const fmtArchive = new Intl.DateTimeFormat('en-US', {
+    month: 'long',
+    year: 'numeric',
+    timeZone: 'UTC'
+});
 function stripForExcerpt(markdown) {
     return (markdown
         // remove fenced code blocks
@@ -133,8 +138,14 @@ function minutesToLabels(minutes) {
         long: `${m} ${unit} read`
     };
 }
+function normalizeTags(tags, categoryLabel, allowMultipleTags) {
+    const cleaned = (tags ?? []).map((tag) => tag.trim()).filter(Boolean);
+    const resolved = cleaned.length > 0 ? cleaned : [categoryLabel];
+    return allowMultipleTags ? resolved : [resolved[0]];
+}
 export function createBlog(config) {
     const categoryOrder = config.categoryOrder ?? DEFAULT_CATEGORY_ORDER;
+    const allowMultipleTags = config.allowMultipleTags ?? false;
     let cachedMetaIndex = null;
     let cachedFullIndex = null;
     let cachedSlugToPath = null;
@@ -178,13 +189,14 @@ export function createBlog(config) {
             const dateObj = parseISODate(metadata.date);
             const rt = minutesToLabels(readingTime(content).minutes);
             const category = normalizeCategory(metadata.category);
+            const tags = normalizeTags(metadata.tags, category.label, allowMultipleTags);
             const excerpt = metadata.excerpt?.trim() || excerptFromContent(content);
             posts.push({
                 slug,
                 title: metadata.title.trim(),
                 excerpt,
                 category,
-                tags: metadata.tags ?? [],
+                tags,
                 author: config.getAuthor(metadata.author),
                 date: metadata.date,
                 dateLong: fmtLong.format(dateObj),
@@ -259,7 +271,121 @@ export function createBlog(config) {
         const featured = list.filter((p) => p.featured);
         return (featured[0] ?? list[0]);
     }
-    return { getAllPosts, getAllPostsFull, getPostBySlug, getCategories, pickHero };
+    async function getAllTags() {
+        const posts = await getAllPosts();
+        const map = new Map();
+        for (const post of posts) {
+            for (const tagName of post.tags) {
+                const tag = toBlogTag(tagName);
+                map.set(tag.slug, tag);
+            }
+        }
+        return Array.from(map.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async function getPostsByTag(tagSlug) {
+        const posts = await getAllPosts();
+        return posts.filter((post) => post.tags.some((tagName) => slugify(tagName) === tagSlug));
+    }
+    async function getPostsByAuthor(authorId) {
+        const posts = await getAllPosts();
+        return posts.filter((post) => post.author.id === authorId);
+    }
+    async function getAllAuthors() {
+        const posts = await getAllPosts();
+        const map = new Map();
+        for (const post of posts)
+            map.set(post.author.id, post.author);
+        return Array.from(map.values()).sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async function getAuthorSummaries() {
+        const posts = await getAllPosts();
+        const map = new Map();
+        for (const post of posts) {
+            const existing = map.get(post.author.id);
+            if (!existing) {
+                map.set(post.author.id, {
+                    author: post.author,
+                    postCount: 1,
+                    latestPostDate: post.date
+                });
+                continue;
+            }
+            existing.postCount += 1;
+            if (parseISODate(post.date).getTime() > parseISODate(existing.latestPostDate).getTime()) {
+                existing.latestPostDate = post.date;
+            }
+        }
+        return Array.from(map.values()).sort((a, b) => b.postCount - a.postCount || a.author.name.localeCompare(b.author.name));
+    }
+    async function getArchiveGroups() {
+        const posts = await getAllPosts();
+        const map = new Map();
+        for (const post of posts) {
+            const date = parseISODate(post.date);
+            const year = date.getUTCFullYear();
+            const month = date.getUTCMonth() + 1;
+            const key = `${year}-${String(month).padStart(2, '0')}`;
+            const existing = map.get(key);
+            if (existing) {
+                existing.posts.push(post);
+                existing.count += 1;
+                continue;
+            }
+            map.set(key, {
+                id: key,
+                year,
+                month,
+                label: fmtArchive.format(date),
+                count: 1,
+                posts: [post]
+            });
+        }
+        return Array.from(map.values()).sort((a, b) => b.id.localeCompare(a.id));
+    }
+    async function getAdjacentPosts(slug) {
+        const posts = await getAllPosts();
+        const index = posts.findIndex((post) => post.slug === slug);
+        if (index === -1)
+            return { previous: null, next: null };
+        return {
+            previous: posts[index + 1] ?? null,
+            next: posts[index - 1] ?? null
+        };
+    }
+    async function getRelatedPosts(slug, limit = 3) {
+        const posts = await getAllPosts();
+        const current = posts.find((post) => post.slug === slug);
+        if (!current)
+            return [];
+        const primaryTag = current.tags[0];
+        if (primaryTag) {
+            const primaryTagSlug = slugify(primaryTag);
+            const sameTag = posts
+                .filter((post) => post.slug !== slug && post.tags.some((tagName) => slugify(tagName) === primaryTagSlug))
+                .sort((a, b) => parseISODate(b.date).getTime() - parseISODate(a.date).getTime())
+                .slice(0, limit);
+            if (sameTag.length > 0)
+                return sameTag;
+        }
+        return posts
+            .filter((post) => post.slug !== slug && post.category.slug === current.category.slug)
+            .slice(0, limit);
+    }
+    return {
+        getAllPosts,
+        getAllPostsFull,
+        getPostBySlug,
+        getCategories,
+        pickHero,
+        getAllTags,
+        getPostsByTag,
+        getPostsByAuthor,
+        getAllAuthors,
+        getAuthorSummaries,
+        getArchiveGroups,
+        getAdjacentPosts,
+        getRelatedPosts
+    };
 }
 export function parseVivaBlogFrontmatter(data) {
     return vivaBlogFrontmatterSchema.parse(data);
@@ -316,6 +442,7 @@ function toBlogTag(name) {
 }
 export function createRawBlog(config) {
     const categoryOrder = config.categoryOrder ?? DEFAULT_CATEGORY_ORDER;
+    const allowMultipleTags = config.allowMultipleTags ?? false;
     const renderMarkdown = config.renderMarkdown ?? defaultRenderMarkdown;
     let cachedContentIndex = null;
     async function buildContentIndex() {
@@ -341,6 +468,7 @@ export function createRawBlog(config) {
             const dateObj = parseISODate(metadata.date);
             const rt = minutesToLabels(readingTime(content).minutes);
             const category = normalizeCategory(metadata.category);
+            const tags = normalizeTags(metadata.tags, category.label, allowMultipleTags);
             const excerpt = metadata.excerpt?.trim() || excerptFromContent(content);
             const rendered = await renderMarkdown(content);
             posts.push({
@@ -348,7 +476,7 @@ export function createRawBlog(config) {
                 title: metadata.title.trim(),
                 excerpt,
                 category,
-                tags: metadata.tags ?? [],
+                tags,
                 author: config.getAuthor(metadata.author),
                 authorId: metadata.author,
                 date: metadata.date,
@@ -443,17 +571,19 @@ export function createRawBlog(config) {
         const current = posts.find((post) => post.slug === slug);
         if (!current)
             return [];
-        const tagSet = new Set(current.tags.map((tag) => slugify(tag)));
+        const primaryTag = current.tags[0];
+        if (primaryTag) {
+            const primaryTagSlug = slugify(primaryTag);
+            const sameTag = posts
+                .filter((post) => post.slug !== slug && post.tags.some((tagName) => slugify(tagName) === primaryTagSlug))
+                .sort((a, b) => parseISODate(b.date).getTime() - parseISODate(a.date).getTime())
+                .slice(0, limit);
+            if (sameTag.length > 0)
+                return sameTag;
+        }
         return posts
-            .filter((post) => post.slug !== slug)
-            .map((post) => {
-            const overlap = post.tags.filter((tag) => tagSet.has(slugify(tag))).length;
-            return { post, overlap };
-        })
-            .filter((entry) => entry.overlap > 0)
-            .sort((a, b) => b.overlap - a.overlap)
-            .slice(0, limit)
-            .map((entry) => entry.post);
+            .filter((post) => post.slug !== slug && post.category.slug === current.category.slug)
+            .slice(0, limit);
     }
     return {
         getAllPosts,

package/packages/core/dist/server/docs.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { DocsPage, DocsPageFull, DocsSidebarSection, DocsSection } from '../types/docs';
+declare const docsFrontmatterSchema: z.ZodObject<{
+    title: z.ZodString;
+    navTitle: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+    sectionLabel: z.ZodOptional<z.ZodString>;
+    order: z.ZodOptional<z.ZodNumber>;
+    sectionOrder: z.ZodOptional<z.ZodNumber>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type DocsFrontmatter = z.infer<typeof docsFrontmatterSchema>;
+export type DocsFrontmatterAdapter = (args: {
+    data: unknown;
+    content: string;
+    slug: string;
+    path: string;
+}) => DocsFrontmatter;
+type CompiledModule = {
+    default: DocsPageFull['component'];
+};
+export type DocsCreateConfig = {
+    compiledModules: Record<string, () => Promise<CompiledModule>>;
+    rawModules: Record<string, () => Promise<string>>;
+    defaultSectionLabel?: string;
+    sectionOrder?: string[];
+    mapFrontmatter?: DocsFrontmatterAdapter;
+};
+export declare function createDocs(config: DocsCreateConfig): {
+    getAllPages: () => Promise<DocsPage[]>;
+    getAllPagesFull: () => Promise<DocsPageFull[]>;
+    getPageBySlug: (slug: string) => Promise<DocsPageFull | null>;
+    getSections: () => Promise<DocsSection[]>;
+    getSidebar: () => Promise<DocsSidebarSection[]>;
+    getAdjacentPages: (slug: string) => Promise<{
+        previous: DocsPage | null;
+        next: DocsPage | null;
+    }>;
+    pickLandingPage: () => Promise<DocsPage | null>;
+};
+export {};

package/packages/core/dist/server/docs.js

@@ -0,0 +1,193 @@
+import { DEV } from 'esm-env';
+import matter from 'gray-matter';
+import { z } from 'zod';
+const docsFrontmatterSchema = z.object({
+    title: z.string(),
+    navTitle: z.string().optional(),
+    description: z.string().optional(),
+    section: z.string().optional(),
+    sectionLabel: z.string().optional(),
+    order: z.number().optional(),
+    sectionOrder: z.number().optional(),
+    tags: z.array(z.string()).optional(),
+    updatedAt: z.string().optional(),
+    draft: z.boolean().optional()
+});
+function slugify(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/['"]/g, '')
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+const fmtLong = new Intl.DateTimeFormat('en-US', {
+    month: 'long',
+    day: 'numeric',
+    year: 'numeric',
+    timeZone: 'UTC'
+});
+function parseUpdatedAt(date) {
+    if (!date)
+        return { iso: undefined, long: undefined };
+    if (/^\d{4}-\d{2}-\d{2}$/.test(date)) {
+        const d = new Date(`${date}T00:00:00Z`);
+        if (!Number.isNaN(d.getTime())) {
+            return { iso: date, long: fmtLong.format(d) };
+        }
+    }
+    const d = new Date(date);
+    if (Number.isNaN(d.getTime()))
+        return { iso: undefined, long: undefined };
+    return { iso: d.toISOString(), long: fmtLong.format(d) };
+}
+function sectionFromMeta(meta, defaultSectionLabel, sectionOrder) {
+    const label = (meta.sectionLabel || meta.section || defaultSectionLabel).trim();
+    const id = slugify(meta.section || label || defaultSectionLabel);
+    const configuredOrder = sectionOrder.indexOf(id);
+    const order = meta.sectionOrder ?? (configuredOrder === -1 ? 1000 : configuredOrder);
+    return { id, label, order };
+}
+export function createDocs(config) {
+    const defaultSectionLabel = config.defaultSectionLabel ?? 'Guides';
+    const sectionOrder = config.sectionOrder ?? ['overview', 'getting-started', 'guides', 'api', 'reference'];
+    let cachedMetaIndex = null;
+    let cachedFullIndex = null;
+    let cachedSlugToPath = null;
+    function getSlugToPath() {
+        if (!DEV && cachedSlugToPath)
+            return cachedSlugToPath;
+        const map = new Map();
+        for (const path of Object.keys(config.rawModules).sort()) {
+            const file = path.split('/').pop();
+            const slug = file?.replace(/\.md(?:\?.*)?$/, '');
+            if (!slug)
+                continue;
+            map.set(slug, path);
+        }
+        if (!DEV)
+            cachedSlugToPath = map;
+        return map;
+    }
+    async function buildMetaIndex() {
+        if (!DEV && cachedMetaIndex)
+            return cachedMetaIndex;
+        const pages = [];
+        const paths = Object.keys(config.rawModules).sort();
+        for (const path of paths) {
+            const file = path.split('/').pop();
+            const slug = file?.replace(/\.md(?:\?.*)?$/, '');
+            if (!slug)
+                continue;
+            const rawFn = config.rawModules[path];
+            if (!rawFn)
+                continue;
+            const raw = await rawFn();
+            const { data, content } = matter(raw);
+            const meta = config.mapFrontmatter
+                ? config.mapFrontmatter({ data, content, slug, path })
+                : docsFrontmatterSchema.parse(data);
+            if (meta.draft)
+                continue;
+            const section = sectionFromMeta(meta, defaultSectionLabel, sectionOrder);
+            const updated = parseUpdatedAt(meta.updatedAt);
+            pages.push({
+                slug,
+                title: meta.title.trim(),
+                navTitle: (meta.navTitle || meta.title).trim(),
+                description: (meta.description || '').trim(),
+                section,
+                order: meta.order ?? 1000,
+                tags: meta.tags ?? [],
+                updatedAt: updated.iso,
+                updatedAtLong: updated.long
+            });
+        }
+        pages.sort((a, b) => {
+            if (a.section.order !== b.section.order)
+                return a.section.order - b.section.order;
+            if (a.section.id !== b.section.id)
+                return a.section.id.localeCompare(b.section.id);
+            if (a.order !== b.order)
+                return a.order - b.order;
+            return a.title.localeCompare(b.title);
+        });
+        if (!DEV)
+            cachedMetaIndex = pages;
+        return pages;
+    }
+    async function getAllPages() {
+        return buildMetaIndex();
+    }
+    async function getAllPagesFull() {
+        if (!DEV && cachedFullIndex)
+            return cachedFullIndex;
+        const meta = await buildMetaIndex();
+        const slugToPath = getSlugToPath();
+        const full = [];
+        for (const page of meta) {
+            const path = slugToPath.get(page.slug);
+            const compiledFn = path ? config.compiledModules[path] : undefined;
+            if (!compiledFn)
+                continue;
+            const compiled = await compiledFn();
+            full.push({ ...page, component: compiled.default });
+        }
+        if (!DEV)
+            cachedFullIndex = full;
+        return full;
+    }
+    async function getPageBySlug(slug) {
+        const page = (await getAllPages()).find((p) => p.slug === slug) ?? null;
+        if (!page)
+            return null;
+        const path = getSlugToPath().get(slug);
+        const compiledFn = path ? config.compiledModules[path] : undefined;
+        if (!compiledFn)
+            return null;
+        const compiled = await compiledFn();
+        return { ...page, component: compiled.default };
+    }
+    async function getSections() {
+        const pages = await getAllPages();
+        const map = new Map();
+        for (const page of pages) {
+            map.set(page.section.id, page.section);
+        }
+        return Array.from(map.values()).sort((a, b) => {
+            if (a.order !== b.order)
+                return a.order - b.order;
+            return a.label.localeCompare(b.label);
+        });
+    }
+    async function getSidebar() {
+        const [sections, pages] = await Promise.all([getSections(), getAllPages()]);
+        return sections.map((section) => ({
+            ...section,
+            pages: pages.filter((page) => page.section.id === section.id)
+        }));
+    }
+    async function getAdjacentPages(slug) {
+        const pages = await getAllPages();
+        const index = pages.findIndex((page) => page.slug === slug);
+        if (index === -1)
+            return { previous: null, next: null };
+        return {
+            previous: pages[index - 1] ?? null,
+            next: pages[index + 1] ?? null
+        };
+    }
+    async function pickLandingPage() {
+        const pages = await getAllPages();
+        return pages[0] ?? null;
+    }
+    return {
+        getAllPages,
+        getAllPagesFull,
+        getPageBySlug,
+        getSections,
+        getSidebar,
+        getAdjacentPages,
+        pickLandingPage
+    };
+}

package/packages/{blogkit → core}/dist/server/index.d.ts

@@ -1 +1,2 @@
 export { createBlog, createRawBlog, parseMarkdownAuthorMap, parseVivaAuthorFrontmatter, parseVivaAuthorProfiles, parseVivaBlogFrontmatter, type BlogCreateConfig, type RawBlogCreateConfig, type MarkdownRenderer, type VivaAuthorFrontmatter, type VivaAuthorProfile, type VivaBlogFrontmatter, type VivaImageAsset, type VivaSeoFields } from './blog';
+export { createDocs, type DocsCreateConfig, type DocsFrontmatter, type DocsFrontmatterAdapter } from './docs';

package/packages/{blogkit → core}/dist/server/index.js

@@ -1 +1,2 @@
 export { createBlog, createRawBlog, parseMarkdownAuthorMap, parseVivaAuthorFrontmatter, parseVivaAuthorProfiles, parseVivaBlogFrontmatter } from './blog';
+export { createDocs } from './docs';

package/packages/{blogkit → core}/dist/types/blog.d.ts

@@ -33,6 +33,20 @@ export type BlogTag = {
     name: string;
     slug: string;
 };
+export type SharePlatform = 'x' | 'linkedin' | 'facebook' | 'reddit' | 'hackernews' | 'copy';
+export type BlogArchiveGroup = {
+    id: string;
+    year: number;
+    month: number;
+    label: string;
+    count: number;
+    posts: BlogPost[];
+};
+export type BlogAuthorSummary = {
+    author: BlogAuthor;
+    postCount: number;
+    latestPostDate: string;
+};
 export type BlogPostWithContent = BlogPost & {
     html: string;
     raw: string;

package/packages/core/dist/types/docs.d.ts

@@ -0,0 +1,28 @@
+import type { ComponentType } from 'svelte';
+export type DocsSection = {
+    id: string;
+    label: string;
+    order: number;
+};
+export type DocsPage = {
+    slug: string;
+    title: string;
+    navTitle: string;
+    description: string;
+    section: DocsSection;
+    order: number;
+    tags: string[];
+    updatedAt?: string;
+    updatedAtLong?: string;
+};
+export type DocsPageFull = DocsPage & {
+    component: ComponentType;
+};
+export type DocsPageWithContent = DocsPage & {
+    html: string;
+    raw: string;
+    frontmatter: Record<string, unknown>;
+};
+export type DocsSidebarSection = DocsSection & {
+    pages: DocsPage[];
+};

package/packages/core/dist/types/docs.js

@@ -0,0 +1 @@
+export {};

package/packages/core/dist/types/experience.d.ts

@@ -0,0 +1,13 @@
+export type ExperienceKind = 'docs' | 'blog';
+export type ExperienceDefinition = {
+    kind: ExperienceKind;
+    label: string;
+    description: string;
+    href: string;
+};
+export type ExperienceCatalog = {
+    defaultKind: ExperienceKind;
+    items: ExperienceDefinition[];
+    byKind: Record<ExperienceKind, ExperienceDefinition>;
+    resolve: (kind?: string | null) => ExperienceDefinition;
+};

package/packages/core/dist/types/experience.js

@@ -0,0 +1 @@
+export {};

package/packages/blogkit/README.md

@@ -1,93 +0,0 @@
-# @aureuma/blogkit
-
-A Mintlify-inspired blog UI + content pipeline helpers for SvelteKit + mdsvex.
-
-This repo keeps `svelta` as a demo app, and exposes the reusable parts as a local workspace package under `packages/blogkit`.
-
-## What you get
-
-- Blog UI components: hero card, post cards, tag tabs, share buttons, summary card, more-posts grid, image lightbox.
-- Server helpers: `createBlog()` to load Markdown posts (frontmatter, excerpt, reading-time, categories, hero).
-- Theme helper: `createThemeController()` and a simple theme switcher component.
-
-### Compatibility
-
-- Component source is compatible with Svelte 4 and Svelte 5 (no runes required).
-- If you already have an existing frontmatter schema, use `mapFrontmatter` to adapt it to BlogKit's expected fields.
-
-## Use In Another Repo
-
-### Install from npm
-
-```sh
-npm i @aureuma/blogkit
-```
-
-### Option A: mono-repo / workspaces (recommended)
-
-1. Add this repo as a submodule (or subtree) inside your project:
-
-```sh
-git submodule add git@github.com:Aureuma/svelta.git packages/svelta
-```
-
-2. Point your workspace config at the package:
-
-```json
-{
-  "workspaces": ["packages/*", "packages/svelta/packages/*"]
-}
-```
-
-3. Import and use:
-
-```ts
-import { BlogCard } from '@aureuma/blogkit';
-import { createBlog } from '@aureuma/blogkit/server';
-```
-
-### Option B: publish to npm
-
-1. Set `"private": false` in `packages/blogkit/package.json`.
-2. From `packages/blogkit`, run `npm publish`.
-
-## Integration Steps (SvelteKit)
-
-1. mdsvex: configure Markdown compilation (`.md`) and Shiki/anchors (see this repo's `svelte.config.js`).
-2. Content:
-   - posts: `src/content/blog/*.md` with YAML frontmatter
-   - assets: `static/blog/covers/*` and `static/blog/authors/*`
-3. Blog loader glue:
-
-```ts
-// src/lib/server/blog.ts
-import { createBlog } from '@aureuma/blogkit/server';
-import { getAuthor } from '$lib/content/authors';
-import type { BlogPostFull } from '@aureuma/blogkit';
-
-type CompiledModule = { default: BlogPostFull['component'] };
-
-const compiledModules = import.meta.glob('/src/content/blog/*.md') as Record<
-  string,
-  () => Promise<CompiledModule>
->;
-const rawModules = import.meta.glob('/src/content/blog/*.md', {
-  query: '?raw',
-  import: 'default'
-}) as Record<string, () => Promise<string>>;
-
-export const blog = createBlog({ compiledModules, rawModules, getAuthor });
-export const { getAllPosts, getPostBySlug, getCategories, pickHero } = blog;
-```
-
-4. Tailwind: ensure your `content` globs include the package so class names are not purged.
-   - If installed from npm: include `./node_modules/@aureuma/blogkit/dist/**/*`.
-
-5. Routes: copy the blog routes from this repo:
-   - `src/routes/blog/*`
-   - `src/routes/feed.xml/*`
-
-## Notes
-
-- `createBlog()` builds the index from raw Markdown only (fast), and imports the compiled mdsvex component only for individual post pages.
-- This package is intended for SvelteKit. UI uses Tailwind utility classes and expects your app to provide the CSS variables/tokens.

package/packages/blogkit/dist/components/blog/BackLink.svelte

@@ -1,23 +0,0 @@
-<script lang="ts">
-	export let href: string = '/blog';
-	export let label: string = 'Back to blog';
-</script>
-
-<a
-	href={href}
-	class="inline-flex items-center gap-2 text-xs font-mono uppercase tracking-[0.6px] text-text-sub transition hover:text-text-main"
->
-	<svg
-		class="size-4"
-		viewBox="0 0 24 24"
-		fill="none"
-		stroke="currentColor"
-		stroke-width="2"
-		stroke-linecap="round"
-		stroke-linejoin="round"
-		aria-hidden="true"
-	>
-		<path d="M15 18l-6-6 6-6" />
-	</svg>
-	<span>{label}</span>
-</a>