jd-intel 0.8.2 → 0.9.0

package/src/adapters/ashby.js

@@ -1,4 +1,4 @@
-import { normalize } from '../normalizer.js';
+import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const API_URL = 'https://jobs.ashbyhq.com/api/non-user-graphql';
@@ -36,23 +36,33 @@ async function fetchAshbyRest(slug) {
   const jobs = data.jobs || [];
 
   return jobs.map(job => {
-    const salary = parseAshbyCompensation(job.compensation);
+    const comp = job.compensation || {};
 
     return normalize({
       companySlug: slug,
       company: data.organizationName || slug,
       title: job.title || '',
-      department: job.departmentName || '',
+      department: job.department || '',
       location: job.location || '',
+      locations: (job.secondaryLocations || []).map(l => l?.location || ''),
+      workplace: parseAshbyWorkplace(job),
       description: job.descriptionHtml || job.descriptionPlain || '',
       url: `https://jobs.ashbyhq.com/${slug}/${job.id}`,
       postedAt: job.publishedAt || null,
-      salary,
+      salary: parseAshbyCompensation(comp),
       metadata: {
         ashbyId: job.id,
         employmentType: job.employmentType || '',
         isRemote: job.isRemote || false,
-        team: job.teamName || '',
+        team: job.team || '',
+        // The rendered summaries keep what min/max drop: "Offers Equity",
+        // "Multiple Ranges", and per-location tiers labelled OTE.
+        compensationSummary: comp.compensationTierSummary || '',
+        compensationTiers: (comp.compensationTiers || []).map(tier => ({
+          title: tier.title || '',
+          summary: tier.tierSummary || '',
+          additionalInformation: tier.additionalInformation || '',
+        })),
       },
     }, 'ashby');
   });
@@ -110,22 +120,47 @@ async function fetchAshbyGraphQL(slug) {
   }, 'ashby'));
 }
 
+const WORKPLACE_TYPES = { remote: 'remote', hybrid: 'hybrid', onsite: 'onsite' };
+
+/**
+ * `workplaceType` is 'Remote', 'Hybrid' or 'OnSite'. `isRemote` is the
+ * older flag and can only say remote, so it is the fallback when the type
+ * is absent. false means nothing: the role may be hybrid or onsite.
+ */
+function parseAshbyWorkplace(job) {
+  const type = WORKPLACE_TYPES[String(job.workplaceType || '').toLowerCase()];
+  if (type) return type;
+  return job.isRemote === true ? 'remote' : null;
+}
+
+const INTERVAL_PERIOD = { '1 YEAR': 'year', '1 MONTH': 'month', '1 HOUR': 'hour' };
+
+/**
+ * Read pay from Ashby's `compensation` object (issue #67).
+ *
+ * `summaryComponents` carries one structured entry per component type
+ * (Salary, Bonus, Commission, Equity); the Salary entry spans every tier.
+ * `scrapeableCompensationSalarySummary` and `compensationTierSummary` are
+ * the rendered strings. A board that publishes no pay still sends the
+ * object, with null summaries and empty arrays, so a miss here has to
+ * return null for the normalizer's text fallback to run.
+ */
 function parseAshbyCompensation(comp) {
-  if (!comp) return null;
-  // Ashby compensation can be a string or structured object
-  if (typeof comp === 'string') {
-    const match = comp.match(/\$?([\d,]+)\s*[-–]\s*\$?([\d,]+)/);
-    if (!match) return null;
+  const salary = (comp.summaryComponents || []).find(c => c.compensationType === 'Salary');
+  if (salary && (salary.minValue != null || salary.maxValue != null)) {
     return {
-      min: parseInt(match[1].replace(/,/g, '')),
-      max: parseInt(match[2].replace(/,/g, '')),
-      currency: 'USD',
+      min: salary.minValue ?? null,
+      max: salary.maxValue ?? null,
+      currency: salary.currencyCode || 'USD',
+      period: INTERVAL_PERIOD[salary.interval] || null,
+      source: 'ats',
     };
   }
-  if (comp.min && comp.max) {
-    return { min: comp.min, max: comp.max, currency: comp.currency || 'USD' };
-  }
-  return null;
+  // The summaries are still the ATS's own compensation field, so a range
+  // read out of one counts as source 'ats'.
+  const parsed = extractSalaryFromText(comp.scrapeableCompensationSalarySummary)
+    || extractSalaryFromText(comp.compensationTierSummary);
+  return parsed ? { ...parsed, source: 'ats' } : null;
 }
 
 export async function hasAshby(slug) {

package/src/adapters/greenhouse.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
@@ -29,19 +29,42 @@ export async function fetchGreenhouse(slug) {
     title: job.title || '',
     department: job.departments?.[0]?.name || '',
     location: job.location?.name || '',
-    description: stripHtml(job.content || ''),
+    workplace: parseGreenhouseWorkplace(job.metadata),
+    // `content` arrives HTML-escaped (`<p>`). Decode that outer layer
+    // once so normalize() sees real tags; it strips and decodes the rest.
+    description: decodeEntities(job.content || ''),
     url: job.absolute_url || '',
-    postedAt: job.updated_at || null,
-    salary: null, // Greenhouse doesn't expose salary in public API
+    // updated_at is an edit time that many boards bulk-refresh, so it is not
+    // a posting date. first_published is. Fallback covers boards without it (#69).
+    postedAt: job.first_published || job.updated_at || null,
+    salary: null, // list endpoint has no structured pay; normalizer parses the pay transparency text
     metadata: {
       greenhouseId: job.id,
       internal_job_id: job.internal_job_id,
       departments: job.departments?.map(d => d.name) || [],
       offices: job.offices?.map(o => o.name) || [],
+      updatedAt: job.updated_at,
     },
   }, 'greenhouse'));
 }
 
+/**
+ * Greenhouse has no native workplace field. Boards that track it define a
+ * custom field ("Location Type", "Workplace Type") that arrives in the
+ * job's `metadata[]`, with `value` a string for single-select fields and
+ * an array for multi-select. Values seen: On-Site, Hybrid (Travel-Required),
+ * Remote. Anything else is no signal and the location string decides.
+ */
+function parseGreenhouseWorkplace(metadata) {
+  const field = (metadata || []).find(m => /location type|workplace type/i.test(m?.name || ''));
+  if (!field) return null;
+  const value = [].concat(field.value ?? []).join(' ').toLowerCase();
+  if (/remote/.test(value)) return 'remote';
+  if (/hybrid/.test(value)) return 'hybrid';
+  if (/on-?site/.test(value)) return 'onsite';
+  return null;
+}
+
 /**
  * Check if a company has a Greenhouse board.
  */

package/src/adapters/lever.js

@@ -1,11 +1,16 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://api.lever.co/v0/postings';
 
+const PERIODS = { 'per-year-salary': 'year', 'per-month-salary': 'month', 'per-hour-wage': 'hour' };
+// Lever's workplaceType is one of these or 'unspecified'.
+const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
+
 /**
  * Fetch all jobs from a Lever job board.
  * Public API, no auth required.
+ * Docs: https://github.com/lever/postings-api
  *
  * @param {string} slug - Company slug (e.g., 'stripe', 'figma')
  * @returns {Promise<Array>} Normalized job objects
@@ -22,30 +27,72 @@ export async function fetchLever(slug) {
   const jobs = await resp.json();
   if (!Array.isArray(jobs)) return [];
 
-  return jobs.map(job => {
-    const salary = parseLeverSalary(job.categories?.commitment, job.text);
+  return jobs.map(job => normalize({
+    companySlug: slug,
+    // Lever's API doesn't return the company name at the board or job level,
+    // so the slug is the honest fallback. `categories.team` is the team within
+    // the company ("Payments Platform"), not the company itself.
+    company: titleCaseSlug(slug),
+    title: job.text || '',
+    department: job.categories?.department || job.categories?.team || '',
+    location: job.categories?.location || '',
+    locations: job.categories?.allLocations || [],
+    workplace: WORKPLACE_TYPES.has(job.workplaceType) ? job.workplaceType : null,
+    description: buildDescription(job),
+    url: job.hostedUrl || '',
+    postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
+    salary: parseLeverSalary(job.salaryRange, job.text),
+    metadata: {
+      leverId: job.id,
+      team: job.categories?.team || '',
+      commitment: job.categories?.commitment || '', // Full-time, Part-time, etc.
+      workplaceType: job.workplaceType || '',
+      salaryDescription: job.salaryDescriptionPlain || '',
+    },
+  }, 'lever'));
+}
+
+/**
+ * Lever splits a posting across `description` (company intro plus overview),
+ * `lists` (one `{text, content}` per section: responsibilities, requirements,
+ * location details) and `additional` (benefits, EEO). Only the first used to
+ * reach the description, so requirements were invisible to filters and to
+ * the assistant (issue #64). Reassemble the whole posting as HTML and let
+ * normalize() render the headings and bullets.
+ */
+function buildDescription(job) {
+  const parts = [job.description || job.descriptionPlain || ''];
+  for (const list of job.lists || []) {
+    const heading = (list.text || '').trim();
+    parts.push((heading ? `<h3>${escapeHtml(heading)}</h3>` : '') + (list.content || ''));
+  }
+  parts.push(job.additional || job.additionalPlain || '');
+  return parts.filter(Boolean).join('\n');
+}
+
+// `lists[].text` is plain text ("Skills & Experience"). Escaped, normalize()
+// decodes it back; raw, a stray `<` would be stripped as a tag.
+function escapeHtml(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
 
-    return normalize({
-      companySlug: slug,
-      // Lever's API doesn't return the company name at the board or job level,
-      // so the slug is the honest fallback. `categories.team` is the team within
-      // the company ("Payments Platform"), not the company itself.
-      company: titleCaseSlug(slug),
-      title: job.text || '',
-      department: job.categories?.department || job.categories?.team || '',
-      location: job.categories?.location || '',
-      description: stripHtml(job.descriptionPlain || job.description || ''),
-      url: job.hostedUrl || '',
-      postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
-      salary,
-      metadata: {
-        leverId: job.id,
-        team: job.categories?.team || '',
-        commitment: job.categories?.commitment || '', // Full-time, Part-time, etc.
-        workplaceType: job.workplaceType || '',
-      },
-    }, 'lever');
-  });
+/**
+ * Lever publishes `salaryRange: {min, max, currency, interval}` on boards
+ * that state pay. Boards that don't sometimes put the range in the title.
+ */
+function parseLeverSalary(range, title) {
+  const min = range?.min || null;
+  const max = range?.max || null;
+  if (min || max) {
+    return {
+      min,
+      max,
+      currency: range.currency || 'USD',
+      period: PERIODS[range.interval] || null,
+      source: 'ats',
+    };
+  }
+  return extractSalaryFromText(title || '');
 }
 
 function titleCaseSlug(slug) {
@@ -55,19 +102,6 @@ function titleCaseSlug(slug) {
   return slug.charAt(0).toUpperCase() + slug.slice(1);
 }
 
-function parseLeverSalary(commitment, title) {
-  // Lever doesn't have a salary field, but sometimes it's in the title
-  const match = (title || '').match(/\$[\d,]+\s*[-–]\s*\$[\d,]+/);
-  if (!match) return null;
-  const nums = match[0].match(/[\d,]+/g);
-  if (!nums || nums.length < 2) return null;
-  return {
-    min: parseInt(nums[0].replace(/,/g, '')),
-    max: parseInt(nums[1].replace(/,/g, '')),
-    currency: 'USD',
-  };
-}
-
 export async function hasLever(slug) {
   try {
     const resp = await fetch(`${BASE_URL}/${slug}?mode=json`, { method: 'HEAD' });

package/src/adapters/recruitee.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 /**
@@ -6,9 +6,16 @@ import { atsErrorFromStatus } from '../errors.js';
  * Public API, no auth required.
  * Docs: https://docs.recruitee.com/reference/offers
  *
- * Single GET returns every offer with the full HTML description
- * inline — no N+1 (unlike SmartRecruiters), no XML (unlike
- * TeamTailor/Personio). The simplest adapter shape in the toolkit.
+ * Single GET returns every offer inline — no N+1 (unlike SmartRecruiters),
+ * no XML (unlike TeamTailor/Personio). The simplest adapter shape in the
+ * toolkit.
+ *
+ * Each offer carries two HTML fields, `description` and `requirements`.
+ * Which one holds the role depends on the tenant's template (and sometimes
+ * the posting): some keep the duties in `description` and the candidate
+ * profile in `requirements`, others put a company intro in `description`
+ * and everything else in `requirements`. Neither alone is the posting, so
+ * both are joined before normalize() strips them (issue #65).
  *
  * @param {string} slug - Recruitee company subdomain (e.g., 'vandebron')
  * @returns {Promise<Array>} Normalized job objects
@@ -30,13 +37,7 @@ export async function fetchRecruitee(slug) {
     let location = place;
     if (offer.remote) location = place ? `Remote - ${place}` : 'Remote';
 
-    let postedAt = null;
-    if (offer.created_at) {
-      // Recruitee returns "2026-05-13 07:38:11 UTC"; coerce to ISO.
-      const iso = offer.created_at.replace(' UTC', 'Z').replace(' ', 'T');
-      const d = new Date(iso);
-      if (!Number.isNaN(d.getTime())) postedAt = d.toISOString();
-    }
+    const createdAt = toIso(offer.created_at);
 
     return normalize({
       companySlug: slug,
@@ -44,19 +45,71 @@ export async function fetchRecruitee(slug) {
       title: offer.title || '',
       department: offer.department || '',
       location,
-      description: stripHtml(offer.description || ''),
+      locations: (offer.locations || []).map(l => [l.city, l.country].filter(Boolean).join(', ')),
+      workplace: parseRecruiteeWorkplace(offer),
+      description: [offer.description, offer.requirements].filter(Boolean).join('\n'),
       url: offer.careers_url || offer.careers_apply_url || '',
-      postedAt,
-      salary: null, // No structured salary; normalizer parses from text
+      // created_at can predate publication by years on long-lived offers,
+      // so it is not a posting date. published_at is.
+      postedAt: toIso(offer.published_at) || createdAt,
+      salary: parseRecruiteeSalary(offer.salary),
       metadata: {
         recruiteeId: offer.guid || offer.id,
         employmentType: offer.employment_type_code || '',
         category: offer.category_code || '',
+        createdAt,
       },
     }, 'recruitee');
   });
 }
 
+/**
+ * Recruitee returns "2026-05-13 07:38:11 UTC"; coerce to ISO.
+ */
+function toIso(ts) {
+  if (!ts) return null;
+  const d = new Date(ts.replace(' UTC', 'Z').replace(' ', 'T'));
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+
+/**
+ * Recruitee sends three booleans, not one enum. Hybrid wins when remote is
+ * also set, and on_site alone is onsite. All false is no signal.
+ */
+function parseRecruiteeWorkplace(offer) {
+  if (offer.hybrid) return 'hybrid';
+  if (offer.remote) return 'remote';
+  if (offer.on_site) return 'onsite';
+  return null;
+}
+
+const PERIODS = new Set(['year', 'month', 'hour']);
+
+/**
+ * Recruitee sends `salary` as `{min, max, period, currency}` with string
+ * amounts. Offers without pay still carry the object, either all-null or
+ * as a "0"/"0" placeholder, so anything without a positive side returns
+ * null and normalize() falls back to the posting text.
+ */
+function parseRecruiteeSalary(salary) {
+  if (!salary) return null;
+  const min = toAmount(salary.min);
+  const max = toAmount(salary.max);
+  if (min === null && max === null) return null;
+  return {
+    min,
+    max,
+    currency: (salary.currency || '').toUpperCase(),
+    period: PERIODS.has(salary.period) ? salary.period : null,
+    source: 'ats',
+  };
+}
+
+function toAmount(value) {
+  const n = parseFloat(value);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
 /**
  * Check if a company has a Recruitee career site.
  */

package/src/adapters/smartrecruiters.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://api.smartrecruiters.com/v1/companies';
@@ -10,7 +10,8 @@ const PAGE_SIZE = 100;
  * Docs: https://developers.smartrecruiters.com/reference/postingsget-1
  *
  * Two-step flow (unavoidable N+1):
- *   - The postings LIST endpoint omits the job description entirely.
+ *   - The postings LIST endpoint omits the job description entirely,
+ *     and the structured `compensation` block with it.
  *   - jd-intel's contract is "full JD text", so we must fetch each
  *     posting's DETAIL endpoint to get jobAd.sections.
  * Large enterprise tenants with hundreds of openings will therefore be
@@ -46,6 +47,7 @@ export async function fetchSmartrecruiters(slug) {
   const jobs = await Promise.all(postings.map(async (p) => {
     let sections = {};
     let postingUrl = '';
+    let salary = null;
 
     try {
       const detailResp = await fetch(`${BASE_URL}/${slug}/postings/${p.id}`);
@@ -53,6 +55,7 @@ export async function fetchSmartrecruiters(slug) {
         const detail = await detailResp.json();
         sections = detail.jobAd?.sections || {};
         postingUrl = detail.postingUrl || detail.applyUrl || '';
+        salary = parseCompensation(detail.compensation);
       }
     } catch {
       // Detail fetch failed: fall back to list-only fields (no description).
@@ -68,8 +71,14 @@ export async function fetchSmartrecruiters(slug) {
     const place = loc.fullLocation
       || [loc.city, loc.region, loc.country].filter(Boolean).join(', ');
     let location = place;
-    if (loc.remote) location = `Remote - ${place}`.replace(/ - $/, ' ');
-    else if (loc.hybrid) location = `Hybrid - ${place}`.replace(/ - $/, ' ');
+    let workplace = null;
+    if (loc.remote) {
+      location = `Remote - ${place}`.replace(/ - $/, ' ');
+      workplace = 'remote';
+    } else if (loc.hybrid) {
+      location = `Hybrid - ${place}`.replace(/ - $/, ' ');
+      workplace = 'hybrid';
+    }
 
     return normalize({
       companySlug: slug,
@@ -77,10 +86,11 @@ export async function fetchSmartrecruiters(slug) {
       title: p.name || '',
       department: p.department?.label || p.function?.label || '',
       location,
-      description: stripHtml(description),
+      workplace,
+      description,
       url: postingUrl,
       postedAt: p.releasedDate || null,
-      salary: null, // SmartRecruiters has no structured salary; normalizer parses text
+      salary, // null when the detail has no compensation; normalize() then parses text
       metadata: {
         smartRecruitersId: p.id,
         refNumber: p.refNumber || '',
@@ -94,6 +104,31 @@ export async function fetchSmartrecruiters(slug) {
   return jobs;
 }
 
+const PERIODS = { YEARLY: 'year', MONTHLY: 'month', HOURLY: 'hour' };
+
+/**
+ * Map the detail response's `compensation` to the shared salary shape.
+ *
+ * SmartRecruiters publishes `{min?, max?, currency, period}`, and both
+ * one-sided cases occur (a "max only" cap, a "from" floor), so each bound
+ * is passed through as null when absent rather than dropping the whole
+ * range. The period is kept as published: a MONTHLY figure is not
+ * annualized because tenants occasionally mislabel it (issue #70).
+ */
+function parseCompensation(comp) {
+  if (!comp || !comp.currency) return null;
+  const min = Number.isFinite(comp.min) ? comp.min : null;
+  const max = Number.isFinite(comp.max) ? comp.max : null;
+  if (min === null && max === null) return null;
+  return {
+    min,
+    max,
+    currency: comp.currency,
+    period: PERIODS[comp.period] ?? null,
+    source: 'ats',
+  };
+}
+
 /**
  * Check if a company exists on SmartRecruiters.
  * (HEAD isn't reliably supported on the postings endpoint, so use a

package/src/adapters/teamtailor.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 /**
@@ -16,10 +16,11 @@ import { atsErrorFromStatus } from '../errors.js';
  * to a custom domain (e.g. jobs.tibber.com).
  *
  * RSS quirk: descriptions are HTML-entity-encoded inside the XML
- * (`<p>...`). We decode that outer layer to real HTML, then
- * hand it to stripHtml() which strips tags and resolves the inner
- * entities. Decode order matters — `&` resolves LAST so that
- * double-encoded sequences (`&`) collapse correctly.
+ * (`<p>...`). We decode that outer layer to real HTML with the
+ * shared decodeEntities() and hand the HTML to normalize(), which
+ * strips tags and resolves the inner entities. Decode order matters —
+ * `&` resolves LAST so double-encoded sequences (`&`)
+ * collapse by one layer per pass.
  *
  * @param {string} slug - TeamTailor career-site slug (e.g., 'tibber')
  * @returns {Promise<Array>} Normalized job objects
@@ -28,6 +29,9 @@ import { atsErrorFromStatus } from '../errors.js';
 // segment, e.g. crunchbase.na.teamtailor.com. '' is the base host.
 const TT_REGIONS = ['', 'na', 'eu'];
 
+// Feeds send `none`, `hybrid`, `fully` or `onsite`. `none` is no signal.
+const REMOTE_STATUS = { hybrid: 'hybrid', fully: 'remote', onsite: 'onsite' };
+
 /**
  * Resolve which TeamTailor host actually serves this slug's feed.
  * Returns the first 200 Response, throws on a non-404 error, or
@@ -64,8 +68,8 @@ export async function fetchTeamtailor(slug) {
   const items = [...xml.matchAll(/<item>([\s\S]*?)<\/item>/g)].map(m => m[1]);
 
   return items.map(item => {
-    const pick = (tag) => {
-      const m = item.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+    const pick = (tag, src = item) => {
+      const m = src.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
       return m ? m[1].trim() : '';
     };
 
@@ -78,6 +82,12 @@ export async function fetchTeamtailor(slug) {
     const country = decodeEntities(pick('tt:country'));
     const remoteStatus = decodeEntities(pick('remoteStatus'));
 
+    // One <tt:location> per office the posting is open in, read the same
+    // way as the primary above so the entries line up.
+    const locations = [...item.matchAll(/<tt:location>([\s\S]*?)<\/tt:location>/g)].map(m =>
+      [decodeEntities(pick('tt:city', m[1])), decodeEntities(pick('tt:country', m[1]))].filter(Boolean).join(', ')
+    );
+
     let location = [city, country].filter(Boolean).join(', ');
     if (/remote/i.test(remoteStatus)) {
       location = location ? `Remote - ${location}` : 'Remote';
@@ -95,7 +105,9 @@ export async function fetchTeamtailor(slug) {
       title,
       department,
       location,
-      description: stripHtml(decodeEntities(pick('description'))),
+      locations,
+      workplace: REMOTE_STATUS[remoteStatus.toLowerCase()] || null,
+      description: decodeEntities(pick('description')),
       url: link,
       postedAt,
       salary: null, // No structured salary; normalizer parses from text
@@ -107,22 +119,6 @@ export async function fetchTeamtailor(slug) {
   });
 }
 
-/**
- * Decode the RSS entity/CDATA layer to real HTML.
- * `&amp;` is intentionally resolved LAST.
- */
-function decodeEntities(s) {
-  if (!s) return '';
-  return s
-    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&apos;/g, "'")
-    .replace(/&amp;/g, '&');
-}
-
 /**
  * Check if a company has a TeamTailor career site.
  */