@cavuno/board 3.0.0 → 3.2.0

package/dist/chunk-STE77MAT.mjs

@@ -0,0 +1,844 @@
+import {
+  getSalaryLexicon,
+  uiCopy
+} from "./chunk-IJCJ26SQ.mjs";
+
+// src/seo/salary.ts
+var compactCurrencyCache = /* @__PURE__ */ new Map();
+function getCompactCurrencyFormatter(language) {
+  const cached = compactCurrencyCache.get(language);
+  if (cached) return cached;
+  const formatter = new Intl.NumberFormat(language, {
+    style: "currency",
+    currency: "USD",
+    notation: "compact",
+    compactDisplay: "short",
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1
+  });
+  compactCurrencyCache.set(language, formatter);
+  return formatter;
+}
+function formatUsd(locale, value) {
+  try {
+    return getCompactCurrencyFormatter(locale).format(value);
+  } catch {
+    if (value >= 1e6) {
+      const millions = value / 1e6;
+      return `$${millions % 1 === 0 ? millions : millions.toFixed(1)}M`;
+    }
+    if (value >= 1e3) {
+      const thousands = value / 1e3;
+      return `$${thousands % 1 === 0 ? thousands : thousands.toFixed(1)}k`;
+    }
+    return `$${value}`;
+  }
+}
+function formatRange(locale, min, max) {
+  return `${formatUsd(locale, min)} \u2013 ${formatUsd(locale, max)}`;
+}
+function formatSeniority(locale, value, overrides) {
+  if (overrides?.[value]) {
+    return overrides[value];
+  }
+  const lexiconLabel = getSalaryLexicon(locale).seniority[value];
+  if (lexiconLabel) {
+    return lexiconLabel;
+  }
+  return value.replace(/_/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+var SENIORITY_ORDER = [
+  "entry_level",
+  "associate",
+  "mid_level",
+  "senior",
+  "lead",
+  "principal",
+  "director",
+  "executive"
+];
+function sortBySeniority(items) {
+  return [...items].sort((a, b) => {
+    const aIdx = SENIORITY_ORDER.indexOf(
+      a.seniority
+    );
+    const bIdx = SENIORITY_ORDER.indexOf(
+      b.seniority
+    );
+    return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
+  });
+}
+var yearly = {
+  unitText: "YEAR",
+  duration: "P1Y"
+};
+function distribution(name, currency, minValue, maxValue, stats = {}) {
+  return {
+    "@type": "MonetaryAmountDistribution",
+    name,
+    currency,
+    minValue,
+    maxValue,
+    ...stats,
+    ...yearly
+  };
+}
+function seniorityDistributions(locale, rows, currency, nameFor) {
+  return rows.map(
+    (row) => distribution(
+      nameFor(formatSeniority(locale, row.seniority)),
+      currency,
+      row.avgSalaryMin,
+      row.avgSalaryMax
+    )
+  );
+}
+function salaryEnvelope(type, name, extra, estimatedSalary) {
+  return {
+    "@context": "https://schema.org",
+    "@type": type,
+    name,
+    ...extra,
+    estimatedSalary
+  };
+}
+function buildSalaryFaq(locale, label, overall) {
+  if (!overall) return [];
+  const range = formatRange(locale, overall.avgMin, overall.avgMax);
+  return [
+    {
+      q: `What is the average salary for ${label}?`,
+      a: `The average salary for ${label} is ${range} per year, based on ${overall.jobCount} job ${overall.jobCount === 1 ? "posting" : "postings"} on this board that disclose pay.`
+    },
+    {
+      q: `How is the salary figure for ${label} calculated?`,
+      a: `These figures are aggregated from current and recent job postings on this board that disclose pay, then averaged across roles. They are estimates, not guarantees of compensation.`
+    }
+  ];
+}
+function itemListJsonLd(items) {
+  if (items.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "ItemList",
+    numberOfItems: items.length,
+    itemListElement: items.map((it, i) => ({
+      "@type": "ListItem",
+      position: i + 1,
+      name: it.name,
+      url: it.url
+    }))
+  };
+}
+function faqJsonLd(faqs) {
+  if (faqs.length === 0) return null;
+  return {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: faqs.map((f) => ({
+      "@type": "Question",
+      name: f.q,
+      acceptedAnswer: { "@type": "Answer", text: f.a }
+    }))
+  };
+}
+function titleSalaryJsonLd(locale, d) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope("Occupation", d.categoryName, {}, [
+    distribution(
+      `${d.categoryName} salary (all levels)`,
+      d.currency,
+      d.overallSalary.avgMin,
+      d.overallSalary.avgMax,
+      {
+        ...d.boardP25Min ? { percentile25: d.boardP25Min } : {},
+        ...d.boardP75Max ? { percentile75: d.boardP75Max } : {}
+      }
+    ),
+    ...seniorityDistributions(
+      locale,
+      d.bySeniority,
+      d.currency,
+      (label) => `${label} ${d.categoryName}`
+    )
+  ]);
+}
+function skillSalaryJsonLd(d) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope("Occupation", d.skillName, {}, [
+    distribution(
+      `${d.skillName} salary (all levels)`,
+      d.currency,
+      d.overallSalary.avgMin,
+      d.overallSalary.avgMax,
+      {
+        median: Math.round(
+          (d.overallSalary.medianMin + d.overallSalary.medianMax) / 2
+        )
+      }
+    )
+  ]);
+}
+function locationSalaryJsonLd(d) {
+  const isCity = d.adminLevel === "city" || d.adminLevel === "locality";
+  if (!isCity || !d.overallSalary) return null;
+  return salaryEnvelope(
+    "Occupation",
+    `Average Salary in ${d.placeName}`,
+    {
+      occupationLocation: {
+        "@type": "City",
+        name: d.placeName,
+        address: { "@type": "PostalAddress", addressCountry: d.countryCode }
+      }
+    },
+    [
+      distribution(
+        `Average salary in ${d.placeName}`,
+        d.currency,
+        d.overallSalary.avgMin,
+        d.overallSalary.avgMax,
+        {
+          median: Math.round(
+            (d.overallSalary.medianMin + d.overallSalary.medianMax) / 2
+          ),
+          // Hosted includes these unconditionally, nulls and all.
+          percentile25: d.overallSalary.p25Min,
+          percentile75: d.overallSalary.p75Max
+        }
+      )
+    ]
+  );
+}
+function crossAxisSalaryJsonLd(locale, args) {
+  if (!args.overall) return null;
+  return salaryEnvelope(
+    "Occupation",
+    `${args.name} salary in ${args.placeName}`,
+    {
+      occupationLocation: {
+        "@type": "AdministrativeArea",
+        name: args.placeName,
+        address: {
+          "@type": "PostalAddress",
+          addressCountry: args.countryCode
+        }
+      }
+    },
+    [
+      distribution(
+        `${args.name} salary in ${args.placeName} (all levels)`,
+        args.currency,
+        args.overall.avgMin,
+        args.overall.avgMax,
+        {
+          ...args.overall.p25Min ? { percentile25: args.overall.p25Min } : {},
+          ...args.overall.p75Max ? { percentile75: args.overall.p75Max } : {}
+        }
+      ),
+      ...seniorityDistributions(
+        locale,
+        args.bySeniority,
+        args.currency,
+        (label) => `${label} ${args.name} in ${args.placeName}`
+      )
+    ]
+  );
+}
+function companySalaryJsonLd(locale, d) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope(
+    "OccupationAggregationByEmployer",
+    `Jobs at ${d.companyName}`,
+    {
+      sampleSize: d.overallSalary.jobCount,
+      hiringOrganization: { "@type": "Organization", name: d.companyName }
+    },
+    [
+      distribution(
+        "base",
+        d.currency,
+        d.overallSalary.avgMin,
+        d.overallSalary.avgMax,
+        {
+          ...d.boardMedianMin && d.boardMedianMax ? { median: Math.round((d.boardMedianMin + d.boardMedianMax) / 2) } : {},
+          ...d.boardP25Min ? { percentile25: d.boardP25Min } : {},
+          ...d.boardP75Max ? { percentile75: d.boardP75Max } : {}
+        }
+      ),
+      ...seniorityDistributions(
+        locale,
+        d.bySeniority,
+        d.currency,
+        (label) => `${label} salary`
+      )
+    ]
+  );
+}
+function companyCategorySalaryJsonLd(locale, d) {
+  if (!d.overallSalary) return null;
+  return salaryEnvelope(
+    "Occupation",
+    `${d.categoryName} at ${d.companyName}`,
+    {
+      occupationalCategory: d.categoryName,
+      hiringOrganization: { "@type": "Organization", name: d.companyName }
+    },
+    [
+      distribution(
+        `${d.categoryName} salary (all levels)`,
+        d.currency,
+        d.overallSalary.avgMin,
+        d.overallSalary.avgMax,
+        {
+          ...d.boardCategoryP25Min ? { percentile25: d.boardCategoryP25Min } : {},
+          ...d.boardCategoryP75Max ? { percentile75: d.boardCategoryP75Max } : {}
+        }
+      ),
+      ...seniorityDistributions(
+        locale,
+        d.bySeniority,
+        d.currency,
+        (label) => `${label} ${d.categoryName}`
+      )
+    ]
+  );
+}
+
+// src/seo/job-posting.ts
+var EDUCATION_TO_CREDENTIAL = {
+  high_school: "high school",
+  associate_degree: "associate degree",
+  bachelor_degree: "bachelor degree",
+  professional_certificate: "professional certificate",
+  postgraduate_degree: "postgraduate degree"
+};
+var EMPLOYMENT_TYPE_TO_GOOGLE = {
+  full_time: "FULL_TIME",
+  part_time: "PART_TIME",
+  contract: "CONTRACTOR",
+  internship: "INTERN",
+  temporary: "TEMPORARY",
+  volunteer: "VOLUNTEER",
+  other: "OTHER"
+};
+var SALARY_TIMEFRAME_TO_UNIT = {
+  per_year: "YEAR",
+  per_month: "MONTH",
+  per_week: "WEEK",
+  per_day: "DAY",
+  per_hour: "HOUR"
+};
+var ALL_COUNTRY_CODES = [
+  "AF",
+  "AX",
+  "AL",
+  "DZ",
+  "AS",
+  "AD",
+  "AO",
+  "AI",
+  "AQ",
+  "AG",
+  "AR",
+  "AM",
+  "AW",
+  "AU",
+  "AT",
+  "AZ",
+  "BS",
+  "BH",
+  "BD",
+  "BB",
+  "BY",
+  "BE",
+  "BZ",
+  "BJ",
+  "BM",
+  "BT",
+  "BO",
+  "BA",
+  "BW",
+  "BV",
+  "BR",
+  "IO",
+  "VG",
+  "BN",
+  "BG",
+  "BF",
+  "BI",
+  "KH",
+  "CM",
+  "CA",
+  "CV",
+  "BQ",
+  "KY",
+  "CF",
+  "TD",
+  "CL",
+  "CN",
+  "CX",
+  "CC",
+  "CO",
+  "KM",
+  "CK",
+  "CR",
+  "HR",
+  "CU",
+  "CW",
+  "CY",
+  "CZ",
+  "DK",
+  "DJ",
+  "DM",
+  "DO",
+  "CD",
+  "EC",
+  "EG",
+  "SV",
+  "GQ",
+  "ER",
+  "EE",
+  "SZ",
+  "ET",
+  "FK",
+  "FO",
+  "FJ",
+  "FI",
+  "FR",
+  "GF",
+  "PF",
+  "TF",
+  "GA",
+  "GM",
+  "GE",
+  "DE",
+  "GH",
+  "GI",
+  "GR",
+  "GL",
+  "GD",
+  "GP",
+  "GU",
+  "GT",
+  "GG",
+  "GN",
+  "GW",
+  "GY",
+  "HT",
+  "HM",
+  "HN",
+  "HK",
+  "HU",
+  "IS",
+  "IN",
+  "ID",
+  "IR",
+  "IQ",
+  "IE",
+  "IM",
+  "IL",
+  "IT",
+  "CI",
+  "JM",
+  "JP",
+  "JE",
+  "JO",
+  "KZ",
+  "KE",
+  "KI",
+  "XK",
+  "KW",
+  "KG",
+  "LA",
+  "LV",
+  "LB",
+  "LS",
+  "LR",
+  "LY",
+  "LI",
+  "LT",
+  "LU",
+  "MO",
+  "MG",
+  "MW",
+  "MY",
+  "MV",
+  "ML",
+  "MT",
+  "MH",
+  "MQ",
+  "MR",
+  "MU",
+  "YT",
+  "MX",
+  "FM",
+  "MD",
+  "MC",
+  "MN",
+  "ME",
+  "MS",
+  "MA",
+  "MZ",
+  "MM",
+  "NA",
+  "NR",
+  "NP",
+  "NL",
+  "NC",
+  "NZ",
+  "NI",
+  "NE",
+  "NG",
+  "NU",
+  "NF",
+  "MK",
+  "MP",
+  "NO",
+  "OM",
+  "PK",
+  "PW",
+  "PS",
+  "PA",
+  "PG",
+  "PY",
+  "PE",
+  "PH",
+  "PN",
+  "PL",
+  "PT",
+  "PR",
+  "QA",
+  "CG",
+  "RE",
+  "RO",
+  "RU",
+  "RW",
+  "BL",
+  "SH",
+  "KN",
+  "LC",
+  "MF",
+  "PM",
+  "VC",
+  "WS",
+  "SM",
+  "ST",
+  "SA",
+  "SN",
+  "RS",
+  "SC",
+  "SL",
+  "SG",
+  "SX",
+  "SK",
+  "SI",
+  "SB",
+  "SO",
+  "ZA",
+  "GS",
+  "KR",
+  "SS",
+  "ES",
+  "LK",
+  "SD",
+  "SR",
+  "SJ",
+  "SE",
+  "CH",
+  "SY",
+  "TW",
+  "TJ",
+  "TZ",
+  "TH",
+  "TL",
+  "TG",
+  "TK",
+  "TO",
+  "TT",
+  "TN",
+  "TR",
+  "TM",
+  "TC",
+  "TV",
+  "UG",
+  "UA",
+  "AE",
+  "GB",
+  "US",
+  "UM",
+  "VI",
+  "UY",
+  "UZ",
+  "VU",
+  "VA",
+  "VE",
+  "VN",
+  "WF",
+  "EH",
+  "YE",
+  "ZM",
+  "ZW"
+];
+function createJobPostingJsonLd({
+  job,
+  board,
+  shareUrl
+}) {
+  const educationRequirements = createEducationRequirements(job);
+  const experienceRequirements = createExperienceRequirements(job);
+  const jsonLd = pruneJsonLd({
+    "@context": "https://schema.org/",
+    "@type": "JobPosting",
+    title: job.title,
+    description: job.description ?? "",
+    identifier: createIdentifier(job, board),
+    datePosted: toIsoDate(job.publishedAt),
+    validThrough: toIsoDate(job.expiresAt),
+    employmentType: job.employmentType ? EMPLOYMENT_TYPE_TO_GOOGLE[job.employmentType] ?? "OTHER" : "OTHER",
+    hiringOrganization: createHiringOrganization(job, board),
+    jobLocation: createJobLocation(job),
+    jobLocationType: job.remoteOption === "remote" ? "TELECOMMUTE" : void 0,
+    applicantLocationRequirements: job.remoteOption === "remote" ? createApplicantLocationRequirements(job) : null,
+    baseSalary: createBaseSalary(job),
+    educationRequirements,
+    experienceRequirements,
+    experienceInPlaceOfEducation: job.experienceInPlaceOfEducation === true && educationRequirements && experienceRequirements ? true : void 0,
+    url: shareUrl
+  });
+  if (!jsonLd || Array.isArray(jsonLd) || Object.keys(jsonLd).length === 0) {
+    return null;
+  }
+  return jsonLd;
+}
+function createIdentifier(job, board) {
+  const organizationName = job.company?.name ?? board.name ?? null;
+  const identifier = { "@type": "PropertyValue", value: job.id };
+  if (organizationName) identifier.name = organizationName;
+  return identifier;
+}
+function createHiringOrganization(job, board) {
+  const name = job.company?.name ?? board.name ?? null;
+  if (!name) return null;
+  const organization = { "@type": "Organization", name };
+  const website = job.company?.website ?? null;
+  const normalizedWebsite = website ? normalizeWebsiteUrl(website) : null;
+  if (normalizedWebsite) organization.sameAs = normalizedWebsite;
+  const logo = job.company?.logoUrl ?? board.logoUrl ?? null;
+  if (logo) organization.logo = logo;
+  return organization;
+}
+function normalizeWebsiteUrl(website) {
+  const trimmed = website.trim();
+  if (!trimmed) return null;
+  return /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+function createBaseSalary(job) {
+  const currency = job.salaryCurrency?.trim();
+  const hasMin = typeof job.salaryMin === "number";
+  const hasMax = typeof job.salaryMax === "number";
+  if (!currency || !hasMin && !hasMax) return null;
+  const value = { "@type": "QuantitativeValue" };
+  if (hasMin) value.minValue = job.salaryMin;
+  if (hasMax) value.maxValue = job.salaryMax;
+  const unitText = job.salaryTimeframe ? SALARY_TIMEFRAME_TO_UNIT[job.salaryTimeframe] : void 0;
+  if (unitText) value.unitText = unitText;
+  if (!hasMin && hasMax && typeof job.salaryMax === "number") {
+    value.value = job.salaryMax;
+    value.minValue = job.salaryMax;
+  } else if (!hasMax && hasMin && typeof job.salaryMin === "number") {
+    value.value = job.salaryMin;
+    value.maxValue = job.salaryMin;
+  }
+  return { "@type": "MonetaryAmount", currency: currency.toUpperCase(), value };
+}
+function createJobLocation(job) {
+  const places = job.officeLocations.map(
+    (office) => createPlaceJsonLd({
+      countryCode: office.countryCode,
+      region: office.region,
+      locality: office.city ?? office.locality,
+      postalCode: office.postalCode,
+      name: office.displayName
+    })
+  ).filter((place) => place !== null);
+  if (places.length === 0) return null;
+  return places.length === 1 ? places[0] : places;
+}
+function createPlaceJsonLd({
+  countryCode,
+  region,
+  locality,
+  postalCode,
+  name
+}) {
+  const address = { "@type": "PostalAddress" };
+  const country = countryCode?.trim();
+  const reg = region?.trim();
+  const loc = locality?.trim();
+  const postal = postalCode?.trim();
+  const placeName = name?.trim();
+  if (country) address.addressCountry = country.toUpperCase();
+  if (reg) address.addressRegion = reg;
+  if (loc) address.addressLocality = loc;
+  if (postal) address.postalCode = postal;
+  const hasAddressDetails = Object.keys(address).length > 1;
+  if (!hasAddressDetails && !placeName) return null;
+  const place = { "@type": "Place" };
+  if (placeName) place.name = placeName;
+  if (hasAddressDetails) place.address = address;
+  return place;
+}
+function createApplicantLocationRequirements(job) {
+  if (job.remoteWorldwide) {
+    return ALL_COUNTRY_CODES.map((code) => ({
+      "@type": "Country",
+      name: code
+    }));
+  }
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const code of job.remoteWorkPermitCountryCodes ?? []) {
+    const normalized = code?.trim().toUpperCase();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    entries.push({ "@type": "Country", name: normalized });
+  }
+  for (const subdivision of job.remoteWorkPermitSubdivisionCodes ?? []) {
+    const countryCode = subdivision?.split("-")[0]?.trim().toUpperCase();
+    if (!countryCode || seen.has(countryCode)) continue;
+    seen.add(countryCode);
+    entries.push({ "@type": "Country", name: countryCode });
+  }
+  if (entries.length === 0) return null;
+  return entries.length === 1 ? entries[0] : entries;
+}
+function createEducationRequirements(job) {
+  const requirements = job.educationRequirements;
+  if (!requirements || requirements.length === 0) return null;
+  if (requirements.includes("no_requirements")) return "no requirements";
+  const credentials = requirements.filter((value) => value in EDUCATION_TO_CREDENTIAL).map((value) => ({
+    "@type": "EducationalOccupationalCredential",
+    credentialCategory: EDUCATION_TO_CREDENTIAL[value]
+  }));
+  return credentials.length > 0 ? credentials : null;
+}
+function createExperienceRequirements(job) {
+  const months = job.experienceMonths;
+  if (typeof months !== "number") return null;
+  if (months === 0) return "no requirements";
+  return {
+    "@type": "OccupationalExperienceRequirements",
+    monthsOfExperience: months
+  };
+}
+function toIsoDate(value) {
+  if (!value) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toISOString();
+}
+function pruneJsonLd(value) {
+  const keep = (entry) => {
+    if (entry == null) return false;
+    if (Array.isArray(entry)) return entry.length > 0;
+    if (typeof entry === "object")
+      return Object.keys(entry).length > 0;
+    return true;
+  };
+  if (Array.isArray(value)) {
+    return value.map((entry) => pruneJsonLd(entry)).filter(keep);
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).map(([key, entry]) => [key, pruneJsonLd(entry)]).filter(([, entry]) => keep(entry));
+    return Object.fromEntries(entries);
+  }
+  return value;
+}
+
+// src/seo/breadcrumbs.ts
+function createBreadcrumbJsonLd(items, options = {}) {
+  const normalizedItems = items.map((item) => {
+    const name = item.label?.trim();
+    return name ? {
+      name,
+      href: item.href?.trim() ?? null
+    } : null;
+  }).filter((item) => !!item);
+  if (normalizedItems.length < 2) {
+    return null;
+  }
+  const listItems = normalizedItems.map((item, index) => {
+    const resolvedHref = item.href ? resolveBreadcrumbHref(item.href, options.origin ?? null) : null;
+    const listItem = {
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name
+    };
+    if (resolvedHref) {
+      listItem.item = resolvedHref;
+    }
+    return listItem;
+  });
+  return {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: listItems
+  };
+}
+function resolveBreadcrumbHref(href, origin) {
+  if (isAbsoluteUrl(href)) {
+    return href;
+  }
+  if (!origin) {
+    return null;
+  }
+  const normalizedPath = href.startsWith("/") ? href : `/${href}`;
+  return `${origin}${normalizedPath}`;
+}
+function isAbsoluteUrl(href) {
+  return /^https?:\/\//i.test(href);
+}
+function buildJobBreadcrumbs(job, language, labels) {
+  const copy = uiCopy(language, labels).breadcrumbs;
+  const crumbs = [
+    { name: copy.home, path: "/" },
+    { name: copy.jobs, path: "/jobs" }
+  ];
+  let lastPlaceSlug = null;
+  for (const place of job.placeHierarchy) {
+    lastPlaceSlug = place.slug;
+    crumbs.push({ name: place.name, path: `/jobs/locations/${place.slug}` });
+  }
+  const primaryCategory = job.categories[0];
+  if (primaryCategory) {
+    crumbs.push({
+      name: primaryCategory.name,
+      path: lastPlaceSlug ? `/jobs/locations/${lastPlaceSlug}/${primaryCategory.slug}` : `/jobs/${primaryCategory.slug}`
+    });
+  }
+  crumbs.push({ name: job.title });
+  return crumbs;
+}
+
+export {
+  formatUsd,
+  formatRange,
+  formatSeniority,
+  SENIORITY_ORDER,
+  sortBySeniority,
+  buildSalaryFaq,
+  itemListJsonLd,
+  faqJsonLd,
+  titleSalaryJsonLd,
+  skillSalaryJsonLd,
+  locationSalaryJsonLd,
+  crossAxisSalaryJsonLd,
+  companySalaryJsonLd,
+  companyCategorySalaryJsonLd,
+  ALL_COUNTRY_CODES,
+  createJobPostingJsonLd,
+  normalizeWebsiteUrl,
+  createBreadcrumbJsonLd,
+  buildJobBreadcrumbs
+};