@treeseed/core 0.1.2

package/dist/vendor/starlight/user-components/rehype-file-tree.js

@@ -0,0 +1,160 @@
+import { AstroError } from "astro/errors";
+import { h, s } from "hastscript";
+import { select } from "hast-util-select";
+import { fromHtml } from "hast-util-from-html";
+import { toString } from "hast-util-to-string";
+import { rehype } from "rehype";
+import { CONTINUE, SKIP, visit } from "unist-util-visit";
+import { Icons } from "../components/Icons.js";
+import { definitions } from "./file-tree-icons.js";
+const folderIcon = makeSVGIcon(Icons["seti:folder"]);
+const defaultFileIcon = makeSVGIcon(Icons["seti:default"]);
+function processFileTree(html, directoryLabel) {
+  const file = fileTreeProcessor.processSync({ data: { directoryLabel }, value: html });
+  return file.toString();
+}
+const fileTreeProcessor = rehype().data("settings", { fragment: true }).use(function fileTree() {
+  return (tree, file) => {
+    const { directoryLabel } = file.data;
+    validateFileTree(tree);
+    visit(tree, "element", (node) => {
+      node.children = node.children.filter(
+        (child) => child.type === "comment" || child.type !== "text" || !/^\n+$/.test(child.value)
+      );
+      if (node.tagName !== "li") return CONTINUE;
+      const [firstChild, ...otherChildren] = node.children;
+      const comment = [];
+      if (firstChild?.type === "text") {
+        const [filename, ...fragments] = firstChild.value.split(" ");
+        firstChild.value = filename || "";
+        const textComment = fragments.join(" ").trim();
+        if (textComment.length > 0) {
+          comment.push(fragments.join(" "));
+        }
+      }
+      const subTreeIndex = otherChildren.findIndex(
+        (child) => child.type === "element" && child.tagName === "ul"
+      );
+      const commentNodes = subTreeIndex > -1 ? otherChildren.slice(0, subTreeIndex) : [...otherChildren];
+      otherChildren.splice(0, subTreeIndex > -1 ? subTreeIndex : otherChildren.length);
+      comment.push(...commentNodes);
+      const firstChildTextContent = firstChild ? toString(firstChild) : "";
+      const isDirectory = /\/\s*$/.test(firstChildTextContent) || otherChildren.some((child) => child.type === "element" && child.tagName === "ul");
+      const isPlaceholder = /^\s*(\.{3}|…)\s*$/.test(firstChildTextContent);
+      const isHighlighted = firstChild?.type === "element" && firstChild.tagName === "strong";
+      const icon = h("span", isDirectory ? folderIcon : getFileIcon(firstChildTextContent));
+      if (isDirectory) {
+        icon.children.unshift(h("span", { class: "sr-only" }, directoryLabel));
+      }
+      node.properties.class = isDirectory ? "directory" : "file";
+      if (isPlaceholder) node.properties.class += " empty";
+      const treeEntryChildren = [
+        h("span", { class: isHighlighted ? "highlight" : "" }, [
+          isPlaceholder ? null : icon,
+          firstChild
+        ])
+      ];
+      if (comment.length > 0) {
+        treeEntryChildren.push(makeText(" "), h("span", { class: "comment" }, ...comment));
+      }
+      const treeEntry = h("span", { class: "tree-entry" }, ...treeEntryChildren);
+      if (isDirectory) {
+        const hasContents = otherChildren.length > 0;
+        node.children = [
+          h("details", { open: hasContents }, [
+            h("summary", treeEntry),
+            ...hasContents ? otherChildren : [h("ul", h("li", "\u2026"))]
+          ])
+        ];
+        return CONTINUE;
+      }
+      node.children = [treeEntry, ...otherChildren];
+      return SKIP;
+    });
+  };
+});
+function makeText(value = "") {
+  return { type: "text", value };
+}
+function makeSVGIcon(svgString) {
+  return s(
+    "svg",
+    {
+      width: 16,
+      height: 16,
+      class: "tree-icon",
+      "aria-hidden": "true",
+      viewBox: "0 0 24 24"
+    },
+    fromHtml(svgString, { fragment: true })
+  );
+}
+function getFileIcon(fileName) {
+  const name = getFileIconName(fileName);
+  if (!name) return defaultFileIcon;
+  if (name in Icons) {
+    const path = Icons[name];
+    return makeSVGIcon(path);
+  }
+  return defaultFileIcon;
+}
+function getFileIconName(fileName) {
+  let icon = definitions.files[fileName];
+  if (icon) return icon;
+  icon = getFileIconTypeFromExtension(fileName);
+  if (icon) return icon;
+  for (const [partial, partialIcon] of Object.entries(definitions.partials)) {
+    if (fileName.includes(partial)) return partialIcon;
+  }
+  return icon;
+}
+function getFileIconTypeFromExtension(fileName) {
+  const firstDotIndex = fileName.indexOf(".");
+  if (firstDotIndex === -1) return;
+  let extension = fileName.slice(firstDotIndex);
+  while (extension !== "") {
+    const icon = definitions.extensions[extension];
+    if (icon) return icon;
+    const nextDotIndex = extension.indexOf(".", 1);
+    if (nextDotIndex === -1) return;
+    extension = extension.slice(nextDotIndex);
+  }
+  return;
+}
+function validateFileTree(tree) {
+  const rootElements = tree.children.filter(isElementNode);
+  const [rootElement] = rootElements;
+  if (rootElements.length === 0) {
+    throwFileTreeValidationError(
+      "The `<FileTree>` component expects its content to be a single unordered list but found no child elements."
+    );
+  }
+  if (rootElements.length !== 1) {
+    throwFileTreeValidationError(
+      `The \`<FileTree>\` component expects its content to be a single unordered list but found multiple child elements: ${rootElements.map((element) => `\`<${element.tagName}>\``).join(" - ")}.`
+    );
+  }
+  if (!rootElement || rootElement.tagName !== "ul") {
+    throwFileTreeValidationError(
+      `The \`<FileTree>\` component expects its content to be an unordered list but found the following element: \`<${rootElement?.tagName}>\`.`
+    );
+  }
+  const listItemElement = select("li", rootElement);
+  if (!listItemElement) {
+    throwFileTreeValidationError(
+      "The `<FileTree>` component expects its content to be an unordered list with at least one list item."
+    );
+  }
+}
+function isElementNode(node) {
+  return node.type === "element";
+}
+function throwFileTreeValidationError(message) {
+  throw new AstroError(
+    message,
+    "To learn more about the `<FileTree>` component, see https://starlight.astro.build/components/file-tree/"
+  );
+}
+export {
+  processFileTree
+};

package/dist/vendor/starlight/user-components/rehype-steps.js

@@ -0,0 +1,53 @@
+import { AstroError } from "astro/errors";
+import { rehype } from "rehype";
+import rehypeFormat from "rehype-format";
+const prettyPrintProcessor = rehype().data("settings", { fragment: true }).use(rehypeFormat);
+const prettyPrintHtml = (html) => prettyPrintProcessor.processSync({ value: html }).toString();
+const stepsProcessor = rehype().data("settings", { fragment: true }).use(function steps() {
+  return (tree, vfile) => {
+    const rootElements = tree.children.filter((item) => item.type === "element");
+    const [rootElement] = rootElements;
+    if (!rootElement) {
+      throw new StepsError(
+        "The `<Steps>` component expects its content to be a single ordered list (`<ol>`) but found no child elements."
+      );
+    } else if (rootElements.length > 1) {
+      throw new StepsError(
+        "The `<Steps>` component expects its content to be a single ordered list (`<ol>`) but found multiple child elements: " + rootElements.map((element) => `\`<${element.tagName}>\``).join(", ") + ".",
+        vfile.value.toString()
+      );
+    } else if (rootElement.tagName !== "ol") {
+      throw new StepsError(
+        `The \`<Steps>\` component expects its content to be a single ordered list (\`<ol>\`) but found the following element: \`<${rootElement.tagName}>\`.`,
+        vfile.value.toString()
+      );
+    }
+    rootElement.properties.role = "list";
+    if (!Array.isArray(rootElement.properties.className)) {
+      rootElement.properties.className = ["sl-steps"];
+    } else {
+      rootElement.properties.className.push("sl-steps");
+    }
+    if (typeof rootElement.properties.start === "number") {
+      const styles = [`--sl-steps-start: ${rootElement.properties.start - 1}`];
+      if (rootElement.properties.style) styles.push(String(rootElement.properties.style));
+      rootElement.properties.style = styles.join(";");
+    }
+  };
+});
+const processSteps = (html) => {
+  const file = stepsProcessor.processSync({ value: html });
+  return { html: file.toString() };
+};
+class StepsError extends AstroError {
+  constructor(message, html) {
+    let hint = "To learn more about the `<Steps>` component, see https://starlight.astro.build/components/steps/";
+    if (html) {
+      hint += "\n\nFull HTML passed to `<Steps>`:\n" + prettyPrintHtml(html);
+    }
+    super(message, hint);
+  }
+}
+export {
+  processSteps
+};

package/dist/vendor/starlight/user-components/rehype-tabs.js

@@ -0,0 +1,73 @@
+import { select } from "hast-util-select";
+import { rehype } from "rehype";
+import { CONTINUE, SKIP, visit } from "unist-util-visit";
+const TabItemTagname = "starlight-tab-item";
+const focusableElementSelectors = [
+  "input:not([disabled]):not([type=hidden])",
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  "button:not([disabled])",
+  "a[href]",
+  "area[href]",
+  "summary",
+  "iframe",
+  "object",
+  "embed",
+  "audio[controls]",
+  "video[controls]",
+  "[contenteditable]",
+  "[tabindex]:not([disabled])"
+].map((selector) => `${selector}:not([hidden]):not([tabindex="-1"])`).join(",");
+let count = 0;
+const getIDs = () => {
+  const id = count++;
+  return { panelId: "tab-panel-" + id, tabId: "tab-" + id };
+};
+const tabsProcessor = rehype().data("settings", { fragment: true }).use(function tabs() {
+  return (tree, file) => {
+    file.data.panels = [];
+    let isFirst = true;
+    visit(tree, "element", (node) => {
+      if (node.tagName !== TabItemTagname || !node.properties) {
+        return CONTINUE;
+      }
+      const { dataLabel, dataIcon } = node.properties;
+      const ids = getIDs();
+      const panel = {
+        ...ids,
+        label: String(dataLabel)
+      };
+      if (dataIcon) panel.icon = String(dataIcon);
+      file.data.panels?.push(panel);
+      delete node.properties.dataLabel;
+      delete node.properties.dataIcon;
+      node.tagName = "div";
+      node.properties.id = ids.panelId;
+      node.properties["aria-labelledby"] = ids.tabId;
+      node.properties.role = "tabpanel";
+      const focusableChild = select(focusableElementSelectors, node);
+      if (!focusableChild) {
+        node.properties.tabindex = 0;
+      }
+      if (isFirst) {
+        isFirst = false;
+      } else {
+        node.properties.hidden = true;
+      }
+      return SKIP;
+    });
+  };
+});
+const processPanels = (html) => {
+  const file = tabsProcessor.processSync({ value: html });
+  return {
+    /** Data for each tab panel. */
+    panels: file.data.panels,
+    /** Processed HTML for the tab panels. */
+    html: file.toString()
+  };
+};
+export {
+  TabItemTagname,
+  processPanels
+};

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

@@ -0,0 +1,14 @@
+import { stripLeadingSlash, stripTrailingSlash } from "./path.js";
+const base = stripTrailingSlash(import.meta.env.BASE_URL);
+function pathWithBase(path) {
+  path = stripLeadingSlash(path);
+  return path ? base + "/" + path : base + "/";
+}
+function fileWithBase(path) {
+  path = stripLeadingSlash(path);
+  return path ? base + "/" + path : base;
+}
+export {
+  fileWithBase,
+  pathWithBase
+};

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

@@ -0,0 +1,13 @@
+import { ensureTrailingSlash, stripTrailingSlash } from "./path.js";
+const canonicalTrailingSlashStrategies = {
+  always: ensureTrailingSlash,
+  never: stripTrailingSlash,
+  ignore: ensureTrailingSlash
+};
+function formatCanonical(href, opts) {
+  if (opts.format === "file") return href;
+  return canonicalTrailingSlashStrategies[opts.trailingSlash](href);
+}
+export {
+  formatCanonical
+};

package/dist/vendor/starlight/utils/collection-fs.js

@@ -0,0 +1,13 @@
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getCollectionUrl } from "./collection.js";
+function resolveCollectionPath(collection, srcDir) {
+  return resolve(fileURLToPath(srcDir), `content/${collection}`);
+}
+function getCollectionPosixPath(collection, srcDir) {
+  return fileURLToPath(getCollectionUrl(collection, srcDir)).replace(/\\/g, "/");
+}
+export {
+  getCollectionPosixPath,
+  resolveCollectionPath
+};

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

@@ -0,0 +1,16 @@
+function getCollectionUrl(collection, srcDir) {
+  return new URL(`content/${getCollectionDir(collection)}/`, srcDir);
+}
+function getCollectionDir(collection) {
+  return collection === "docs" ? "knowledge" : collection;
+}
+function getCollectionPathFromRoot(collection, { root, srcDir }) {
+  return (typeof srcDir === "string" ? srcDir : srcDir.pathname).replace(
+    typeof root === "string" ? root : root.pathname,
+    ""
+  ) + "content/" + getCollectionDir(collection);
+}
+export {
+  getCollectionPathFromRoot,
+  getCollectionUrl
+};

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

@@ -0,0 +1,39 @@
+import { fileWithBase, pathWithBase } from "./base.js";
+import {
+  ensureHtmlExtension,
+  ensureTrailingSlash,
+  stripHtmlExtension,
+  stripTrailingSlash
+} from "./path.js";
+const defaultFormatStrategy = {
+  addBase: pathWithBase,
+  handleExtension: (href) => stripHtmlExtension(href)
+};
+const formatStrategies = {
+  file: {
+    addBase: fileWithBase,
+    handleExtension: (href) => ensureHtmlExtension(href)
+  },
+  directory: defaultFormatStrategy,
+  preserve: defaultFormatStrategy
+};
+const trailingSlashStrategies = {
+  always: ensureTrailingSlash,
+  never: stripTrailingSlash,
+  ignore: (href) => href
+};
+function formatPath(href, { format = "directory", trailingSlash = "ignore" }) {
+  const formatStrategy = formatStrategies[format];
+  const trailingSlashStrategy = trailingSlashStrategies[trailingSlash];
+  href = formatStrategy.handleExtension(href);
+  href = formatStrategy.addBase(href);
+  if (format === "file") return href;
+  href = href === "/" ? href : trailingSlashStrategy(href);
+  return href;
+}
+function createPathFormatter(opts) {
+  return (href) => formatPath(href, opts);
+}
+export {
+  createPathFormatter
+};

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

@@ -0,0 +1,60 @@
+import i18next from "i18next";
+import builtinTranslations from "../translations/index.js";
+import { BuiltInDefaultLocale } from "./i18n.js";
+const I18nextNamespace = "starlight";
+async function createTranslationSystem(config, userTranslations, pluginTranslations = {}) {
+  const defaultLocale = config.defaultLocale.lang || config.defaultLocale?.locale || BuiltInDefaultLocale.lang;
+  const translations = {
+    [defaultLocale]: buildResources(
+      builtinTranslations[defaultLocale],
+      builtinTranslations[stripLangRegion(defaultLocale)],
+      pluginTranslations[defaultLocale],
+      userTranslations[defaultLocale]
+    )
+  };
+  if (config.locales) {
+    for (const locale in config.locales) {
+      const lang = localeToLang(locale, config.locales, config.defaultLocale);
+      translations[lang] = buildResources(
+        builtinTranslations[lang] || builtinTranslations[stripLangRegion(lang)],
+        pluginTranslations[lang],
+        userTranslations[lang]
+      );
+    }
+  }
+  const i18n = i18next.createInstance();
+  await i18n.init({
+    resources: translations,
+    fallbackLng: config.defaultLocale.lang || config.defaultLocale?.locale || BuiltInDefaultLocale.lang
+  });
+  return (lang) => {
+    lang ??= config.defaultLocale?.lang || BuiltInDefaultLocale.lang;
+    const t = i18n.getFixedT(lang, I18nextNamespace);
+    t.all = () => i18n.getResourceBundle(lang, I18nextNamespace);
+    t.exists = (key, options) => i18n.exists(key, { lng: lang, ns: I18nextNamespace, ...options });
+    t.dir = (dirLang = lang) => i18n.dir(dirLang);
+    return t;
+  };
+}
+function stripLangRegion(lang) {
+  return lang.replace(/-[a-zA-Z]{2}/, "");
+}
+function localeToLang(locale, locales, defaultLocale) {
+  const lang = locale ? locales?.[locale]?.lang : locales?.root?.lang;
+  const defaultLang = defaultLocale?.lang || defaultLocale?.locale;
+  return lang || defaultLang || BuiltInDefaultLocale.lang;
+}
+function buildResources(...dictionaries) {
+  const dictionary = {};
+  for (const dict of dictionaries) {
+    for (const key in dict) {
+      const value = dict[key];
+      if (value) dictionary[key] = value;
+    }
+  }
+  return { [I18nextNamespace]: dictionary };
+}
+export {
+  I18nextNamespace,
+  createTranslationSystem
+};

package/dist/vendor/starlight/utils/error-map.js

@@ -0,0 +1,110 @@
+import { AstroError } from "astro/errors";
+function parseWithFriendlyErrors(schema, input, message) {
+  return processParsedData(schema.safeParse(input, { errorMap }), message);
+}
+async function parseAsyncWithFriendlyErrors(schema, input, message) {
+  return processParsedData(await schema.safeParseAsync(input, { errorMap }), message);
+}
+function processParsedData(parsedData, message) {
+  if (!parsedData.success) {
+    throw new AstroError(message, parsedData.error.issues.map((i) => i.message).join("\n"));
+  }
+  return parsedData.data;
+}
+const errorMap = (baseError, ctx) => {
+  const baseErrorPath = flattenErrorPath(baseError.path);
+  if (baseError.code === "invalid_union") {
+    const typeOrLiteralErrByPath = /* @__PURE__ */ new Map();
+    for (const unionError of baseError.unionErrors.map((e) => e.errors).flat()) {
+      if (unionError.code === "invalid_type" || unionError.code === "invalid_literal") {
+        const flattenedErrorPath = flattenErrorPath(unionError.path);
+        if (typeOrLiteralErrByPath.has(flattenedErrorPath)) {
+          typeOrLiteralErrByPath.get(flattenedErrorPath).expected.push(unionError.expected);
+        } else {
+          typeOrLiteralErrByPath.set(flattenedErrorPath, {
+            code: unionError.code,
+            received: unionError.received,
+            expected: [unionError.expected]
+          });
+        }
+      }
+    }
+    const messages = [prefix(baseErrorPath, "Did not match union.")];
+    const details = [...typeOrLiteralErrByPath.entries()].filter(([, error]) => error.expected.length === baseError.unionErrors.length).map(
+      ([key, error]) => key === baseErrorPath ? (
+        // Avoid printing the key again if it's a base error
+        `> ${getTypeOrLiteralMsg(error)}`
+      ) : `> ${prefix(key, getTypeOrLiteralMsg(error))}`
+    );
+    if (details.length === 0) {
+      const expectedShapes = [];
+      for (const unionError of baseError.unionErrors) {
+        const expectedShape = [];
+        for (const issue of unionError.issues) {
+          if (issue.code === "invalid_union") {
+            return errorMap(issue, ctx);
+          }
+          const relativePath = flattenErrorPath(issue.path).replace(baseErrorPath, "").replace(leadingPeriod, "");
+          if ("expected" in issue && typeof issue.expected === "string") {
+            expectedShape.push(
+              relativePath ? `${relativePath}: ${issue.expected}` : issue.expected
+            );
+          } else {
+            expectedShape.push(relativePath);
+          }
+        }
+        if (expectedShape.length === 1 && !expectedShape[0]?.includes(":")) {
+          expectedShapes.push(expectedShape.join(""));
+        } else {
+          expectedShapes.push(`{ ${expectedShape.join("; ")} }`);
+        }
+      }
+      if (expectedShapes.length) {
+        details.push("> Expected type `" + expectedShapes.join(" | ") + "`");
+        details.push("> Received `" + stringify(ctx.data) + "`");
+      }
+    }
+    return {
+      message: messages.concat(details).join("\n")
+    };
+  } else if (baseError.code === "invalid_literal" || baseError.code === "invalid_type") {
+    return {
+      message: prefix(
+        baseErrorPath,
+        getTypeOrLiteralMsg({
+          code: baseError.code,
+          received: baseError.received,
+          expected: [baseError.expected]
+        })
+      )
+    };
+  } else if (baseError.message) {
+    return { message: prefix(baseErrorPath, baseError.message) };
+  } else {
+    return { message: prefix(baseErrorPath, ctx.defaultError) };
+  }
+};
+const getTypeOrLiteralMsg = (error) => {
+  if (typeof error.received === "undefined" || error.received === "undefined") return "Required";
+  const expectedDeduped = new Set(error.expected);
+  switch (error.code) {
+    case "invalid_type":
+      return `Expected type \`${unionExpectedVals(expectedDeduped)}\`, received \`${stringify(
+        error.received
+      )}\``;
+    case "invalid_literal":
+      return `Expected \`${unionExpectedVals(expectedDeduped)}\`, received \`${stringify(
+        error.received
+      )}\``;
+  }
+};
+const prefix = (key, msg) => key.length ? `**${key}**: ${msg}` : msg;
+const unionExpectedVals = (expectedVals) => [...expectedVals].map((expectedVal) => stringify(expectedVal)).join(" | ");
+const flattenErrorPath = (errorPath) => errorPath.join(".");
+const stringify = (val) => JSON.stringify(val, null, 1).split(newlinePlusWhitespace).join(" ");
+const newlinePlusWhitespace = /\n\s*/;
+const leadingPeriod = /^\./;
+export {
+  parseAsyncWithFriendlyErrors,
+  parseWithFriendlyErrors
+};

package/dist/vendor/starlight/utils/format-path.js

@@ -0,0 +1,9 @@
+import project from "virtual:starlight/project-context";
+import { createPathFormatter } from "./createPathFormatter.js";
+const formatPath = createPathFormatter({
+  format: project.build.format,
+  trailingSlash: project.trailingSlash
+});
+export {
+  formatPath
+};

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

@@ -0,0 +1,18 @@
+import { PAGE_TITLE_ID } from "../constants.js";
+function generateToC(headings, { minHeadingLevel, maxHeadingLevel, title }) {
+  headings = headings.filter(({ depth }) => depth >= minHeadingLevel && depth <= maxHeadingLevel);
+  const toc = [{ depth: 2, slug: PAGE_TITLE_ID, text: title, children: [] }];
+  for (const heading of headings) injectChild(toc, { ...heading, children: [] });
+  return toc;
+}
+function injectChild(items, item) {
+  const lastItem = items.at(-1);
+  if (!lastItem || lastItem.depth >= item.depth) {
+    items.push(item);
+  } else {
+    return injectChild(lastItem.children, item);
+  }
+}
+export {
+  generateToC
+};

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

@@ -0,0 +1,92 @@
+import { basename, dirname, relative, resolve } from "node:path";
+import { realpathSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+const makeAPI = (directory) => {
+  return {
+    getNewestCommitDate: (file) => getNewestCommitDate(resolve(directory, file))
+  };
+};
+function getNewestCommitDate(file) {
+  const result = spawnSync("git", ["log", "--format=%ct", "--max-count=1", basename(file)], {
+    cwd: dirname(file),
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    throw new Error(`Failed to retrieve the git history for file "${file}"`);
+  }
+  const output = result.stdout.trim();
+  const regex = /^(?<timestamp>\d+)$/;
+  const match = output.match(regex);
+  if (!match?.groups?.timestamp) {
+    throw new Error(`Failed to validate the timestamp for file "${file}"`);
+  }
+  const timestamp = Number(match.groups.timestamp);
+  const date = new Date(timestamp * 1e3);
+  return date;
+}
+function getRepoRoot(directory) {
+  const result = spawnSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd: directory,
+    encoding: "utf-8"
+  });
+  if (result.error) {
+    return directory;
+  }
+  try {
+    return realpathSync(result.stdout.trim());
+  } catch {
+    return directory;
+  }
+}
+function getAllNewestCommitDate(rootPath, docsPath) {
+  const repoRoot = getRepoRoot(docsPath);
+  const gitLog = spawnSync(
+    "git",
+    [
+      "log",
+      // Format each history entry as t:<seconds since epoch>
+      "--format=t:%ct",
+      // In each entry include the name and status for each modified file
+      "--name-status",
+      "--",
+      docsPath
+    ],
+    {
+      cwd: repoRoot,
+      encoding: "utf-8",
+      // The default `maxBuffer` for `spawnSync` is 1024 * 1024 bytes, a.k.a 1 MB. In big projects,
+      // the full git history can be larger than this, so we increase this to ~10 MB. For example,
+      // Cloudflare passed 1 MB with ~4,800 pages and ~17,000 commits. If we get reports of others
+      // hitting ENOBUFS errors here in the future, we may want to switch to streaming the git log
+      // with `spawn` instead.
+      // See https://github.com/withastro/starlight/issues/3154
+      maxBuffer: 10 * 1024 * 1024
+    }
+  );
+  if (gitLog.error) {
+    return [];
+  }
+  let runningDate = Date.now();
+  const latestDates = /* @__PURE__ */ new Map();
+  for (const logLine of gitLog.stdout.split("\n")) {
+    if (logLine.startsWith("t:")) {
+      runningDate = Number.parseInt(logLine.slice(2)) * 1e3;
+    }
+    const tabSplit = logLine.lastIndexOf("	");
+    if (tabSplit === -1) continue;
+    const fileName = logLine.slice(tabSplit + 1);
+    const currentLatest = latestDates.get(fileName) || 0;
+    latestDates.set(fileName, Math.max(currentLatest, runningDate));
+  }
+  return Array.from(latestDates.entries()).map(([file, date]) => {
+    const fileFullPath = resolve(repoRoot, file);
+    let fileInDirectory = relative(rootPath, fileFullPath);
+    fileInDirectory = fileInDirectory?.replace(/\\/g, "/");
+    return [fileInDirectory, date];
+  });
+}
+export {
+  getAllNewestCommitDate,
+  getNewestCommitDate,
+  makeAPI
+};