@brandlab-digital/conformance 3.3.2 → 3.4.0

package/dist/page-standard.js

@@ -0,0 +1,536 @@
+/**
+ * The Brandlab on-page and location standard (3.4.0) as pure checks over the
+ * server HTML of a production build. The estate journey enforces the objective
+ * ones; the page-quality journey reports the judgement ones without failing.
+ *
+ * Every function reads only the HTML a crawler receives before any script runs.
+ */
+// Conformance compiles without the other packages (the operations evaluator builds it from source alone), so
+// the few site-core rules it needs are mirrored here; page-standard.test.ts keeps them identical to site-core.
+/** Great-circle distance in kilometres, as site-core's distanceBetweenCentresKm. */
+export function distanceBetweenCentresKm(from, to) {
+    const radians = (degrees) => (degrees * Math.PI) / 180;
+    const latitudeDelta = radians(to.latitude - from.latitude);
+    const longitudeDelta = radians(to.longitude - from.longitude);
+    const haversine = Math.sin(latitudeDelta / 2) ** 2 +
+        Math.cos(radians(from.latitude)) * Math.cos(radians(to.latitude)) * Math.sin(longitudeDelta / 2) ** 2;
+    return 2 * 6371.0088 * Math.asin(Math.min(1, Math.sqrt(haversine)));
+}
+/** The first place listed after a farther one, as site-core's findNeighbourOrderProblem. */
+export function findNeighbourOrderProblem(origin, slugs, centreOf, toleranceKm = 0.05) {
+    const from = centreOf(origin);
+    if (!from)
+        return null;
+    let previous;
+    for (const [index, slug] of slugs.entries()) {
+        const to = centreOf(slug);
+        if (!to)
+            continue;
+        const current = { slug, distanceKm: distanceBetweenCentresKm(from, to) };
+        if (previous && current.distanceKm + toleranceKm < previous.distanceKm) {
+            return {
+                index,
+                slug,
+                previous: previous.slug,
+                detail: `${slug} (${current.distanceKm.toFixed(1)} km) is listed after ${previous.slug} (${previous.distanceKm.toFixed(1)} km); nearby places are ranked nearest first`,
+            };
+        }
+        previous = current;
+    }
+    return null;
+}
+const SITEMAP_FAMILY_BY_KIND = Object.freeze({
+    service: 'services',
+    location: 'locations',
+    'service-location': 'service-locations',
+    'blog-post': 'blog',
+    project: 'projects',
+});
+/** The split sitemap family of a route kind, as site-core's sitemapFamilyForKind. */
+export function sitemapFamilyForKind(kind) {
+    return Object.hasOwn(SITEMAP_FAMILY_BY_KIND, kind) ? SITEMAP_FAMILY_BY_KIND[kind] : 'core';
+}
+const LOCATION_ROUTE_KINDS = new Set(['location', 'service-location']);
+function isIndexableLocationRoute(route) {
+    return LOCATION_ROUTE_KINDS.has(route.kind ?? '') && route.indexing === 'index';
+}
+/** As site-core's checkLocationCapacity: blocked only beyond both the limit and the pages at record (or the approval). */
+export function checkLocationCapacity(routes, capacity) {
+    const indexable = routes.filter(isIndexableLocationRoute).length;
+    if (!capacity) {
+        return { indexable, limit: null, allowed: null, overCapacity: false, blocked: false, detail: `${indexable} indexable location page(s); no location capacity is recorded yet.` };
+    }
+    const approval = capacity.approval;
+    const allowed = approval ? approval.maxIndexable ?? Number.POSITIVE_INFINITY : Math.max(capacity.limit, capacity.indexableAtRecord);
+    const overCapacity = indexable > capacity.limit;
+    const blocked = indexable > allowed;
+    const approved = approval ? ` under ${approval.approvedBy}'s approval of ${approval.approvedAt} (review by ${approval.reviewBy})` : '';
+    const detail = blocked
+        ? `${indexable} indexable location page(s) exceed what the site may carry (${allowed}: capacity ${capacity.limit} recorded ${capacity.recordedAt} with ${capacity.indexableAtRecord} at record${approved}). Add pages only within capacity, or record Romie's approval.`
+        : overCapacity
+            ? `${indexable} indexable location page(s) against a capacity of ${capacity.limit} (recorded ${capacity.recordedAt})${approved}; no pages may be added.`
+            : `${indexable} indexable location page(s) within a capacity of ${capacity.limit} (recorded ${capacity.recordedAt}).`;
+    return { indexable, limit: capacity.limit, allowed: Number.isFinite(allowed) ? allowed : null, overCapacity, blocked, detail };
+}
+/** As site-core's buildLocationReviewList: indexable location pages without evidence or with an open review flag. */
+export function buildLocationReviewList(routes) {
+    const items = [];
+    for (const route of routes) {
+        if (!isIndexableLocationRoute(route))
+            continue;
+        const evidence = route.locationDecision?.evidence ?? [];
+        const reasons = [];
+        if (evidence.length === 0) {
+            reasons.push('no qualifying evidence recorded (job, base suburb, facts and demand, existing clicks or enquiries, or an approved exception)');
+        }
+        const review = route.locationDecision?.review?.trim();
+        if (review)
+            reasons.push(review);
+        if (reasons.length > 0)
+            items.push({ ...(route.id ? { id: route.id } : {}), path: route.path, evidence, reasons });
+    }
+    return items.sort((a, b) => a.path.localeCompare(b.path));
+}
+// A variable specifier: the module is the site's own site-core (3.4.0 or later), resolved when a journey runs.
+const GEOGRAPHY_MODULE = '@brandlab-digital/site-core/geography';
+let geography;
+/** The suburb centres and place names of the site's installed site-core geography. */
+export function loadBrandlabGeography() {
+    geography ??= import(GEOGRAPHY_MODULE).then((module) => {
+        if (typeof module.getSuburbCentre !== 'function') {
+            throw new Error('@brandlab-digital/site-core/geography has no getSuburbCentre: install site-core 3.4.0 or later with the conformance package.');
+        }
+        const registries = [module.sydneyGeography, module.centralCoastGeography];
+        const placeNames = new Map();
+        const names = [];
+        for (const registry of registries) {
+            for (const record of [...registry.suburbs, ...registry.nonSuburbLocalities, ...registry.regions, ...registry.subRegions]) {
+                if (!placeNames.has(record.slug))
+                    placeNames.set(record.slug, record.name);
+            }
+            for (const record of [...registry.suburbs, ...registry.nonSuburbLocalities, ...registry.councils, ...registry.subRegions])
+                names.push(record.name);
+            for (const region of registry.regions)
+                names.push(region.name, region.seoName, ...(region.alternateNames ?? []));
+        }
+        return { centreOf: module.getSuburbCentre, placeNames, maskPlaces: createPlaceMask(names) };
+    });
+    return geography;
+}
+// ---------------------------------------------------------------------------
+// Structured data
+// ---------------------------------------------------------------------------
+/** Types that describe the business itself; a rating on them is a self-serving rating. */
+export const BUSINESS_SCHEMA_TYPES = new Set([
+    'LocalBusiness', 'HomeAndConstructionBusiness', 'GeneralContractor', 'Plumber', 'Electrician',
+    'RoofingContractor', 'HousePainter', 'Locksmith', 'MovingCompany', 'HVACBusiness', 'ProfessionalService',
+    'Organization', 'Corporation', 'EmergencyService',
+]);
+const RETIRED_RICH_RESULT_TYPES = new Set(['FAQPage', 'HowTo']);
+function schemaTypes(node) {
+    return [].concat(node['@type'] ?? []).map((type) => String(type).replace(/^(?:https?:\/\/)?schema\.org\//i, ''));
+}
+function collectNodes(payloads) {
+    const nodes = [];
+    const visit = (value) => {
+        if (!value || typeof value !== 'object')
+            return;
+        if (Array.isArray(value)) {
+            value.forEach(visit);
+            return;
+        }
+        const node = value;
+        nodes.push(node);
+        Object.values(node).forEach(visit);
+    };
+    payloads.forEach(visit);
+    return nodes;
+}
+function digits(value) {
+    return String(value ?? '').replace(/\D/g, '').replace(/^61/, '0');
+}
+/**
+ * The structured-data rules a crawler can check on one page: no FAQPage or
+ * HowTo, no rating on the business itself, a WebSite node with name and url on
+ * the homepage, and the business name and telephone matching the facts record.
+ */
+export function structuredDataProblems(payloads, options) {
+    const problems = [];
+    const nodes = collectNodes(payloads);
+    const businessId = options.businessId === undefined ? `${options.origin}/#business` : options.businessId;
+    for (const node of nodes) {
+        const types = schemaTypes(node);
+        const retired = types.find((type) => RETIRED_RICH_RESULT_TYPES.has(type));
+        if (retired)
+            problems.push(`JSON-LD declares ${retired}; FAQ and HowTo markup is no longer used`);
+        const isBusiness = types.some((type) => BUSINESS_SCHEMA_TYPES.has(type)) || (businessId !== false && node['@id'] === businessId && types.length > 0);
+        if (!isBusiness)
+            continue;
+        if (node.aggregateRating !== undefined || node.review !== undefined || node.reviews !== undefined) {
+            problems.push(`JSON-LD rates the business itself (${String(node['@id'] ?? types.join('/'))} has ${node.aggregateRating !== undefined ? 'aggregateRating' : 'review'}); stars are not allowed for the business's own rating`);
+        }
+        if (options.business && (businessId === false || node['@id'] === businessId)) {
+            const { name, telephone } = options.business;
+            if (name && typeof node.name === 'string' && node.name.trim() !== name.trim()) {
+                problems.push(`JSON-LD business name "${node.name}" does not match the business facts ("${name}")`);
+            }
+            if (telephone && node.telephone !== undefined && digits(node.telephone) !== digits(telephone)) {
+                problems.push(`JSON-LD business telephone ${String(node.telephone)} does not match the business facts (${telephone})`);
+            }
+        }
+    }
+    if (options.home) {
+        const website = nodes.find((node) => schemaTypes(node).includes('WebSite'));
+        const expected = new URL('/', options.origin).href;
+        if (!website) {
+            problems.push('the homepage JSON-LD has no WebSite node (name and url) for the site name');
+        }
+        else {
+            if (typeof website.name !== 'string' || !website.name.trim())
+                problems.push('the homepage WebSite node has no name');
+            const url = typeof website.url === 'string' ? safeHref(website.url, options.origin) : null;
+            if (!url || url.replace(/\/$/, '') !== expected.replace(/\/$/, '')) {
+                problems.push(`the homepage WebSite node's url is ${String(website.url ?? 'missing')} (expected ${expected})`);
+            }
+        }
+    }
+    return [...new Set(problems)];
+}
+function safeHref(value, base) {
+    try {
+        return new URL(value, base).href;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseSitemapEntries(xml) {
+    return [...xml.matchAll(/<url>([\s\S]*?)<\/url>/gi)].flatMap((match) => {
+        const loc = /<loc>\s*([^<\s]+)\s*<\/loc>/i.exec(match[1])?.[1];
+        if (!loc)
+            return [];
+        const lastmod = /<lastmod>\s*([^<\s]+)\s*<\/lastmod>/i.exec(match[1])?.[1];
+        return [{ url: new URL(decodeXml(loc)).href, ...(lastmod ? { lastmod: decodeXml(lastmod) } : {}) }];
+    });
+}
+/**
+ * Whether the sitemap is split by page family (services, locations,
+ * service-in-suburb, blog, projects and the rest) once the catalogue's
+ * indexable pages span more than one family, each file holding one family.
+ */
+export function sitemapFamilyProblems(input) {
+    const familyOf = new Map();
+    for (const route of input.routes) {
+        if (route.indexing !== 'index')
+            continue;
+        familyOf.set(new URL(route.canonicalPath ?? route.path, `${input.origin}/`).href, sitemapFamilyForKind(route.kind ?? ''));
+    }
+    const families = new Set(familyOf.values());
+    if (families.size <= 1)
+        return [];
+    if (!input.index) {
+        return [`the sitemap is one file for ${families.size} page families (${[...families].sort().join(', ')}); split it by family (brandlab.config sitemap.mode 'split') so Search Console reports each family's coverage`];
+    }
+    const problems = [];
+    for (const file of input.files) {
+        const inFile = new Set(file.entries.map((entry) => familyOf.get(entry.url)).filter((family) => Boolean(family)));
+        if (inFile.size > 1)
+            problems.push(`${file.path} mixes page families (${[...inFile].sort().join(', ')}); each sitemap file holds one family`);
+    }
+    return problems;
+}
+/** Hours before the run in which a shared timestamp looks like the build, not a content change. */
+const BUILD_WINDOW_HOURS = 48;
+/**
+ * `lastmod` must date the content, never the build: it equals the route's
+ * `lastSignificantChange` (and is absent without one), is never in the future,
+ * and pages do not share one fresh timestamp.
+ */
+export function sitemapLastmodProblems(entries, routes, origin, now = Date.now()) {
+    const routeByUrl = new Map(routes.map((route) => [new URL(route.canonicalPath ?? route.path, `${origin}/`).href, route]));
+    const problems = [];
+    const recentTimestamps = new Map();
+    for (const entry of entries) {
+        if (!entry.lastmod)
+            continue;
+        const time = Date.parse(entry.lastmod);
+        if (Number.isNaN(time)) {
+            problems.push(`${entry.url}: lastmod "${entry.lastmod}" is not a date`);
+            continue;
+        }
+        if (time > now + 24 * 3_600_000)
+            problems.push(`${entry.url}: lastmod ${entry.lastmod} is in the future`);
+        const route = routeByUrl.get(entry.url);
+        if (route && !route.lastSignificantChange) {
+            problems.push(`${entry.url}: lastmod ${entry.lastmod} without a content date (the route has no lastSignificantChange)`);
+        }
+        else if (route?.lastSignificantChange && Date.parse(route.lastSignificantChange) !== time) {
+            problems.push(`${entry.url}: lastmod ${entry.lastmod} is not the route's content date ${route.lastSignificantChange}`);
+        }
+        if (/T\d{2}:\d{2}/.test(entry.lastmod) && now - time >= 0 && now - time < BUILD_WINDOW_HOURS * 3_600_000) {
+            recentTimestamps.set(entry.lastmod, (recentTimestamps.get(entry.lastmod) ?? 0) + 1);
+        }
+    }
+    for (const [timestamp, count] of recentTimestamps) {
+        if (count > 1)
+            problems.push(`${count} URLs share the lastmod ${timestamp}, a timestamp from the last ${BUILD_WINDOW_HOURS} hours: lastmod must be the content date, not the build time`);
+    }
+    return problems;
+}
+// ---------------------------------------------------------------------------
+// HTML structure: main content, link groups and text blocks
+// ---------------------------------------------------------------------------
+const VOID_ELEMENTS = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr']);
+const LIST_ELEMENTS = new Set(['ul', 'ol']);
+const CONTAINER_ELEMENTS = new Set(['div', 'section', 'aside', 'article', 'p', 'dl', 'table', 'tbody', 'nav', 'main', 'figure']);
+const CHROME_ELEMENTS = new Set(['header', 'footer', 'nav']);
+function stripInert(html) {
+    return html.replace(/<(script|style|template|noscript|svg)\b[\s\S]*?<\/\1>/gi, ' ').replace(/<!--[\s\S]*?-->/g, ' ');
+}
+/** The page's main content: `<main>` when present, else the body. */
+export function mainContent(html) {
+    const cleaned = stripInert(html);
+    const main = /<main\b[^>]*>([\s\S]*)<\/main>/i.exec(cleaned)?.[1];
+    if (main !== undefined)
+        return main;
+    return /<body\b[^>]*>([\s\S]*?)(?:<\/body>|$)/i.exec(cleaned)?.[1] ?? cleaned;
+}
+/**
+ * The links of the main content grouped by the list (or, outside a list, the
+ * nearest container) that holds them, in document order; links inside a
+ * header, footer or navigation block are left out.
+ */
+export function extractLinkGroups(html) {
+    const content = mainContent(html);
+    const stack = [];
+    const groups = new Map();
+    let nextId = 1;
+    for (const match of content.matchAll(/<(\/?)([a-zA-Z][a-zA-Z0-9-]*)\b([^>]*)>/g)) {
+        const closing = match[1] === '/';
+        const tag = match[2].toLowerCase();
+        const attributes = match[3] ?? '';
+        if (closing) {
+            const index = stack.map((element) => element.tag).lastIndexOf(tag);
+            if (index >= 0)
+                stack.length = index;
+            continue;
+        }
+        if (tag === 'a') {
+            const href = /\bhref=(?:"([^"]*)"|'([^']*)')/i.exec(attributes);
+            if (href && !stack.some((element) => CHROME_ELEMENTS.has(element.tag))) {
+                const holder = [...stack].reverse().find((element) => LIST_ELEMENTS.has(element.tag)) ??
+                    [...stack].reverse().find((element) => CONTAINER_ELEMENTS.has(element.tag));
+                const key = holder?.id ?? 0;
+                if (!groups.has(key))
+                    groups.set(key, []);
+                groups.get(key).push(decodeXml(href[1] ?? href[2] ?? ''));
+            }
+        }
+        if (VOID_ELEMENTS.has(tag) || attributes.trimEnd().endsWith('/'))
+            continue;
+        stack.push({ tag, id: nextId++ });
+    }
+    return [...groups.values()];
+}
+/** The most links a list may hold and still be a nearby list rather than a directory. */
+const NEARBY_LIST_MAX = 12;
+/**
+ * Nearby lists on a location page must be ranked by distance: any list of 3 to
+ * 12 links to other places with a centre is checked; a directory longer than
+ * that is not a nearby list.
+ */
+export function neighbourOrderProblems(input) {
+    const problems = [];
+    const base = new URL(input.pageUrl);
+    for (const group of extractLinkGroups(input.html)) {
+        const places = [];
+        for (const href of group) {
+            let url;
+            try {
+                url = new URL(href, base);
+            }
+            catch {
+                continue;
+            }
+            if (url.origin !== base.origin)
+                continue;
+            const place = input.placeOf(normalisePath(url.pathname));
+            if (place && !places.includes(place))
+                places.push(place);
+        }
+        const located = places.filter((place) => place !== input.origin && input.centreOf(place));
+        if (located.length < 3 || places.length > NEARBY_LIST_MAX)
+            continue;
+        const problem = findNeighbourOrderProblem(input.origin, located, input.centreOf);
+        if (problem)
+            problems.push(`nearby list [${located.join(', ')}] is not ranked by distance: ${problem.detail}`);
+    }
+    return problems;
+}
+const BLOCK_TAGS = /<\/?(?:p|li|h[1-6]|td|th|dt|dd|blockquote|figcaption|caption|div|section|article|aside|br|tr|summary|details|label|button)\b[^>]*>/gi;
+/** The main content's text blocks (header, footer and navigation removed), lower-cased with whitespace collapsed. */
+export function textBlocks(html) {
+    let content = mainContent(html);
+    for (const tag of CHROME_ELEMENTS)
+        content = content.replace(new RegExp(`<${tag}\\b[\\s\\S]*?<\\/${tag}>`, 'gi'), ' ');
+    return decodeXml(content.replace(BLOCK_TAGS, '\n').replace(/<[^>]+>/g, ' '))
+        .replace(/&nbsp;|&#160;/g, ' ')
+        .split('\n')
+        .map((block) => block.toLowerCase().replace(/\s+/g, ' ').trim())
+        .filter((block) => block.split(' ').length >= 3);
+}
+/** Masks place names and postcodes so name-swapped copy compares as the same text. */
+export function createPlaceMask(names) {
+    const unique = [...new Set(names.map((name) => name.trim().toLowerCase()).filter((name) => name.length >= 3))]
+        .sort((a, b) => b.length - a.length)
+        .map((name) => name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+'));
+    const pattern = unique.length ? new RegExp(`\\b(?:${unique.join('|')})\\b`, 'g') : null;
+    return (text) => (pattern ? text.replace(pattern, '{place}') : text).replace(/\b2\d{3}\b/g, '{postcode}');
+}
+const SHINGLE = 5;
+function shingles(words) {
+    const result = new Set();
+    for (let index = 0; index + SHINGLE <= words.length; index += 1)
+        result.add(words.slice(index, index + SHINGLE).join(' '));
+    return result;
+}
+function words(text) {
+    return text.replace(/[^a-z0-9{}' -]+/g, ' ').split(/\s+/).filter(Boolean);
+}
+/**
+ * Centerpiece similarity: shared blocks (on half or more of the location pages)
+ * are removed, place names are masked, and each page's five-word phrases are
+ * compared with its three nearest siblings that have a centre. Pages without a
+ * centre are not scored.
+ */
+export function centerpieceSimilarity(pages, centreOf, siblings = 3) {
+    const located = pages.filter((page) => centreOf(page.place));
+    if (located.length < 2)
+        return [];
+    const frequency = new Map();
+    for (const page of located)
+        for (const block of new Set(page.blocks))
+            frequency.set(block, (frequency.get(block) ?? 0) + 1);
+    const threshold = Math.max(2, Math.ceil(located.length / 2));
+    const prepared = located.map((page) => {
+        const unique = page.blocks.filter((block) => (frequency.get(block) ?? 0) < threshold);
+        const tokens = unique.flatMap(words);
+        return { page, tokens, shingles: shingles(tokens), centre: centreOf(page.place) };
+    });
+    return prepared.map((current) => {
+        const nearest = prepared
+            .filter((other) => other !== current && other.page.place !== current.page.place)
+            .map((other) => ({ other, distance: Math.hypot(other.centre.latitude - current.centre.latitude, (other.centre.longitude - current.centre.longitude) * Math.cos((current.centre.latitude * Math.PI) / 180)) }))
+            .sort((a, b) => a.distance - b.distance)
+            .slice(0, siblings);
+        if (current.shingles.size === 0) {
+            return { path: current.page.path, score: nearest.length ? 1 : 0, sibling: nearest[0]?.other.page.path ?? null, uniqueWords: current.tokens.length };
+        }
+        let best = { score: 0, sibling: null };
+        for (const { other } of nearest) {
+            let shared = 0;
+            for (const phrase of current.shingles)
+                if (other.shingles.has(phrase))
+                    shared += 1;
+            const score = shared / current.shingles.size;
+            if (score > best.score)
+                best = { score, sibling: other.page.path };
+        }
+        return { path: current.page.path, score: Math.round(best.score * 1000) / 1000, sibling: best.sibling, uniqueWords: current.tokens.length };
+    });
+}
+/** Similarity at or above this is reported as a warning. */
+export const SIMILARITY_WARN = 0.5;
+/** Similarity at or above this puts the page on the review list; it stays indexed. */
+export const SIMILARITY_REVIEW = 0.7;
+// ---------------------------------------------------------------------------
+// Titles, headings, descriptions and page weight
+// ---------------------------------------------------------------------------
+export const TITLE_MAX_LENGTH = 60;
+export const DESCRIPTION_MIN_LENGTH = 70;
+export const DESCRIPTION_MAX_LENGTH = 170;
+export const HTML_MAX_BYTES = 1_048_576;
+/** Title format warnings: over 60 characters, more than one pipe, brackets, emoji, capitals or "near me". */
+export function titleFormatProblems(title) {
+    const problems = [];
+    const length = [...title].length;
+    if (length > TITLE_MAX_LENGTH)
+        problems.push(`${length} characters (keep to about ${TITLE_MAX_LENGTH})`);
+    const pipes = title.split('|').length - 1;
+    if (pipes > 1)
+        problems.push(`${pipes} pipes (use one hyphen or colon as the separator)`);
+    if (/[[\](){}]/.test(title))
+        problems.push('brackets');
+    if (/\p{Extended_Pictographic}/u.test(title))
+        problems.push('emoji');
+    const letters = title.replace(/[^A-Za-z]/g, '');
+    if (letters.length >= 6 && letters === letters.toUpperCase())
+        problems.push('all capitals');
+    else if (/\b[A-Z]{5,}\b/.test(title))
+        problems.push(`capitalised word ${/\b[A-Z]{5,}\b/.exec(title)[0]}`);
+    if (/\bnear (?:me|you)\b/i.test(title))
+        problems.push('"near me" wording');
+    return problems;
+}
+const STOP_WORDS = new Set(['a', 'an', 'and', 'the', 'in', 'for', 'of', 'to', 'on', 'at', 'by', 'with', 'our', 'your', 'from', 'we', 'you', 'is', 'are', 'best', 'local', 'sydney-wide']);
+function contentWords(text) {
+    return text
+        .toLowerCase()
+        .replace(/&/g, ' and ')
+        .replace(/[^a-z0-9' ]+/g, ' ')
+        .split(/\s+/)
+        .map((word) => word.replace(/'s$|'$/, '').replace(/(?<=[a-z]{3})s$/, ''))
+        .filter((word) => word && !STOP_WORDS.has(word));
+}
+/** The title's primary phrase: the part before its first separator. */
+export function primaryTitlePhrase(title) {
+    return title.split(/\s+[|–—-]\s+|:\s+/)[0].trim();
+}
+/**
+ * Whether the title and the H1 share the page's primary phrase: half or more of
+ * the title's primary words appear in the H1, and the page's place (when it has
+ * one) appears in both.
+ */
+export function titleHeadingProblems(title, h1, place) {
+    const primary = contentWords(primaryTitlePhrase(title));
+    const heading = new Set(contentWords(h1));
+    const problems = [];
+    if (primary.length > 0) {
+        const shared = primary.filter((word) => heading.has(word)).length;
+        if (shared / primary.length < 0.5)
+            problems.push(`the H1 "${h1}" does not say what the title's primary phrase "${primaryTitlePhrase(title)}" says`);
+    }
+    if (place) {
+        const pattern = new RegExp(`\\b${place.toLowerCase().replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\s+/g, '\\s+')}\\b`);
+        if (!pattern.test(title.toLowerCase()))
+            problems.push(`the title does not name ${place}`);
+        if (!pattern.test(h1.toLowerCase()))
+            problems.push(`the H1 does not name ${place}`);
+    }
+    return problems;
+}
+export function descriptionLengthProblem(description) {
+    const length = [...description].length;
+    if (length < DESCRIPTION_MIN_LENGTH)
+        return `${length} characters (aim for ${DESCRIPTION_MIN_LENGTH}–${DESCRIPTION_MAX_LENGTH})`;
+    if (length > DESCRIPTION_MAX_LENGTH)
+        return `${length} characters (aim for ${DESCRIPTION_MIN_LENGTH}–${DESCRIPTION_MAX_LENGTH})`;
+    return null;
+}
+/** The text of every H1 in the server HTML. */
+export function headingTexts(html) {
+    return [...stripInert(html).matchAll(/<h1\b[^>]*>([\s\S]*?)<\/h1>/gi)].map((match) => decodeXml(match[1].replace(/<[^>]+>/g, ' ')).replace(/\s+/g, ' ').trim());
+}
+export function normalisePath(path) {
+    const pathname = path.split(/[?#]/)[0] || '/';
+    return pathname.length > 1 ? pathname.replace(/\/+$/, '') : '/';
+}
+export function decodeXml(value) {
+    return value
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#x27;|&#39;|&apos;/g, "'");
+}
+//# sourceMappingURL=page-standard.js.map