@anja.codes/vitakit 0.1.0

package/dist/shared/vitakit.BRhjqpAt.mjs

@@ -0,0 +1,250 @@
+import { readdir, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { Eta } from 'eta';
+import { m as fail, p as formatZodIssues, k as atMost, o as resolveAsset, n as isSitePath } from './vitakit.BxcnlFGP.mjs';
+import { entrySecondaryParts, entryTitleField, formatDateRange } from './index.mjs';
+import { r as richSource } from './vitakit.BlU-p01e.mjs';
+import { parse } from 'yaml';
+import { z } from 'zod';
+
+const REPLACEMENTS = {
+  "\\": "\\textbackslash{}",
+  "&": "\\&",
+  "%": "\\%",
+  $: "\\$",
+  "#": "\\#",
+  _: "\\_",
+  "{": "\\{",
+  "}": "\\}",
+  "~": "\\textasciitilde{}",
+  "^": "\\textasciicircum{}"
+};
+const TYPOGRAPHY = [
+  // Directional quotes: "..." -> ``...''
+  [/"([^"]*)"/g, "``$1''"],
+  // An en dash written literally
+  [/\u2013/g, "--"],
+  [/\u2014/g, "---"],
+  [/\u2026/g, "\\ldots{}"],
+  [/\u00a0/g, "~"]
+];
+function escapeTex(value, { typography = true, source } = {}) {
+  if (source !== void 0 && /(?<!\\)\$/.test(value)) {
+    throw new Error(`unbalanced math delimiters in: ${source}`);
+  }
+  let result = value.replace(/[\\&%$#_{}~^]/g, (character) => REPLACEMENTS[character]);
+  if (typography) {
+    for (const [pattern, replacement] of TYPOGRAPHY) result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function escapeRichTex(value) {
+  const parts = [];
+  const pattern = /\$\$[\s\S]*?\$\$|\$(?:\\.|[^$\\])*\$/g;
+  let index = 0;
+  for (const match of value.matchAll(pattern)) {
+    const start = match.index;
+    parts.push(escapeTex(value.slice(index, start), { source: value }));
+    parts.push(match[0]);
+    index = start + match[0].length;
+  }
+  parts.push(escapeTex(value.slice(index), { source: value }));
+  return parts.join("");
+}
+const URL_SPECIAL = /%[0-9A-Fa-f]{2}|[%\\{}^ #&]/g;
+function escapeUrl(value) {
+  return value.replace(URL_SPECIAL, (match) => {
+    if (match.length === 3 || match === "#" || match === "&") return `\\${match}`;
+    return `\\%${match.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
+  });
+}
+
+const sectionOptions = z.strictObject({
+  /**
+   * Keep entries whose field equals the value, or one of several values:
+   *
+   * ```yaml
+   * where: { kind: invited }
+   * where: { kind: [invited, seminar] }
+   * ```
+   */
+  where: z.record(z.string(), z.union([z.string(), z.array(z.string()).min(1)])).default({}),
+  /** Keep only the newest N entries. */
+  limit: z.number().int().positive().optional(),
+  /** Drop entries starting before this year. */
+  since: z.number().int().optional(),
+  /** Drop entries starting after this year. */
+  until: z.number().int().optional(),
+  /** Heading used by `\vitasection`; defaults to the section id, capitalised. */
+  title: z.string().min(1).optional()
+});
+const documentSchema = z.strictObject({
+  /**
+   * Highest visibility level this document may include. Defaults to `cv`,
+   * because a CV is the reason the `cv` level exists; use `private` for an
+   * application containing a cover letter, address or referees.
+   *
+   * There is no "publish this PDF" option: PDFs are never part of the website
+   * build (see `vitakit-check`), and the website renders CV data directly.
+   */
+  visibility: z.enum(["public", "cv", "private"]).default("cv"),
+  sections: z.record(z.string(), sectionOptions).default({}),
+  publications: z.strictObject({
+    groups: z.array(z.string()).optional()
+  }).default({})
+});
+const DEFAULTS = documentSchema.parse({});
+async function discoverDocuments(cvDir) {
+  const files = (await readdir(cvDir).catch(() => fail("cv-tex/", "directory is missing"))).filter((name) => name.endsWith(".tex")).sort();
+  const documents = [];
+  for (const file of files) {
+    const name = basename(file, ".tex");
+    const source = await readFile(join(cvDir, file), "utf8");
+    if (!/\\begin\{document\}/.test(source)) continue;
+    const optionsFile = join(cvDir, `${name}.yml`);
+    const raw = await readFile(optionsFile, "utf8").catch(() => void 0);
+    let options = DEFAULTS;
+    if (raw !== void 0) {
+      const parsed = documentSchema.safeParse(parse(raw) ?? {});
+      if (!parsed.success) fail(`cv-tex/${name}.yml`, `invalid
+${formatZodIssues(parsed.error)}`);
+      options = parsed.data;
+    }
+    documents.push({ name, texFile: join(cvDir, file), options });
+  }
+  if (!documents.length) fail("cv-tex/", "no .tex file contains \\begin{document}");
+  return documents;
+}
+function valueOf(entry, field) {
+  if (field === "year") return entry.date?.from?.year;
+  const value = entry[field];
+  if (typeof value === "object" && value !== null && "text" in value) return value.text;
+  if (typeof value === "object" && value !== null && "name" in value) return value.name;
+  return value;
+}
+function selectEntries(entries, options, sectionId) {
+  const section = options.sections[sectionId] ?? { where: {} };
+  let result = entries.filter((entry) => atMost(entry.visibility, options.visibility));
+  if (section.since !== void 0) {
+    result = result.filter((entry) => Number(valueOf(entry, "year") ?? 0) >= section.since);
+  }
+  if (section.until !== void 0) {
+    result = result.filter((entry) => Number(valueOf(entry, "year") ?? Infinity) <= section.until);
+  }
+  for (const [field, expected] of Object.entries(section.where ?? {})) {
+    const wanted = new Set(Array.isArray(expected) ? expected : [expected]);
+    result = result.filter((entry) => wanted.has(String(valueOf(entry, field) ?? "")));
+  }
+  return section.limit ? result.slice(0, section.limit) : result;
+}
+
+const bundledTexDir = resolveAsset("tex");
+const eta = new Eta({ autoEscape: false, autoTrim: [false, false] });
+function tidy(body) {
+  return body.replace(/[ \t]+$/gm, "").replace(/\n{2,}/g, "\n").trim();
+}
+const SITE_PATH_HELP = "is a path on the website, and the PDF can only link it with the address the site is published at: add it to content/profile.yml, e.g. `url: https://jane.example.org/`";
+function helpers(where, source) {
+  const tex = (value) => value === void 0 || value === null ? "" : escapeTex(String(value));
+  const rich = (value) => {
+    if (value === void 0 || value === null) return "";
+    const source2 = richSource(value);
+    try {
+      return escapeRichTex(source2);
+    } catch (error) {
+      return fail(where, error instanceof Error ? error.message : String(error));
+    }
+  };
+  const href = (value) => {
+    if (isSitePath(value)) fail(source, `${value} ${SITE_PATH_HELP}`);
+    return escapeUrl(value);
+  };
+  const url = (value) => value ? href(String(value)) : "";
+  const inst = (value) => {
+    const institution = value;
+    if (!institution?.name) return "";
+    return institution.url ? `\\href{${href(institution.url)}}{${escapeTex(institution.name)}}` : escapeTex(institution.name);
+  };
+  const linkOrText = (value) => {
+    if (typeof value === "string") return escapeTex(value);
+    const item = value;
+    if (!item?.label) return "";
+    return item.url ? `\\href{${href(item.url)}}{${escapeTex(item.label)}}` : escapeTex(item.label);
+  };
+  const date = (value) => escapeTex(formatDateRange(value));
+  const term = (entry) => typeof entry.term === "string" ? escapeTex(entry.term) : date(entry.date);
+  const titleOf = (entry) => {
+    const field = entryTitleField(entry);
+    return field ? entry[field] : "";
+  };
+  const secondaryOf = (entry) => entrySecondaryParts(entry, entryTitleField(entry)).map((part) => part.kind === "institution" ? inst(part.institution) : escapeTex(part.text)).filter(Boolean).join(", ");
+  const bibgroup = (group) => {
+    const unsafe = /[\s%#\\{},~]/;
+    const bad = [group.id, ...group.entries.map((entry) => entry.key)].find((value) => !value || unsafe.test(value));
+    if (bad !== void 0) {
+      fail(where, `"${bad}" cannot be used as a citation key or group id in LaTeX; use letters, digits and - _ : . / +`);
+    }
+    return `\\vitabibgroup{${group.id}}{${group.entries.map((entry) => entry.key).join(",")}}`;
+  };
+  return { tex, rich, url, inst, linkOrText, date, term, titleOf, secondaryOf, bibgroup };
+}
+async function resolveTemplate(id, userDir) {
+  const candidates = [join(userDir, `${id}.eta`), join(bundledTexDir, "templates", `${id}.eta`), join(bundledTexDir, "templates", "_generic.eta")];
+  for (const path of candidates) {
+    if (existsSync(path)) return { path, source: await readFile(path, "utf8") };
+  }
+  throw new Error(`vitakit: no template for section ${id}`);
+}
+async function assertTemplatesAreUsed(templateDir, ids) {
+  const files = await readdir(templateDir).catch(() => []);
+  const known = /* @__PURE__ */ new Set([...ids, "publications", "_generic"]);
+  for (const file of files.filter((name) => name.endsWith(".eta")).sort()) {
+    const id = file.slice(0, -".eta".length);
+    if (known.has(id)) continue;
+    const suggestion = ids.find((candidate) => candidate.startsWith(id) || id.startsWith(candidate));
+    fail(
+      `cv-tex/templates/${file}`,
+      `no section is called "${id}", so this template is never used${suggestion ? `; did you mean ${suggestion}.eta?` : ""}
+  sections: ${ids.join(", ") || "(none)"}`
+    );
+  }
+}
+async function emitDocument(emit) {
+  await mkdir(emit.outDir, { recursive: true });
+  await assertTemplatesAreUsed(emit.templateDir, Object.keys(emit.sections));
+  const written = [];
+  for (const [id, entries] of Object.entries(emit.sections)) {
+    const where = `cv-tex/generated/${id}.tex`;
+    const selected = selectEntries(entries, emit.options, id);
+    const { source } = await resolveTemplate(id, emit.templateDir);
+    let body;
+    try {
+      body = tidy(eta.renderString(source, { entries: selected, ...helpers(where, `content/${id}.yml`) }));
+    } catch (error) {
+      throw new Error(`template ${id}.eta: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    const file = join(emit.outDir, `${id}.tex`);
+    await writeFile(file, `% Generated by vitakit. Do not edit; edit content/${id}.yml instead.
+${body.trim()}
+`);
+    written.push(file);
+  }
+  if (emit.publications.length) {
+    const groups = emit.options.publications.groups ? emit.options.publications.groups.map((id) => emit.publications.find((group) => group.id === id)).filter((group) => group !== void 0) : emit.publications;
+    if (!emit.siteUrl) {
+      const local = groups.flatMap((group) => group.entries).find((entry) => entry.titleUrl && isSitePath(entry.titleUrl));
+      if (local) fail("content/publications.bib", `${local.key}: url ${local.titleUrl} ${SITE_PATH_HELP}`);
+    }
+    const { source } = await resolveTemplate("publications", emit.templateDir);
+    const body = tidy(eta.renderString(source, { groups, ...helpers("publications.tex", "content/publications.bib") }));
+    const file = join(emit.outDir, "publications.tex");
+    await writeFile(file, `% Generated by vitakit. Do not edit; edit content/publications.bib instead.
+${body.trim()}
+`);
+    written.push(file);
+  }
+  return written;
+}
+
+export { SITE_PATH_HELP as S, escapeTex as a, bundledTexDir as b, escapeUrl as c, discoverDocuments as d, emitDocument as e, documentSchema as f, escapeRichTex as g, selectEntries as s };

package/dist/shared/vitakit.BlU-p01e.mjs

@@ -0,0 +1,14 @@
+function isRichText(value) {
+  return typeof value === "object" && value !== null && typeof value.text === "string";
+}
+function richSource(value) {
+  if (typeof value === "string") return value;
+  return isRichText(value) ? value.text : "";
+}
+function richHtml(value) {
+  if (typeof value === "string") return value || void 0;
+  if (isRichText(value) && typeof value.html === "string") return value.html;
+  return void 0;
+}
+
+export { richHtml as a, richSource as r };

package/dist/shared/vitakit.BxcnlFGP.mjs

@@ -0,0 +1,325 @@
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { z } from 'zod';
+
+const PATH_KEY = "__vitakitPath";
+const isSitePath = (value) => value.startsWith("/") && !value.startsWith("//");
+const sitePathMarker = (path) => ({ [PATH_KEY]: path });
+function isSitePathMarker(value) {
+  return typeof value === "object" && value !== null && PATH_KEY in value;
+}
+function resolveSitePaths(value, resolve) {
+  if (isSitePathMarker(value)) return resolve(value[PATH_KEY]);
+  if (Array.isArray(value)) return value.map((item) => resolveSitePaths(item, resolve));
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveSitePaths(item, resolve)]));
+  }
+  return value;
+}
+function absoluteSitePath(path, siteUrl) {
+  return siteUrl ? `${siteUrl.replace(/\/?$/, "/")}${path.slice(1)}` : path;
+}
+
+function sourcePath(asset) {
+  return asset === "styles" ? asset : join("src", asset);
+}
+let root;
+function packageRoot() {
+  if (root) return root;
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (existsSync(join(dir, "package.json"))) return root = dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("vitakit: cannot locate the package root; the installation is incomplete");
+}
+const built = /[/\\]dist[/\\]/.test(import.meta.url);
+function resolveAsset(asset) {
+  const base = packageRoot();
+  const order = built ? ["dist", void 0] : [void 0, "dist"];
+  const candidates = order.map((prefix) => prefix ? join(base, prefix, asset) : join(base, sourcePath(asset)));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `vitakit: missing bundled asset "${asset}"; looked in
+` + candidates.map((candidate) => `  ${candidate}`).join("\n") + "\nRun `pnpm build` in the package, or reinstall it."
+  );
+}
+
+class ContentError extends Error {
+  constructor(where, message) {
+    super(`${where}: ${message}`);
+    this.where = where;
+    this.name = "ContentError";
+  }
+}
+function fail(where, message) {
+  throw new ContentError(where, message);
+}
+function messageOf(error) {
+  if (error instanceof ContentError) return error.message.slice(error.where.length + 2);
+  return error instanceof Error ? error.message : String(error);
+}
+function whereOf(error, fallback) {
+  return error instanceof ContentError ? error.where : fallback;
+}
+async function importProjectModule(path, mtimeMs, where) {
+  try {
+    return await import(`${pathToFileURL(path).href}?mtime=${mtimeMs}`);
+  } catch (error) {
+    fail(where, importFailure(error));
+  }
+}
+function importFailure(error, node = process.versions.node) {
+  if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+    return `cannot load TypeScript on Node ${node}; vitakit needs Node 22.18 or newer`;
+  }
+  return messageOf(error);
+}
+function formatZodIssues(error) {
+  return error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+}
+class Issues {
+  constructor(strict) {
+    this.strict = strict;
+  }
+  list = [];
+  /** Record a problem, or throw it when strict. */
+  record(where, message) {
+    if (this.strict) fail(where, message);
+    this.list.push({ where, message });
+  }
+  /** Run `run`; when lenient, record any failure and use `fallback` instead. */
+  async attempt(where, run, fallback) {
+    try {
+      return await run();
+    } catch (error) {
+      if (this.strict) throw error;
+      this.list.push({ where: whereOf(error, where), message: messageOf(error) });
+      return fallback;
+    }
+  }
+}
+
+const MARKER_KEY = "__vitakitRich";
+function isRichMarker(value) {
+  return typeof value === "object" && value !== null && MARKER_KEY in value;
+}
+function richMarker(value) {
+  return { [MARKER_KEY]: value };
+}
+function renderRichFields(value, renderer, path, where) {
+  if (isRichMarker(value)) {
+    try {
+      return { text: value[MARKER_KEY], html: renderer.inline(value[MARKER_KEY]) };
+    } catch (error) {
+      fail(where, `${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => renderRichFields(item, renderer, `${path}[${index}]`, where));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(
+      ([key, item]) => [key, renderRichFields(item, renderer, path ? `${path}.${key}` : key, where)]
+    ));
+  }
+  return value;
+}
+
+const text = z.string().trim().min(1);
+const richText = text.transform((value) => richMarker(value));
+const absoluteUrl = z.string().trim().refine(
+  // One check, not `.url().refine(...)`: zod runs a refinement even after
+  // `.url()` failed, and `new URL()` then throws instead of reporting.
+  (value) => URL.canParse(value) && ["http:", "https:", "mailto:"].includes(new URL(value).protocol),
+  "expected an http(s) or mailto URL"
+);
+const url = z.string().trim().transform((value, context) => {
+  if (isSitePath(value) && !/\s/.test(value)) return sitePathMarker(value);
+  const parsed = absoluteUrl.safeParse(value);
+  if (parsed.success) return parsed.data;
+  context.addIssue({ code: "custom", message: "expected an http(s) or mailto URL, or a path on the site such as /slides/talk.pdf" });
+  return z.NEVER;
+});
+const DATE = /^(\d{4})(?:-(\d{2}))?(?:-(\d{2}))?$/;
+function parseDatePoint(value, context) {
+  const match = DATE.exec(value);
+  if (!match) {
+    context.addIssue({ code: "custom", message: `expected a date like 2024, 2024-03 or 2024-03-15, got "${value}"` });
+    return void 0;
+  }
+  const [, y, m, d] = match;
+  const year = Number(y);
+  const month = m === void 0 ? void 0 : Number(m);
+  const day = d === void 0 ? void 0 : Number(d);
+  if (month !== void 0 && (month < 1 || month > 12)) {
+    context.addIssue({ code: "custom", message: `month out of range in "${value}"` });
+    return void 0;
+  }
+  if (day !== void 0) {
+    const date = new Date(Date.UTC(year, month - 1, day));
+    if (date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+      context.addIssue({ code: "custom", message: `"${value}" is not a real date` });
+      return void 0;
+    }
+  }
+  return {
+    raw: value,
+    year,
+    month,
+    day,
+    // Pad missing parts so that 2024 < 2024-03 < 2024-03-15 sorts correctly.
+    sortKey: `${String(year).padStart(4, "0")}-${String(month ?? 1).padStart(2, "0")}-${String(day ?? 1).padStart(2, "0")}`
+  };
+}
+const datePoint = z.union([z.string(), z.number().int()]).transform((value) => String(value));
+const dateRange = z.union([
+  datePoint,
+  z.strictObject({
+    from: datePoint,
+    to: z.union([datePoint, z.literal("present")]).optional()
+  })
+]).transform((value, context) => {
+  const source = typeof value === "string" ? { from: value, to: void 0 } : value;
+  const from = parseDatePoint(source.from, context);
+  const ongoing = source.to === "present";
+  const to = source.to === void 0 || ongoing ? void 0 : parseDatePoint(source.to, context);
+  if (!from || source.to !== void 0 && !ongoing && !to) return z.NEVER;
+  if (to && to.sortKey < from.sortKey) {
+    context.addIssue({ code: "custom", message: `range ends (${to.raw}) before it starts (${from.raw})` });
+    return z.NEVER;
+  }
+  return { from, to, ongoing, point: typeof value === "string" };
+});
+const institution = z.union([
+  text.transform((name) => ({ name })),
+  z.strictObject({ name: text, url: url.optional() })
+]);
+const link = z.union([
+  url.transform((value) => ({
+    label: typeof value === "string" ? value.replace(/^https?:\/\//, "").replace(/\/$/, "") : value[PATH_KEY],
+    url: value
+  })),
+  z.strictObject({ label: text, url })
+]);
+const visibility = z.enum(["public", "cv", "private"]).default("public");
+function entry(shape) {
+  return z.strictObject({ visibility, ...shape });
+}
+function section(shape) {
+  return z.array(entry(shape));
+}
+
+const education = section({
+  date: dateRange,
+  degree: text,
+  institution,
+  thesis: z.strictObject({
+    title: richText,
+    type: text.optional(),
+    supervisor: z.union([text, link]).optional(),
+    url: url.optional()
+  }).optional(),
+  note: text.optional()
+});
+
+const employment = section({
+  date: dateRange,
+  position: text,
+  institution,
+  project: z.strictObject({
+    title: richText,
+    funder: text.optional(),
+    grant: text.optional(),
+    url: url.optional()
+  }).optional(),
+  note: text.optional()
+});
+
+const teaching = section({
+  date: dateRange,
+  title: richText,
+  role: text.optional(),
+  institution: institution.optional(),
+  /** e.g. `2024S`, `Winter 2023/24` -- free text, shown as written. */
+  term: text.optional(),
+  url: url.optional(),
+  note: text.optional()
+});
+
+const talks = section({
+  date: dateRange,
+  /** Markdown, math allowed. */
+  title: richText,
+  event: text.optional(),
+  location: text.optional(),
+  kind: z.enum(["invited", "contributed", "seminar", "poster", "outreach"]).optional(),
+  url: url.optional(),
+  slides: url.optional()
+});
+
+const supervision = section({
+  date: dateRange,
+  student: text,
+  /** A thesis still in progress; shown as such instead of as completed. */
+  ongoing: z.boolean().default(false),
+  /** Markdown, math allowed. */
+  title: richText,
+  degree: text.optional(),
+  institution: institution.optional(),
+  coSupervisor: text.optional()
+});
+
+const profile = z.strictObject({
+  name: text,
+  title: text.optional(),
+  affiliation: institution.optional(),
+  email: z.string().trim().email().optional(),
+  links: z.array(link).default([]),
+  /**
+   * One or two sentences for metadata: the page description and social
+   * previews. Prose belongs in `content/pages/index.md`, which is where a
+   * reader sees it -- this is deliberately not rendered on the page.
+   */
+  summary: text.optional(),
+  /**
+   * Where the website is published, e.g. `https://jane.example.org/` or
+   * `https://jane.github.io/site/`. The PDF needs it to link paths on the site
+   * such as `/slides/talk.pdf`; the website itself does not.
+   */
+  url: absoluteUrl.optional(),
+  /** Path below `public/`, e.g. `/img/portrait.jpg`. */
+  avatar: text.startsWith("/").optional(),
+  /** Navigation, in the order it should appear. */
+  nav: z.array(z.strictObject({ label: text, to: text })).default([]),
+  /** Footer line; inline Markdown. */
+  footer: text.optional()
+});
+const page = z.strictObject({
+  title: text,
+  description: text.optional(),
+  route: text.regex(/^\/(?:[a-z0-9-]+\/)*$/, "expected a route like /research/").optional(),
+  order: z.number().int().default(100)
+});
+const schemas = {
+  education,
+  employment,
+  teaching,
+  talks,
+  supervision
+};
+function extendSection(base, shape) {
+  return z.array(base.element.extend(shape));
+}
+
+const LEVEL = { public: 0, cv: 1, private: 2 };
+function atMost(value, limit) {
+  return LEVEL[value ?? "public"] <= LEVEL[limit];
+}
+
+export { whereOf as A, messageOf as B, page as C, Issues as I, MARKER_KEY as M, employment as a, entry as b, extendSection as c, dateRange as d, education as e, section as f, supervision as g, teaching as h, institution as i, text as j, atMost as k, link as l, fail as m, isSitePath as n, resolveAsset as o, formatZodIssues as p, importProjectModule as q, richText as r, schemas as s, talks as t, url as u, visibility as v, renderRichFields as w, resolveSitePaths as x, profile as y, absoluteSitePath as z };