@binarynoir/vitepress-blog 0.0.0-stage → 0.1.1

package/dist/chunk-DICBXOTS.js

@@ -0,0 +1,1001 @@
+// src/collect.ts
+function isPost(page) {
+  return page.post !== null;
+}
+function isIndex(page) {
+  return page.index !== null;
+}
+function dirname(relativePath) {
+  return relativePath.includes("/") ? relativePath.slice(0, relativePath.lastIndexOf("/")) : "";
+}
+function isInFolders(relativePath, folders) {
+  return folders.length === 0 || folders.some((folder) => !folder || relativePath.startsWith(`${folder}/`));
+}
+function folderDepth(index) {
+  return Math.max(0, ...index.index.folders.map((folder) => folder ? folder.split("/").length : 0));
+}
+function hasAnyTag(post, tags) {
+  if (tags.length === 0) return true;
+  const wanted = new Set(tags.map((tag) => tag.toLowerCase()));
+  return post.post.tags.some((tag) => wanted.has(tag.toLowerCase()));
+}
+function blogCoversPost(index, post, sections) {
+  if (index.index.scope === "section") return isInFolders(post.relativePath, index.index.folders);
+  if (!isInFolders(post.relativePath, index.index.folders)) return false;
+  if (post.post.scope === "site") return true;
+  return !sections.some((section) => isInFolders(post.relativePath, section.index.folders));
+}
+function compareDates(a, b) {
+  if (a && b) return b.getTime() - a.getTime();
+  return a ? -1 : b ? 1 : 0;
+}
+function compareByDate(a, b) {
+  return compareDates(a.post.date, b.post.date) || a.post.title.localeCompare(b.post.title);
+}
+function pinStickyPosts(posts, limit) {
+  const sticky = posts.filter((post) => post.post.sticky);
+  const pinned = new Set(limit ? sticky.slice(0, limit) : sticky);
+  return { pinned: [...pinned], rest: posts.filter((post) => !pinned.has(post)) };
+}
+function listBlogPosts(pages, index, options) {
+  const sections = pages.filter(isIndex).filter((page) => page.index.scope === "section");
+  let posts = pages.filter(isPost).filter((post) => options.drafts || !post.post.draft).filter((post) => blogCoversPost(index, post, sections) && hasAnyTag(post, index.index.tags)).sort(compareByDate);
+  if (options.stickyFirst) {
+    const { pinned, rest } = pinStickyPosts(posts, index.index.stickyLimit);
+    posts = [...pinned, ...rest];
+  }
+  return options.applyLimit && index.index.limit ? posts.slice(0, index.index.limit) : posts;
+}
+function findHomeBlog(pages, post, drafts) {
+  const listing = pages.filter(isIndex).filter((index) => listBlogPosts(pages, index, { drafts, stickyFirst: false, applyLimit: false }).includes(post));
+  const sections = listing.filter((index) => index.index.scope === "section");
+  if (sections.length) return deepestFirst(sections, post.relativePath)[0];
+  return listing[0] ?? null;
+}
+function deepestFirst(sections, relativePath) {
+  const isAbove = (index) => Number(isInFolders(relativePath, [dirname(index.relativePath)]));
+  return [...sections].sort((a, b) => folderDepth(b) - folderDepth(a) || isAbove(b) - isAbove(a));
+}
+function findBlogForPage(pages, relativePath) {
+  const indexes = pages.filter(isIndex);
+  const covering = indexes.filter((index) => isInFolders(relativePath, index.index.folders));
+  const sections = covering.filter((index) => index.index.scope === "section");
+  if (sections.length) return deepestFirst(sections, relativePath)[0];
+  const main = indexes.filter((index) => index.index.scope === "site");
+  return main.find((index) => covering.includes(index)) ?? main[0] ?? null;
+}
+function findBlogsListing(pages, post) {
+  return pages.filter(isIndex).filter(
+    (index) => listBlogPosts(pages, index, { drafts: false, stickyFirst: false, applyLimit: false }).includes(post)
+  );
+}
+
+// src/util.ts
+var HTML_ESCAPES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(/[&<>"']/g, (character) => HTML_ESCAPES[character]);
+}
+function escapeMarkdown(text) {
+  const escaped = text.replace(/[\\`*_[\]#|~]/g, "\\$&").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return /[{}]/.test(escaped) ? `<span v-pre>${escaped}</span>` : escaped;
+}
+function escapeTemplateText(text) {
+  const escaped = escapeHtml(text);
+  return /[{}]/.test(escaped) ? `<span v-pre>${escaped}</span>` : escaped;
+}
+function isExternalUrl(url) {
+  return /^(?:[a-z][a-z\d+.-]*:|\/\/)/i.test(url);
+}
+function toMarkdownUrl(url) {
+  return encodeURI(url).replace(/[()]/g, (character) => character === "(" ? "%28" : "%29");
+}
+function toPageLink(text, routePath) {
+  return `[${escapeMarkdown(text)}](${toMarkdownUrl(`/${routePath}`)})`;
+}
+function toUrlPath(routePath, cleanUrls) {
+  return `/${routePath.replace(/(^|\/)index\.md$/, "$1").replace(/\.md$/, cleanUrls ? "" : ".html")}`;
+}
+function joinUrl(base, urlPath) {
+  return `${base.replace(/\/+$/, "")}/${urlPath.replace(/^\/+/, "")}`;
+}
+function toIsoDate(date) {
+  return date.toISOString().slice(0, 10);
+}
+function formatDate(date, locale, format) {
+  return new Intl.DateTimeFormat(locale, { timeZone: "UTC", ...format }).format(date);
+}
+
+// src/feed.ts
+import { createHash } from "crypto";
+import { readFileSync, statSync } from "fs";
+import path from "path";
+function toAbsoluteUrl(urlPath, site) {
+  return joinUrl(site.siteUrl, joinUrl(site.base, urlPath));
+}
+function toPageUrl(routePath, site) {
+  return toAbsoluteUrl(toUrlPath(routePath, site.cleanUrls), site);
+}
+function toFeedPath(index) {
+  return path.posix.join(path.posix.dirname(index.routePath), index.index.feed.path);
+}
+var IMAGE_TYPES = {
+  ".avif": "image/avif",
+  ".gif": "image/gif",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".webp": "image/webp"
+};
+function toImageType(file) {
+  return IMAGE_TYPES[path.extname(file).toLowerCase()];
+}
+function resolvePostImage(post, site) {
+  const { image } = post.post;
+  if (!image) return null;
+  if (isExternalUrl(image)) return { url: image.startsWith("//") ? `https:${image}` : image, type: toImageType(image) };
+  if (/^[@~]/.test(image)) return null;
+  const file = image.startsWith("/") ? path.join(site.publicDir, decodeURI(image)) : path.resolve(path.dirname(post.absolutePath), decodeURI(image));
+  let bytes;
+  try {
+    bytes = statSync(file).size;
+  } catch {
+    return null;
+  }
+  if (image.startsWith("/")) return { url: toAbsoluteUrl(image, site), file, bytes, type: toImageType(file) };
+  const hash = createHash("sha256").update(readFileSync(file)).digest("hex").slice(0, 8);
+  const extension = path.extname(file);
+  const outputPath = path.posix.join(site.imagesDir, `${path.basename(file, extension)}-${hash}${extension}`);
+  return { url: toAbsoluteUrl(outputPath, site), file, outputPath, bytes, type: toImageType(file) };
+}
+function escapeXml(value) {
+  return value.replace(/[&<>"']/g, (character) => `&#${character.charCodeAt(0)};`);
+}
+function element(name, value, attributes = "") {
+  return value ? `<${name}${attributes}>${escapeXml(value)}</${name}>` : "";
+}
+function renderFeed({ index, posts, site, language, siteDescription }) {
+  const feed = index.index.feed;
+  const pageUrl = toPageUrl(index.routePath, site);
+  const newest = posts.map((post) => post.post.updated ?? post.post.date).find((date) => date !== null);
+  const items = posts.map((post) => {
+    const url = toPageUrl(post.routePath, site);
+    const image = resolvePostImage(post, site);
+    const lines = [
+      element("title", post.post.title),
+      element("link", url),
+      element("guid", url, ' isPermaLink="true"'),
+      post.post.date ? element("pubDate", post.post.date.toUTCString()) : "",
+      element("description", post.post.summary),
+      ...post.post.authors.map(
+        (author) => element("dc:creator", author.email ? `${author.email} (${author.name})` : author.name)
+      ),
+      ...[post.post.category, ...post.post.tags].filter(Boolean).map((category) => element("category", category)),
+      image ? `<media:content url="${escapeXml(image.url)}" medium="image"${image.type ? ` type="${image.type}"` : ""} />` : "",
+      image?.bytes !== void 0 && image.type ? `<enclosure url="${escapeXml(image.url)}" length="${image.bytes}" type="${image.type}" />` : ""
+    ];
+    return `    <item>
+${lines.filter(Boolean).map((line) => `      ${line}`).join("\n")}
+    </item>`;
+  });
+  const channel = [
+    element("title", feed.title ?? index.title),
+    element("link", pageUrl),
+    element("description", feed.description ?? (index.description || siteDescription || index.title)),
+    `<atom:link href="${escapeXml(toAbsoluteUrl(toFeedPath(index), site))}" rel="self" type="application/rss+xml" />`,
+    element("language", language),
+    newest ? element("lastBuildDate", newest.toUTCString()) : "",
+    element("generator", "@binarynoir/vitepress-blog")
+  ];
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:media="http://search.yahoo.com/mrss/">',
+    "  <channel>",
+    ...channel.filter(Boolean).map((line) => `    ${line}`),
+    ...items,
+    "  </channel>",
+    "</rss>",
+    ""
+  ].join("\n");
+}
+
+// src/types.ts
+var DEFAULT_LABELS = {
+  by: "By",
+  updated: "Updated",
+  readingTime: "{n} min read",
+  newer: "Newer post",
+  older: "Older post",
+  allPosts: "All posts in {blog}",
+  draft: "Draft",
+  sticky: "Pinned",
+  noPosts: "No posts yet.",
+  undated: "Undated",
+  tags: "Keywords",
+  tagged: "Posts tagged {tag}",
+  showAll: "Show all posts",
+  noTagged: "No posts tagged {tag}.",
+  previous: "Previous",
+  next: "Next",
+  pages: "Pages",
+  subscribe: "Subscribe",
+  rssFeed: "RSS feed for {blog}"
+};
+
+// src/render.ts
+import path2 from "path";
+var BLOG_POSTS_PLACEHOLDER = "<!-- blog-posts -->";
+function createRenderContext(options, pageDirectory, feeds = !!options.siteUrl) {
+  return {
+    locale: options.locale ?? "en-US",
+    dateFormat: options.dateFormat ?? { dateStyle: "long" },
+    labels: { ...DEFAULT_LABELS, ...options.labels },
+    pageDirectory,
+    feeds
+  };
+}
+var RSS_ICON = '<svg class="vp-blog-rss__icon" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true"><circle cx="6" cy="18" r="2.5" fill="currentColor"></circle><path fill="currentColor" d="M3.5 10.5v3a7 7 0 0 1 7 7h3a10 10 0 0 0-10-10z"></path><path fill="currentColor" d="M3.5 3.5v3a14 14 0 0 1 14 14h3a17 17 0 0 0-17-17z"></path></svg>';
+function renderRssLink(index, context, show = index.index.rssLink) {
+  if (!show || !context.feeds || !index.index.feed) return "";
+  const title = fill(context.labels.rssFeed, { blog: index.title }).replace(/"/g, "&quot;");
+  const url = toMarkdownUrl(`/${toFeedPath(index)}`);
+  return `<span class="vp-blog-rss">[${RSS_ICON} ${escapeMarkdown(context.labels.subscribe)}](${url} "${title}")</span>`;
+}
+function fill(template, values) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => values[key] ?? match);
+}
+function toImageSource(post, pageDirectory) {
+  const { image } = post.post;
+  if (!image || isExternalUrl(image) || /^[/@~]/.test(image)) return image;
+  const absolute = path2.resolve(path2.dirname(post.absolutePath), image);
+  const relative = path2.relative(pageDirectory, absolute).split(path2.sep).join("/");
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function renderTime(date, context) {
+  return `<time datetime="${toIsoDate(date)}">${escapeTemplateText(formatDate(date, context.locale, context.dateFormat))}</time>`;
+}
+function renderAuthor(author) {
+  return author.url ? `[${escapeMarkdown(author.name)}](${toMarkdownUrl(author.url)})` : escapeMarkdown(author.name);
+}
+function renderAuthors(authors, context) {
+  if (authors.length === 0) return "";
+  const placeholders = authors.map((_, index) => `\0${index}\0`);
+  const joined = new Intl.ListFormat(context.locale, { type: "conjunction" }).format(placeholders);
+  const names = joined.replace(/\u0000(\d+)\u0000/g, (_, index) => renderAuthor(authors[Number(index)]));
+  return `${escapeMarkdown(context.labels.by)} ${names}`;
+}
+function renderBadge(kind, context) {
+  return `<span class="vp-blog-badge vp-blog-badge--${kind}">${escapeTemplateText(context.labels[kind])}</span>`;
+}
+function toTagUrl(blogRoutePath, tag) {
+  const value = encodeURIComponent(tag.toLowerCase()).replace(/[()]/g, (c) => c === "(" ? "%28" : "%29");
+  const page = blogRoutePath.replace(/(^|\/)index\.md$/, "$1");
+  return `${toMarkdownUrl(`/${page}`)}?tag=${value}`;
+}
+function renderTags(tags, blogRoutePath) {
+  return tags.map(
+    (tag) => blogRoutePath ? `[${escapeMarkdown(tag)}](${toTagUrl(blogRoutePath, tag)})` : `<span class="vp-blog-tag">${escapeTemplateText(tag)}</span>`
+  ).join(" ");
+}
+function toTagsAttribute(post) {
+  return escapeHtml(post.post.tags.map((tag) => tag.toLowerCase()).join("|"));
+}
+function renderMeta(post, context, include) {
+  const { date, updated, readingMinutes, authors, draft, sticky } = post.post;
+  const parts = [];
+  if (include.badges) {
+    const badges = [draft && renderBadge("draft", context), sticky && renderBadge("sticky", context)];
+    const shown = badges.filter(Boolean).join(" ");
+    if (shown) parts.push(shown);
+  }
+  if (date) parts.push(renderTime(date, context));
+  if (include.updated && updated && (!date || updated.getTime() !== date.getTime())) {
+    parts.push(`${escapeMarkdown(context.labels.updated)} ${renderTime(updated, context)}`);
+  }
+  if (readingMinutes) parts.push(escapeMarkdown(fill(context.labels.readingTime, { n: String(readingMinutes) })));
+  if (include.authors) {
+    const names = renderAuthors(authors, context);
+    if (names) parts.push(names);
+  }
+  return parts.join(" \xB7 ");
+}
+function block(className, content) {
+  return content ? [`<div class="${className}">`, "", content, "", "</div>"] : [];
+}
+function imageStyle(post) {
+  return post.post.imagePosition ? ` style="--vp-blog-image-position: ${post.post.imagePosition}"` : "";
+}
+function renderCard(post, context, index) {
+  const link = `/${post.routePath}`;
+  const image = toImageSource(post, context.pageDirectory);
+  const modifiers = [
+    post.post.sticky && "sticky",
+    post.post.draft && "draft",
+    image && "with-image",
+    image && post.post.imageFit === "contain" && "contain"
+  ].filter(Boolean).map((modifier) => ` vp-blog-card--${modifier}`).join("");
+  const alt = escapeMarkdown(post.post.imageAlt);
+  return [
+    `<article class="vp-blog-card${modifiers}"${imageStyle(post)} data-vp-blog-item data-tags="${toTagsAttribute(post)}">`,
+    ...image ? block("vp-blog-card__image", `[![${alt}](${toMarkdownUrl(image)})](${toMarkdownUrl(link)})`) : [],
+    '<div class="vp-blog-card__body">',
+    ...block("vp-blog-card__title", toPageLink(post.post.title, post.routePath)),
+    ...block("vp-blog-card__meta", renderMeta(post, context, { authors: true, updated: false, badges: true })),
+    ...block("vp-blog-card__summary", escapeMarkdown(post.post.summary)),
+    ...index.index.showTags ? block("vp-blog-card__tags", renderTags(post.post.tags, index.routePath)) : [],
+    "</div>",
+    "</article>"
+  ];
+}
+function renderCompactItem(post, context) {
+  const date = post.post.date ? `${renderTime(post.post.date, context)} ` : "";
+  const badges = [post.post.draft && renderBadge("draft", context), post.post.sticky && renderBadge("sticky", context)].filter(Boolean).join(" ");
+  const marker = `<span hidden data-vp-blog-item data-tags="${toTagsAttribute(post)}"></span>`;
+  return `- ${marker}${date}${toPageLink(post.post.title, post.routePath)}${badges ? ` ${badges}` : ""}`;
+}
+function renderGroup(posts, index, context) {
+  const { layout } = index.index;
+  if (layout === "compact") {
+    return [
+      '<div class="vp-blog-list vp-blog-list--compact">',
+      "",
+      ...posts.map((post) => renderCompactItem(post, context)),
+      "",
+      "</div>"
+    ];
+  }
+  return [
+    `<div class="vp-blog-list vp-blog-list--${layout}">`,
+    ...posts.flatMap((post) => renderCard(post, context, index)),
+    "</div>"
+  ];
+}
+function renderYears(posts, index, context) {
+  const years = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    const year = post.post.date ? String(post.post.date.getUTCFullYear()) : context.labels.undated;
+    years.set(year, [...years.get(year) ?? [], post]);
+  }
+  const lines = [];
+  for (const [year, group] of years) {
+    lines.push(
+      '<section class="vp-blog-year">',
+      "",
+      `## ${escapeMarkdown(year)}`,
+      "",
+      ...renderGroup(group, index, context),
+      "",
+      "</section>"
+    );
+  }
+  return lines;
+}
+function collectTags(posts) {
+  const tags = /* @__PURE__ */ new Map();
+  for (const post of posts) {
+    for (const tag of new Set(post.post.tags)) {
+      const entry = tags.get(tag.toLowerCase()) ?? { tag, count: 0 };
+      entry.count++;
+      tags.set(tag.toLowerCase(), entry);
+    }
+  }
+  return [...tags.values()].sort((a, b) => a.tag.localeCompare(b.tag, void 0, { sensitivity: "base" }));
+}
+function renderTagList(posts, index, context) {
+  const tags = collectTags(posts);
+  if (!index.index.tagList || tags.length === 0) return [];
+  const links = tags.map(
+    ({ tag, count }) => `[${escapeMarkdown(tag)} <span class="vp-blog-tags__count">${count}</span>](${toTagUrl(index.routePath, tag)})`
+  );
+  const label = `<span class="vp-blog-tags__label">${escapeTemplateText(context.labels.tags)}</span>`;
+  return [
+    `<nav class="vp-blog-tags" aria-label="${escapeHtml(context.labels.tags)}">`,
+    "",
+    `${label} ${links.join(" ")}`,
+    "",
+    "</nav>"
+  ];
+}
+function renderClientAttributes(index, context) {
+  const { labels } = context;
+  const attributes = {
+    "data-page-size": String(index.index.pageSize),
+    "data-label-tagged": labels.tagged,
+    "data-label-show-all": labels.showAll,
+    "data-label-no-tagged": labels.noTagged,
+    "data-label-previous": labels.previous,
+    "data-label-next": labels.next,
+    "data-label-pages": labels.pages
+  };
+  return Object.entries(attributes).map(([name, value]) => `${name}="${escapeHtml(value)}"`).join(" ");
+}
+function renderPostList(pinned, rest, index, context) {
+  const all = [...pinned, ...rest];
+  if (all.length === 0) return `<p class="vp-blog-empty">${escapeTemplateText(context.labels.noPosts)}</p>
+`;
+  const lines = [
+    `<div class="vp-blog" data-vp-blog ${renderClientAttributes(index, context)}>`,
+    ...block("vp-blog-subscribe", renderRssLink(index, context)),
+    ...renderTagList(all, index, context),
+    '<div class="vp-blog-filter" data-vp-blog-filter hidden></div>'
+  ];
+  if (pinned.length)
+    lines.push(
+      '<section class="vp-blog-sticky" data-vp-blog-sticky>',
+      ...renderGroup(pinned, index, context),
+      "</section>"
+    );
+  if (rest.length)
+    lines.push(...index.index.groupByYear ? renderYears(rest, index, context) : renderGroup(rest, index, context));
+  lines.push(`<nav class="vp-blog-pagination" data-vp-blog-pagination hidden></nav>`, "</div>");
+  return `${lines.join("\n")}
+`;
+}
+function renderPostHeader(post, context, show, blogRoutePath = null) {
+  const lines = [];
+  if (show.byline) {
+    const meta = renderMeta(post, context, { authors: true, updated: true, badges: true });
+    const tags = post.post.tags.length ? `<span class="vp-blog-byline__tags">${renderTags(post.post.tags, blogRoutePath)}</span>` : "";
+    lines.push(...block("vp-blog-byline", [meta, tags].filter(Boolean).join("\n\n")));
+  }
+  if (show.cover && post.post.image) {
+    const image = /^[./@~]/.test(post.post.image) || isExternalUrl(post.post.image) ? post.post.image : `./${post.post.image}`;
+    lines.push(...block("vp-blog-cover", `![${escapeMarkdown(post.post.imageAlt)}](${toMarkdownUrl(image)})`));
+  }
+  return lines.join("\n");
+}
+function renderNavLink(kind, post, context) {
+  if (!post) return [`<div class="vp-blog-post-nav__${kind}"></div>`];
+  const label = `<span class="vp-blog-post-nav__label">${escapeTemplateText(context.labels[kind])}</span>`;
+  return block(`vp-blog-post-nav__${kind}`, `${label}<br>
+${toPageLink(post.post.title, post.routePath)}`);
+}
+function renderPostNav(post, posts, blog, context) {
+  const position = posts.indexOf(post);
+  const newer = position > 0 ? posts[position - 1] : void 0;
+  const older = position >= 0 ? posts[position + 1] : void 0;
+  const lines = ['<nav class="vp-blog-post-nav">'];
+  if (newer || older) lines.push(...renderNavLink("newer", newer, context), ...renderNavLink("older", older, context));
+  lines.push(
+    ...block("vp-blog-post-nav__all", toPageLink(fill(context.labels.allPosts, { blog: blog.title }), blog.routePath))
+  );
+  lines.push("</nav>");
+  return lines.join("\n");
+}
+
+// src/frontmatter.ts
+import path3 from "path";
+import { parse } from "yaml";
+var POST_FRONTMATTER_KEY = "blog";
+var INDEX_FRONTMATTER_KEY = "blog-index";
+var FRONTMATTER = /^---[ \t]*\r?\n(?:([\s\S]*?)\r?\n)?---[ \t]*(?:\r?\n|$)/;
+var BLOG_KEY = /^blog(?:-index)?[ \t]*:/m;
+var FENCED_CODE = /^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?(?:^[ \t]*\1[`~]*[ \t]*$|(?![\s\S]))/gm;
+var HEADING_1 = /^ {0,3}#[ \t]+(.*?)(?:[ \t]+#+)?[ \t]*$/m;
+var TAG_SYNTAX = /\(\(<?tag([|/])[^|/)\r\n]*(?:\1[^|/)\r\n]*){0,2}\)\)/g;
+var MAX_SUMMARY_LENGTH = 200;
+function readFrontmatter(raw) {
+  const source = raw.replace(/^/, "");
+  const match = FRONTMATTER.exec(source);
+  if (!match) return { data: {}, content: source };
+  const data = match[1] ? parse(match[1]) : null;
+  return {
+    data: data && typeof data === "object" && !Array.isArray(data) ? data : {},
+    content: source.slice(match[0].length)
+  };
+}
+function mayHaveBlogFrontmatter(raw) {
+  const frontmatter = FRONTMATTER.exec(raw.replace(/^/, ""))?.[1];
+  return frontmatter !== void 0 && BLOG_KEY.test(frontmatter);
+}
+function stripTagSyntax(text) {
+  return text.replace(TAG_SYNTAX, " ").replace(/\s+/g, " ").trim();
+}
+function toRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function toText(value) {
+  return typeof value === "string" ? value.trim() : typeof value === "number" ? String(value) : "";
+}
+function toBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function toStringList(value) {
+  const values = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+  return values.map(toText).filter(Boolean);
+}
+function toDate(value) {
+  if (value instanceof Date) return Number.isNaN(value.getTime()) ? null : value;
+  if (typeof value !== "string" && typeof value !== "number") return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime()) ? null : date;
+}
+function toAuthor(value, options) {
+  if (typeof value === "string") {
+    const name2 = value.trim();
+    if (!name2) return null;
+    const known = options.authors && Object.hasOwn(options.authors, name2) ? options.authors[name2] : void 0;
+    return known ? toAuthor(known, {}) : { name: name2 };
+  }
+  const record = toRecord(value);
+  const name = toText(record.name);
+  if (!name) return null;
+  const author = { name };
+  if (toText(record.url)) author.url = toText(record.url);
+  if (toText(record.email)) author.email = toText(record.email);
+  return author;
+}
+function toAuthors(value, options) {
+  const values = Array.isArray(value) ? value : value === void 0 ? [] : [value];
+  const authors = values.map((item) => toAuthor(item, options)).filter((author) => author !== null);
+  if (authors.length === 0 && options.defaultAuthor) {
+    const fallback = toAuthor(options.defaultAuthor, options);
+    if (fallback) authors.push(fallback);
+  }
+  return authors;
+}
+function toImagePosition(value) {
+  const parts = value.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const valid = /^(?:top|bottom|left|right|center|-?\d+(?:\.\d+)?(?:%|px|rem|em)?)$/;
+  return parts.length > 0 && parts.length <= 4 && parts.every((part) => valid.test(part)) ? parts.join(" ") : "";
+}
+function toScope(value) {
+  return value === "site" || value === "global" ? "site" : "section";
+}
+function withoutCode(content) {
+  return content.replace(FENCED_CODE, "");
+}
+function readHeading(content) {
+  return HEADING_1.exec(withoutCode(content))?.[1]?.replace(/[ \t]*\{#[^}]*\}$/, "").trim() ?? "";
+}
+function toPlainText(markdown) {
+  return markdown.replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/<[^>]+>/g, "").replace(/[*_`~]/g, "").replace(/\s+/g, " ").trim();
+}
+function readExcerpt(content) {
+  for (const block2 of withoutCode(content).split(/\r?\n[ \t]*\r?\n/)) {
+    const text = block2.trim();
+    if (!text || /^(?:#|<|>|\||:::|\[\[|!\[|[-*+] |\d+[.)] |\{)/.test(text)) continue;
+    const plain = toPlainText(text);
+    if (!plain) continue;
+    return plain.length > MAX_SUMMARY_LENGTH ? `${plain.slice(0, MAX_SUMMARY_LENGTH - 1).trimEnd()}\u2026` : plain;
+  }
+  return "";
+}
+function estimateReadingMinutes(content, wordsPerMinute) {
+  if (wordsPerMinute <= 0) return 0;
+  const words = toPlainText(withoutCode(content)).split(" ").filter(Boolean).length;
+  return Math.max(1, Math.ceil(words / wordsPerMinute));
+}
+function resolvePostData(data, content, fallbackTitle, options = {}) {
+  const value = data[POST_FRONTMATTER_KEY];
+  if (!value) return null;
+  const post = toRecord(value);
+  const pick = (key) => post[key] ?? data[key];
+  const stripTags = options.stripTags ?? true;
+  const clean = (text) => stripTags ? stripTagSyntax(text) : text;
+  const image = toRecord(pick("image"));
+  return {
+    title: clean(toText(post.title) || toText(data.title) || readHeading(content)) || fallbackTitle,
+    summary: clean(toText(post.summary) || toText(data.description) || readExcerpt(content)),
+    date: toDate(pick("date")),
+    updated: toDate(pick("updated")),
+    image: toText(image.src) || toText(pick("image")),
+    imageAlt: toText(image.alt) || toText(post.imageAlt) || toText(data.imageAlt),
+    imageFit: (toText(image.fit) || toText(post.imageFit)) === "contain" ? "contain" : "cover",
+    imagePosition: toImagePosition(toText(image.position) || toText(post.imagePosition)),
+    authors: toAuthors(post.author ?? post.authors ?? data.author ?? data.authors, options),
+    tags: toStringList(pick("tags")),
+    category: toText(pick("category")),
+    scope: toScope(post.scope),
+    sticky: post.sticky === true,
+    draft: post.draft === true,
+    byline: toBoolean(post.byline),
+    cover: toBoolean(post.cover),
+    postNav: toBoolean(post.postNav),
+    readingMinutes: estimateReadingMinutes(content, options.wordsPerMinute ?? 200)
+  };
+}
+function toLayout(value) {
+  return value === "grid" || value === "compact" ? value : "list";
+}
+function defaultFeedPath(relativePath) {
+  const name = path3.posix.basename(relativePath, ".md");
+  return name === "index" ? "feed.xml" : `${name}-feed.xml`;
+}
+function toFeed(value, relativePath) {
+  if (value === false) return null;
+  const feed = toRecord(value);
+  const config = { path: toText(feed.path) || defaultFeedPath(relativePath) };
+  if (toText(feed.title)) config.title = toText(feed.title);
+  if (toText(feed.description)) config.description = toText(feed.description);
+  if (typeof feed.limit === "number" && feed.limit > 0) config.limit = Math.floor(feed.limit);
+  return config;
+}
+function resolveFolders(folders, pageRelativePath) {
+  return folders.map((folder) => {
+    const resolved = /^\.\.?(\/|$)/.test(folder) ? path3.posix.join(path3.posix.dirname(pageRelativePath), folder) : path3.posix.normalize(folder);
+    return resolved.replace(/^\/+|\/+$/g, "").replace(/^\.$/, "");
+  });
+}
+function toCount(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? Math.floor(value) : fallback;
+}
+function resolveIndexConfig(data, relativePath, defaults = {}) {
+  const value = data[INDEX_FRONTMATTER_KEY];
+  if (!value) return null;
+  const options = toRecord(value);
+  const scope = toScope(options.scope);
+  const folders = toStringList(options.folders);
+  const ownFolder = path3.posix.dirname(relativePath).replace(/^\.$/, "");
+  return {
+    scope,
+    folders: folders.length ? resolveFolders(folders, relativePath) : scope === "section" ? [ownFolder] : [],
+    tags: toStringList(options.tags),
+    limit: typeof options.limit === "number" && options.limit > 0 ? Math.floor(options.limit) : 0,
+    layout: toLayout(options.layout),
+    groupByYear: options.groupBy === "year",
+    showTags: options.showTags !== false,
+    tagList: options.tagList !== false,
+    pageSize: toCount(options.pageSize, toCount(defaults.pageSize, 10)),
+    stickyLimit: toCount(options.stickyLimit, toCount(defaults.stickyLimit, 0)),
+    rssLink: typeof options.rssLink === "boolean" ? options.rssLink : defaults.rssLink ?? true,
+    feed: toFeed(options.feed, relativePath)
+  };
+}
+
+// src/scan.ts
+import { createHash as createHash2 } from "crypto";
+import { readdirSync, readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
+import path4 from "path";
+var scanCache = /* @__PURE__ */ new Map();
+function listMarkdownFiles(directory, ancestors = /* @__PURE__ */ new Set()) {
+  let realDirectory;
+  try {
+    realDirectory = realpathSync(directory);
+  } catch {
+    return [];
+  }
+  if (ancestors.has(realDirectory)) return [];
+  const chain = new Set(ancestors).add(realDirectory);
+  const files = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const fullPath = path4.join(directory, entry.name);
+    let isDirectory = entry.isDirectory();
+    let isFile = entry.isFile();
+    if (entry.isSymbolicLink()) {
+      try {
+        const target = statSync2(fullPath);
+        isDirectory = target.isDirectory();
+        isFile = target.isFile();
+      } catch {
+        continue;
+      }
+    }
+    if (isDirectory) files.push(...listMarkdownFiles(fullPath, chain));
+    else if (isFile && entry.name.endsWith(".md")) files.push(fullPath);
+  }
+  return files;
+}
+function toFallbackTitle(relativePath) {
+  const parts = relativePath.replace(/\.md$/, "").split("/");
+  const name = parts.at(-1) === "index" && parts.length > 1 ? parts.at(-2) : parts.at(-1);
+  return name.replace(/[-_]+/g, " ");
+}
+var warned = /* @__PURE__ */ new Set();
+function scanPage(raw, relativePath, options = {}) {
+  if (!mayHaveBlogFrontmatter(raw)) return null;
+  const { data, content } = readFrontmatter(raw);
+  const fallbackTitle = toFallbackTitle(relativePath);
+  const index = resolveIndexConfig(data, relativePath, options);
+  const post = index ? null : resolvePostData(data, content, fallbackTitle, options);
+  if (!index && !post) return null;
+  const rawTitle = typeof data.title === "string" && data.title.trim() || readHeading(content);
+  const title = options.stripTags ?? true ? stripTagSyntax(rawTitle) : rawTitle;
+  return {
+    relativePath,
+    title: post?.title ?? (title || fallbackTitle),
+    description: typeof data.description === "string" ? data.description.trim() : "",
+    post,
+    index
+  };
+}
+function toOptionsKey(options) {
+  return JSON.stringify([
+    options.authors,
+    options.defaultAuthor,
+    options.wordsPerMinute,
+    options.stripTags,
+    options.pageSize,
+    options.stickyLimit,
+    options.rssLink
+  ]);
+}
+function indexBlogSource(sourceDirectory, options = {}, rewrites = {}) {
+  const pages = [];
+  const present = /* @__PURE__ */ new Set();
+  const optionsKey = toOptionsKey(options);
+  for (const absolutePath of listMarkdownFiles(sourceDirectory).sort()) {
+    present.add(absolutePath);
+    const stats = statSync2(absolutePath);
+    const relativePath = path4.relative(sourceDirectory, absolutePath).split(path4.sep).join("/");
+    let entry = scanCache.get(absolutePath);
+    if (!entry || entry.mtimeMs !== stats.mtimeMs || entry.size !== stats.size || entry.optionsKey !== optionsKey) {
+      let page = null;
+      try {
+        page = scanPage(readFileSync2(absolutePath, "utf8"), relativePath, options);
+      } catch (error) {
+        if (!warned.has(absolutePath)) {
+          warned.add(absolutePath);
+          console.warn(`[vitepress-blog] skipped ${relativePath}: ${error.message}`);
+        }
+      }
+      entry = { mtimeMs: stats.mtimeMs, size: stats.size, optionsKey, page };
+      scanCache.set(absolutePath, entry);
+    }
+    if (entry.page) pages.push({ ...entry.page, absolutePath, routePath: rewrites[relativePath] ?? relativePath });
+  }
+  for (const cached of scanCache.keys()) {
+    if (cached.startsWith(sourceDirectory + path4.sep) && !present.has(cached)) scanCache.delete(cached);
+  }
+  return pages;
+}
+function loadBlogPages(sourceDirectory, options = {}, info = {}) {
+  const built = info.pages ? new Set(info.pages) : null;
+  return indexBlogSource(sourceDirectory, options, info.rewrites?.map).filter(
+    (page) => !built || built.has(page.relativePath)
+  );
+}
+function fingerprintBlogSource(pages) {
+  const hash = createHash2("sha1");
+  for (const page of pages) {
+    const { mtimeMs, size } = statSync2(page.absolutePath);
+    hash.update(`${page.relativePath}:${mtimeMs}:${size}
+`);
+  }
+  return hash.digest("hex").slice(0, 12);
+}
+
+// src/widget.ts
+import path5 from "path";
+import { parse as parse2 } from "yaml";
+var widgetPages = /* @__PURE__ */ new Set();
+var WIDGET_NAME = "blog-posts";
+var WIDGET_OPEN = new RegExp(`^ {0,3}:{3,}[ \\t]*${WIDGET_NAME}[ \\t]*$`);
+var WIDGET_CLOSE = /^ {0,3}:{3,}[ \t]*$/;
+var FENCE = /^[ \t]*(`{3,}|~{3,})/;
+var DEFAULT_LIMIT = 5;
+function hasWidget(source) {
+  return source.includes(`${WIDGET_NAME}`) && source.split("\n").some((line) => WIDGET_OPEN.test(line));
+}
+function toRecord2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function toCount2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : void 0;
+}
+function findWidgetBlog(pages, blog, pageRelativePath) {
+  const indexes = pages.filter(isIndex);
+  if (!blog) return findBlogForPage(pages, pageRelativePath);
+  let target = /^\.\.?(\/|$)/.test(blog) ? path5.posix.join(path5.posix.dirname(pageRelativePath), blog) : blog.replace(/^\/+/, "");
+  target = target.replace(/\.html$/, "");
+  const candidates = target.endsWith(".md") ? [target] : target === "" || target.endsWith("/") ? [`${target}index.md`] : [`${target}.md`, `${target}/index.md`];
+  return indexes.find((index) => candidates.includes(index.routePath)) ?? indexes.find((index) => candidates.includes(index.relativePath)) ?? null;
+}
+function resolveWidgetConfig(body) {
+  let data = {};
+  let problem;
+  try {
+    data = toRecord2(body.trim() ? parse2(body) : {});
+  } catch (error) {
+    problem = `its settings are not valid YAML: ${error.message.split("\n")[0]}`;
+  }
+  const layout = data.layout === "list" || data.layout === "grid" || data.layout === "compact" ? data.layout : void 0;
+  return {
+    config: {
+      blog: typeof data.blog === "string" ? data.blog.trim() : "",
+      limit: toCount2(data.limit) ?? DEFAULT_LIMIT,
+      stickyLimit: toCount2(data.stickyLimit),
+      layout,
+      showTags: typeof data.showTags === "boolean" ? data.showTags : void 0,
+      tags: toStringList(data.tags),
+      more: data.more === false ? null : typeof data.more === "string" && data.more.trim() ? data.more.trim() : "",
+      rssLink: typeof data.rssLink === "boolean" ? data.rssLink : void 0
+    },
+    problem
+  };
+}
+function renderWidget(body, environment) {
+  const { pages, pageRelativePath, drafts, context, warn } = environment;
+  const { config, problem } = resolveWidgetConfig(body);
+  if (problem) warn(problem);
+  const blog = findWidgetBlog(pages, config.blog, pageRelativePath);
+  if (!blog) {
+    warn(config.blog ? `no blog page found at "${config.blog}"` : 'no blog covers this page: name one with "blog:"');
+    return "";
+  }
+  const stickyLimit = config.stickyLimit ?? blog.index.stickyLimit;
+  const wanted = new Set(config.tags.map((tag) => tag.toLowerCase()));
+  const posts = listBlogPosts(pages, blog, { drafts, stickyFirst: false, applyLimit: false }).filter(
+    (post) => wanted.size === 0 || post.post.tags.some((tag) => wanted.has(tag.toLowerCase()))
+  );
+  const { pinned, rest } = pinStickyPosts(posts, stickyLimit);
+  const shown = [...pinned, ...rest].slice(0, config.limit || void 0);
+  const view = {
+    ...blog,
+    index: {
+      ...blog.index,
+      layout: config.layout ?? blog.index.layout,
+      showTags: config.showTags ?? blog.index.showTags
+    }
+  };
+  const lines = [`<div class="vp-blog-widget">`];
+  if (shown.length) lines.push(...renderGroup(shown, view, context));
+  else lines.push(`<p class="vp-blog-empty">${escapeTemplateText(context.labels.noPosts)}</p>`);
+  const footer = [renderRssLink(blog, context, config.rssLink ?? blog.index.rssLink)];
+  if (config.more !== null) {
+    footer.push(toPageLink(config.more || context.labels.allPosts.replace("{blog}", blog.title), blog.routePath));
+  }
+  if (footer.some(Boolean)) {
+    lines.push('<div class="vp-blog-widget__footer">', "", footer.filter(Boolean).join(" "), "", "</div>");
+  }
+  lines.push("</div>");
+  return lines.join("\n");
+}
+function applyWidgets(source, environment) {
+  const lines = source.split("\n");
+  const output = [];
+  let fence = "";
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const marker = FENCE.exec(line)?.[1];
+    if (marker && (!fence || marker[0] === fence[0] && marker.length >= fence.length)) {
+      fence = fence ? "" : marker;
+      output.push(line);
+      continue;
+    }
+    if (fence || !WIDGET_OPEN.test(line)) {
+      output.push(line);
+      continue;
+    }
+    const close = lines.findIndex((candidate, at) => at > index && WIDGET_CLOSE.test(candidate));
+    if (close === -1) {
+      environment.warn(`"::: ${WIDGET_NAME}" on line ${index + 1} has no closing ":::"`);
+      output.push(line);
+      continue;
+    }
+    const lineWarn = (message) => environment.warn(`the block on line ${index + 1}: ${message}`);
+    output.push("", renderWidget(lines.slice(index + 1, close).join("\n"), { ...environment, warn: lineWarn }), "");
+    index = close;
+  }
+  return output.join("\n");
+}
+
+// src/plugin.ts
+import path6 from "path";
+var FENCE2 = /^[ \t]*(`{3,}|~{3,})/;
+var HEADING_12 = /^ {0,3}#[ \t]+\S/;
+function readSourceInfo() {
+  return globalThis.VITEPRESS_CONFIG ?? {};
+}
+function insertAfterTitle(source, insert) {
+  const lines = source.split("\n");
+  let fence = "";
+  for (const [index, line] of lines.entries()) {
+    const marker = FENCE2.exec(line)?.[1];
+    if (marker && (!fence || marker[0] === fence[0])) {
+      fence = fence ? "" : marker;
+      continue;
+    }
+    if (!fence && HEADING_12.test(line)) {
+      return [...lines.slice(0, index + 1), "", insert, "", ...lines.slice(index + 1)].join("\n");
+    }
+  }
+  return `${insert}
+
+${source}`;
+}
+function hasFeeds(options) {
+  return !!(options.siteUrl ?? readSourceInfo().userConfig?.sitemap?.hostname);
+}
+function withPostList(source, page, pages, options) {
+  if (!isIndex(page)) return source;
+  const posts = listBlogPosts(pages, page, { drafts: options.drafts ?? false, stickyFirst: true, applyLimit: true });
+  const { pinned, rest } = pinStickyPosts(posts, page.index.stickyLimit);
+  const context = createRenderContext(options, path6.dirname(page.absolutePath), hasFeeds(options));
+  const generated = renderPostList(pinned, rest, page, context);
+  return source.includes(BLOG_POSTS_PLACEHOLDER) ? source.replace(BLOG_POSTS_PLACEHOLDER, () => `
+${generated}
+`) : `${source.replace(/\s*$/, "")}
+
+${generated}`;
+}
+function withPostDecorations(source, page, pages, options) {
+  if (!isPost(page)) return source;
+  const context = createRenderContext(options, path6.dirname(page.absolutePath));
+  const drafts = options.drafts ?? false;
+  const blog = findHomeBlog(pages, page, drafts);
+  const header = renderPostHeader(
+    page,
+    context,
+    { byline: page.post.byline ?? options.byline ?? true, cover: page.post.cover ?? options.cover ?? false },
+    blog?.routePath ?? null
+  );
+  let result = header ? insertAfterTitle(source, header) : source;
+  if (page.post.postNav ?? options.postNav ?? true) {
+    if (blog) {
+      const posts = listBlogPosts(pages, blog, { drafts, stickyFirst: false, applyLimit: false });
+      result = `${result.replace(/\s*$/, "")}
+
+${renderPostNav(page, posts, blog, context)}
+`;
+    }
+  }
+  return result;
+}
+var warned2 = /* @__PURE__ */ new Set();
+function applyBlog({ src, env }, options) {
+  const frontmatter = env?.frontmatter;
+  const isBlogPage = !!(frontmatter?.blog || frontmatter?.["blog-index"]);
+  const widgets = hasWidget(src);
+  if (!isBlogPage && !widgets) return src;
+  if (typeof env.path !== "string" || typeof env.relativePath !== "string") return src;
+  const sourceDirectory = path6.resolve(env.path, ...env.relativePath.split("/").map(() => ".."));
+  const realPath = typeof env.realPath === "string" ? env.realPath : env.path;
+  const relativePath = path6.relative(sourceDirectory, realPath).split(path6.sep).join("/");
+  const pages = loadBlogPages(sourceDirectory, options, readSourceInfo());
+  let result = src;
+  if (widgets) {
+    widgetPages.add(realPath);
+    result = applyWidgets(result, {
+      pages,
+      pageRelativePath: relativePath,
+      drafts: options.drafts ?? false,
+      context: createRenderContext(options, path6.dirname(realPath), hasFeeds(options)),
+      warn: (message) => {
+        const key = `${relativePath}: ${message}`;
+        if (warned2.has(key)) return;
+        warned2.add(key);
+        console.warn(`[vitepress-blog] ${relativePath}: ${message}`);
+      }
+    });
+  }
+  const page = pages.find((candidate) => candidate.relativePath === relativePath);
+  if (!page) return result;
+  return page.index ? withPostList(result, page, pages, options) : withPostDecorations(result, page, pages, options);
+}
+function blogMarkdown(md, options = {}) {
+  md.core.ruler.before("normalize", "vitepress_blog", (state) => {
+    state.src = applyBlog(state, options);
+  });
+}
+
+export {
+  isPost,
+  isIndex,
+  listBlogPosts,
+  findBlogsListing,
+  joinUrl,
+  toPageUrl,
+  toFeedPath,
+  resolvePostImage,
+  renderFeed,
+  DEFAULT_LABELS,
+  BLOG_POSTS_PLACEHOLDER,
+  POST_FRONTMATTER_KEY,
+  INDEX_FRONTMATTER_KEY,
+  mayHaveBlogFrontmatter,
+  loadBlogPages,
+  fingerprintBlogSource,
+  widgetPages,
+  WIDGET_NAME,
+  hasWidget,
+  blogMarkdown
+};
+//# sourceMappingURL=chunk-DICBXOTS.js.map