@justanarthur/payload-www 0.1.1

package/dist/render-pages.js

@@ -0,0 +1,1450 @@
+
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/render/components/PageShowcase.tsx
+var exports_PageShowcase = {};
+__export(exports_PageShowcase, {
+  PageShowcase: () => PageShowcase
+});
+import * as React from "react";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+function PageShowcase({
+  children,
+  metadata,
+  jsonLd,
+  localeSwitcher,
+  metadataHeading = "Page metadata",
+  jsonLdHeading = "JSON-LD"
+}) {
+  const og = metadata.openGraph;
+  const twitter = metadata.twitter;
+  const rows = [
+    ["Title", resolveTitle(metadata.title)],
+    ["Description", metadata.description],
+    ["Canonical", metadata.alternates?.canonical],
+    [
+      "Languages",
+      metadata.alternates?.languages ? Object.entries(metadata.alternates.languages).map(([locale, url]) => `${locale}: ${url}`).join(`
+`) : undefined
+    ],
+    ["Open Graph title", og?.title],
+    ["Open Graph description", og?.description],
+    ["Open Graph type", og?.type],
+    ["Open Graph url", og?.url],
+    ["Open Graph site name", og?.siteName],
+    ["Twitter card", twitter?.card],
+    ["Twitter title", twitter?.title],
+    ["Twitter description", twitter?.description],
+    ["Twitter site", twitter?.site],
+    ["Twitter creator", twitter?.creator]
+  ];
+  return /* @__PURE__ */ jsxs("div", {
+    className: "page-showcase grid gap-8 lg:grid-cols-[1fr_320px]",
+    children: [
+      /* @__PURE__ */ jsx4("main", {
+        className: "page-showcase__main",
+        children
+      }),
+      /* @__PURE__ */ jsxs("aside", {
+        className: "page-showcase__sidebar flex flex-col gap-6 text-sm",
+        children: [
+          /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__locale",
+            children: [
+              /* @__PURE__ */ jsx4("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: "Language"
+              }),
+              localeSwitcher
+            ]
+          }),
+          /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__metadata",
+            children: [
+              /* @__PURE__ */ jsx4("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: metadataHeading
+              }),
+              /* @__PURE__ */ jsx4("dl", {
+                className: "m-0 grid grid-cols-[max-content_1fr] gap-x-3 gap-y-1.5",
+                children: rows.filter(([, value]) => value !== undefined && value !== "").map(([label, value]) => /* @__PURE__ */ jsxs(React.Fragment, {
+                  children: [
+                    /* @__PURE__ */ jsx4("dt", {
+                      className: "font-medium text-muted-foreground",
+                      children: label
+                    }),
+                    /* @__PURE__ */ jsx4("dd", {
+                      className: "m-0 whitespace-pre-wrap break-words font-mono text-xs",
+                      children: value
+                    })
+                  ]
+                }, label))
+              })
+            ]
+          }),
+          jsonLd.length > 0 ? /* @__PURE__ */ jsxs("section", {
+            className: "page-showcase__jsonld",
+            children: [
+              /* @__PURE__ */ jsx4("h2", {
+                className: "m-0 mb-2 text-xs font-semibold uppercase tracking-wide text-muted-foreground",
+                children: jsonLdHeading
+              }),
+              jsonLd.map(({ id, schema }) => /* @__PURE__ */ jsxs("details", {
+                className: "mb-2 rounded border border-border bg-muted/30 p-2",
+                children: [
+                  /* @__PURE__ */ jsx4("summary", {
+                    className: "cursor-pointer font-mono text-xs",
+                    children: id
+                  }),
+                  /* @__PURE__ */ jsx4("pre", {
+                    className: "mt-2 overflow-x-auto whitespace-pre-wrap break-words font-mono text-[10px] leading-snug",
+                    children: JSON.stringify(schema, null, 2)
+                  })
+                ]
+              }, id))
+            ]
+          }) : null
+        ]
+      })
+    ]
+  });
+}
+function resolveTitle(title) {
+  if (!title)
+    return;
+  if (typeof title === "string")
+    return title;
+  if (title === null)
+    return;
+  const t = title;
+  return t.absolute ?? t.template ?? t.default;
+}
+var init_PageShowcase = () => {};
+
+// src/render/components/LocaleSwitcher.tsx
+var exports_LocaleSwitcher = {};
+__export(exports_LocaleSwitcher, {
+  LocaleSwitcher: () => LocaleSwitcher
+});
+import { jsx as jsx5, jsxs as jsxs2 } from "react/jsx-runtime";
+function LocaleSwitcher({
+  currentLocale,
+  hreflangAlternates,
+  labels
+}) {
+  const locales = Object.keys(hreflangAlternates).filter((k) => k !== "x-default");
+  return /* @__PURE__ */ jsx5("nav", {
+    "aria-label": "Language",
+    className: "locale-switcher",
+    children: /* @__PURE__ */ jsxs2("ul", {
+      className: "flex flex-wrap gap-2 list-none p-0 m-0",
+      children: [
+        locales.map((locale) => {
+          const href = hreflangAlternates[locale];
+          if (!href)
+            return null;
+          const isCurrent = locale === currentLocale;
+          return /* @__PURE__ */ jsx5("li", {
+            children: /* @__PURE__ */ jsx5("a", {
+              href,
+              "aria-current": isCurrent ? "true" : undefined,
+              hrefLang: locale,
+              className: "locale-switcher__link",
+              "data-locale": locale,
+              children: labels?.[locale] ?? locale.toUpperCase()
+            })
+          }, locale);
+        }),
+        hreflangAlternates["x-default"] ? /* @__PURE__ */ jsx5("li", {
+          children: /* @__PURE__ */ jsx5("a", {
+            href: hreflangAlternates["x-default"],
+            hrefLang: "x-default",
+            className: "locale-switcher__link",
+            "data-locale": "x-default",
+            children: labels?.["x-default"] ?? "Default"
+          })
+        }, "x-default") : null
+      ]
+    })
+  });
+}
+var init_LocaleSwitcher = () => {};
+
+// src/render/pages/createCollectionPageExports.tsx
+import"server-only";
+import { Suspense } from "react";
+
+// src/config/constants.ts
+var PAGES_RENDER_PATH = "@justanarthur/payload-www/render-pages#PagesPage";
+var POSTS_RENDER_PATH = "@justanarthur/payload-www/render-pages#PostsPage";
+var HEADER_RENDER_PATH = "@justanarthur/payload-www/render-pages#HeaderPage";
+var FOOTER_RENDER_PATH = "@justanarthur/payload-www/render-pages#FooterPage";
+var LIVE_PREVIEW_LISTENER_PATH = "@justanarthur/payload-www/render-components#LivePreviewListener";
+var PAGES_SLUG = "pages";
+var POSTS_SLUG = "posts";
+var STATIC_PAGES_SLUG = "staticPages";
+
+// src/core/utils/getFromImportMap.ts
+function getFromImportMap(key, importMap) {
+  return importMap[key.includes("#") ? key : key + "#default"];
+}
+
+// src/render/utils/renderCollectionModule.tsx
+import { jsx } from "react/jsx-runtime";
+function renderCollectionModule(collection = [], slug, importMap, props) {
+  const renderPath = collection?.find((c) => c.slug === slug)?.custom?.path;
+  if (!renderPath)
+    return null;
+  const CollectionRenderModule = getFromImportMap(renderPath, importMap);
+  if (!CollectionRenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx(CollectionRenderModule, {
+    importMap,
+    ...props
+  });
+}
+
+// src/render/metadata/hreflang.ts
+async function buildHreflangAlternates({
+  siteUrl,
+  locale,
+  urlPrefix,
+  storedSlug,
+  queryAllLocaleSlugs,
+  nested,
+  homeSlug,
+  defaultLocale,
+  locales,
+  localePrefix = "always"
+}) {
+  const allLocaleSlugs = await queryAllLocaleSlugs(storedSlug, locale);
+  const languages = {};
+  const urlFor = (l, slug) => {
+    const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+    const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+    const urlPath = slug === homeSlug ? "/" : nested ? "/" + slug.replaceAll("_", "/") : "/" + slug;
+    const localeSegment = localePrefix === "never" ? "" : localePrefix === "as-needed" && l === defaultLocale ? "" : `/${l}`;
+    return `${siteUrl}${localeSegment}${prefixSegment}${urlPath}`;
+  };
+  for (const l of locales) {
+    const slugForLocale = allLocaleSlugs?.[l];
+    if (!slugForLocale)
+      continue;
+    languages[l] = urlFor(l, slugForLocale);
+  }
+  if (allLocaleSlugs?.[defaultLocale]) {
+    languages["x-default"] = urlFor(defaultLocale, allLocaleSlugs[defaultLocale]);
+  }
+  return languages;
+}
+
+// src/render/metadata/jsonld.ts
+function getImageUrl(doc, siteUrl) {
+  const img = doc?.meta?.image ?? doc?.heroImage ?? doc?.image;
+  if (!img)
+    return null;
+  if (typeof img === "string")
+    return img;
+  if (img?.url)
+    return img.url.startsWith("http") ? img.url : `${siteUrl}${img.url}`;
+  return null;
+}
+function resolveLocalizedField(value, locale) {
+  if (value == null)
+    return "";
+  if (typeof value === "string") {
+    if (!value.startsWith("{"))
+      return value;
+    try {
+      const parsed = JSON.parse(value);
+      return resolveLocalizedField(parsed, locale);
+    } catch {
+      return value;
+    }
+  }
+  if (typeof value !== "object")
+    return "";
+  const obj = value;
+  if (typeof obj[locale] === "string" && obj[locale].length > 0) {
+    return obj[locale];
+  }
+  return Object.values(obj).filter((v) => typeof v === "string" && v.length > 0).join(" / ");
+}
+function buildArticleLd({
+  doc,
+  url,
+  locale,
+  siteUrl,
+  type = "BlogPosting",
+  publisherName,
+  publisherLogo
+}) {
+  const name = publisherName ?? new URL(siteUrl).hostname;
+  const ld = {
+    "@context": "https://schema.org",
+    "@type": type,
+    "@id": `${url}#article`,
+    headline: resolveLocalizedField(doc.title, locale),
+    description: resolveLocalizedField(doc.meta?.description ?? doc.description ?? doc.excerpt, locale),
+    inLanguage: locale,
+    url,
+    dateModified: doc.updatedAt ? new Date(doc.updatedAt).toISOString() : undefined
+  };
+  const datePublished = doc.publishedAt ?? doc.createdAt;
+  if (datePublished)
+    ld.datePublished = new Date(datePublished).toISOString();
+  const imgUrl = getImageUrl(doc, siteUrl);
+  if (imgUrl)
+    ld.image = imgUrl;
+  ld.author = { "@type": "Organization", name, url: siteUrl };
+  const publisher = { "@type": "Organization", name };
+  if (publisherLogo !== undefined) {
+    if (publisherLogo !== null)
+      publisher.logo = { "@type": "ImageObject", url: publisherLogo };
+  }
+  ld.publisher = publisher;
+  return ld;
+}
+function buildBreadcrumbsLd({
+  items,
+  currentUrl
+}) {
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.label,
+      item: index === items.length - 1 ? currentUrl : item.url
+    }))
+  };
+}
+function buildOrganizationLd({
+  siteUrl,
+  name,
+  logo,
+  sameAs
+}) {
+  const org = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    "@id": `${siteUrl}#organization`,
+    url: siteUrl,
+    ...name && { name },
+    ...logo && { logo: { "@type": "ImageObject", url: logo } },
+    ...sameAs && sameAs.length > 0 && { sameAs }
+  };
+  return org;
+}
+
+// src/render/metadata/slug.ts
+var SLUG_NESTED_DIVIDER = "_";
+function segmentsToStoredSlug(segments, nested) {
+  if (!Array.isArray(segments))
+    return segments;
+  if (nested)
+    return segments.join(SLUG_NESTED_DIVIDER);
+  return segments[0] ?? "";
+}
+function segmentsToUrlPath(segments, nested) {
+  if (!Array.isArray(segments))
+    return "/" + segments;
+  if (nested)
+    return "/" + segments.join("/");
+  return "/" + (segments[0] ?? "");
+}
+function storedSlugToSegments(storedSlug, nested) {
+  if (nested)
+    return storedSlug.split(SLUG_NESTED_DIVIDER);
+  return storedSlug;
+}
+function buildCanonicalUrl({
+  siteUrl,
+  locale,
+  urlPrefix,
+  urlPath
+}) {
+  const trimmedPrefix = urlPrefix.replace(/^\/|\/$/g, "");
+  const prefixSegment = trimmedPrefix ? `/${trimmedPrefix}` : "";
+  return `${siteUrl}/${locale}${prefixSegment}${urlPath}`;
+}
+function getUrlPath(segments, nested, homeSlug) {
+  const urlPath = segmentsToUrlPath(segments, nested);
+  if (nested && !Array.isArray(segments)) {
+    if (segments === homeSlug)
+      return "/";
+  } else if (nested && Array.isArray(segments)) {
+    const stored = segments.join(SLUG_NESTED_DIVIDER);
+    if (stored === homeSlug)
+      return "/";
+  }
+  return urlPath;
+}
+
+// src/render/metadata/query.ts
+import { getPayload } from "payload";
+import { cache } from "react";
+var queryDocBySlug = cache(async function queryDocBySlug2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft,
+    limit: 1,
+    pagination: false,
+    overrideAccess: draft,
+    where: { [slugField]: { equals: slug } },
+    locale
+  });
+  return result.docs?.[0] ?? null;
+});
+var queryAllDocs = cache(async function queryAllDocs2({
+  collectionSlug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1000,
+    pagination: false,
+    overrideAccess: false,
+    select: { [slugField]: true },
+    locale
+  });
+  return result.docs ?? [];
+});
+var queryAllLocaleSlugs = cache(async function queryAllLocaleSlugs2({
+  collectionSlug,
+  slug,
+  slugField = "slug",
+  locale,
+  config
+}) {
+  const payload = await getPayload({ config });
+  const result = await payload.find({
+    collection: collectionSlug,
+    draft: false,
+    limit: 1,
+    pagination: false,
+    overrideAccess: false,
+    locale,
+    where: { [slugField]: { equals: slug } },
+    select: { [slugField]: true }
+  });
+  const doc = result.docs?.[0];
+  if (!doc)
+    return;
+  const fieldValue = doc?.[slugField];
+  if (fieldValue && typeof fieldValue === "object") {
+    return fieldValue;
+  }
+  const resolved = await config;
+  const rawLocales = Array.isArray(resolved?.localization?.localeCodes) ? resolved.localization.localeCodes : resolved?.localization?.locales?.map((l) => l.code) ?? [];
+  const out = {};
+  for (const l of rawLocales)
+    out[l] = String(fieldValue ?? slug);
+  return out;
+});
+var queryGlobal = cache(async function queryGlobal2({
+  globalSlug,
+  locale,
+  depth = 0,
+  draft = false,
+  config
+}) {
+  const payload = await getPayload({ config });
+  try {
+    const global = await payload.findGlobal({
+      slug: globalSlug,
+      depth,
+      draft,
+      locale
+    });
+    return global;
+  } catch {
+    return null;
+  }
+});
+function getRenderModuleExports(exportName, collection, importMap) {
+  const path = collection?.custom?.path;
+  if (!path)
+    return;
+  const mod = getFromImportMap(path, importMap);
+  return mod?.[exportName];
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { RichText } from "@payloadcms/richtext-lexical/react";
+
+// src/core/utils/generateImportName.ts
+function generateImportName(type, slug) {
+  switch (type) {
+    case "block":
+      return `Block${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
+    case "page":
+      return `Page${slug.replace(/(^\w|-\w)/g, (m) => m.replace("-", "").toUpperCase())}#default`;
+    default:
+      throw new Error(`Unknown type: ${type}`);
+  }
+}
+
+// src/render/blocks/renderBlocks.tsx
+import { jsx as jsx2, Fragment } from "react/jsx-runtime";
+var RenderBlocks = ({
+  blocks,
+  blockProps,
+  config,
+  importMap,
+  locale,
+  searchParams
+}) => {
+  if (!blocks || !Array.isArray(blocks) || blocks.length === 0)
+    return null;
+  const rendered = [];
+  for (let i = 0;i < blocks.length; i++) {
+    const block = blocks[i];
+    const { blockType } = block;
+    const importMapPath = config.admin?.dependencies?.[blockType]?.path ?? generateImportName("block", blockType);
+    const Block = getFromImportMap(importMapPath, importMap);
+    if (!Block) {
+      console.warn(`No block found for type: ${blockType}, config.admin?.dependencies?.[blockType]: ${config.admin?.dependencies?.[blockType]}`);
+      continue;
+    }
+    rendered.push(/* @__PURE__ */ jsx2(Block, {
+      index: i,
+      ...blockProps,
+      ...block,
+      locale,
+      searchParams
+    }, i));
+  }
+  return /* @__PURE__ */ jsx2(Fragment, {
+    children: rendered
+  });
+};
+
+// src/render/pages/PagesPage.tsx
+import { jsx as jsx3, Fragment as Fragment2 } from "react/jsx-runtime";
+async function PagesPage({ doc, ...props }) {
+  if (!doc)
+    return /* @__PURE__ */ jsx3(Fragment2, {});
+  const blocks = doc.blocks ?? [];
+  return /* @__PURE__ */ jsx3(Fragment2, {
+    children: /* @__PURE__ */ jsx3(RenderBlocks, {
+      blocks,
+      ...props
+    })
+  });
+}
+
+// src/render/pages/createCollectionPageExports.tsx
+import { jsx as jsx6, jsxs as jsxs3, Fragment as Fragment4 } from "react/jsx-runtime";
+var HOME_SLUG = "";
+function createCollectionPageExports({
+  slug = "pages",
+  config: configPromise,
+  routing,
+  importMap: importMapArg,
+  renderPath
+}, deps, options = {}) {
+  const importMap = importMapArg ?? {};
+  const { jsonLd: jsonLdOption = true, changefreq = "weekly", priority = 0.5, websiteName } = options;
+  const {
+    getServerSideURL,
+    generateMeta,
+    metadataType: metadataTypeOverride,
+    showcase: showcaseOption,
+    homeExtras
+  } = deps;
+  const showcaseEnabled = showcaseOption?.enabled === true;
+  const { metadataHeading, jsonLdHeading } = showcaseOption ?? {};
+  const locales = routing.locales;
+  const defaultLocale = routing.defaultLocale;
+  const metadataType = metadataTypeOverride ?? (slug === POSTS_SLUG ? "article" : "website");
+  const defaultRenderPath = slug === POSTS_SLUG ? POSTS_RENDER_PATH : PAGES_RENDER_PATH;
+  const localePrefixMode = typeof routing.localePrefix === "string" ? routing.localePrefix : routing.localePrefix?.mode ?? "always";
+  const buildLocalePath = (locale, storedSlug) => {
+    const urlPath = getUrlPath(storedSlug, false, HOME_SLUG);
+    if (localePrefixMode === "never")
+      return urlPath;
+    if (localePrefixMode === "as-needed" && locale === defaultLocale)
+      return urlPath;
+    return `/${locale}${urlPath}`;
+  };
+  async function fetchDoc(locale, storedSlug, draft = false) {
+    return queryDocBySlug({
+      collectionSlug: slug,
+      slug: storedSlug,
+      locale,
+      draft,
+      config: configPromise
+    });
+  }
+  async function resolveHreflangAlternates(locale, storedSlug) {
+    const siteUrl = getServerSideURL();
+    const urlPath = buildLocalePath(locale, storedSlug);
+    const canonical = `${siteUrl}${urlPath}`;
+    const languages = await buildHreflangAlternates({
+      siteUrl,
+      locale,
+      urlPrefix: "",
+      storedSlug,
+      nested: false,
+      homeSlug: HOME_SLUG,
+      defaultLocale,
+      locales,
+      localePrefix: localePrefixMode,
+      queryAllLocaleSlugs: (s, l) => queryAllLocaleSlugs({ collectionSlug: slug, slug: s, slugField: "slug", locale: l, config: configPromise })
+    });
+    const alternates = {};
+    for (const [key, url] of Object.entries(languages)) {
+      alternates[key] = url;
+    }
+    return { alternates, canonical };
+  }
+  const default_ = async (props) => {
+    const { slug: rawSlugSegments, locale: incomingLocale } = await props.params ?? {};
+    const slugSegments = Array.isArray(rawSlugSegments) ? rawSlugSegments : [];
+    const locale = typeof incomingLocale === "string" ? incomingLocale : defaultLocale;
+    if (!locales.includes(locale)) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const { setRequestLocale } = await import("next-intl/server");
+    setRequestLocale(locale);
+    const { draftMode } = await import("next/headers");
+    const { isEnabled: draft } = await draftMode();
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const doc = await fetchDoc(locale, storedSlug, draft);
+    if (!doc) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const cfg = await configPromise;
+    const collectionCustomPath = cfg.collections.find((c) => c.slug === slug)?.custom?.path;
+    const effectivePath = renderPath ?? collectionCustomPath ?? defaultRenderPath;
+    const render = effectivePath === PAGES_RENDER_PATH ? /* @__PURE__ */ jsx6(PagesPage, {
+      doc,
+      importMap,
+      config: cfg,
+      locale
+    }) : effectivePath === POSTS_RENDER_PATH ? doc ? await renderPostBody(doc, locale) : null : renderCollectionModule(cfg.collections, slug, importMap, {
+      ...props,
+      config: cfg,
+      locale,
+      searchParams: props.searchParams,
+      doc
+    });
+    const jsonLdNodes = doc ? await generateJsonLd(slugSegments, doc, locale) : [];
+    const { alternates: hreflangAlternates, canonical } = await resolveHreflangAlternates(locale, storedSlug);
+    console.log("render", { render, doc });
+    const inner = /* @__PURE__ */ jsxs3(Fragment4, {
+      children: [
+        jsonLdNodes.map(({ id, schema }) => /* @__PURE__ */ jsx6("script", {
+          type: "application/ld+json",
+          dangerouslySetInnerHTML: { __html: JSON.stringify(schema) }
+        }, id)),
+        render,
+        draft ? (() => {
+          const ResolvedListener = importMap?.[LIVE_PREVIEW_LISTENER_PATH];
+          if (!ResolvedListener)
+            return null;
+          return /* @__PURE__ */ jsx6(Suspense, {
+            fallback: null,
+            children: /* @__PURE__ */ jsx6(ResolvedListener, {})
+          });
+        })() : null,
+        storedSlug === HOME_SLUG && homeExtras ? await homeExtras({ locale, doc }) : null
+      ]
+    });
+    if (!showcaseEnabled || !doc)
+      return inner;
+    const { PageShowcase: PageShowcase2 } = await Promise.resolve().then(() => (init_PageShowcase(), exports_PageShowcase));
+    const { LocaleSwitcher: LocaleSwitcher2 } = await Promise.resolve().then(() => (init_LocaleSwitcher(), exports_LocaleSwitcher));
+    const meta = await generateMeta({
+      doc,
+      url: canonical,
+      type: metadataType,
+      locale
+    });
+    return /* @__PURE__ */ jsx6(PageShowcase2, {
+      metadata: meta,
+      metadataHeading,
+      jsonLdHeading,
+      jsonLd: jsonLdNodes,
+      localeSwitcher: /* @__PURE__ */ jsx6(LocaleSwitcher2, {
+        currentLocale: locale,
+        hreflangAlternates,
+        labels: routing.labels
+      }),
+      children: inner
+    });
+  };
+  async function generateMetadata(props) {
+    const cfg = await configPromise;
+    const { slug: rawSlugSegments, locale: incomingLocale } = await props.params ?? {};
+    const slugSegments = Array.isArray(rawSlugSegments) ? rawSlugSegments : [];
+    const locale = typeof incomingLocale === "string" ? incomingLocale : defaultLocale;
+    if (!locales.includes(locale))
+      return { title: "Not found", robots: { index: false, follow: false } };
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const doc = await fetchDoc(locale, storedSlug);
+    if (!doc)
+      return { title: "Not found", robots: { index: false, follow: false } };
+    const collection = cfg.collections.find((c) => c.slug === slug);
+    if (!collection)
+      return {};
+    const { canonical, alternates } = await resolveHreflangAlternates(locale, storedSlug);
+    const meta = await generateMeta({
+      doc,
+      url: canonical,
+      type: metadataType,
+      locale
+    });
+    meta.alternates = {
+      canonical,
+      languages: Object.keys(alternates).length ? alternates : undefined
+    };
+    return meta;
+  }
+  async function generateJsonLd(slugSegments, doc, locale) {
+    if (jsonLdOption === false || !doc)
+      return [];
+    const siteUrl = getServerSideURL();
+    const storedSlug = segmentsToStoredSlug(slugSegments, false);
+    const urlPath = buildLocalePath(locale, storedSlug);
+    const canonical = `${siteUrl}${urlPath}`;
+    const entries = Array.isArray(jsonLdOption) ? jsonLdOption : metadataType === "article" ? [{ type: "article" }] : [{ type: "website" }];
+    const outputs = [];
+    for (const entry of entries) {
+      const id = entry.id ?? `jsonld-${entry.type}-${outputs.length}`;
+      let schema = null;
+      switch (entry.type) {
+        case "article": {
+          const articleOpts = {
+            doc,
+            url: canonical,
+            locale,
+            siteUrl,
+            type: entry.schemaType ?? "BlogPosting"
+          };
+          if (entry.publisherName !== undefined)
+            articleOpts.publisherName = entry.publisherName;
+          if (entry.publisherLogo !== undefined)
+            articleOpts.publisherLogo = entry.publisherLogo;
+          schema = buildArticleLd(articleOpts);
+          break;
+        }
+        case "website": {
+          schema = {
+            "@context": "https://schema.org",
+            "@type": "WebSite",
+            "@id": `${siteUrl}#website`,
+            url: siteUrl,
+            name: entry.name ?? websiteName ?? new URL(siteUrl).hostname,
+            ...entry.alternateName ? { alternateName: entry.alternateName } : {},
+            inLanguage: locale
+          };
+          break;
+        }
+        case "organization": {
+          schema = buildOrganizationLd({
+            siteUrl,
+            name: entry.name,
+            logo: entry.logo,
+            sameAs: entry.sameAs
+          });
+          break;
+        }
+        case "breadcrumbs": {
+          let items = entry.items ?? [];
+          if (!items.length && entry.buildItems)
+            items = entry.buildItems(doc, canonical);
+          if (items.length > 0)
+            schema = buildBreadcrumbsLd({ items, currentUrl: canonical });
+          break;
+        }
+        case "custom": {
+          schema = entry.build({ doc, url: canonical, locale, siteUrl });
+          break;
+        }
+      }
+      if (schema)
+        outputs.push({ id, schema });
+    }
+    return outputs;
+  }
+  async function generateStaticParams() {
+    const params = [];
+    for (const locale of locales) {
+      const docs = await queryAllDocs({ collectionSlug: slug, slugField: "slug", locale, config: configPromise });
+      for (const doc of docs) {
+        const slugVal = doc.slug;
+        if (typeof slugVal !== "string" || slugVal === "")
+          continue;
+        const segments = storedSlugToSegments(slugVal, false);
+        params.push({ slug: Array.isArray(segments) ? segments : [segments], locale });
+      }
+    }
+    return params;
+  }
+  async function generateSitemap() {
+    const docs = await queryAllDocs({
+      collectionSlug: slug,
+      slugField: "slug",
+      locale: defaultLocale,
+      config: configPromise
+    });
+    const siteUrl = getServerSideURL().replace(/\/$/, "");
+    const urls = [];
+    for (const doc of docs) {
+      const slugVal = doc.slug;
+      if (typeof slugVal !== "string" || slugVal === "")
+        continue;
+      for (const locale of locales) {
+        const urlPath = buildLocalePath(locale, slugVal);
+        const updatedAt = doc.updatedAt;
+        const lastmod = typeof updatedAt === "string" ? new Date(updatedAt).toISOString() : undefined;
+        urls.push({ url: `${siteUrl}${urlPath}`, lastModified: lastmod, changeFrequency: changefreq, priority });
+      }
+    }
+    return urls;
+  }
+  return {
+    default: default_,
+    generateMetadata,
+    generateStaticParams,
+    generateSitemap,
+    generateJsonLd
+  };
+}
+function addCollectionsToSitemap(exports) {
+  async function buildSitemap() {
+    const all = await Promise.all(exports.map((e) => e.generateSitemap()));
+    return all.flat();
+  }
+  return { default: buildSitemap, generateSitemap: buildSitemap };
+}
+async function renderPostBody(doc, locale) {
+  const typedDoc = doc;
+  const title = typedDoc.title ?? "";
+  const excerpt = typedDoc.excerpt ?? null;
+  const content = typedDoc.content;
+  return /* @__PURE__ */ jsxs3("article", {
+    className: "posts-page prose prose-neutral dark:prose-invert mx-auto max-w-3xl py-10",
+    children: [
+      /* @__PURE__ */ jsxs3("header", {
+        className: "posts-page__header not-prose mb-8",
+        children: [
+          /* @__PURE__ */ jsx6("h1", {
+            className: "posts-page__title text-4xl font-semibold tracking-tight",
+            children: title
+          }),
+          excerpt ? /* @__PURE__ */ jsx6("p", {
+            className: "posts-page__excerpt mt-3 text-lg text-muted-foreground",
+            children: excerpt
+          }) : null
+        ]
+      }),
+      content ? /* @__PURE__ */ jsx6("div", {
+        className: "posts-page__content",
+        children: /* @__PURE__ */ jsx6(RichText, {
+          data: content
+        })
+      }) : null
+    ]
+  });
+}
+
+// src/render/pages/createRootLayoutExports.tsx
+import"server-only";
+
+// src/render/utils/renderGlobalModule.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function renderGlobalModule(globals = [], slug, importMap, props) {
+  const renderPath = globals?.find((g) => g.slug === slug)?.custom?.path;
+  if (!renderPath)
+    return null;
+  const GlobalRenderModule = getFromImportMap(renderPath, importMap);
+  if (!GlobalRenderModule) {
+    if (false) {}
+    return null;
+  }
+  return /* @__PURE__ */ jsx7(GlobalRenderModule, {
+    importMap,
+    ...props
+  });
+}
+
+// src/render/pages/createRootLayoutExports.tsx
+import { jsx as jsx8, jsxs as jsxs4, Fragment as Fragment5 } from "react/jsx-runtime";
+function createRootLayoutExports(args) {
+  const { config: configPromise, routing, importMap = {}, providers, head, htmlAttrs } = args;
+  async function RootLayout({
+    children,
+    params
+  }) {
+    const { locale } = await params;
+    if (!routing.locales.includes(locale)) {
+      const { notFound } = await import("next/navigation");
+      notFound();
+    }
+    const { setRequestLocale, getMessages } = await import("next-intl/server");
+    setRequestLocale(locale);
+    const messages = await getMessages();
+    const { draftMode: nextDraftMode } = await import("next/headers");
+    const { isEnabled: draftMode } = await nextDraftMode();
+    const cfg = await configPromise;
+    const [headerData, footerData] = await Promise.all([
+      queryGlobal({ globalSlug: "header", locale, depth: 0, config: configPromise }),
+      queryGlobal({ globalSlug: "footer", locale, depth: 0, config: configPromise })
+    ]);
+    const headerEl = renderGlobalModule(cfg.globals, "header", importMap, {
+      data: headerData,
+      locale
+    });
+    const footerEl = renderGlobalModule(cfg.globals, "footer", importMap, {
+      data: footerData,
+      locale
+    });
+    const htmlAttributeOverrides = htmlAttrs?.(locale) ?? {};
+    const mergedHtmlAttrs = {
+      lang: locale,
+      suppressHydrationWarning: true,
+      ...htmlAttributeOverrides
+    };
+    const providersArgs = {
+      children: /* @__PURE__ */ jsxs4(Fragment5, {
+        children: [
+          headerEl,
+          children,
+          footerEl
+        ]
+      }),
+      locale,
+      messages,
+      draftMode
+    };
+    return /* @__PURE__ */ jsxs4("html", {
+      ...mergedHtmlAttrs,
+      children: [
+        /* @__PURE__ */ jsx8("head", {
+          children: head?.()
+        }),
+        /* @__PURE__ */ jsx8("body", {
+          children: providers ? providers(providersArgs) : children
+        })
+      ]
+    });
+  }
+  return {
+    default: RootLayout,
+    generateStaticParams: () => routing.locales.map((locale) => ({ locale }))
+  };
+}
+
+// src/render/pages/createStaticPageExports.tsx
+import"server-only";
+
+// src/core/access/index.ts
+var anyone = () => true;
+var authenticated = ({ req: { user } }) => Boolean(user);
+var authenticatedOrPublished = ({ req: { user } }) => {
+  if (user)
+    return true;
+  return { _status: { equals: "published" } };
+};
+
+// src/render/_locale.ts
+function prefixFor(locale, defaultLocale, mode) {
+  if (mode === "never")
+    return "";
+  if (mode === "as-needed" && locale === defaultLocale)
+    return "";
+  return `/${locale}`;
+}
+function resolveLocale(req) {
+  if (!req || typeof req !== "object")
+    return "";
+  const r = req;
+  if (typeof r.locale === "string" && r.locale.length > 0)
+    return r.locale;
+  const fallback = r.payload?.config?.localization?.defaultLocale;
+  if (typeof fallback === "string" && fallback.length > 0)
+    return fallback;
+  return "";
+}
+function allLocales(req) {
+  if (!req || typeof req !== "object")
+    return [];
+  const r = req;
+  const list = r.payload?.config?.localization?.locales;
+  if (!Array.isArray(list) || list.length === 0)
+    return [];
+  const out = [];
+  for (const entry of list) {
+    if (typeof entry === "string" && entry.length > 0) {
+      out.push(entry);
+    } else if (entry && typeof entry === "object" && "code" in entry) {
+      const code = entry.code;
+      if (typeof code === "string" && code.length > 0)
+        out.push(code);
+    }
+  }
+  return out;
+}
+
+// src/render/hooks/_shared.ts
+var cachePromise = null;
+function nextCacheImport() {
+  return cachePromise ??= import("next/cache");
+}
+function shouldSkipRevalidate(context) {
+  return Boolean(context?.disableRevalidate);
+}
+async function safeRevalidatePath(payload, path) {
+  try {
+    const { revalidatePath } = await nextCacheImport();
+    revalidatePath(path);
+  } catch (error) {
+    payload.logger.error(`revalidatePath("${path}") failed: ${String(error)}`);
+  }
+}
+async function safeRevalidateTag(payload, tag, profile = "max") {
+  try {
+    const { revalidateTag } = await nextCacheImport();
+    revalidateTag(tag, profile);
+  } catch (error) {
+    payload.logger.error(`revalidateTag("${tag}") failed: ${String(error)}`);
+  }
+}
+
+// src/render/hooks/revalidateCollection.ts
+function createRevalidateCollectionHook(options) {
+  const {
+    collectionSlug,
+    urlPathPrefix = "",
+    sitemapTag,
+    localePrefix: modeOption,
+    defaultLocale: defaultLocaleOption,
+    pathMode = "url"
+  } = options;
+  const resolvedSitemapTag = sitemapTag === false ? false : sitemapTag ?? `${collectionSlug}-sitemap`;
+  const resolveDefaults = (req) => {
+    const mode = modeOption ?? "always";
+    const defaultLocale = defaultLocaleOption ?? req?.payload?.config?.localization?.defaultLocale ?? "";
+    return { mode, defaultLocale };
+  };
+  const localesToFanOut = (req) => {
+    const all = allLocales(req);
+    if (all.length > 0)
+      return all;
+    const single = resolveLocale(req);
+    return single ? [single] : [];
+  };
+  const collectionPath = (slug, locale, mode, defaultLocale) => {
+    const prefix = prefixFor(locale, defaultLocale, mode);
+    if (!slug)
+      return `${prefix}${urlPathPrefix}` || "/";
+    return `${prefix}${urlPathPrefix}/${slug}`;
+  };
+  const fanOutPaths = async (payload, req, slug, label) => {
+    const { mode, defaultLocale } = resolveDefaults(req);
+    const locales = localesToFanOut(req);
+    for (const locale of locales) {
+      const path = collectionPath(slug, locale, mode, defaultLocale);
+      payload.logger.info?.(`${label} ${path}`);
+      await safeRevalidatePath(payload, path);
+    }
+  };
+  const fireCollectionTags = async (payload, docId, req) => {
+    if (typeof docId === "string" || typeof docId === "number") {
+      await safeRevalidateTag(payload, `collection_${collectionSlug}_${docId}`);
+    }
+    if (resolvedSitemapTag !== false) {
+      await safeRevalidateTag(payload, resolvedSitemapTag);
+    }
+  };
+  const afterChange = async ({ doc, previousDoc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc;
+    const { payload } = req;
+    const typed = doc;
+    const prev = previousDoc;
+    const isPublished = typed._status === "published";
+    const wasPublished = prev?._status === "published";
+    const prevSlugIsString = typeof prev?.slug === "string";
+    const slugChanged = prevSlugIsString && prev?.slug !== typed.slug;
+    if (isPublished) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, typed.slug, `Revalidating ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    if (wasPublished && (!isPublished || slugChanged)) {
+      if (pathMode !== "tag-only") {
+        await fanOutPaths(payload, req, prev?.slug, `Revalidating old ${collectionSlug} at path:`);
+      }
+      await fireCollectionTags(payload, typed.id, req);
+    }
+    return doc;
+  };
+  const afterDelete = async ({ doc, req }) => {
+    if (shouldSkipRevalidate(req.context))
+      return doc ?? null;
+    const { payload } = req;
+    const typed = doc;
+    if (pathMode !== "tag-only") {
+      await fanOutPaths(payload, req, typed?.slug, `Revalidating deleted ${collectionSlug} at path:`);
+    }
+    await fireCollectionTags(payload, typed?.id, req);
+    return doc ?? null;
+  };
+  return { afterChange, afterDelete };
+}
+var createRevalidatePageHooks = (opts = {}) => createRevalidateCollectionHook({
+  collectionSlug: "pages",
+  urlPathPrefix: "",
+  ...opts
+});
+
+// src/data/collections/StaticPages/index.ts
+var createStaticPagesCollection = (blocks) => {
+  const { afterChange, afterDelete } = createRevalidateCollectionHook({
+    collectionSlug: STATIC_PAGES_SLUG,
+    pathMode: "tag-only",
+    sitemapTag: "static-pages"
+  });
+  return {
+    slug: STATIC_PAGES_SLUG,
+    dbName: "sp",
+    admin: { group: "System", useAsTitle: "title" },
+    access: {
+      create: authenticated,
+      delete: authenticated,
+      read: authenticatedOrPublished,
+      update: authenticated
+    },
+    fields: [
+      {
+        name: "kind",
+        type: "select",
+        required: true,
+        unique: true,
+        index: true,
+        options: [
+          { label: "Not found (404)", value: "not-found" },
+          { label: "Server error (500)", value: "server-error" },
+          { label: "Search empty", value: "search-empty" },
+          { label: "Offline", value: "offline" }
+        ],
+        admin: {
+          position: "sidebar",
+          description: "Which system page this row powers. One row per kind."
+        }
+      },
+      {
+        name: "title",
+        type: "text",
+        required: true,
+        localized: true,
+        admin: { description: "Admin-only label. Not rendered." }
+      },
+      {
+        type: "tabs",
+        tabs: [
+          {
+            fields: [
+              {
+                name: "blocks",
+                type: "blocks",
+                localized: true,
+                blocks,
+                admin: { initCollapsed: true },
+                dbName: "b"
+              }
+            ],
+            label: "Content"
+          }
+        ]
+      },
+      {
+        name: "publishedAt",
+        type: "date",
+        admin: { position: "sidebar" }
+      }
+    ],
+    hooks: {
+      afterChange: [afterChange],
+      afterDelete: [afterDelete]
+    },
+    versions: { drafts: { autosave: { interval: 1000 } } }
+  };
+};
+
+// src/render/pages/createStaticPageExports.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function createStaticPageExports({
+  kind = "not-found",
+  config: configPromise,
+  importMap: importMapArg
+}) {
+  const importMap = importMapArg ?? {};
+  const default_ = async () => {
+    const { getLocale } = await import("next-intl/server");
+    const locale = await getLocale();
+    const doc = await queryDocBySlug({
+      collectionSlug: STATIC_PAGES_SLUG,
+      slug: kind,
+      slugField: "kind",
+      locale,
+      config: configPromise
+    });
+    if (!doc) {
+      console.warn("[createStaticPageExports] !doc: STATIC_PAGES_SLUG=", STATIC_PAGES_SLUG, "slug:" + kind);
+      return /* @__PURE__ */ jsx9("section", {
+        children: /* @__PURE__ */ jsx9("h1", {
+          children: "404"
+        })
+      });
+    }
+    const cfg = await configPromise;
+    return /* @__PURE__ */ jsx9(PagesPage, {
+      doc,
+      locale,
+      importMap,
+      config: cfg
+    });
+  };
+  return { default: default_ };
+}
+
+// src/exports/render-pages.ts
+init_PageShowcase();
+
+// src/render/pages/PostsPage.tsx
+import { RichText as RichText2 } from "@payloadcms/richtext-lexical/react";
+import { jsx as jsx10, jsxs as jsxs5, Fragment as Fragment6 } from "react/jsx-runtime";
+async function PostsPage({ doc, locale, importMap: _importMap }) {
+  if (!doc)
+    return /* @__PURE__ */ jsx10(Fragment6, {});
+  const title = readText(doc.title, locale);
+  const excerpt = readText(doc.excerpt, locale);
+  const content = doc.content;
+  return /* @__PURE__ */ jsxs5("article", {
+    className: "posts-page prose prose-neutral dark:prose-invert mx-auto max-w-3xl py-10",
+    children: [
+      /* @__PURE__ */ jsxs5("header", {
+        className: "posts-page__header not-prose mb-8",
+        children: [
+          /* @__PURE__ */ jsx10("h1", {
+            className: "posts-page__title text-4xl font-semibold tracking-tight",
+            children: title
+          }),
+          excerpt ? /* @__PURE__ */ jsx10("p", {
+            className: "posts-page__excerpt mt-3 text-lg text-muted-foreground",
+            children: excerpt
+          }) : null
+        ]
+      }),
+      content ? /* @__PURE__ */ jsx10("div", {
+        className: "posts-page__content",
+        children: /* @__PURE__ */ jsx10(RichText2, {
+          data: content
+        })
+      }) : null
+    ]
+  });
+}
+function readText(value, preferredLocale) {
+  if (typeof value !== "string")
+    return "";
+  if (!value.startsWith("{"))
+    return value;
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "string")
+      return parsed;
+    if (parsed && typeof parsed === "object") {
+      const obj = parsed;
+      if (preferredLocale && typeof obj[preferredLocale] === "string" && obj[preferredLocale].length > 0) {
+        return obj[preferredLocale];
+      }
+      const first = Object.values(obj).find((v) => typeof v === "string" && v.length > 0);
+      return typeof first === "string" ? first : value;
+    }
+    return value;
+  } catch {
+    return value;
+  }
+}
+
+// src/render/pages/HeaderPage.tsx
+import"server-only";
+import { jsx as jsx11, jsxs as jsxs6, Fragment as Fragment7 } from "react/jsx-runtime";
+function HeaderPage({ data, locale: _locale }) {
+  if (!data)
+    return /* @__PURE__ */ jsx11(Fragment7, {});
+  const nav = data.nav ?? [];
+  const items = nav.filter((b) => b.blockType === "navItem");
+  const columns = nav.filter((b) => b.blockType === "navColumn");
+  const renderLink = (link, fallbackHref = "#") => {
+    if (!link)
+      return /* @__PURE__ */ jsx11("a", {
+        href: fallbackHref,
+        children: link?.label ?? ""
+      });
+    if (link.type === "custom" && typeof link.url === "string") {
+      return /* @__PURE__ */ jsx11("a", {
+        href: link.url,
+        children: link.label
+      });
+    }
+    if (link.type === "reference" && link.reference) {
+      const ref = link.reference;
+      if (typeof ref === "object" && ref.slug) {
+        return /* @__PURE__ */ jsx11("a", {
+          href: `/${ref.slug}`,
+          children: link.label
+        });
+      }
+    }
+    return /* @__PURE__ */ jsx11("a", {
+      href: fallbackHref,
+      children: link.label ?? ""
+    });
+  };
+  return /* @__PURE__ */ jsxs6("nav", {
+    children: [
+      items.map((item, i) => /* @__PURE__ */ jsx11("span", {
+        style: { marginRight: 16 },
+        children: renderLink(item.link)
+      }, `item-${i}`)),
+      columns.map((col, i) => /* @__PURE__ */ jsxs6("div", {
+        style: { display: "inline-block", marginRight: 24, verticalAlign: "top" },
+        children: [
+          col.title ? /* @__PURE__ */ jsx11("strong", {
+            children: col.title
+          }) : null,
+          /* @__PURE__ */ jsx11("div", {
+            children: (col.links ?? []).map((entry, j) => /* @__PURE__ */ jsx11("div", {
+              children: renderLink(entry.link)
+            }, `col-${i}-link-${j}`))
+          })
+        ]
+      }, `col-${i}`))
+    ]
+  });
+}
+
+// src/render/pages/FooterPage.tsx
+import"server-only";
+import { jsx as jsx12, jsxs as jsxs7, Fragment as Fragment8 } from "react/jsx-runtime";
+function FooterPage({ data, locale: _locale }) {
+  if (!data)
+    return /* @__PURE__ */ jsx12(Fragment8, {});
+  const nav = data.nav ?? [];
+  const items = nav.filter((b) => b.blockType === "navItem");
+  const columns = nav.filter((b) => b.blockType === "navColumn");
+  const renderLink = (link, fallbackHref = "#") => {
+    if (!link)
+      return /* @__PURE__ */ jsx12("a", {
+        href: fallbackHref,
+        children: link?.label ?? ""
+      });
+    if (link.type === "custom" && typeof link.url === "string") {
+      return /* @__PURE__ */ jsx12("a", {
+        href: link.url,
+        children: link.label
+      });
+    }
+    if (link.type === "reference" && link.reference) {
+      const ref = link.reference;
+      if (typeof ref === "object" && ref.slug) {
+        return /* @__PURE__ */ jsx12("a", {
+          href: `/${ref.slug}`,
+          children: link.label
+        });
+      }
+    }
+    return /* @__PURE__ */ jsx12("a", {
+      href: fallbackHref,
+      children: link.label ?? ""
+    });
+  };
+  return /* @__PURE__ */ jsx12("footer", {
+    children: /* @__PURE__ */ jsxs7("div", {
+      children: [
+        items.map((item, i) => /* @__PURE__ */ jsx12("span", {
+          style: { marginRight: 16 },
+          children: renderLink(item.link)
+        }, `item-${i}`)),
+        columns.map((col, i) => /* @__PURE__ */ jsxs7("div", {
+          style: { display: "inline-block", marginRight: 24, verticalAlign: "top" },
+          children: [
+            col.title ? /* @__PURE__ */ jsx12("strong", {
+              children: col.title
+            }) : null,
+            /* @__PURE__ */ jsx12("div", {
+              children: (col.links ?? []).map((entry, j) => /* @__PURE__ */ jsx12("div", {
+                children: renderLink(entry.link)
+              }, `col-${i}-link-${j}`))
+            })
+          ]
+        }, `col-${i}`))
+      ]
+    })
+  });
+}
+
+// src/exports/render-pages.ts
+var PageShowcase2 = PageShowcase;
+var render_pages_default = {
+  addCollectionsToSitemap,
+  createCollectionPageExports,
+  createRootLayoutExports,
+  createStaticPageExports,
+  HeaderPage,
+  FooterPage,
+  PagesPage,
+  PostsPage,
+  PageShowcase: PageShowcase2
+};
+export {
+  render_pages_default as default,
+  createStaticPageExports,
+  createRootLayoutExports,
+  createCollectionPageExports,
+  addCollectionsToSitemap,
+  PostsPage,
+  PagesPage,
+  PageShowcase2 as PageShowcase,
+  HeaderPage,
+  FooterPage
+};