@treeseed/core 0.1.2

package/dist/vendor/starlight/utils/gitInlined.js

@@ -0,0 +1,13 @@
+const makeAPI = (data) => {
+  const trackedDocsFiles = new Map(data);
+  return {
+    getNewestCommitDate: (file) => {
+      const timestamp = trackedDocsFiles.get(file);
+      if (!timestamp) throw new Error(`Failed to retrieve the git history for file "${file}"`);
+      return new Date(timestamp);
+    }
+  };
+};
+export {
+  makeAPI
+};

package/dist/vendor/starlight/utils/head.js

@@ -0,0 +1,156 @@
+import config from "virtual:starlight/user-config";
+import project from "virtual:starlight/project-context";
+import { version } from "../package.json.js";
+import { HeadConfigSchema } from "../schemas/head.js";
+import { fileWithBase } from "./base.js";
+import { formatCanonical } from "./canonical.js";
+import { localizedUrl } from "./localizedUrl.js";
+import { isAbsoluteUrl } from "./url.js";
+const HeadSchema = HeadConfigSchema({ source: "content" });
+function getHead({ entry, lang }, context, siteTitle) {
+  const { data } = entry;
+  const canonical = context.site ? new URL(context.url.pathname, context.site) : void 0;
+  const canonicalHref = canonical?.href ? formatCanonical(canonical.href, {
+    format: project.build.format,
+    trailingSlash: project.trailingSlash
+  }) : void 0;
+  const description = data.description || config.description;
+  const headDefaults = [
+    { tag: "meta", attrs: { charset: "utf-8" } },
+    {
+      tag: "meta",
+      attrs: { name: "viewport", content: "width=device-width, initial-scale=1" }
+    },
+    { tag: "title", content: `${data.title} ${config.titleDelimiter} ${siteTitle}` },
+    ...canonicalHref !== void 0 ? [{ tag: "link", attrs: { rel: "canonical", href: canonicalHref } }] : [],
+    { tag: "meta", attrs: { name: "generator", content: context.generator } },
+    {
+      tag: "meta",
+      attrs: { name: "generator", content: `Starlight v${version}` }
+    },
+    // Favicon
+    {
+      tag: "link",
+      attrs: {
+        rel: "shortcut icon",
+        href: isAbsoluteUrl(config.favicon.href) ? config.favicon.href : fileWithBase(config.favicon.href),
+        type: config.favicon.type
+      }
+    },
+    // OpenGraph Tags
+    { tag: "meta", attrs: { property: "og:title", content: data.title } },
+    { tag: "meta", attrs: { property: "og:type", content: "article" } },
+    ...canonicalHref !== void 0 ? [{ tag: "meta", attrs: { property: "og:url", content: canonicalHref } }] : [],
+    { tag: "meta", attrs: { property: "og:locale", content: lang } },
+    ...description !== void 0 ? [{ tag: "meta", attrs: { property: "og:description", content: description } }] : [],
+    { tag: "meta", attrs: { property: "og:site_name", content: siteTitle } },
+    // Twitter Tags
+    {
+      tag: "meta",
+      attrs: { name: "twitter:card", content: "summary_large_image" }
+    }
+  ];
+  if (description)
+    headDefaults.push({
+      tag: "meta",
+      attrs: { name: "description", content: description }
+    });
+  if (canonical && config.isMultilingual) {
+    for (const locale in config.locales) {
+      const localeOpts = config.locales[locale];
+      if (!localeOpts) continue;
+      headDefaults.push({
+        tag: "link",
+        attrs: {
+          rel: "alternate",
+          hreflang: localeOpts.lang,
+          href: localizedUrl(canonical, locale, project.trailingSlash).href
+        }
+      });
+    }
+  }
+  if (context.site) {
+    headDefaults.push({
+      tag: "link",
+      attrs: {
+        rel: "sitemap",
+        href: fileWithBase("/sitemap-index.xml")
+      }
+    });
+  }
+  const twitterLink = config.social?.find(({ icon }) => icon === "twitter" || icon === "x.com");
+  if (twitterLink) {
+    headDefaults.push({
+      tag: "meta",
+      attrs: {
+        name: "twitter:site",
+        content: new URL(twitterLink.href).pathname.replace("/", "@")
+      }
+    });
+  }
+  return createHead(headDefaults, config.head, data.head);
+}
+function createHead(defaults, ...heads) {
+  let head = HeadSchema.parse(defaults);
+  for (const next of heads) {
+    head = mergeHead(head, next);
+  }
+  return sortHead(head);
+}
+function hasTag(head, entry) {
+  switch (entry.tag) {
+    case "title":
+      return head.some(({ tag }) => tag === "title");
+    case "meta":
+      return hasOneOf(head, entry, ["name", "property", "http-equiv"]);
+    case "link":
+      return head.some(
+        ({ attrs }) => entry.attrs?.rel === "canonical" && attrs?.rel === "canonical" || entry.attrs?.rel === "sitemap" && attrs?.rel === "sitemap"
+      );
+    default:
+      return false;
+  }
+}
+function hasOneOf(head, entry, keys) {
+  const attr = getAttr(keys, entry);
+  if (!attr) return false;
+  const [key, val] = attr;
+  return head.some(({ tag, attrs }) => tag === entry.tag && attrs?.[key] === val);
+}
+function getAttr(keys, entry) {
+  let attr;
+  for (const key of keys) {
+    const val = entry.attrs?.[key];
+    if (val) {
+      attr = [key, val];
+      break;
+    }
+  }
+  return attr;
+}
+function mergeHead(oldHead, newHead) {
+  return [...oldHead.filter((tag) => !hasTag(newHead, tag)), ...newHead];
+}
+function sortHead(head) {
+  return head.sort((a, b) => {
+    const aImportance = getImportance(a);
+    const bImportance = getImportance(b);
+    return aImportance > bImportance ? -1 : bImportance > aImportance ? 1 : 0;
+  });
+}
+function getImportance(entry) {
+  if (entry.tag === "meta" && entry.attrs && ("charset" in entry.attrs || "http-equiv" in entry.attrs || entry.attrs.name === "viewport")) {
+    return 100;
+  }
+  if (entry.tag === "title") return 90;
+  if (entry.tag !== "meta") {
+    if (entry.tag === "link" && entry.attrs && "rel" in entry.attrs && entry.attrs.rel === "shortcut icon") {
+      return 70;
+    }
+    return 80;
+  }
+  return 0;
+}
+export {
+  getHead
+};

package/dist/vendor/starlight/utils/i18n.js

@@ -0,0 +1,121 @@
+import { AstroError } from "astro/errors";
+const wellKnownRTL = ["ar", "fa", "he", "prs", "ps", "syc", "ug", "ur"];
+const BuiltInDefaultLocale = { ...getLocaleInfo("en"), lang: "en" };
+function processI18nConfig(starlightConfig, astroI18nConfig) {
+  if (astroI18nConfig && !starlightConfig.isUsingBuiltInDefaultLocale) {
+    throw new AstroError(
+      "Cannot provide both an Astro `i18n` configuration and a Starlight `locales` configuration.",
+      "Remove one of the two configurations.\nSee more at https://starlight.astro.build/guides/i18n/"
+    );
+  } else if (astroI18nConfig) {
+    return {
+      astroI18nConfig,
+      starlightConfig: {
+        ...starlightConfig,
+        ...getStarlightI18nConfig(astroI18nConfig)
+      }
+    };
+  }
+  return { astroI18nConfig: getAstroI18nConfig(starlightConfig), starlightConfig };
+}
+function getAstroI18nConfig(config) {
+  return {
+    // When using custom locale `path`s, the default locale must match one of these paths.
+    // In Starlight, this matches the `locale` property if defined, and we fallback to the `lang`
+    // property if not (which would be set to the language’s directory name by default).
+    defaultLocale: (
+      // If the default locale is explicitly set to `root`, we use the `lang` property instead.
+      (config.defaultLocale.locale === "root" ? config.defaultLocale.lang : config.defaultLocale.locale ?? config.defaultLocale.lang) ?? BuiltInDefaultLocale.lang
+    ),
+    locales: config.locales ? Object.entries(config.locales).map(([locale, localeConfig]) => {
+      return {
+        codes: [localeConfig?.lang ?? locale],
+        path: locale === "root" ? localeConfig?.lang ?? BuiltInDefaultLocale.lang : locale
+      };
+    }) : [config.defaultLocale.lang],
+    routing: {
+      prefixDefaultLocale: (
+        // Sites with multiple languages without a root locale.
+        config.isMultilingual && config.locales?.root === void 0 || // Sites with a single non-root language different from the built-in default locale.
+        !config.isMultilingual && config.locales !== void 0
+      ),
+      redirectToDefaultLocale: false,
+      fallbackType: "redirect"
+    }
+  };
+}
+function getStarlightI18nConfig(astroI18nConfig) {
+  if (astroI18nConfig.routing === "manual") {
+    throw new AstroError(
+      "Starlight is not compatible with the `manual` routing option in the Astro i18n configuration."
+    );
+  }
+  const prefixDefaultLocale = astroI18nConfig.routing.prefixDefaultLocale;
+  const isMultilingual = astroI18nConfig.locales.length > 1;
+  const isMonolingualWithRootLocale = !isMultilingual && !prefixDefaultLocale;
+  const locales = isMonolingualWithRootLocale ? void 0 : Object.fromEntries(
+    astroI18nConfig.locales.map((locale) => [
+      isDefaultAstroLocale(astroI18nConfig, locale) && !prefixDefaultLocale ? "root" : isAstroLocaleExtendedConfig(locale) ? locale.path : locale,
+      inferStarlightLocaleFromAstroLocale(locale)
+    ])
+  );
+  const defaultAstroLocale = astroI18nConfig.locales.find(
+    (locale) => isDefaultAstroLocale(astroI18nConfig, locale)
+  );
+  if (!defaultAstroLocale) {
+    throw new AstroError(
+      "Astro default locale not found.",
+      "This should never happen. Please open a new issue: https://github.com/withastro/starlight/issues/new?template=---01-bug-report.yml"
+    );
+  }
+  return {
+    isMultilingual,
+    locales,
+    defaultLocale: {
+      ...inferStarlightLocaleFromAstroLocale(defaultAstroLocale),
+      locale: isMonolingualWithRootLocale || isMultilingual && !prefixDefaultLocale ? void 0 : isAstroLocaleExtendedConfig(defaultAstroLocale) ? defaultAstroLocale.codes[0] : defaultAstroLocale
+    }
+  };
+}
+function inferStarlightLocaleFromAstroLocale(astroLocale) {
+  const lang = isAstroLocaleExtendedConfig(astroLocale) ? astroLocale.codes[0] : astroLocale;
+  return { ...getLocaleInfo(lang), lang };
+}
+function isDefaultAstroLocale(astroI18nConfig, locale) {
+  return (isAstroLocaleExtendedConfig(locale) ? locale.path : locale) === astroI18nConfig.defaultLocale;
+}
+function isAstroLocaleExtendedConfig(locale) {
+  return typeof locale !== "string";
+}
+function getLocaleInfo(lang) {
+  try {
+    const locale = new Intl.Locale(lang);
+    const label = new Intl.DisplayNames(locale, { type: "language" }).of(lang);
+    if (!label || lang === label) throw new Error("Label not found.");
+    return {
+      label: label[0]?.toLocaleUpperCase(locale) + label.slice(1),
+      dir: getLocaleDir(locale)
+    };
+  } catch {
+    throw new AstroError(
+      `Failed to get locale information for the '${lang}' locale.`,
+      "Make sure to provide a valid BCP-47 tags (e.g. en, ar, or zh-CN)."
+    );
+  }
+}
+function getLocaleDir(locale) {
+  if ("textInfo" in locale) {
+    return locale.textInfo.direction;
+  } else if ("getTextInfo" in locale) {
+    return locale.getTextInfo().direction;
+  }
+  return wellKnownRTL.includes(locale.language) ? "rtl" : "ltr";
+}
+function pickLang(dictionary, lang) {
+  return dictionary[lang];
+}
+export {
+  BuiltInDefaultLocale,
+  pickLang,
+  processI18nConfig
+};

package/dist/vendor/starlight/utils/localizedUrl.js

@@ -0,0 +1,37 @@
+import config from "virtual:starlight/user-config";
+import { stripTrailingSlash } from "./path.js";
+function localizedUrl(url, locale, trailingSlash) {
+  url = new URL(url);
+  if (!config.locales) {
+    return url;
+  }
+  if (locale === "root") locale = "";
+  const base = stripTrailingSlash(import.meta.env.BASE_URL);
+  const hasBase = url.pathname.startsWith(base);
+  if (hasBase) url.pathname = url.pathname.replace(base, "");
+  const [_leadingSlash, baseSegment] = url.pathname.split("/");
+  const htmlExt = ".html";
+  const isRootHtml = baseSegment?.endsWith(htmlExt);
+  const baseSlug = isRootHtml ? baseSegment?.slice(0, -1 * htmlExt.length) : baseSegment;
+  if (baseSlug && baseSlug in config.locales) {
+    if (locale) {
+      url.pathname = url.pathname.replace(baseSlug, locale);
+    } else if (isRootHtml) {
+      url.pathname = "/index.html";
+    } else {
+      url.pathname = url.pathname.replace("/" + baseSlug, "");
+    }
+  } else if (locale) {
+    if (baseSegment === "index.html") {
+      url.pathname = "/" + locale + ".html";
+    } else {
+      url.pathname = "/" + locale + url.pathname;
+    }
+  }
+  if (hasBase) url.pathname = base + url.pathname;
+  if (trailingSlash === "never") url.pathname = stripTrailingSlash(url.pathname);
+  return url;
+}
+export {
+  localizedUrl
+};

package/dist/vendor/starlight/utils/navigation.js

@@ -0,0 +1,320 @@
+import { AstroError } from "astro/errors";
+import project from "virtual:starlight/project-context";
+import config from "virtual:starlight/user-config";
+import { getCollectionPathFromRoot } from "./collection.js";
+import { createPathFormatter } from "./createPathFormatter.js";
+import { formatPath } from "./format-path.js";
+import { BuiltInDefaultLocale, pickLang } from "./i18n.js";
+import {
+  ensureLeadingSlash,
+  ensureTrailingSlash,
+  stripExtension,
+  stripLeadingAndTrailingSlashes
+} from "./path.js";
+import { getLocaleRoutes, routes } from "./routing.js";
+import { localeToLang, localizedId, slugToPathname } from "./slugs.js";
+import { isAbsoluteUrl } from "./url.js";
+const DirKey = /* @__PURE__ */ Symbol("DirKey");
+const SlugKey = /* @__PURE__ */ Symbol("SlugKey");
+const neverPathFormatter = createPathFormatter({ trailingSlash: "never" });
+const docsCollectionPathFromRoot = getCollectionPathFromRoot("docs", project);
+function makeDir(slug) {
+  const dir = {};
+  Object.defineProperty(dir, DirKey, { enumerable: false });
+  Object.defineProperty(dir, SlugKey, { value: slug, enumerable: false });
+  return dir;
+}
+function isDir(data) {
+  return DirKey in data;
+}
+function configItemToEntry(item, currentPathname, locale, routes2) {
+  if ("link" in item) {
+    return linkFromSidebarLinkItem(item, locale);
+  } else if ("autogenerate" in item) {
+    return groupFromAutogenerateConfig(item, locale, routes2, currentPathname);
+  } else if ("slug" in item) {
+    return linkFromInternalSidebarLinkItem(item, locale);
+  } else {
+    const label = pickLang(item.translations, localeToLang(locale)) || item.label;
+    return {
+      type: "group",
+      label,
+      entries: item.items.map((i) => configItemToEntry(i, currentPathname, locale, routes2)),
+      collapsed: item.collapsed,
+      badge: getSidebarBadge(item.badge, locale, label)
+    };
+  }
+}
+function groupFromAutogenerateConfig(item, locale, routes2, currentPathname) {
+  const { attrs, collapsed: subgroupCollapsed, directory } = item.autogenerate;
+  const localeDir = locale ? locale + "/" + directory : directory;
+  const dirDocs = routes2.filter((doc) => {
+    const filePathFromContentDir = getRoutePathRelativeToCollectionRoot(doc, locale);
+    return (
+      // Match against `foo.md` or `foo/index.md`.
+      stripExtension(filePathFromContentDir) === localeDir || // Match against `foo/anything/else.md`.
+      filePathFromContentDir.startsWith(localeDir + "/")
+    );
+  });
+  const tree = treeify(dirDocs, locale, localeDir);
+  const label = pickLang(item.translations, localeToLang(locale)) || item.label;
+  return {
+    type: "group",
+    label,
+    entries: sidebarFromDir(
+      tree,
+      currentPathname,
+      locale,
+      subgroupCollapsed ?? item.collapsed,
+      attrs
+    ),
+    collapsed: item.collapsed,
+    badge: getSidebarBadge(item.badge, locale, label)
+  };
+}
+function linkFromSidebarLinkItem(item, locale) {
+  let href = item.link;
+  if (!isAbsoluteUrl(href)) {
+    href = ensureLeadingSlash(href);
+    if (locale) href = "/" + locale + href;
+  }
+  const label = pickLang(item.translations, localeToLang(locale)) || item.label;
+  return makeSidebarLink(href, label, getSidebarBadge(item.badge, locale, label), item.attrs);
+}
+function linkFromInternalSidebarLinkItem(item, locale) {
+  const slug = item.slug === "index" ? "" : item.slug;
+  const localizedSlug = locale ? slug ? locale + "/" + slug : locale : slug;
+  const route = routes.find((entry) => localizedSlug === entry.slug);
+  if (!route) {
+    const hasExternalSlashes = item.slug.at(0) === "/" || item.slug.at(-1) === "/";
+    if (hasExternalSlashes) {
+      throw new AstroError(
+        `The slug \`"${item.slug}"\` specified in the Starlight sidebar config must not start or end with a slash.`,
+        `Please try updating \`"${item.slug}"\` to \`"${stripLeadingAndTrailingSlashes(item.slug)}"\`.`
+      );
+    } else {
+      throw new AstroError(
+        `The slug \`"${item.slug}"\` specified in the Starlight sidebar config does not exist.`,
+        "Update the Starlight config to reference a valid entry slug in the docs content collection.\nLearn more about Astro content collection slugs at https://docs.astro.build/en/reference/modules/astro-content/#getentry"
+      );
+    }
+  }
+  const frontmatter = route.entry.data;
+  const label = pickLang(item.translations, localeToLang(locale)) || item.label || frontmatter.sidebar?.label || frontmatter.title;
+  const badge = item.badge ?? frontmatter.sidebar?.badge;
+  const attrs = { ...frontmatter.sidebar?.attrs, ...item.attrs };
+  return makeSidebarLink(
+    slugToPathname(route.slug),
+    label,
+    getSidebarBadge(badge, locale, label),
+    attrs
+  );
+}
+function makeSidebarLink(href, label, badge, attrs) {
+  if (!isAbsoluteUrl(href)) {
+    href = formatPath(href);
+  }
+  return makeLink({ label, href, badge, attrs });
+}
+function makeLink({
+  attrs = {},
+  badge = void 0,
+  ...opts
+}) {
+  return { type: "link", ...opts, badge, isCurrent: false, attrs };
+}
+function pathsMatch(pathA, pathB) {
+  return neverPathFormatter(pathA) === neverPathFormatter(pathB);
+}
+function getBreadcrumbs(path, baseDir) {
+  const pathWithoutExt = stripExtension(path);
+  if (pathWithoutExt === baseDir) return [];
+  baseDir = ensureTrailingSlash(baseDir);
+  const relativePath = pathWithoutExt.startsWith(baseDir) ? pathWithoutExt.replace(baseDir, "") : pathWithoutExt;
+  return relativePath.split("/");
+}
+function getRoutePathRelativeToCollectionRoot(route, locale) {
+  return project.legacyCollections ? route.id : (
+    // For collections with a loader, use a localized filePath relative to the collection
+    localizedId(route.entry.filePath.replace(`${docsCollectionPathFromRoot}/`, ""), locale)
+  );
+}
+function treeify(routes2, locale, baseDir) {
+  const treeRoot = makeDir(baseDir);
+  routes2.filter((doc) => !doc.entry.data.sidebar.hidden).map((doc) => [getRoutePathRelativeToCollectionRoot(doc, locale), doc]).sort(([a], [b]) => b.split("/").length - a.split("/").length).forEach(([filePathFromContentDir, doc]) => {
+    const parts = getBreadcrumbs(filePathFromContentDir, baseDir);
+    let currentNode = treeRoot;
+    parts.forEach((part, index) => {
+      const isLeaf = index === parts.length - 1;
+      if (isLeaf && Object.hasOwn(currentNode, part)) {
+        currentNode = currentNode[part];
+        part = "index";
+      }
+      if (!isLeaf) {
+        const path = currentNode[SlugKey];
+        currentNode[part] ||= makeDir(stripLeadingAndTrailingSlashes(path + "/" + part));
+        currentNode = currentNode[part];
+      } else {
+        currentNode[part] = doc;
+      }
+    });
+  });
+  return treeRoot;
+}
+function linkFromRoute(route, attrs) {
+  return makeSidebarLink(
+    slugToPathname(route.slug),
+    route.entry.data.sidebar.label || route.entry.data.title,
+    route.entry.data.sidebar.badge,
+    { ...attrs, ...route.entry.data.sidebar.attrs }
+  );
+}
+function getOrder(routeOrDir) {
+  return isDir(routeOrDir) ? Math.min(...Object.values(routeOrDir).flatMap(getOrder)) : (
+    // If no order value is found, set it to the largest number possible.
+    routeOrDir.entry.data.sidebar.order ?? Number.MAX_VALUE
+  );
+}
+function sortDirEntries(dir) {
+  const collator = new Intl.Collator(localeToLang(void 0));
+  return dir.sort(([_keyA, a], [_keyB, b]) => {
+    const [aOrder, bOrder] = [getOrder(a), getOrder(b)];
+    if (aOrder !== bOrder) return aOrder < bOrder ? -1 : 1;
+    return collator.compare(isDir(a) ? a[SlugKey] : a.slug, isDir(b) ? b[SlugKey] : b.slug);
+  });
+}
+function groupFromDir(dir, fullPath, dirName, currentPathname, locale, collapsed, attrs) {
+  const entries = sortDirEntries(Object.entries(dir)).map(
+    ([key, dirOrRoute]) => dirToItem(dirOrRoute, `${fullPath}/${key}`, key, currentPathname, locale, collapsed, attrs)
+  );
+  return {
+    type: "group",
+    label: dirName,
+    entries,
+    collapsed,
+    badge: void 0
+  };
+}
+function dirToItem(dirOrRoute, fullPath, dirName, currentPathname, locale, collapsed, attrs) {
+  return isDir(dirOrRoute) ? groupFromDir(dirOrRoute, fullPath, dirName, currentPathname, locale, collapsed, attrs) : linkFromRoute(dirOrRoute, attrs);
+}
+function sidebarFromDir(tree, currentPathname, locale, collapsed, attrs) {
+  return sortDirEntries(Object.entries(tree)).map(
+    ([key, dirOrRoute]) => dirToItem(dirOrRoute, key, key, currentPathname, locale, collapsed, attrs)
+  );
+}
+const intermediateSidebars = /* @__PURE__ */ new Map();
+function getSidebar(pathname, locale) {
+  let intermediateSidebar = intermediateSidebars.get(locale);
+  if (!intermediateSidebar) {
+    intermediateSidebar = getIntermediateSidebarFromConfig(config.sidebar, pathname, locale);
+    intermediateSidebars.set(locale, intermediateSidebar);
+  }
+  return getSidebarFromIntermediateSidebar(intermediateSidebar, pathname);
+}
+function getSidebarFromConfig(sidebarConfig, pathname, locale) {
+  const intermediateSidebar = getIntermediateSidebarFromConfig(sidebarConfig, pathname, locale);
+  return getSidebarFromIntermediateSidebar(intermediateSidebar, pathname);
+}
+function getIntermediateSidebarFromConfig(sidebarConfig, pathname, locale) {
+  const routes2 = getLocaleRoutes(locale);
+  if (sidebarConfig) {
+    return sidebarConfig.map((group) => configItemToEntry(group, pathname, locale, routes2));
+  } else {
+    const tree = treeify(routes2, locale, locale || "");
+    return sidebarFromDir(tree, pathname, locale, false);
+  }
+}
+function getSidebarFromIntermediateSidebar(intermediateSidebar, pathname) {
+  const sidebar = structuredClone(intermediateSidebar);
+  setIntermediateSidebarCurrentEntry(sidebar, pathname);
+  return sidebar;
+}
+function setIntermediateSidebarCurrentEntry(intermediateSidebar, pathname) {
+  for (const entry of intermediateSidebar) {
+    if (entry.type === "link" && pathsMatch(encodeURI(entry.href), pathname)) {
+      entry.isCurrent = true;
+      return true;
+    }
+    if (entry.type === "group" && setIntermediateSidebarCurrentEntry(entry.entries, pathname)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getSidebarHash(sidebar) {
+  let hash = 0;
+  const sidebarIdentity = recursivelyBuildSidebarIdentity(sidebar);
+  for (let i = 0; i < sidebarIdentity.length; i++) {
+    const char = sidebarIdentity.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+  }
+  return (hash >>> 0).toString(36).padStart(7, "0");
+}
+function recursivelyBuildSidebarIdentity(sidebar) {
+  return sidebar.flatMap(
+    (entry) => entry.type === "group" ? entry.label + recursivelyBuildSidebarIdentity(entry.entries) : entry.label + entry.href
+  ).join("");
+}
+function flattenSidebar(sidebar) {
+  return sidebar.flatMap(
+    (entry) => entry.type === "group" ? flattenSidebar(entry.entries) : entry
+  );
+}
+function getPrevNextLinks(sidebar, paginationEnabled, config2) {
+  const entries = flattenSidebar(sidebar);
+  const currentIndex = entries.findIndex((entry) => entry.isCurrent);
+  const prev = applyPrevNextLinkConfig(entries[currentIndex - 1], paginationEnabled, config2.prev);
+  const next = applyPrevNextLinkConfig(
+    currentIndex > -1 ? entries[currentIndex + 1] : void 0,
+    paginationEnabled,
+    config2.next
+  );
+  return { prev, next };
+}
+function applyPrevNextLinkConfig(link, paginationEnabled, config2) {
+  if (config2 === false) return void 0;
+  else if (config2 === true) return link;
+  else if (typeof config2 === "string" && link) {
+    return { ...link, label: config2 };
+  } else if (typeof config2 === "object") {
+    if (link) {
+      return {
+        ...link,
+        label: config2.label ?? link.label,
+        href: config2.link ?? link.href,
+        // Explicitly remove sidebar link attributes for prev/next links.
+        attrs: {}
+      };
+    } else if (config2.link && config2.label) {
+      return makeLink({ href: config2.link, label: config2.label });
+    }
+  }
+  return paginationEnabled ? link : void 0;
+}
+function getSidebarBadge(config2, locale, itemLabel) {
+  if (!config2) return;
+  if (typeof config2 === "string") {
+    return { variant: "default", text: config2 };
+  }
+  return { ...config2, text: getSidebarBadgeText(config2.text, locale, itemLabel) };
+}
+function getSidebarBadgeText(text, locale, itemLabel) {
+  if (typeof text === "string") return text;
+  const defaultLang = config.defaultLocale?.lang || config.defaultLocale?.locale || BuiltInDefaultLocale.lang;
+  const defaultText = text[defaultLang];
+  if (!defaultText) {
+    throw new AstroError(
+      `The badge text for "${itemLabel}" must have a key for the default language "${defaultLang}".`,
+      "Update the Starlight config to include a badge text for the default language.\nLearn more about sidebar badges internationalization at https://starlight.astro.build/guides/sidebar/#internationalization-with-badges"
+    );
+  }
+  return pickLang(text, localeToLang(locale)) || defaultText;
+}
+export {
+  flattenSidebar,
+  getPrevNextLinks,
+  getSidebar,
+  getSidebarFromConfig,
+  getSidebarHash
+};