@singi-labs/sifa-sdk 0.12.57 → 0.12.59

package/dist/jsonld/index.cjs

@@ -0,0 +1,891 @@
+'use strict';
+
+// src/jsonld/terms.ts
+var VOCABULARIES = {
+  schema: "https://schema.org/",
+  bibo: "http://purl.org/ontology/bibo/",
+  dcterms: "http://purl.org/dc/terms/",
+  foaf: "http://xmlns.com/foaf/0.1/",
+  org: "http://www.w3.org/ns/org#",
+  prism: "http://prismstandard.org/namespaces/basic/2.1/",
+  event: "http://purl.org/NET/c4dm/event.owl#",
+  skos: "http://www.w3.org/2004/02/skos/core#"
+};
+var UNMAPPED = [
+  {
+    lexicon: "id.sifa.confirmation",
+    terms: [],
+    match: "noMatch",
+    note: "A record affirming another record is reification. schema:Review and schema:ClaimReview both imply an evaluation that a confirmation does not make."
+  },
+  {
+    lexicon: "id.sifa.endorsement",
+    terms: [],
+    match: "noMatch",
+    note: "Same reification problem as confirmation. Any mapping that lets a consumer aggregate endorsements into a score works against the descriptive-only trust model."
+  },
+  {
+    lexicon: "id.sifa.graph.connection",
+    terms: [],
+    match: "noMatch",
+    note: "foaf:knows carries no consent semantics. A Sifa connection is bilateral and confirmed; flattening it to foaf:knows would misrepresent an unconfirmed acquaintance claim as mutual."
+  },
+  {
+    lexicon: "id.sifa.graph.follow",
+    terms: [],
+    match: "noMatch",
+    note: "See id.sifa.graph.connection."
+  },
+  {
+    lexicon: "id.sifa.meeting",
+    terms: [],
+    match: "noMatch",
+    note: "Attestation semantics; same reification problem as confirmation."
+  }
+];
+var PROFILE_SELF = [
+  { lexicon: "id.sifa.profile.self", terms: ["schema:Person", "foaf:Person"], match: "exactMatch" },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "displayName",
+    terms: ["schema:name", "foaf:name"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "givenName",
+    terms: ["schema:givenName", "foaf:givenname"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "familyName",
+    terms: ["schema:familyName", "foaf:family_name"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "avatar",
+    terms: ["schema:image", "foaf:depiction"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "headline",
+    terms: ["schema:jobTitle"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "about",
+    terms: ["schema:description"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "location",
+    terms: ["schema:homeLocation"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "pronouns",
+    terms: [],
+    match: "noMatch",
+    note: "No stable external term. schema.org has no pronouns property."
+  },
+  {
+    lexicon: "id.sifa.profile.self",
+    field: "discoverable",
+    terms: [],
+    match: "noMatch",
+    note: "Sifa indexing control, not a fact about the person."
+  }
+];
+var PROFILE_POSITION = [
+  {
+    lexicon: "id.sifa.profile.position",
+    terms: ["org:Membership", "schema:OrganizationRole"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "company",
+    terms: ["org:organization", "schema:worksFor"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "entityRef",
+    terms: ["schema:sameAs"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "title",
+    terms: ["org:role", "schema:roleName"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "description",
+    terms: ["dcterms:description"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "employmentType",
+    terms: ["schema:employmentType"],
+    match: "closeMatch",
+    note: "schema:employmentType is free text. ESCO is the better value anchor."
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "workplaceType",
+    terms: ["schema:jobLocationType"],
+    match: "narrowMatch",
+    note: "schema.org models only a remote flag; Sifa distinguishes onSite, remote, and hybrid."
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "location",
+    terms: ["schema:jobLocation"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "startedAt",
+    terms: ["schema:startDate"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "endedAt",
+    terms: ["schema:endDate"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.position",
+    field: "isPrimary",
+    terms: [],
+    match: "noMatch",
+    note: "Sifa display ordering concern."
+  }
+];
+var PROFILE_EDUCATION = [
+  {
+    lexicon: "id.sifa.profile.education",
+    terms: ["schema:EducationalOccupationalCredential"],
+    match: "closeMatch",
+    note: "One record maps to two schema.org assertions: alumniOf for the institution and hasCredential for the degree."
+  },
+  {
+    lexicon: "id.sifa.profile.education",
+    field: "institution",
+    terms: ["schema:alumniOf"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.education",
+    field: "degree",
+    terms: ["schema:hasCredential", "bibo:degree"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.education",
+    field: "fieldOfStudy",
+    terms: ["schema:educationalCredentialAwarded"],
+    match: "closeMatch",
+    note: "ISCED-F is the value anchor."
+  },
+  {
+    lexicon: "id.sifa.profile.education",
+    field: "grade",
+    terms: [],
+    match: "noMatch",
+    note: "No comparable external term; grading scales are not portable."
+  }
+];
+var PROFILE_PUBLICATION = [
+  {
+    lexicon: "id.sifa.profile.publication",
+    terms: ["bibo:Document", "schema:CreativeWork"],
+    match: "broadMatch",
+    note: "Refine to bibo:AcademicArticle, bibo:Book, bibo:Report or bibo:Thesis when a resource type is known. COAR is the value anchor."
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "title",
+    terms: ["dcterms:title", "schema:name"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "subtitle",
+    terms: ["schema:alternativeHeadline"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "publisher",
+    terms: ["dcterms:publisher", "schema:publisher"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "url",
+    terms: ["bibo:uri", "schema:url"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "description",
+    terms: ["bibo:abstract", "schema:abstract"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "authors",
+    terms: ["bibo:authorList", "schema:author"],
+    match: "exactMatch",
+    note: "bibo:authorList is an ordered rdf:List and preserves author order, which schema:author does not guarantee."
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "publishedAt",
+    terms: ["dcterms:issued", "schema:datePublished"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.publication",
+    field: "doi",
+    terms: ["bibo:doi", "prism:doi"],
+    match: "exactMatch",
+    note: "Present on the AppView view type (ORCID-sourced), not yet on the id.sifa.profile.publication lexicon, so user-authored publications cannot carry one."
+  }
+];
+var PROFILE_PRESENTATION = [
+  {
+    lexicon: "id.sifa.profile.presentation",
+    terms: ["bibo:Slideshow", "schema:PresentationDigitalDocument"],
+    match: "closeMatch",
+    note: 'Neither term carries the "reusable, deliverable more than once" semantics of the Sifa record.'
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "title",
+    terms: ["dcterms:title", "schema:name"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "description",
+    terms: ["bibo:abstract", "schema:abstract"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "duration",
+    terms: ["schema:timeRequired"],
+    match: "narrowMatch",
+    note: "The lexicon models a range; schema:timeRequired is a single ISO 8601 duration."
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "intendedAudiences",
+    terms: ["schema:audience"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "writeupRef",
+    terms: ["dcterms:isReferencedBy", "schema:subjectOf"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentation",
+    field: "coverImage",
+    terms: ["schema:image", "foaf:depiction"],
+    match: "exactMatch"
+  }
+];
+var PROFILE_PRESENTATION_DELIVERY = [
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    terms: ["schema:Event", "event:Event"],
+    match: "closeMatch",
+    note: "BIBO models this relation as bibo:Slideshow bibo:presentedAt event:Event."
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "presentationRef",
+    terms: ["bibo:presentedAt", "schema:workPerformed"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "title",
+    terms: ["dcterms:title", "schema:name"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "role",
+    terms: ["bibo:performer", "schema:performer"],
+    match: "closeMatch",
+    note: "No external vocabulary distinguishes presenter, panelist, keynote, workshop and host at this granularity."
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "eventName",
+    terms: ["schema:superEvent", "bibo:Conference"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "date",
+    terms: ["schema:startDate", "event:time"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "address",
+    terms: ["schema:location", "event:place"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "mode",
+    terms: ["schema:eventAttendanceMode"],
+    match: "exactMatch",
+    note: "The community.lexicon.calendar.event known values are already one-to-one with the schema.org enumeration."
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "status",
+    terms: ["schema:eventStatus"],
+    match: "exactMatch",
+    note: "As with mode, already one-to-one with the schema.org enumeration."
+  },
+  {
+    lexicon: "id.sifa.profile.presentationDelivery",
+    field: "coSpeakers",
+    terms: ["schema:performer"],
+    match: "exactMatch"
+  }
+];
+var PROFILE_OTHER = [
+  {
+    lexicon: "id.sifa.profile.certification",
+    terms: ["schema:EducationalOccupationalCredential"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.certification",
+    field: "credentialUrl",
+    terms: ["schema:url"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.certification",
+    field: "expiresAt",
+    terms: ["schema:validUntil"],
+    match: "exactMatch"
+  },
+  { lexicon: "id.sifa.profile.course", terms: ["schema:Course"], match: "exactMatch" },
+  {
+    lexicon: "id.sifa.profile.course",
+    field: "number",
+    terms: ["schema:courseCode"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.honor",
+    terms: ["schema:award"],
+    match: "broadMatch",
+    note: "schema:award is a bare string, so issuer and date are lost. No better term exists in BIBO either."
+  },
+  {
+    lexicon: "id.sifa.profile.project",
+    terms: ["schema:Project", "foaf:Project"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.skill",
+    terms: ["schema:knowsAbout", "schema:DefinedTerm"],
+    match: "closeMatch",
+    note: "ESCO is the value anchor."
+  },
+  {
+    lexicon: "id.sifa.profile.volunteering",
+    terms: ["org:Membership", "schema:OrganizationRole"],
+    match: "closeMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.involvement",
+    terms: ["org:Membership"],
+    match: "broadMatch",
+    note: "The kind known values have no external equivalent."
+  },
+  {
+    lexicon: "id.sifa.profile.language",
+    terms: ["schema:knowsLanguage"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.profile.language",
+    field: "proficiency",
+    terms: [],
+    match: "noMatch",
+    note: "The known values are CEFR-shaped but not CEFR-named. Map only; renaming a published lexicon for a cosmetic gain is not worth the break."
+  },
+  {
+    lexicon: "id.sifa.profile.externalAccount",
+    terms: ["schema:sameAs", "foaf:account"],
+    match: "exactMatch"
+  },
+  {
+    lexicon: "id.sifa.org.profile",
+    terms: ["schema:Organization", "org:FormalOrganization"],
+    match: "exactMatch",
+    note: "ROR is the value anchor."
+  }
+];
+var TERM_MAPPINGS = [
+  ...PROFILE_SELF,
+  ...PROFILE_POSITION,
+  ...PROFILE_EDUCATION,
+  ...PROFILE_PUBLICATION,
+  ...PROFILE_PRESENTATION,
+  ...PROFILE_PRESENTATION_DELIVERY,
+  ...PROFILE_OTHER,
+  ...UNMAPPED
+];
+function expandCurie(curie) {
+  const separator = curie.indexOf(":");
+  if (separator <= 0) return null;
+  const prefix = curie.slice(0, separator);
+  const local = curie.slice(separator + 1);
+  if (!local) return null;
+  if (!Object.prototype.hasOwnProperty.call(VOCABULARIES, prefix)) return null;
+  return `${VOCABULARIES[prefix]}${local}`;
+}
+function mappingsForLexicon(nsid) {
+  return TERM_MAPPINGS.filter((m) => m.lexicon === nsid);
+}
+function isDeliberatelyUnmapped(nsid, field) {
+  return TERM_MAPPINGS.some(
+    (m) => m.lexicon === nsid && m.field === field && m.match === "noMatch"
+  );
+}
+
+// src/format/location-utils.ts
+function formatLocation(loc) {
+  if (!loc) return "";
+  const locality = loc.locality ?? loc.city;
+  const parts = [locality, loc.region, loc.country].filter(Boolean);
+  if (loc.postalCode && !locality) {
+    return `${loc.postalCode}, ${loc.country}`;
+  }
+  return parts.join(", ");
+}
+
+// src/logic/primary-position.ts
+function pickPrimaryPosition(positions) {
+  if (!positions || positions.length === 0) return void 0;
+  const active = positions.filter((p) => !p.endedAt);
+  if (active.length === 0) return void 0;
+  const flagged = active.find((p) => p.primary === true);
+  if (flagged) return flagged;
+  return [...active].sort((a, b) => (b.startedAt ?? "").localeCompare(a.startedAt ?? ""))[0];
+}
+
+// src/profile/section-model.ts
+function filterHidden(items) {
+  return (items ?? []).filter((i) => !i.hidden);
+}
+
+// src/jsonld/url.ts
+var DEFAULT_BASE_URL = "https://sifa.id";
+function normaliseBaseUrl(baseUrl) {
+  const value = baseUrl ?? DEFAULT_BASE_URL;
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;
+  return value.slice(0, end);
+}
+function profileUrl(baseUrl, handle) {
+  return `${baseUrl}/p/${handle}`;
+}
+
+// src/jsonld/profile.ts
+var MAX_KNOWS_ABOUT = 20;
+var MEANINGFUL_TEXT_RE = /[\p{L}\p{N}]/u;
+var identity = (input) => input;
+function hasMeaningfulText(value) {
+  return typeof value === "string" && MEANINGFUL_TEXT_RE.test(value);
+}
+function visible(items) {
+  return filterHidden(items ? [...items] : void 0);
+}
+function rankKnowsAbout(skills, s) {
+  const ranked = visible(skills).filter((sk) => Boolean(sk.name)).sort((a, b) => (b.endorsementCount ?? 0) - (a.endorsementCount ?? 0)).slice(0, MAX_KNOWS_ABOUT).map((sk) => s(sk.name));
+  return ranked.length > 0 ? ranked : void 0;
+}
+function buildSameAs(profile) {
+  const sameAs = [];
+  const hasBluesky = profile.activeApps?.some((a) => a.id === "bluesky") ?? false;
+  if (hasBluesky) sameAs.push(`https://bsky.app/profile/${profile.handle}`);
+  if (profile.website) {
+    const url = profile.website.startsWith("http") ? profile.website : `https://${profile.website}`;
+    if (!sameAs.includes(url)) sameAs.push(url);
+  }
+  for (const account of profile.verifiedAccounts ?? []) {
+    if (account.url && !sameAs.includes(account.url)) sameAs.push(account.url);
+  }
+  return sameAs;
+}
+function buildHomeLocation(location, s) {
+  const addressLocality = location.locality ?? location.city;
+  const addressCountry = location.countryCode;
+  const hasAddress = Boolean(addressLocality) || Boolean(addressCountry);
+  return {
+    "@type": "Place",
+    name: s(formatLocation(location)),
+    ...hasAddress && {
+      address: {
+        "@type": "PostalAddress",
+        ...addressLocality && { addressLocality: s(addressLocality) },
+        ...addressCountry && { addressCountry }
+      }
+    }
+  };
+}
+function buildPersonJsonLd(profile, options = {}) {
+  const s = options.sanitize ?? identity;
+  const baseUrl = normaliseBaseUrl(options.baseUrl);
+  const positions = visible(profile.positions);
+  const currentPosition = pickPrimaryPosition(positions);
+  const knowsAbout = rankKnowsAbout(profile.skills, s);
+  const sameAs = buildSameAs(profile);
+  const hasCredential = [
+    ...visible(profile.education).filter((e) => e.degree).map((e) => ({
+      "@type": "EducationalOccupationalCredential",
+      credentialCategory: "degree",
+      name: [e.degree, e.fieldOfStudy].filter(Boolean).join(" "),
+      ...e.institution && {
+        recognizedBy: { "@type": "EducationalOrganization", name: s(e.institution) }
+      }
+    })),
+    ...visible(profile.certifications).filter((c) => c.name).map((c) => ({
+      "@type": "EducationalOccupationalCredential",
+      name: s(c.name),
+      ...(c.authority ?? c.issuingOrg) && {
+        recognizedBy: {
+          "@type": "Organization",
+          name: s(c.authority ?? c.issuingOrg)
+        }
+      },
+      ...c.credentialUrl && { url: c.credentialUrl }
+    }))
+  ];
+  const givenTrimmed = profile.givenName?.trim();
+  const familyTrimmed = profile.familyName?.trim();
+  const structuredName = givenTrimmed && familyTrimmed ? `${givenTrimmed} ${familyTrimmed}` : void 0;
+  const awards = visible(profile.honors).filter((h) => h.title).map((h) => s(h.title));
+  const languages = visible(profile.languages).filter((l) => l.language).map((l) => l.language);
+  return {
+    "@context": "https://schema.org",
+    "@type": "Person",
+    name: s(structuredName ?? profile.displayName ?? profile.handle),
+    ...givenTrimmed && { givenName: s(givenTrimmed) },
+    ...familyTrimmed && { familyName: s(familyTrimmed) },
+    jobTitle: hasMeaningfulText(profile.headline) ? s(profile.headline) : currentPosition?.title ? s(currentPosition.title) : void 0,
+    description: hasMeaningfulText(profile.about) ? s(profile.about) : void 0,
+    url: `${baseUrl}/p/${profile.handle}`,
+    image: profile.avatar ?? void 0,
+    ...profile.location && { homeLocation: buildHomeLocation(profile.location, s) },
+    ...positions.length > 0 && {
+      worksFor: positions.filter((p) => p.company).map((p) => ({
+        "@type": "Organization",
+        name: s(p.company),
+        ...p.title && {
+          member: {
+            "@type": "OrganizationRole",
+            roleName: s(p.title),
+            ...p.startedAt && { startDate: p.startedAt },
+            ...p.endedAt && { endDate: p.endedAt }
+          }
+        }
+      }))
+    },
+    ...visible(profile.education).length > 0 && {
+      alumniOf: visible(profile.education).filter((e) => e.institution).map((e) => ({ "@type": "EducationalOrganization", name: s(e.institution) }))
+    },
+    ...hasCredential.length > 0 && { hasCredential },
+    ...visible(profile.volunteering).length > 0 && {
+      memberOf: visible(profile.volunteering).filter((v) => v.organization).map((v) => ({
+        "@type": "OrganizationRole",
+        memberOf: { "@type": "Organization", name: s(v.organization) },
+        ...v.role && { roleName: s(v.role) },
+        ...v.startDate && { startDate: v.startDate },
+        ...v.endDate && { endDate: v.endDate }
+      }))
+    },
+    ...awards.length > 0 && { award: awards },
+    ...languages.length > 0 && { knowsLanguage: languages },
+    ...knowsAbout && { knowsAbout },
+    ...sameAs.length > 0 && { sameAs }
+  };
+}
+var PROFILE_SECTION_HAS_PART = [
+  { id: "about", label: "About", populated: (p) => Boolean(p.about && p.headline) },
+  { id: "career", label: "Career", populated: (p) => visible(p.positions).length > 0 },
+  { id: "education", label: "Education", populated: (p) => visible(p.education).length > 0 },
+  { id: "projects", label: "Projects", populated: (p) => (p.projects?.length ?? 0) > 0 },
+  {
+    id: "credentials",
+    label: "Credentials",
+    populated: (p) => visible(p.certifications).length > 0
+  },
+  {
+    id: "publications",
+    label: "Publications",
+    populated: (p) => (p.publications?.length ?? 0) > 0
+  },
+  {
+    id: "volunteering",
+    label: "Volunteering",
+    populated: (p) => visible(p.volunteering).length > 0
+  },
+  { id: "awards", label: "Awards", populated: (p) => visible(p.honors).length > 0 },
+  { id: "languages", label: "Languages", populated: (p) => visible(p.languages).length > 0 },
+  { id: "skills", label: "Skills", populated: (p) => visible(p.skills).length > 0 },
+  {
+    id: "other-profiles",
+    label: "Other profiles",
+    populated: (p) => (p.externalAccounts?.length ?? 0) > 0
+  }
+];
+function buildProfilePageJsonLd(profile, options = {}) {
+  const person = buildPersonJsonLd(profile, options);
+  const { "@context": _context, ...personWithoutContext } = person;
+  const url = `${normaliseBaseUrl(options.baseUrl)}/p/${profile.handle}`;
+  const hasPart = PROFILE_SECTION_HAS_PART.filter((section) => section.populated(profile)).map(
+    (section) => ({
+      "@type": "WebPageElement",
+      name: section.label,
+      url: `${url}#${section.id}`
+    })
+  );
+  return {
+    "@context": "https://schema.org",
+    "@type": "ProfilePage",
+    url,
+    ...profile.updatedAt && { dateModified: profile.updatedAt },
+    mainEntity: personWithoutContext,
+    ...hasPart.length > 0 && { hasPart }
+  };
+}
+function buildBreadcrumbListJsonLd(profile, options = {}) {
+  const s = options.sanitize ?? identity;
+  const baseUrl = normaliseBaseUrl(options.baseUrl);
+  const name = s(profile.displayName ?? profile.handle);
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: [
+      { "@type": "ListItem", position: 1, name: "Sifa", item: `${baseUrl}/` },
+      {
+        "@type": "ListItem",
+        position: 2,
+        name,
+        item: `${baseUrl}/p/${profile.handle}`
+      }
+    ]
+  };
+}
+
+// src/format/talk-slug.ts
+var MAX_SLUG_LENGTH = 60;
+var COMBINING_MARKS = /[̀-ͯ]/g;
+function slugifyTitle(title) {
+  const slug = title.normalize("NFKD").replace(COMBINING_MARKS, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.slice(0, MAX_SLUG_LENGTH).replace(/-+$/g, "");
+}
+function buildTalkSlug(title, rkey) {
+  const slug = slugifyTitle(title);
+  return slug ? `${slug}-${rkey}` : rkey;
+}
+
+// src/jsonld/works.ts
+var DOI_RESOLVER = "https://doi.org/";
+var ORCID_RESOLVER = "https://orcid.org/";
+var identity2 = (input) => input;
+function authorNode(author, baseUrl, s) {
+  return {
+    "@type": "Person",
+    name: s(author.displayName ?? author.handle),
+    url: profileUrl(baseUrl, author.handle)
+  };
+}
+function confirmedActorNodes(actors, baseUrl, s) {
+  return (actors ?? []).filter((a) => a.confirmed === true && Boolean(a.handle)).map((a) => ({
+    "@type": "Person",
+    name: s(a.displayName ?? a.handle),
+    url: profileUrl(baseUrl, a.handle)
+  }));
+}
+function visible2(items) {
+  return filterHidden(items ? [...items] : void 0);
+}
+var ATTENDANCE_MODE = {
+  "community.lexicon.calendar.event#inperson": "https://schema.org/OfflineEventAttendanceMode",
+  "community.lexicon.calendar.event#virtual": "https://schema.org/OnlineEventAttendanceMode",
+  "community.lexicon.calendar.event#hybrid": "https://schema.org/MixedEventAttendanceMode"
+};
+var EVENT_STATUS = {
+  "community.lexicon.calendar.event#scheduled": "https://schema.org/EventScheduled",
+  "community.lexicon.calendar.event#cancelled": "https://schema.org/EventCancelled",
+  "community.lexicon.calendar.event#postponed": "https://schema.org/EventPostponed",
+  "community.lexicon.calendar.event#rescheduled": "https://schema.org/EventRescheduled"
+};
+var LINK_SLIDES = "id.sifa.defs#linkSlides";
+var LINK_RECORDING = "id.sifa.defs#linkRecording";
+function lookup(table, key) {
+  if (!key) return void 0;
+  return Object.prototype.hasOwnProperty.call(table, key) ? table[key] : void 0;
+}
+function deliveryPlace(delivery, s) {
+  const addressLocality = delivery.locationLocality ?? void 0;
+  const addressRegion = delivery.locationRegion ?? void 0;
+  const addressCountry = delivery.countryCode ?? void 0;
+  if (addressLocality || addressRegion || addressCountry) {
+    return {
+      "@type": "Place",
+      address: {
+        "@type": "PostalAddress",
+        ...addressLocality && { addressLocality: s(addressLocality) },
+        ...addressRegion && { addressRegion: s(addressRegion) },
+        ...addressCountry && { addressCountry }
+      }
+    };
+  }
+  if (delivery.location) {
+    return { "@type": "Place", name: s(delivery.location) };
+  }
+  return void 0;
+}
+function linkOfType(links, type) {
+  return links?.find((l) => l.type === type)?.uri;
+}
+function buildPresentationJsonLd(presentation, author, options = {}) {
+  const s = options.sanitize ?? identity2;
+  const baseUrl = normaliseBaseUrl(options.baseUrl);
+  const speaker = authorNode(author, baseUrl, s);
+  const events = visible2(presentation.deliveries).map((delivery) => {
+    const place = deliveryPlace(delivery, s);
+    const recording = linkOfType(delivery.links, LINK_RECORDING);
+    const slides = linkOfType(delivery.links, LINK_SLIDES) ?? linkOfType(presentation.links, LINK_SLIDES);
+    return {
+      "@type": "Event",
+      name: s(delivery.eventName ?? delivery.title ?? presentation.title),
+      ...delivery.date && { startDate: delivery.date },
+      ...place && { location: place },
+      ...lookup(ATTENDANCE_MODE, delivery.mode) && {
+        eventAttendanceMode: lookup(ATTENDANCE_MODE, delivery.mode)
+      },
+      ...lookup(EVENT_STATUS, delivery.status) && {
+        eventStatus: lookup(EVENT_STATUS, delivery.status)
+      },
+      performer: [speaker, ...confirmedActorNodes(delivery.coSpeakers, baseUrl, s)],
+      ...recording && { recordedIn: { "@type": "VideoObject", url: recording } },
+      ...slides && {
+        workFeatured: { "@type": "PresentationDigitalDocument", url: slides }
+      }
+    };
+  });
+  return {
+    "@context": "https://schema.org",
+    "@type": "PresentationDigitalDocument",
+    name: s(presentation.title),
+    ...presentation.description && { abstract: s(presentation.description) },
+    ...presentation.duration && { timeRequired: `PT${presentation.duration.minMinutes}M` },
+    ...presentation.coverImageUrl && { image: presentation.coverImageUrl },
+    author: speaker,
+    url: `${baseUrl}/p/${author.handle}/talk/${buildTalkSlug(presentation.title, presentation.rkey)}`,
+    ...events.length > 0 && { subjectOf: events }
+  };
+}
+function bareDoi(doi) {
+  return doi.replace(/^https?:\/\/(dx\.)?doi\.org\//i, "").replace(/^doi:/i, "");
+}
+function buildPublicationJsonLd(publication, author, options = {}) {
+  const s = options.sanitize ?? identity2;
+  const baseUrl = normaliseBaseUrl(options.baseUrl);
+  const authors = publication.contributors && publication.contributors.length > 0 ? publication.contributors.map((c) => ({
+    "@type": "Person",
+    name: s(c.name),
+    ...c.handle && { url: profileUrl(baseUrl, c.handle) },
+    ...c.orcidId && { sameAs: [`${ORCID_RESOLVER}${c.orcidId}`] }
+  })) : [authorNode(author, baseUrl, s)];
+  const doi = publication.doi ? bareDoi(publication.doi) : void 0;
+  return {
+    "@context": "https://schema.org",
+    "@type": "ScholarlyArticle",
+    name: s(publication.title),
+    ...publication.subtitle && { alternativeHeadline: s(publication.subtitle) },
+    ...publication.description && { abstract: s(publication.description) },
+    ...publication.publisher && {
+      publisher: { "@type": "Organization", name: s(publication.publisher) }
+    },
+    ...publication.date && { datePublished: publication.date },
+    ...publication.url && { url: publication.url },
+    author: authors,
+    ...doi && {
+      identifier: { "@type": "PropertyValue", propertyID: "DOI", value: doi },
+      sameAs: [`${DOI_RESOLVER}${doi}`]
+    }
+  };
+}
+function buildCourseJsonLd(course, options = {}) {
+  const s = options.sanitize ?? identity2;
+  return {
+    "@context": "https://schema.org",
+    "@type": "Course",
+    name: s(course.name),
+    ...course.number && { courseCode: s(course.number) },
+    ...course.institution && {
+      provider: { "@type": "EducationalOrganization", name: s(course.institution) }
+    }
+  };
+}
+function buildProjectJsonLd(project, author, options = {}) {
+  const s = options.sanitize ?? identity2;
+  const baseUrl = normaliseBaseUrl(options.baseUrl);
+  const members = confirmedActorNodes(project.members, baseUrl, s);
+  return {
+    "@context": "https://schema.org",
+    "@type": "Project",
+    name: s(project.name),
+    ...project.description && { description: s(project.description) },
+    ...project.url && { url: project.url },
+    ...project.startDate && { startDate: project.startDate },
+    ...project.endDate && { endDate: project.endDate },
+    member: [authorNode(author, baseUrl, s), ...members]
+  };
+}
+
+exports.TERM_MAPPINGS = TERM_MAPPINGS;
+exports.VOCABULARIES = VOCABULARIES;
+exports.buildBreadcrumbListJsonLd = buildBreadcrumbListJsonLd;
+exports.buildCourseJsonLd = buildCourseJsonLd;
+exports.buildPersonJsonLd = buildPersonJsonLd;
+exports.buildPresentationJsonLd = buildPresentationJsonLd;
+exports.buildProfilePageJsonLd = buildProfilePageJsonLd;
+exports.buildProjectJsonLd = buildProjectJsonLd;
+exports.buildPublicationJsonLd = buildPublicationJsonLd;
+exports.expandCurie = expandCurie;
+exports.isDeliberatelyUnmapped = isDeliberatelyUnmapped;
+exports.mappingsForLexicon = mappingsForLexicon;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map