@goflag/cli 0.2.5 → 0.2.8

package/dist/{chunk-5FO2Q3II.js → chunk-SKX7UCGC.js}

@@ -970,7 +970,8 @@ async function inspect(url, options = {}) {
       extractor: {
         mode: "static",
         escalated: false,
-        escalationReason: `would-have-escalated (${heuristic.reason}) but ${err.message}`
+        escalationReason: heuristic.reason,
+        escalationBlocked: err.message
       },
       html: { static: staticBody },
       probes: probes2
@@ -1115,6 +1116,7 @@ function push(out, seen, href, source) {
 }
 
 // src/lib/core/crawl.ts
+var MAX_ATTEMPTS = 2;
 async function crawl(options) {
   const depthLimit = options.depth ?? 1;
   const concurrency = Math.max(1, options.concurrency ?? 4);
@@ -1128,6 +1130,7 @@ async function crawl(options) {
       pages: [],
       visited: [],
       errors: [{ url: options.entryUrl, message: "entry URL is not a valid http(s) URL" }],
+      recovered: [],
       truncated: false
     };
   }
@@ -1143,6 +1146,7 @@ async function crawl(options) {
   }
   const pages = [];
   const errors = [];
+  const recovered = [];
   let truncated = false;
   const seenFinal = /* @__PURE__ */ new Set();
   while (queue.length > 0) {
@@ -1163,9 +1167,15 @@ async function crawl(options) {
     const results = await Promise.all(inspections);
     for (const result of results) {
       if (result.kind === "err") {
+        const attempt = (result.item.attempt ?? 0) + 1;
+        if (attempt < MAX_ATTEMPTS) {
+          queue.push({ ...result.item, attempt });
+          continue;
+        }
         errors.push({ url: result.item.url, message: result.error });
         continue;
       }
+      if (result.item.attempt) recovered.push(result.item.url);
       const finalUrl = canonicaliseUrl(result.page.fetch.finalUrl) ?? result.page.fetch.finalUrl;
       if (seenFinal.has(finalUrl)) continue;
       seenFinal.add(finalUrl);
@@ -1198,6 +1208,7 @@ async function crawl(options) {
     pages,
     visited: [...visitedSet],
     errors,
+    recovered,
     truncated
   };
 }
@@ -1784,17 +1795,60 @@ function sortIssues(issues) {
   });
 }
 
-// src/lib/core/i18n.ts
-var BCP47_LOOSE = /^[a-z]{2,3}(-[a-z]{2}|-\d{3})?$/i;
-function localeIdentity(tag) {
-  return tag.trim().toLowerCase();
-}
+// src/lib/core/bcp47.ts
+var languageNames = new Intl.DisplayNames(["en"], { type: "language", fallback: "none" });
+var regionNames = new Intl.DisplayNames(["en"], { type: "region", fallback: "none" });
+var scriptNames = new Intl.DisplayNames(["en"], { type: "script", fallback: "none" });
+var NOT_AN_AUDIENCE_REGION = /* @__PURE__ */ new Set(["ZZ", "XA", "XB"]);
+var NOT_AN_AUDIENCE_LANGUAGE = /* @__PURE__ */ new Set(["mul", "zxx", "und", "mis"]);
+var NOT_A_SCRIPT = /* @__PURE__ */ new Set(["Zzzz"]);
+var ICU_KNOWS_LANGUAGES = languageNames.of("fr") !== void 0 && languageNames.of("qq") === void 0 && regionNames.of("BR") !== void 0;
+var ICU_UNAVAILABLE_WARNING = "This Node build cannot tell a real language tag from an invented one (small-icu). hreflang tags were checked for shape only, so `locale.invalid` may have missed tags that do not exist.";
+var BCP47_SHAPE = /^[a-z]{2,3}(-[a-z]{2}|-\d{3})?$/i;
 function looksLikeLocaleSegment(segment) {
-  return BCP47_LOOSE.test(segment);
+  return BCP47_SHAPE.test(segment);
 }
 function isValidLocale(tag) {
   if (tag === "x-default") return true;
-  return BCP47_LOOSE.test(tag);
+  if (!ICU_KNOWS_LANGUAGES) return BCP47_SHAPE.test(tag);
+  let canonical;
+  try {
+    canonical = Intl.getCanonicalLocales(tag)[0] ?? "";
+  } catch {
+    return false;
+  }
+  if (!canonical) return false;
+  let parts;
+  try {
+    parts = new Intl.Locale(canonical);
+  } catch {
+    return false;
+  }
+  const language = (parts.language ?? "").toLowerCase();
+  if (!language) return false;
+  if (NOT_AN_AUDIENCE_LANGUAGE.has(language)) return false;
+  if (languageNames.of(language) === void 0) return false;
+  if (parts.script) {
+    if (NOT_A_SCRIPT.has(parts.script)) return false;
+    if (scriptNames.of(parts.script) === void 0) return false;
+  }
+  if (parts.region) {
+    if (NOT_AN_AUDIENCE_REGION.has(parts.region)) return false;
+    if (regionNames.of(parts.region) === void 0) return false;
+  }
+  return true;
+}
+function isKnownLanguageTag(tag) {
+  const primary = (tag.toLowerCase().split("-")[0] ?? "").trim();
+  if (!primary) return false;
+  if (NOT_AN_AUDIENCE_LANGUAGE.has(primary)) return false;
+  if (!ICU_KNOWS_LANGUAGES) return BCP47_SHAPE.test(primary);
+  return languageNames.of(primary) !== void 0;
+}
+
+// src/lib/core/i18n.ts
+function localeIdentity(tag) {
+  return tag.trim().toLowerCase();
 }
 function buildI18nMatrix(pages, options = {}) {
   const inspectedByUrl = /* @__PURE__ */ new Map();
@@ -1802,10 +1856,18 @@ function buildI18nMatrix(pages, options = {}) {
   const grid = /* @__PURE__ */ new Map();
   const locales = /* @__PURE__ */ new Set();
   const routes = /* @__PURE__ */ new Set();
+  const declaredSet = new Set(options.declaredUrls ?? []);
   for (const locale of options.locales ?? []) {
     const tag = locale.trim().toLowerCase();
     if (tag) locales.add(tag);
   }
+  function rowOf2(url, pathnameRoute) {
+    return options.clusterRouteOf?.(url) ?? pathnameRoute;
+  }
+  function sourceOf(url) {
+    if (inspectedByUrl.has(url)) return "crawled";
+    return declaredSet.has(url) ? "sitemap" : "alternate";
+  }
   function record(route, locale, url) {
     routes.add(route);
     locales.add(locale);
@@ -1815,13 +1877,13 @@ function buildI18nMatrix(pages, options = {}) {
       grid.set(route, row);
     }
     if (!row.has(locale)) {
-      row.set(locale, { url, inspected: inspectedByUrl.has(url) });
+      row.set(locale, { url, inspected: inspectedByUrl.has(url), source: sourceOf(url) });
     }
   }
   for (const page of pages) {
     const url = new URL(page.fetch.finalUrl);
     const { route: selfRoute, locale: selfLocale } = splitRoute(url.pathname);
-    record(selfRoute, selfLocale, page.fetch.finalUrl);
+    record(rowOf2(page.fetch.finalUrl, selfRoute), selfLocale, page.fetch.finalUrl);
     for (const alt of page.links.alternates) {
       let altUrl;
       try {
@@ -1831,7 +1893,7 @@ function buildI18nMatrix(pages, options = {}) {
       }
       const { route } = splitRoute(altUrl.pathname);
       const locale = alt.isXDefault ? "x-default" : localeIdentity(alt.hreflang);
-      record(route || selfRoute, locale, altUrl.toString());
+      record(rowOf2(altUrl.toString(), route || selfRoute), locale, altUrl.toString());
     }
   }
   for (const declared of options.declaredUrls ?? []) {
@@ -1842,7 +1904,7 @@ function buildI18nMatrix(pages, options = {}) {
       continue;
     }
     const { route, locale } = splitRoute(url.pathname);
-    record(route, locale, url.toString());
+    record(rowOf2(url.toString(), route), locale, url.toString());
   }
   const sortedLocales = sortLocales([...locales]);
   const sortedRoutes = [...routes].sort((a, b) => a.localeCompare(b));
@@ -1851,11 +1913,20 @@ function buildI18nMatrix(pages, options = {}) {
     cells[route] = {};
     for (const locale of sortedLocales) {
       const slot = grid.get(route)?.get(locale);
-      cells[route][locale] = slot ? { url: slot.url, inspected: slot.inspected } : { url: null, inspected: false };
+      cells[route][locale] = slot ? { url: slot.url, inspected: slot.inspected, source: slot.source } : { url: null, inspected: false };
     }
   }
   return { locales: sortedLocales, routes: sortedRoutes, cells };
 }
+function countUnverifiedAlternates(matrix) {
+  let count2 = 0;
+  for (const route of matrix.routes) {
+    for (const locale of matrix.locales) {
+      if (matrix.cells[route]?.[locale]?.source === "alternate") count2++;
+    }
+  }
+  return count2;
+}
 function reciprocityIssues(pages) {
   const issues = [];
   const byUrl = /* @__PURE__ */ new Map();
@@ -1956,6 +2027,9 @@ function declaredLocales(page) {
   }
   return out;
 }
+function rowOf(site, url, pathname) {
+  return site.clusterRouteOf?.(url) ?? splitRoute(pathname).route;
+}
 function sitemapLocalesByRoute(site) {
   const byRoute = /* @__PURE__ */ new Map();
   for (const entry of site.discovery?.urls ?? []) {
@@ -1965,8 +2039,9 @@ function sitemapLocalesByRoute(site) {
     } catch {
       continue;
     }
-    const { route, locale } = splitRoute(pathname);
+    const { locale } = splitRoute(pathname);
     if (locale === "x-default") continue;
+    const route = rowOf(site, entry.loc, pathname);
     const set = byRoute.get(route) ?? /* @__PURE__ */ new Set();
     set.add(locale.toLowerCase());
     byRoute.set(route, set);
@@ -2030,7 +2105,7 @@ var hreflangSitemapMismatch = {
       } catch {
         continue;
       }
-      const { route } = splitRoute(pathname);
+      const route = rowOf(site, page.fetch.finalUrl, pathname);
       const inSitemap = bySitemap.get(route);
       if (!inSitemap || inSitemap.size === 0) continue;
       const onlyInSitemap = sorted(new Set([...inSitemap].filter((l) => !head.has(l))));
@@ -2159,13 +2234,6 @@ function sortSiteIssues(drafts) {
 }
 
 // src/lib/core/locales.ts
-var ISO_639_1 = new Set(
-  "aa ab ae af ak am an ar as av ay az ba be bg bh bi bm bn bo br bs ca ce ch co cr cs cu cv cy da de dv dz ee el en eo es et eu fa ff fi fj fo fr fy ga gd gl gn gu gv ha he hi ho hr ht hu hy hz ia id ie ig ii ik io is it iu ja jv ka kg ki kj kk kl km kn ko kr ks ku kv kw ky la lb lg li ln lo lt lu lv mg mh mi mk ml mn mr ms mt my na nb nd ne ng nl nn no nr nv ny oc oj om or os pa pi pl ps pt qu rm rn ro ru rw sa sc sd se sg si sk sl sm sn so sq sr ss st su sv sw ta te tg th ti tk tl tn to tr ts tt tw ty ug uk ur uz ve vi vo wa wo xh yi yo za zh zu".split(" ")
-);
-function isKnownLanguageTag(tag) {
-  const primary = tag.toLowerCase().split("-")[0] ?? "";
-  return ISO_639_1.has(primary);
-}
 function localePrefixOf(url) {
   let pathname;
   try {
@@ -2246,6 +2314,26 @@ import { gunzipSync } from "zlib";
 
 // src/lib/core/sitemap/parse.ts
 import * as cheerio2 from "cheerio";
+function alternatesOf(node) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  node.children().each((_, el) => {
+    const tag = "tagName" in el ? el.tagName ?? "" : "";
+    if (tag.split(":").pop()?.toLowerCase() !== "link") return;
+    const attrs = "attribs" in el ? el.attribs : void 0;
+    if (!attrs) return;
+    const rel = (attrs.rel ?? "alternate").trim().toLowerCase();
+    if (rel !== "alternate") return;
+    const hreflang = (attrs.hreflang ?? "").trim();
+    const href = (attrs.href ?? "").trim();
+    if (!hreflang || !href) return;
+    const key = `${hreflang.toLowerCase()}\0${href}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push({ hreflang, href });
+  });
+  return out;
+}
 function parseSitemap(body) {
   const trimmed = body.trim();
   if (trimmed.length === 0) {
@@ -2284,6 +2372,8 @@ function parseSitemap(body) {
       if (changefreq) entry.changefreq = changefreq;
       const priority = node.find("priority").first().text().trim();
       if (priority) entry.priority = priority;
+      const alternates = alternatesOf(node);
+      if (alternates.length > 0) entry.alternates = alternates;
       urls.push(entry);
     });
     return { kind: "urlset", wellFormed: true, urls };
@@ -2503,6 +2593,155 @@ function relaxTlsIfRequested2(enabled) {
   };
 }
 
+// src/lib/core/clusters.ts
+function normalise(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return null;
+  }
+  url.hash = "";
+  const path = url.pathname.length > 1 ? url.pathname.replace(/\/+$/, "") : url.pathname;
+  return `${url.origin}${path}${url.search}`;
+}
+var X_DEFAULT = "x-default";
+function clusterCount(rows) {
+  return new Set(rows.values()).size;
+}
+function indexOf(rows, conflicts, refused) {
+  return {
+    rows,
+    routeOf: (url) => {
+      const key = normalise(url);
+      return key === null ? void 0 : rows.get(key);
+    },
+    size: clusterCount(rows),
+    conflicts,
+    refused
+  };
+}
+function buildClusterIndex(entries) {
+  const rows = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  let refused = 0;
+  for (const entry of entries) {
+    const alternates = entry.alternates;
+    if (!alternates || alternates.length === 0) continue;
+    const xDefault = alternates.find((a) => a.hreflang.trim().toLowerCase() === X_DEFAULT);
+    if (!xDefault) {
+      refused++;
+      continue;
+    }
+    const anchorUrl = normalise(xDefault.href);
+    if (!anchorUrl) {
+      refused++;
+      continue;
+    }
+    const { route: anchorRoute } = splitRoute(new URL(anchorUrl).pathname);
+    const members = [entry.loc, ...alternates.map((a) => a.href)];
+    for (const member of members) {
+      const url = normalise(member);
+      if (!url) continue;
+      const existing = rows.get(url);
+      if (existing === void 0) {
+        rows.set(url, anchorRoute);
+        continue;
+      }
+      if (existing !== anchorRoute && !conflicts.includes(url)) conflicts.push(url);
+    }
+  }
+  return indexOf(rows, conflicts, refused);
+}
+function readHeads(pages) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const self = normalise(page.fetch.finalUrl);
+    if (self === null || seen.has(self)) continue;
+    const peers = /* @__PURE__ */ new Set();
+    const xDefaults = /* @__PURE__ */ new Set();
+    for (const alt of page.links.alternates) {
+      const href = normalise(alt.href);
+      if (href === null) continue;
+      if (alt.isXDefault) xDefaults.add(href);
+      else if (href !== self) peers.add(href);
+    }
+    seen.set(self, { peers, xDefault: xDefaults.size === 1 ? [...xDefaults][0] : null });
+  }
+  return seen;
+}
+function buildHeadClusterIndex(pages) {
+  const seen = readHeads(pages);
+  const parent = /* @__PURE__ */ new Map();
+  for (const url of seen.keys()) parent.set(url, url);
+  const find = (start) => {
+    let root = start;
+    while (parent.get(root) !== root) root = parent.get(root);
+    let cursor = start;
+    while (parent.get(cursor) !== root) {
+      const next = parent.get(cursor);
+      parent.set(cursor, root);
+      cursor = next;
+    }
+    return root;
+  };
+  for (const [url, decl] of seen) {
+    for (const peer of decl.peers) {
+      if (!seen.get(peer)?.peers.has(url)) continue;
+      const [a, b] = [find(url), find(peer)];
+      if (a !== b) parent.set(a, b);
+    }
+  }
+  const components = /* @__PURE__ */ new Map();
+  for (const url of seen.keys()) {
+    const root = find(url);
+    const members = components.get(root);
+    if (members) members.push(url);
+    else components.set(root, [url]);
+  }
+  const rows = /* @__PURE__ */ new Map();
+  let refused = 0;
+  for (const members of components.values()) {
+    if (members.length < 2) continue;
+    const declared = new Set(
+      members.map((m) => seen.get(m)?.xDefault).filter((x) => Boolean(x))
+    );
+    if (declared.size !== 1) {
+      refused++;
+      continue;
+    }
+    const anchor = [...declared][0];
+    if (!members.includes(anchor)) {
+      refused++;
+      continue;
+    }
+    const { route } = splitRoute(new URL(anchor).pathname);
+    for (const member of members) rows.set(member, route);
+  }
+  return indexOf(rows, [], refused);
+}
+function combineClusterIndexes(primary, secondary) {
+  const rows = new Map(secondary.rows);
+  const conflicts = [...primary.conflicts];
+  const add = (url) => {
+    if (!conflicts.includes(url)) conflicts.push(url);
+  };
+  for (const url of secondary.conflicts) add(url);
+  for (const [url, route] of primary.rows) {
+    const claimed = rows.get(url);
+    if (claimed !== void 0 && claimed !== route) add(url);
+    rows.set(url, route);
+  }
+  return indexOf(rows, conflicts, primary.refused + secondary.refused);
+}
+function clustersOnlyFrom(primary, secondary) {
+  const routes = /* @__PURE__ */ new Set();
+  for (const [url, route] of secondary.rows) {
+    if (!primary.rows.has(url)) routes.add(route);
+  }
+  return routes.size;
+}
+
 // src/lib/core/coverage.ts
 var DEFAULT_PER_FAMILY = 3;
 var DEFAULT_THRESHOLD = 8;
@@ -3435,6 +3674,11 @@ function localeOfUrl(url) {
   }
   return null;
 }
+function blockedEscalationWarning(pages) {
+  const blocked = pages.filter((p) => p.extractor.escalationBlocked);
+  if (blocked.length === 0) return null;
+  return `${blocked.length} page(s) looked client-rendered and were judged on their static HTML, because the browser could not be started: ${blocked[0].extractor.escalationBlocked} Their metadata findings may be phantoms \u2014 install Playwright and Chromium, or pass --static to say the static HTML is what you meant to judge.`;
+}
 function deriveTranslationHoles(matrix, ignoreRoutes = []) {
   const realLocales = matrix.locales.filter((l) => l !== "x-default");
   if (realLocales.length < 2) return [];
@@ -3501,6 +3745,7 @@ async function runAudit(inputUrl, options = {}) {
     crawlFallback: false
   }).catch(() => void 0);
   const allSitemapUrls = (discovery?.urls ?? []).map((u) => u.loc);
+  const sitemapClusters = buildClusterIndex(discovery?.urls ?? []);
   const coverageMode = options.coverage ?? (allSitemapUrls.length > 0 ? "structural" : "all");
   const selection = coverageMode === "structural" && allSitemapUrls.length > 0 ? selectByStructure(allSitemapUrls, { locales: options.locales }) : void 0;
   const sitemapUrls = selection?.urls ?? allSitemapUrls;
@@ -3533,6 +3778,13 @@ async function runAudit(inputUrl, options = {}) {
   });
   const pages = crawlResult.pages;
   const warnings = crawlResult.errors.map((e) => `crawl: ${e.url} \u2014 ${e.message}`);
+  if (crawlResult.recovered.length > 0) {
+    warnings.push(
+      `${crawlResult.recovered.length} page(s) failed once and answered on retry: ${crawlResult.recovered.slice(0, 3).join(", ")}${crawlResult.recovered.length > 3 ? `, +${crawlResult.recovered.length - 3} more` : ""}.`
+    );
+  }
+  const escalationWarning = blockedEscalationWarning(pages);
+  if (escalationWarning) warnings.push(escalationWarning);
   const okPages = pages.filter((p) => isOkStatus(p.fetch.status));
   const documents = okPages.filter(isHtmlPage);
   const { kept: htmlPages, dropped: duplicatePages } = dropCanonicalDuplicates(documents);
@@ -3595,10 +3847,26 @@ async function runAudit(inputUrl, options = {}) {
       suggestion ? `No sitemap and no --locales: i18n checks are off. Locale-looking prefixes found \u2014 re-run with \`--locales ${suggestion}\` to enable them.` : `No sitemap and no --locales: i18n checks are off. Prefixes seen (${localeAxis.candidates.map((c) => c.tag).join(", ")}) do not look like locales; pass --locales if any of them is one.`
     );
   }
+  if (!ICU_KNOWS_LANGUAGES) warnings.push(ICU_UNAVAILABLE_WARNING);
+  const headClusters = buildHeadClusterIndex(htmlPages);
+  const clusters = combineClusterIndexes(sitemapClusters, headClusters);
+  const clustersFromHead = clustersOnlyFrom(sitemapClusters, headClusters);
   const matrix = buildI18nMatrix(htmlPages, {
     declaredUrls: sitemapUrls,
-    locales: localeAxis.locales
+    locales: localeAxis.locales,
+    clusterRouteOf: clusters.routeOf
   });
+  if (clusters.conflicts.length > 0) {
+    warnings.push(
+      `${clusters.conflicts.length} URL(s) are declared in two different hreflang clusters by the sitemap and/or the pages' \`<head>\`; the sitemap's declaration was kept: ${clusters.conflicts.slice(0, 3).join(", ")}${clusters.conflicts.length > 3 ? `, +${clusters.conflicts.length - 3} more` : ""}.`
+    );
+  }
+  const unverifiedAlternates = countUnverifiedAlternates(matrix);
+  if (unverifiedAlternates > 0) {
+    warnings.push(
+      `${unverifiedAlternates} translation${unverifiedAlternates === 1 ? "" : "s"} in the matrix ${unverifiedAlternates === 1 ? "is" : "are"} vouched for only by an \`hreflang\` on another page \u2014 not crawled, and not in the sitemap. They are counted as present, so a page advertised but not served reads as translated rather than missing.`
+    );
+  }
   const holes = localeAxis.multilingual ? deriveTranslationHoles(matrix, options.ignoreHoles) : [];
   const ignoredHoles = localeAxis.multilingual && (options.ignoreHoles?.length ?? 0) > 0 ? deriveTranslationHoles(matrix).length - holes.length : 0;
   const reciprocity = reciprocityIssues(htmlPages).map((issue) => ({
@@ -3617,7 +3885,11 @@ async function runAudit(inputUrl, options = {}) {
     matrix,
     localeAxis,
     discovery,
-    robots
+    robots,
+    // Same index the matrix was built from, so a rule that groups by route
+    // and the grid that reports holes cannot disagree about which URLs are
+    // one page.
+    clusterRouteOf: clusters.routeOf
   };
   const siteOccurrence = /* @__PURE__ */ new Map();
   const siteIssues = lintSite(siteContext).map((draft) => {
@@ -3743,6 +4015,24 @@ async function runAudit(inputUrl, options = {}) {
       },
       ...ignoredHoles > 0 ? { ignoredHoles } : {},
       ...duplicatePages > 0 ? { duplicatePages } : {},
+      ...unverifiedAlternates > 0 ? { unverifiedAlternates } : {},
+      // Only when the site declared clusters. A merge that changes which rows
+      // exist must be visible: the alternative is a hole count that moved for
+      // a reason nothing in the report explains.
+      ...clusters.size > 0 || clusters.refused > 0 ? {
+        declaredClusters: {
+          count: clusters.size,
+          ...clusters.conflicts.length > 0 ? { conflicts: clusters.conflicts.length } : {},
+          // Which source did the work. On a site that declares both ways
+          // the two indexes describe the same clusters, so this counts the
+          // rows only the `<head>` supplied rather than a difference of
+          // totals that would claim a gain that is not there.
+          ...clustersFromHead > 0 ? { fromHead: clustersFromHead } : {},
+          // Declared and not used, for want of an anchor to name the row
+          // after. A declaration we saw and did not act on has to be said.
+          ...clusters.refused > 0 ? { refused: clusters.refused } : {}
+        }
+      } : {},
       ...discovery ? {
         sitemap: {
           found: discovery.diagnostics.found,
@@ -4399,9 +4689,12 @@ var Logger = class {
 };
 
 export {
+  RULES,
+  SITE_RULES,
   DEFAULT_PROFILE,
   PROFILES,
   PROFILE_NAMES,
+  PROSE_RULES,
   routeKey,
   targetKey,
   fingerprint,
@@ -4414,4 +4707,4 @@ export {
   summarize,
   Logger
 };
-//# sourceMappingURL=chunk-5FO2Q3II.js.map
+//# sourceMappingURL=chunk-SKX7UCGC.js.map