@cavuno/board 1.26.0 → 1.28.0

package/dist/seo.mjs

@@ -0,0 +1,1079 @@
+// src/seo/blog.ts
+function createBlogArticleJsonLd({
+  post,
+  boardName,
+  permalink,
+  ogImageUrl
+}) {
+  const article = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: post.title,
+    url: permalink,
+    mainEntityOfPage: { "@type": "WebPage", "@id": permalink },
+    publisher: { "@type": "Organization", name: boardName }
+  };
+  if (post.customExcerpt) article.description = post.customExcerpt;
+  if (post.publishedAt) article.datePublished = post.publishedAt;
+  const image = post.coverUrl ?? ogImageUrl;
+  if (image) article.image = image;
+  const author = post.authors[0];
+  if (author) {
+    article.author = {
+      "@type": "Person",
+      name: author.name,
+      ...author.websiteUrl ? { url: author.websiteUrl } : {}
+    };
+  }
+  return article;
+}
+function createAuthorProfileJsonLd({
+  author,
+  canonical,
+  description,
+  origin,
+  posts,
+  totalPosts
+}) {
+  if (!author.name) {
+    return null;
+  }
+  const normalizedDescription = description.trim();
+  const sameAs = [
+    normalizeUrl(author.websiteUrl),
+    normalizeUrl(author.twitterUrl),
+    normalizeUrl(author.linkedinUrl),
+    normalizeUrl(author.githubUrl)
+  ].filter((value) => Boolean(value));
+  const authorId = `${canonical}#profile`;
+  const hasPart = posts.slice(0, 5).map((post) => {
+    const postUrl = buildAbsoluteUrl(origin, `/blog/${post.slug}`);
+    if (!postUrl) {
+      return null;
+    }
+    return {
+      "@type": "Article",
+      headline: post.title,
+      url: postUrl,
+      datePublished: post.publishedAt,
+      author: { "@id": authorId }
+    };
+  }).filter((value) => value !== null);
+  const agentInteractionStatistic = totalPosts > 0 ? {
+    "@type": "InteractionCounter",
+    interactionType: "https://schema.org/WriteAction",
+    userInteractionCount: totalPosts
+  } : void 0;
+  const profilePage = {
+    "@context": "https://schema.org",
+    "@type": "ProfilePage",
+    url: canonical,
+    mainEntity: {
+      "@type": "Person",
+      "@id": authorId,
+      name: author.name,
+      alternateName: author.slug ?? void 0,
+      identifier: author.id ?? void 0,
+      description: normalizedDescription || void 0,
+      image: author.avatarUrl ?? void 0,
+      sameAs: sameAs.length > 0 ? sameAs : void 0,
+      url: canonical,
+      mainEntityOfPage: canonical,
+      agentInteractionStatistic
+    }
+  };
+  if (hasPart.length > 0) {
+    profilePage.hasPart = hasPart;
+  }
+  return profilePage;
+}
+function normalizeUrl(value) {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const candidate = trimmed.startsWith("http://") || trimmed.startsWith("https://") ? trimmed : `https://${trimmed}`;
+    return new URL(candidate).toString();
+  } catch {
+    return null;
+  }
+}
+function buildAbsoluteUrl(origin, path) {
+  if (!origin || !path) {
+    return null;
+  }
+  try {
+    return new URL(path, origin).toString();
+  } catch {
+    return null;
+  }
+}
+
+// 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);
+}
+
+// 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/listing.ts
+function listingHead(options) {
+  const countPrefix = typeof options.count === "number" ? `${options.count} ` : "";
+  const title = `${countPrefix}${options.heading} | ${options.boardName}`;
+  const description = `Browse ${countPrefix}${options.heading.toLowerCase()} on ${options.boardName}.`;
+  const url = `${options.origin}${options.path}`;
+  return {
+    meta: [
+      { title },
+      { name: "description", content: description },
+      { property: "og:title", content: title },
+      { property: "og:description", content: description },
+      { property: "og:type", content: "website" },
+      { property: "og:url", content: url }
+    ],
+    links: [{ rel: "canonical", href: url }]
+  };
+}
+function listingJsonLd(options) {
+  const jobUrl = (job) => job.company ? `${options.origin}/companies/${job.company.slug}/jobs/${job.slug}` : `${options.origin}/jobs/${job.slug}`;
+  const objects = [
+    {
+      "@context": "https://schema.org",
+      // Deliberately NOT createBreadcrumbJsonLd (breadcrumbs.ts): listing trails
+      // are code-constructed (never user copy), so the hosted listing page skips
+      // the trim/drop-blank/min-2 gate that module transcribes. Same schema.org
+      // fragment, different (intentional) semantics — do not unify blindly.
+      "@type": "BreadcrumbList",
+      itemListElement: options.breadcrumbs.map((crumb, index) => ({
+        "@type": "ListItem",
+        position: index + 1,
+        name: crumb.name,
+        ...crumb.path ? { item: `${options.origin}${crumb.path}` } : {}
+      }))
+    }
+  ];
+  if (options.jobs && options.jobs.length > 0) {
+    objects.push({
+      "@context": "https://schema.org",
+      "@type": "ItemList",
+      itemListElement: options.jobs.map((job, index) => ({
+        "@type": "ListItem",
+        position: index + 1,
+        url: jobUrl(job)
+      }))
+    });
+  }
+  return objects;
+}
+
+// src/format/salary-lexicon.ts
+var EN = {
+  timeframe: {
+    per_year: "Yearly",
+    per_month: "Monthly",
+    per_week: "Weekly",
+    per_day: "Daily",
+    per_hour: "Hourly"
+  },
+  rangePrefix: { from: "From", upTo: "Up to" },
+  seniority: {
+    entry_level: "Entry level",
+    associate: "Associate",
+    mid_level: "Mid-level",
+    senior: "Senior",
+    lead: "Lead",
+    principal: "Principal",
+    director: "Director",
+    executive: "Executive"
+  },
+  frames: {
+    entitySalariesTitle: ({ entity, range }) => `${entity} Salaries (${range}/yr)`,
+    salariesInPlaceTitle: ({ place, range }) => `Salaries in ${place} (${range}/yr)`,
+    salariesInPlaceTitleNoRange: ({ place }) => `Salaries in ${place}`,
+    entitySalariesInPlaceTitle: ({ entity, place, range }) => `${entity} Salaries in ${place} (${range}/yr)`,
+    companySalariesTitle: ({ company, range }) => `${company} Salaries${range ? ` (${range}/yr)` : ""}`,
+    companyCategorySalariesTitle: ({ company, category, range }) => `${company} ${category} Salaries${range ? ` (${range}/yr)` : ""}`,
+    professionalsEarn: ({ entity, range, count }) => `${entity} professionals earn ${range}/yr on average across ${count} job postings.`,
+    rolesPay: ({ entity, range, count }) => `${entity} roles pay ${range}/yr on average across ${count} job postings.`,
+    professionalsInLocationEarn: ({ entity, place, range, count }) => `${entity} professionals in ${place} earn ${range}/yr on average across ${count} job postings.`,
+    seniorityRange: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel} roles start at ${lowAmount}, ${highLabel} roles reach ${highAmount}.`,
+    seniorityRangeWhile: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel} salaries start at ${lowAmount}, while ${highLabel} roles reach ${highAmount}.`,
+    compareAcrossTopPaying: ({ count }) => `Compare across ${count} top-paying ${count === 1 ? "company" : "companies"}.`,
+    compareAcrossTop: ({ count }) => `Compare across ${count} top ${count === 1 ? "company" : "companies"}.`,
+    boardWideAverage: ({ entity, range }) => `Board-wide ${entity} average: ${range}/yr.`,
+    averageSalaryInCity: ({ place, range, count }) => `Average salary in ${place} is ${range}/yr across ${count} jobs. Browse salary data by title and skill.`,
+    browseLocationsInRegion: ({ count, place }) => `Browse salary data across ${count} locations in ${place}. Compare salaries by title, skill, and company.`,
+    companyPays: ({ company, range, count }) => `${company} pays ${range}/yr on average across ${count} job postings.`,
+    breakdownAcrossCategories: ({ count }) => `Breakdown across ${count} job ${count === 1 ? "category" : "categories"}.`,
+    compareWithSimilar: ({ count }) => `Compare with ${count} similar ${count === 1 ? "company" : "companies"}.`,
+    salaryInfoFor: ({ company, board }) => `Salary information for ${company} on ${board}.`,
+    categoryRolesAtCompanyPay: ({ category, company, range, count }) => `${category} roles at ${company} pay ${range}/yr based on ${count} job postings.`,
+    categorySalaryDataFor: ({ category, company, board }) => `${category} salary data for ${company} on ${board}.`
+  }
+};
+var DE = {
+  timeframe: {
+    per_year: "pro Jahr",
+    per_month: "pro Monat",
+    per_week: "pro Woche",
+    per_day: "pro Tag",
+    per_hour: "pro Stunde"
+  },
+  rangePrefix: { from: "ab", upTo: "bis zu" },
+  seniority: {
+    entry_level: "Entry-Level",
+    associate: "Associate",
+    mid_level: "Mid-Level",
+    senior: "Senior",
+    lead: "Lead",
+    principal: "Principal",
+    director: "Director",
+    executive: "F\xFChrungskraft"
+  },
+  frames: {
+    entitySalariesTitle: ({ entity, range }) => `${entity} Geh\xE4lter (${range}/Jahr)`,
+    salariesInPlaceTitle: ({ place, range }) => `Geh\xE4lter in ${place} (${range}/Jahr)`,
+    salariesInPlaceTitleNoRange: ({ place }) => `Geh\xE4lter in ${place}`,
+    entitySalariesInPlaceTitle: ({ entity, place, range }) => `${entity} Geh\xE4lter in ${place} (${range}/Jahr)`,
+    companySalariesTitle: ({ company, range }) => `${company} Geh\xE4lter${range ? ` (${range}/Jahr)` : ""}`,
+    companyCategorySalariesTitle: ({ company, category, range }) => `${company} ${category} Geh\xE4lter${range ? ` (${range}/Jahr)` : ""}`,
+    professionalsEarn: ({ entity, range, count }) => `${entity}-Fachkr\xE4fte verdienen durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    rolesPay: ({ entity, range, count }) => `${entity}-Positionen werden mit durchschnittlich ${range}/Jahr verg\xFCtet, basierend auf ${count} Stellenanzeigen.`,
+    professionalsInLocationEarn: ({ entity, place, range, count }) => `${entity}-Fachkr\xE4fte in ${place} verdienen durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    seniorityRange: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel}-Positionen beginnen bei ${lowAmount}, ${highLabel}-Positionen erreichen ${highAmount}.`,
+    seniorityRangeWhile: ({ lowLabel, lowAmount, highLabel, highAmount }) => `${lowLabel}-Geh\xE4lter beginnen bei ${lowAmount}, w\xE4hrend ${highLabel}-Positionen ${highAmount} erreichen.`,
+    compareAcrossTopPaying: ({ count }) => `Vergleichen Sie ${count} ${count === 1 ? "bestzahlendes" : "bestzahlende"} Unternehmen.`,
+    compareAcrossTop: ({ count }) => `Vergleichen Sie ${count} Top-Unternehmen.`,
+    boardWideAverage: ({ entity, range }) => `Gesamtdurchschnitt ${entity}: ${range}/Jahr.`,
+    averageSalaryInCity: ({ place, range, count }) => `Das Durchschnittsgehalt in ${place} betr\xE4gt ${range}/Jahr, basierend auf ${count} Stellen. Gehaltsdaten nach Titel und F\xE4higkeiten durchsuchen.`,
+    browseLocationsInRegion: ({ count, place }) => `Gehaltsdaten f\xFCr ${count} Standorte in ${place} durchsuchen. Geh\xE4lter nach Titel, F\xE4higkeiten und Unternehmen vergleichen.`,
+    companyPays: ({ company, range, count }) => `${company} zahlt durchschnittlich ${range}/Jahr, basierend auf ${count} Stellenanzeigen.`,
+    breakdownAcrossCategories: ({ count }) => `Aufschl\xFCsselung \xFCber ${count} Job-${count === 1 ? "Kategorie" : "Kategorien"}.`,
+    compareWithSimilar: ({ count }) => `Vergleichen Sie mit ${count} \xE4hnlichen Unternehmen.`,
+    salaryInfoFor: ({ company, board }) => `Gehaltsinformationen f\xFCr ${company} auf ${board}.`,
+    categoryRolesAtCompanyPay: ({ category, company, range, count }) => `${category}-Positionen bei ${company} werden mit ${range}/Jahr verg\xFCtet, basierend auf ${count} Stellenanzeigen.`,
+    categorySalaryDataFor: ({ category, company, board }) => `${category}-Gehaltsdaten f\xFCr ${company} auf ${board}.`
+  }
+};
+var LEXICONS = { en: EN, de: DE };
+function getSalaryLexicon(locale) {
+  return locale && LEXICONS[locale] || EN;
+}
+
+// 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}`
+      )
+    ]
+  );
+}
+export {
+  ALL_COUNTRY_CODES,
+  SENIORITY_ORDER,
+  buildSalaryFaq,
+  companyCategorySalaryJsonLd,
+  companySalaryJsonLd,
+  createAuthorProfileJsonLd,
+  createBlogArticleJsonLd,
+  createBreadcrumbJsonLd,
+  createJobPostingJsonLd,
+  crossAxisSalaryJsonLd,
+  faqJsonLd,
+  formatRange,
+  formatSeniority,
+  formatUsd,
+  itemListJsonLd,
+  listingHead,
+  listingJsonLd,
+  locationSalaryJsonLd,
+  normalizeWebsiteUrl,
+  skillSalaryJsonLd,
+  sortBySeniority,
+  titleSalaryJsonLd
+};