@pas7/nextjs-sitemap-hreflang 0.3.1

package/dist/index.js

@@ -0,0 +1,783 @@
+// src/lib/assertHreflang.ts
+function assertHreflang(entries, options) {
+  const requireAbsolute = options.requireAbsolute ?? true;
+  const requireXDefaultWhenMultiple = options.requireXDefaultWhenMultiple ?? true;
+  const requireSelf = options.requireSelf ?? false;
+  const issues = [];
+  for (const entry of entries) {
+    const languages = entry.alternates?.languages;
+    if (!languages) continue;
+    const pairs = Object.entries(languages);
+    if (pairs.length === 0) {
+      issues.push({
+        code: "MISSING_LANGUAGES",
+        entryUrl: entry.url,
+        message: "alternates.languages is empty"
+      });
+      continue;
+    }
+    if (requireXDefaultWhenMultiple && pairs.length > 1 && !languages["x-default"]) {
+      issues.push({
+        code: "MISSING_XDEFAULT",
+        entryUrl: entry.url,
+        message: "Missing x-default hreflang for a multilingual entry"
+      });
+    }
+    if (requireSelf && options.canonicalLocale) {
+      if (!languages[options.canonicalLocale]) {
+        issues.push({
+          code: "MISSING_SELF",
+          entryUrl: entry.url,
+          message: `Missing self hreflang for canonicalLocale=${options.canonicalLocale}`
+        });
+      }
+    }
+    const hrefSeen = /* @__PURE__ */ new Set();
+    for (const [locale, href] of pairs) {
+      if (!isValidLocaleKey(locale)) {
+        issues.push({
+          code: "INVALID_LOCALE_KEY",
+          entryUrl: entry.url,
+          message: `Invalid locale key: ${locale}`
+        });
+      }
+      if (requireAbsolute && !isAbsoluteUrl(href)) {
+        issues.push({
+          code: "NON_ABSOLUTE_URL",
+          entryUrl: entry.url,
+          message: `Non-absolute hreflang href for ${locale}: ${href}`
+        });
+      }
+      if (hrefSeen.has(href)) {
+        issues.push({
+          code: "DUPLICATE_HREF",
+          entryUrl: entry.url,
+          message: `Duplicate hreflang href detected: ${href}`
+        });
+      }
+      hrefSeen.add(href);
+    }
+  }
+  return { ok: issues.length === 0, issues };
+}
+function isAbsoluteUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function isValidLocaleKey(key) {
+  if (key === "x-default") return true;
+  return /^[a-z]{2}(-[A-Z]{2})?$/.test(key);
+}
+
+// src/lib/url.ts
+function normalizeUrl(url, trailingSlash) {
+  const u = new URL(url);
+  if (trailingSlash === "preserve") return u.toString();
+  if (trailingSlash === "always") {
+    if (!u.pathname.endsWith("/")) u.pathname = `${u.pathname}/`;
+    return u.toString();
+  }
+  if (u.pathname !== "/" && u.pathname.endsWith("/")) u.pathname = u.pathname.slice(0, -1);
+  return u.toString();
+}
+function resolveAbsoluteUrl(input, baseUrl) {
+  if (input.startsWith("http://") || input.startsWith("https://")) return input;
+  return new URL(input.startsWith("/") ? input : `/${input}`, baseUrl).toString();
+}
+function getOriginFromAbsoluteUrl(absoluteUrl) {
+  const u = new URL(absoluteUrl);
+  return `${u.protocol}//${u.host}`;
+}
+
+// src/lib/buildLanguagesMap.ts
+function buildLanguagesMap(input) {
+  const trailingSlash = input.trailingSlash ?? "preserve";
+  const languages = {};
+  for (const locale of input.locales) {
+    const href = input.resolveHref(locale);
+    const abs = resolveAbsoluteUrl(href, input.baseUrl);
+    languages[locale] = normalizeUrl(abs, trailingSlash);
+  }
+  const canonical = languages[input.canonicalLocale] ?? normalizeUrl(input.baseUrl, trailingSlash);
+  if (input.includeXDefault) {
+    const xDefault = resolveXDefaultForLanguages({
+      canonical,
+      languages,
+      baseUrl: input.baseUrl,
+      strategy: input.xDefaultStrategy ?? { type: "loc" },
+      trailingSlash
+    });
+    languages["x-default"] = xDefault;
+  }
+  return { canonical, languages };
+}
+function resolveXDefaultForLanguages(args) {
+  const { canonical, languages, baseUrl, strategy, trailingSlash } = args;
+  if (strategy.type === "loc") return normalizeUrl(canonical, trailingSlash);
+  if (strategy.type === "root") return normalizeUrl(resolveAbsoluteUrl("/", baseUrl), trailingSlash);
+  if (strategy.type === "custom") return normalizeUrl(resolveAbsoluteUrl(strategy.url, baseUrl), trailingSlash);
+  if (strategy.type === "locale") {
+    const href2 = languages[strategy.locale];
+    if (href2) return normalizeUrl(href2, trailingSlash);
+    return normalizeUrl(canonical, trailingSlash);
+  }
+  const href = strategy.resolve({ url: canonical });
+  return normalizeUrl(resolveAbsoluteUrl(href, baseUrl), trailingSlash);
+}
+
+// src/lib/withHreflang.ts
+function withHreflang(entries, options) {
+  const trailingSlash = options.trailingSlash ?? "preserve";
+  const ensureAbsolute = options.ensureAbsolute ?? true;
+  const ensureXDefault = options.ensureXDefault ?? true;
+  const ensureSelf = options.ensureSelf ?? false;
+  return entries.map((entry) => {
+    if (options.shouldApply && !options.shouldApply(entry)) return entry;
+    const url = normalizeEntryUrl(entry.url, options.baseUrl, ensureAbsolute, trailingSlash);
+    const languages = entry.alternates?.languages ? normalizeLanguages(entry.alternates.languages, options.baseUrl, ensureAbsolute, trailingSlash) : void 0;
+    if (!languages) {
+      return { ...entry, url };
+    }
+    const nextLanguages = { ...languages };
+    if (ensureSelf && options.canonicalLocale) {
+      if (!nextLanguages[options.canonicalLocale]) nextLanguages[options.canonicalLocale] = url;
+    }
+    if (ensureXDefault) {
+      if (!nextLanguages["x-default"]) {
+        const xDefault = resolveXDefaultForLanguages({
+          canonical: url,
+          languages: nextLanguages,
+          baseUrl: options.baseUrl ?? url,
+          strategy: options.xDefaultStrategy ?? { type: "loc" },
+          trailingSlash
+        });
+        nextLanguages["x-default"] = xDefault;
+      }
+    }
+    const alternates = { ...entry.alternates ?? {}, languages: nextLanguages };
+    return { ...entry, url, alternates };
+  });
+}
+function normalizeEntryUrl(url, baseUrl, ensureAbsolute, trailingSlash) {
+  const abs = ensureAbsolute ? resolveAbsoluteUrl(url, baseUrl ?? url) : url;
+  return normalizeUrl(abs, trailingSlash);
+}
+function normalizeLanguages(languages, baseUrl, ensureAbsolute, trailingSlash) {
+  const out = {};
+  for (const [k, v] of Object.entries(languages)) {
+    const abs = ensureAbsolute ? resolveAbsoluteUrl(v, baseUrl ?? v) : v;
+    out[k] = normalizeUrl(abs, trailingSlash);
+  }
+  return out;
+}
+function assertHreflangExport(entries, options) {
+  return assertHreflang(entries, options);
+}
+function withHreflangFromRouting(entries, strategy, options) {
+  const trailingSlash = options.trailingSlash ?? "preserve";
+  const ensureAbsolute = options.ensureAbsolute ?? true;
+  const ensureXDefault = options.ensureXDefault ?? true;
+  const ensureSelf = options.ensureSelf ?? false;
+  return entries.map((entry) => {
+    if (options.shouldApply && !options.shouldApply(entry)) return entry;
+    let pathname;
+    try {
+      const url = new URL(entry.url, options.baseUrl);
+      pathname = url.pathname;
+    } catch {
+      pathname = entry.url;
+    }
+    const languages = {};
+    for (const locale of strategy.locales) {
+      const href = strategy.hrefFor({ pathname, locale });
+      const abs = ensureAbsolute ? resolveAbsoluteUrl(href, options.baseUrl) : href;
+      languages[locale] = normalizeUrl(abs, trailingSlash);
+    }
+    if (ensureXDefault && !languages["x-default"]) {
+      const canonical = languages[strategy.canonicalLocale] ?? normalizeUrl(entry.url, trailingSlash);
+      const xDefault = resolveXDefaultForLanguages({
+        canonical,
+        languages,
+        baseUrl: options.baseUrl,
+        strategy: strategy.xDefault ?? { type: "loc" },
+        trailingSlash
+      });
+      languages["x-default"] = xDefault;
+    }
+    if (ensureSelf && !languages[strategy.canonicalLocale]) {
+      const url = normalizeEntryUrl(entry.url, options.baseUrl, ensureAbsolute, trailingSlash);
+      languages[strategy.canonicalLocale] = url;
+    }
+    const alternates = { ...entry.alternates ?? {}, languages };
+    return { ...entry, alternates };
+  });
+}
+
+// src/lib/routing.ts
+function routingPrefixAsNeeded(options) {
+  const { defaultLocale, locales, basePath = "" } = options;
+  return {
+    locales,
+    canonicalLocale: defaultLocale,
+    hrefFor: ({ pathname, locale }) => {
+      const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+      const base = basePath || "";
+      if (locale === defaultLocale) {
+        return `${base}${normalizedPath}`;
+      }
+      return `${base}/${locale}${normalizedPath}`;
+    }
+  };
+}
+function routingPrefixAlways(options) {
+  const { defaultLocale, locales, basePath = "" } = options;
+  return {
+    locales,
+    canonicalLocale: defaultLocale,
+    hrefFor: ({ pathname, locale }) => {
+      const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+      const base = basePath || "";
+      return `${base}/${locale}${normalizedPath}`;
+    }
+  };
+}
+function routingDomainBased(options) {
+  const { defaultLocale, locales, localeToDomain } = options;
+  return {
+    locales,
+    canonicalLocale: defaultLocale,
+    hrefFor: ({ pathname, locale }) => {
+      const domain = localeToDomain[locale];
+      if (!domain) {
+        const defaultDomain = localeToDomain[defaultLocale] || "";
+        const normalizedPath2 = pathname.startsWith("/") ? pathname : `/${pathname}`;
+        return `${defaultDomain}/${locale}${normalizedPath2}`;
+      }
+      const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+      return `${domain}${normalizedPath}`;
+    }
+  };
+}
+function routingSuffixLocale(options) {
+  const { defaultLocale, locales, basePath = "" } = options;
+  return {
+    locales,
+    canonicalLocale: defaultLocale,
+    hrefFor: ({ pathname, locale }) => {
+      const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+      const path = normalizedPath.endsWith("/") && normalizedPath !== "/" ? normalizedPath.slice(0, -1) : normalizedPath;
+      const base = basePath || "";
+      if (locale === defaultLocale) {
+        return `${base}${path}`;
+      }
+      return `${base}${path}/${locale}`;
+    }
+  };
+}
+function routingCustom(options) {
+  if (options.xDefault !== void 0) {
+    return {
+      locales: options.locales,
+      canonicalLocale: options.canonicalLocale,
+      hrefFor: options.hrefFor,
+      xDefault: options.xDefault
+    };
+  }
+  return {
+    locales: options.locales,
+    canonicalLocale: options.canonicalLocale,
+    hrefFor: options.hrefFor
+  };
+}
+function routingPAS7(options) {
+  const {
+    defaultLocale,
+    locales,
+    hubPaths = ["/blog", "/projects", "/services", "/cases"],
+    detailPathPattern = /^\/(blog|projects|services|cases)\//
+  } = options;
+  return {
+    locales,
+    canonicalLocale: defaultLocale,
+    hrefFor: ({ pathname, locale }) => {
+      const normalizedPath = pathname.startsWith("/") ? pathname : `/${pathname}`;
+      if (normalizedPath === "/" || normalizedPath === "") {
+        if (locale === defaultLocale) return "/";
+        return `/${locale}`;
+      }
+      if (detailPathPattern.test(normalizedPath)) {
+        const parts = normalizedPath.split("/").filter(Boolean);
+        if (parts.length >= 3) {
+          const section = parts[0];
+          const slug = parts.slice(2).join("/");
+          return `/${section}/${locale}/${slug}`;
+        }
+      }
+      const matchingHub = hubPaths.find((hub) => {
+        const normalizedHub = hub.startsWith("/") ? hub : `/${hub}`;
+        return normalizedPath === normalizedHub || normalizedPath === `${normalizedHub}/`;
+      });
+      if (matchingHub) {
+        const normalizedHub = matchingHub.startsWith("/") ? matchingHub.replace(/\/$/, "") : `/${matchingHub.replace(/\/$/, "")}`;
+        if (locale === defaultLocale) return normalizedHub;
+        return `${normalizedHub}/${locale}`;
+      }
+      if (locale === defaultLocale) return normalizedPath;
+      return `/${locale}${normalizedPath}`;
+    }
+  };
+}
+
+// src/lib/expandLocales.ts
+function expandLocaleEntries(entries, options) {
+  if (options.mode === "cluster-only") {
+    return [...entries];
+  }
+  const result = [];
+  for (const entry of entries) {
+    const languages = entry.alternates?.languages;
+    if (!languages || Object.keys(languages).length === 0) {
+      result.push(entry);
+      continue;
+    }
+    for (const [locale, href] of Object.entries(languages)) {
+      if (locale === "x-default" && !options.includeXDefault) continue;
+      if (options.locales && !options.locales.includes(locale)) continue;
+      const expandedEntry = {
+        ...entry,
+        url: href
+        // alternates.languages remains the full cluster
+      };
+      result.push(expandedEntry);
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return result.filter((e) => {
+    if (seen.has(e.url)) return false;
+    seen.add(e.url);
+    return true;
+  });
+}
+
+// src/lib/fromManifest.ts
+function createSitemapEntriesFromManifest(items, options) {
+  const routeStyle = options.routeStyle ?? "locale-segment";
+  const includeXDefault = options.ensureXDefault ?? true;
+  const trailingSlash = options.trailingSlash ?? "preserve";
+  const includeLocales = options.includeLocales ? new Set(options.includeLocales) : null;
+  const entries = [];
+  for (const item of items) {
+    const slug = normalizeSlug(item.slug);
+    if (!slug) continue;
+    const locales = unique(item.locales).filter((locale) => includeLocales ? includeLocales.has(locale) : true);
+    if (locales.length === 0) continue;
+    const configuredCanonical = options.canonicalLocale ?? options.defaultLocale;
+    const effectiveCanonicalLocale = locales.includes(configuredCanonical) ? configuredCanonical : locales[0] ?? configuredCanonical;
+    const languages = {};
+    for (const locale of locales) {
+      const pathname = options.pathnameFor?.({
+        slug,
+        locale,
+        defaultLocale: options.defaultLocale,
+        sectionPath: options.sectionPath,
+        routeStyle
+      }) ?? buildPathname({
+        slug,
+        locale,
+        defaultLocale: options.defaultLocale,
+        sectionPath: options.sectionPath,
+        routeStyle
+      });
+      const href = normalizeUrl(resolveAbsoluteUrl(pathname, options.baseUrl), trailingSlash);
+      languages[locale] = href;
+    }
+    const canonicalUrl = languages[effectiveCanonicalLocale] ?? normalizeUrl(resolveAbsoluteUrl("/", options.baseUrl), trailingSlash);
+    const lastModified = pickLastModified(item);
+    const baseEntry = {
+      url: canonicalUrl,
+      alternates: { languages },
+      ...lastModified ? { lastModified } : {},
+      ...item.changeFrequency ? { changeFrequency: item.changeFrequency } : {},
+      ...typeof item.priority === "number" ? { priority: item.priority } : {},
+      ...item.images ? { images: [...item.images] } : {}
+    };
+    const [entryWithHreflang] = withHreflang([baseEntry], {
+      baseUrl: options.baseUrl,
+      trailingSlash,
+      ensureAbsolute: true,
+      ensureXDefault: includeXDefault,
+      ensureSelf: true,
+      canonicalLocale: effectiveCanonicalLocale,
+      ...options.xDefaultStrategy ? { xDefaultStrategy: options.xDefaultStrategy } : {}
+    });
+    if (entryWithHreflang) entries.push(entryWithHreflang);
+  }
+  return entries;
+}
+function buildPathname(args) {
+  const section = normalizeSection(args.sectionPath);
+  if (args.routeStyle === "prefix-as-needed") {
+    if (args.locale === args.defaultLocale) return joinPath(section, args.slug);
+    return joinPath(`/${args.locale}`, section, args.slug);
+  }
+  if (args.routeStyle === "prefix-always") {
+    return joinPath(`/${args.locale}`, section, args.slug);
+  }
+  if (args.routeStyle === "suffix-locale") {
+    if (args.locale === args.defaultLocale) return joinPath(section, args.slug);
+    return joinPath(section, args.slug, args.locale);
+  }
+  return joinPath(section, args.locale, args.slug);
+}
+function normalizeSlug(slug) {
+  return slug.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function normalizeSection(sectionPath) {
+  const normalized = sectionPath.trim();
+  if (!normalized || normalized === "/") return "";
+  return `/${normalized.replace(/^\/+/, "").replace(/\/+$/, "")}`;
+}
+function joinPath(...parts) {
+  const cleaned = parts.map((part) => part.trim()).filter(Boolean).map((part) => part.replace(/^\/+/, "").replace(/\/+$/, ""));
+  if (cleaned.length === 0) return "/";
+  return `/${cleaned.join("/")}`;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function pickLastModified(item) {
+  return item.lastModified ?? item.updatedAt ?? item.publishedAt ?? item.date;
+}
+
+// src/xml/xml.ts
+function xmlEscape(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function hasXhtmlNamespace(xml) {
+  return /<urlset[^>]*\sxmlns:xhtml="http:\/\/www\.w3\.org\/1999\/xhtml"[^>]*>/.test(xml);
+}
+function ensureXhtmlNamespace(xml) {
+  if (hasXhtmlNamespace(xml)) return xml;
+  return xml.replace(
+    /<urlset(\s[^>]*?)?>/m,
+    (m) => m.includes("xmlns:xhtml=") ? m : m.replace("<urlset", '<urlset xmlns:xhtml="http://www.w3.org/1999/xhtml"')
+  );
+}
+function extractUrlBlocks(xml) {
+  return xml.match(/<url>[\s\S]*?<\/url>/g) ?? [];
+}
+function extractLoc(urlBlock) {
+  return urlBlock.match(/<loc>([^<]+)<\/loc>/)?.[1]?.trim() ?? null;
+}
+function extractXhtmlLinks(urlBlock) {
+  const out = [];
+  const re = /<xhtml:link[^>]*\shreflang="([^"]+)"[^>]*\shref="([^"]+)"[^>]*\/>/g;
+  for (const m of urlBlock.matchAll(re)) {
+    if (m[1] !== void 0 && m[2] !== void 0) {
+      out.push({ hreflang: m[1], href: m[2] });
+    }
+  }
+  return out;
+}
+function hasXDefault(urlBlock) {
+  return /<xhtml:link[^>]*\shreflang="x-default"[^>]*\/>/.test(urlBlock);
+}
+function insertXhtmlLink(urlBlock, linkXml) {
+  const lastLinkIdx = urlBlock.lastIndexOf("<xhtml:link");
+  if (lastLinkIdx === -1) {
+    const locEnd = urlBlock.indexOf("</loc>");
+    if (locEnd === -1) return urlBlock;
+    const insertPos = locEnd + "</loc>".length;
+    return `${urlBlock.slice(0, insertPos)}
+    ${linkXml}${urlBlock.slice(insertPos)}`;
+  }
+  const lineEnd = urlBlock.indexOf("\n", lastLinkIdx);
+  if (lineEnd === -1) return `${urlBlock}
+    ${linkXml}`;
+  return `${urlBlock.slice(0, lineEnd)}
+    ${linkXml}${urlBlock.slice(lineEnd)}`;
+}
+function reorderXhtmlLinks(urlBlock, options) {
+  if (options.order === "preserve") return urlBlock;
+  const links = extractXhtmlLinks(urlBlock);
+  if (links.length === 0) return urlBlock;
+  const loc = extractLoc(urlBlock);
+  let canonical;
+  if (options.canonicalLocale) {
+    canonical = links.find((l) => l.hreflang === options.canonicalLocale);
+  }
+  if (!canonical && loc) {
+    canonical = links.find((l) => l.href === loc);
+  }
+  const canonicalLinks = canonical ? [canonical] : [];
+  const otherLinks = links.filter((l) => l !== canonical && l.hreflang !== "x-default");
+  const xDefaultLinks = links.filter((l) => l.hreflang === "x-default");
+  const orderedLinks = [...canonicalLinks, ...otherLinks, ...xDefaultLinks];
+  const newBlock = urlBlock.replace(/<xhtml:link[^>]*\/>\s*/g, "");
+  const locEnd = newBlock.indexOf("</loc>");
+  if (locEnd === -1) return urlBlock;
+  const insertPos = locEnd + "</loc>".length;
+  const linksXml = orderedLinks.map((l) => `
+    <xhtml:link rel="alternate" hreflang="${xmlEscape(l.hreflang)}" href="${xmlEscape(l.href)}" />`).join("");
+  return `${newBlock.slice(0, insertPos)}${linksXml}
+  ${newBlock.slice(insertPos).trimStart()}`;
+}
+function normalizeTrailingSlashInBlock(urlBlock, policy) {
+  if (policy === "preserve") return urlBlock;
+  let result = urlBlock.replace(/<loc>([^<]+)<\/loc>/g, (_, url) => {
+    return `<loc>${applyTrailingSlashPolicy(url, policy)}</loc>`;
+  });
+  result = result.replace(
+    /(<xhtml:link[^>]*href=")([^"]+)("[^>]*\/>)/g,
+    (_, prefix, url, suffix) => {
+      return `${prefix}${applyTrailingSlashPolicy(url, policy)}${suffix}`;
+    }
+  );
+  return result;
+}
+function applyTrailingSlashPolicy(url, policy) {
+  try {
+    const u = new URL(url);
+    if (policy === "always" && !u.pathname.endsWith("/")) {
+      u.pathname += "/";
+    } else if (policy === "never" && u.pathname !== "/" && u.pathname.endsWith("/")) {
+      u.pathname = u.pathname.slice(0, -1);
+    }
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+
+// src/xml/inject.ts
+function injectXDefaultIntoSitemapXml(xml, options) {
+  const ensureNamespace = options.ensureNamespace ?? true;
+  const xDefaultStrategy = options.xDefaultStrategy ?? { type: "loc" };
+  const order = options.order ?? "preserve";
+  const trailingSlash = options.trailingSlash ?? "preserve";
+  const xmlWithNs = ensureNamespace ? ensureXhtmlNamespace(xml) : xml;
+  const blocks = extractUrlBlocks(xmlWithNs);
+  if (blocks.length === 0) return xmlWithNs;
+  let out = xmlWithNs;
+  for (const block of blocks) {
+    const loc = extractLoc(block);
+    if (!loc) continue;
+    const links = extractXhtmlLinks(block);
+    if (links.length === 0) continue;
+    let nextBlock = block;
+    if (!hasXDefault(block)) {
+      const href = resolveXDefaultHref({
+        loc,
+        links,
+        ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+        strategy: xDefaultStrategy
+      });
+      const linkXml = `<xhtml:link rel="alternate" hreflang="x-default" href="${xmlEscape(href)}" />`;
+      nextBlock = insertXhtmlLink(nextBlock, linkXml);
+    }
+    if (order === "canonical-first") {
+      nextBlock = reorderXhtmlLinks(nextBlock, {
+        ...options.canonicalLocale ? { canonicalLocale: options.canonicalLocale } : {},
+        order: "canonical-first"
+      });
+    }
+    if (trailingSlash !== "preserve") {
+      nextBlock = normalizeTrailingSlashInBlock(nextBlock, trailingSlash);
+    }
+    out = out.replace(block, nextBlock);
+  }
+  return out;
+}
+function resolveXDefaultHref(args) {
+  const { loc, links, baseUrl, strategy } = args;
+  const locAbs = baseUrl ? resolveAbsoluteUrl(loc, baseUrl) : loc;
+  const origin = isAbsolute(locAbs) ? getOriginFromAbsoluteUrl(locAbs) : baseUrl;
+  if (strategy.type === "loc") return locAbs;
+  if (strategy.type === "root") {
+    if (!origin) return locAbs;
+    return resolveAbsoluteUrl("/", origin);
+  }
+  if (strategy.type === "custom") {
+    if (!origin) return strategy.url;
+    return resolveAbsoluteUrl(strategy.url, origin);
+  }
+  if (strategy.type === "locale") {
+    const found = links.find((l) => l.hreflang === strategy.locale)?.href;
+    if (found) return baseUrl ? resolveAbsoluteUrl(found, baseUrl) : found;
+    return locAbs;
+  }
+  const computed = strategy.resolve({ url: locAbs });
+  if (!origin) return computed;
+  return resolveAbsoluteUrl(computed, origin);
+}
+function isAbsolute(u) {
+  return u.startsWith("http://") || u.startsWith("https://");
+}
+
+// src/xml/check.ts
+function checkSitemapXmlHreflang(xml, options) {
+  const requireNamespace = options.requireNamespace ?? true;
+  const requireXDefaultWhenMultiple = options.requireXDefaultWhenMultiple ?? true;
+  const requireAbsolute = options.requireAbsolute ?? true;
+  const checkDuplicateKeys = options.checkDuplicateKeys ?? true;
+  const checkDuplicateHrefs = options.checkDuplicateHrefs ?? true;
+  const checkHreflangCasing = options.checkHreflangCasing ?? true;
+  const originPolicy = options.originPolicy ?? "off";
+  const issues = [];
+  const blocks = extractUrlBlocks(xml);
+  if (requireNamespace) {
+    const usesXhtml = /<xhtml:link\b/.test(xml);
+    if (usesXhtml && !hasXhtmlNamespace(xml)) {
+      issues.push({
+        code: "MISSING_LANGUAGES",
+        entryUrl: "sitemap.xml",
+        message: 'Missing xmlns:xhtml="http://www.w3.org/1999/xhtml" in <urlset>'
+      });
+    }
+  }
+  for (const block of blocks) {
+    const loc = extractLoc(block);
+    if (!loc) continue;
+    const links = extractXhtmlLinks(block);
+    if (links.length === 0) continue;
+    const hasXDefault2 = links.some((l) => l.hreflang === "x-default");
+    if (requireXDefaultWhenMultiple && links.length > 1 && !hasXDefault2) {
+      issues.push({
+        code: "MISSING_XDEFAULT",
+        entryUrl: loc,
+        message: "Missing x-default hreflang in sitemap url block"
+      });
+    }
+    if (checkDuplicateKeys) {
+      const seenKeys = /* @__PURE__ */ new Set();
+      for (const link of links) {
+        if (seenKeys.has(link.hreflang)) {
+          issues.push({
+            code: "DUPLICATE_HREFLANG_KEY",
+            entryUrl: loc,
+            message: `Duplicate hreflang key: ${link.hreflang}`
+          });
+        }
+        seenKeys.add(link.hreflang);
+      }
+    }
+    if (checkDuplicateHrefs) {
+      const hrefToLocales = /* @__PURE__ */ new Map();
+      for (const link of links) {
+        const locales = hrefToLocales.get(link.href) ?? [];
+        locales.push(link.hreflang);
+        hrefToLocales.set(link.href, locales);
+      }
+      for (const [href, locales] of hrefToLocales) {
+        const nonXDefaultLocales = locales.filter((l) => l !== "x-default");
+        if (nonXDefaultLocales.length > 1) {
+          issues.push({
+            code: "DUPLICATE_HREF",
+            entryUrl: loc,
+            message: `Duplicate hreflang href detected: ${href} (locales: ${nonXDefaultLocales.join(", ")})`
+          });
+        }
+      }
+    }
+    if (checkHreflangCasing) {
+      for (const link of links) {
+        if (!isValidHreflangCasing(link.hreflang)) {
+          issues.push({
+            code: "INVALID_HREFLANG_CASING",
+            entryUrl: loc,
+            message: `Invalid hreflang casing: ${link.hreflang}. Expected format: en, pt-BR, or x-default`
+          });
+        }
+      }
+    }
+    if (originPolicy === "same") {
+      const locOrigin = getOrigin(loc);
+      if (locOrigin) {
+        for (const link of links) {
+          const linkOrigin = getOrigin(link.href);
+          if (linkOrigin && linkOrigin !== locOrigin) {
+            issues.push({
+              code: "INCONSISTENT_ORIGIN",
+              entryUrl: loc,
+              message: `Inconsistent origin for ${link.hreflang}: expected ${locOrigin}, got ${linkOrigin}`
+            });
+          }
+        }
+      }
+    } else if (originPolicy === "allowlist") {
+      const allowedOrigins = options.allowedOrigins ?? [];
+      for (const link of links) {
+        const linkOrigin = getOrigin(link.href);
+        if (linkOrigin && !allowedOrigins.includes(linkOrigin)) {
+          issues.push({
+            code: "INCONSISTENT_ORIGIN",
+            entryUrl: loc,
+            message: `Origin not in allowlist for ${link.hreflang}: ${linkOrigin}`
+          });
+        }
+      }
+      const locOrigin = getOrigin(loc);
+      if (locOrigin && !allowedOrigins.includes(locOrigin)) {
+        issues.push({
+          code: "INCONSISTENT_ORIGIN",
+          entryUrl: loc,
+          message: `Origin not in allowlist for loc: ${locOrigin}`
+        });
+      }
+    }
+    if (requireAbsolute) {
+      for (const link of links) {
+        if (!isAbsolute2(link.href)) {
+          issues.push({
+            code: "NON_ABSOLUTE_URL",
+            entryUrl: loc,
+            message: `Non-absolute hreflang href for ${link.hreflang}: ${link.href}`
+          });
+        }
+      }
+      if (!isAbsolute2(loc)) {
+        issues.push({
+          code: "NON_ABSOLUTE_URL",
+          entryUrl: loc,
+          message: `Non-absolute <loc>: ${loc}`
+        });
+      }
+    }
+  }
+  return { ok: issues.length === 0, issues };
+}
+function isAbsolute2(u) {
+  return u.startsWith("http://") || u.startsWith("https://");
+}
+function getOrigin(url) {
+  try {
+    const u = new URL(url);
+    return u.origin;
+  } catch {
+    return null;
+  }
+}
+function isValidHreflangCasing(key) {
+  if (key === "x-default") return true;
+  if (/^[a-z]{2}$/.test(key)) return true;
+  if (/^[a-z]{2}-[A-Z]{2}$/.test(key)) return true;
+  return false;
+}
+export {
+  assertHreflangExport as assertHreflang,
+  buildLanguagesMap,
+  checkSitemapXmlHreflang,
+  createSitemapEntriesFromManifest,
+  expandLocaleEntries,
+  injectXDefaultIntoSitemapXml,
+  normalizeUrl,
+  resolveAbsoluteUrl,
+  routingCustom,
+  routingDomainBased,
+  routingPAS7,
+  routingPrefixAlways,
+  routingPrefixAsNeeded,
+  routingSuffixLocale,
+  withHreflang,
+  withHreflangFromRouting
+};
+//# sourceMappingURL=index.js.map