nuxt-seo-utils 8.3.3 → 8.4.1

package/dist/module.mjs

@@ -1,20 +1,22 @@
 import fs, { existsSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
-import { useNuxt, addTypeTemplate, extendRouteRules, useLogger, defineNuxtModule, createResolver, addServerHandler, hasNuxtModule, addPlugin, addImports, hasNuxtCompatibility, directoryToURL, addVitePlugin } from '@nuxt/kit';
+import { useNuxt, addTypeTemplate, useLogger, defineNuxtModule, createResolver, addServerHandler, hasNuxtModule, addPlugin, addImports, hasNuxtCompatibility, directoryToURL, addVitePlugin } from '@nuxt/kit';
 import { defu } from 'defu';
 import { resolveModulePath } from 'exsolve';
 import { installNuxtSiteConfig } from 'nuxt-site-config/kit';
-import { useModuleLogger, resolveHostUnheadMajor } from 'nuxtseo-shared/kit';
+import { useModuleLogger, setupNitroRuntimeCompatibility, renderNitroTypeAugmentations, resolveHostUnheadMajor } from 'nuxtseo-shared/kit';
 import { resolve, extname, relative, dirname, basename } from 'pathe';
-import { readPackageJSON } from 'pkg-types';
+import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { unpackMeta } from '@unhead/vue/utils';
 import { glob } from 'tinyglobby';
 import { encodePath, joinURL } from 'ufo';
+import { c as classifyIconFilename, g as getIconRel, n as normalizeIconSizes, a as partitionColorModeIconLinks } from './shared/nuxt-seo-utils.NAV2YNQn.mjs';
 import escapeRE from 'escape-string-regexp';
 import { readFile, readdir } from 'node:fs/promises';
 import imageSize from 'image-size';
 import { JSON_TYPES, SKIP_JS_TYPES } from '../dist/runtime/shared/minify.js';
 import { setupDevToolsUI as setupDevToolsUI$1 } from 'nuxtseo-shared/devtools';
+import 'node:buffer';
 
 function extendNuxtConfigAppHeadSeoMeta(nuxt = useNuxt()) {
   const seoMeta = nuxt.options.app?.seoMeta || nuxt.options.app?.head?.seoMeta || {};
@@ -74,20 +76,15 @@ export {}
 }
 
 const MetaTagFileDeepGlobs = [
-  "**/og-image.{png,jpg,jpeg,gif}",
-  "**/opengraph-image.{png,jpg,jpeg,gif}",
-  "**/twitter-image.{png,jpg,jpeg,gif}",
-  "**/apple-icon.{jpg,jpeg,png}",
-  "**/apple-touch.{jpg,jpeg,png}",
-  "**/apple-touch-*.{jpg,jpeg,png}",
-  "**/apple-touch-icon.{jpg,jpeg,png}",
-  "**/apple-touch-icon-*.{jpg,jpeg,png}",
-  "**/icon.{ico,jpg,jpeg,png,svg}",
-  "**/icon-*.{ico,jpg,jpeg,png,svg}"
+  "**/{og-image,opengraph-image,twitter-image}.{png,jpg,jpeg,gif}",
+  "**/{favicon*,icon*}.{ico,jpg,jpeg,png,svg}",
+  "**/*.icon*.{ico,jpg,jpeg,png,svg}",
+  "**/apple-*.{jpg,jpeg,png}",
+  "**/*.apple-*.{jpg,jpeg,png}"
 ];
-const META_TAG_FILE_RE = /^(?:(?:og-image|opengraph-image)\.(?:png|jpe?g|gif)|twitter-image\.(?:png|jpe?g|gif)|apple-(?:icon|touch|touch-icon)(?:-[^.]+)?\.(?:jpe?g|png)|icon(?:-[^.]+)?\.(?:ico|jpe?g|png|svg)|favicon\.ico)$/;
+const SOCIAL_IMAGE_RE = /^(?:og-image|opengraph-image|twitter-image)\.(?:png|jpe?g|gif)$/;
 function isMetaTagFile(filename) {
-  return META_TAG_FILE_RE.test(filename);
+  return SOCIAL_IMAGE_RE.test(filename) || classifyIconFilename(filename) !== void 0;
 }
 
 const INDEX_SUFFIX_RE = /-index$/;
@@ -190,9 +187,6 @@ function parseSegment(segment) {
   return tokens;
 }
 
-function hasLinkRel(input, rel) {
-  return input.link?.some((link) => link.rel === rel);
-}
 function hasMetaProperty(input, property) {
   return input.meta?.some((meta) => meta.property === property);
 }
@@ -201,12 +195,12 @@ async function getImageMeta(base, path, isIcon = false) {
   const absolutePath = resolve(base, path);
   const file = absolutePath.split("/").pop();
   const keyword = file.split(".")[0];
-  let ext = absolutePath.split(".").pop();
+  let ext = absolutePath.split(".").pop()?.toLowerCase();
   if (ext === "jpg")
     ext = "jpeg";
-  const { width, height } = await getImageDimensions(absolutePath);
+  const { width, height, images } = await getImageDimensions(absolutePath);
   const payload = {
-    type: ext === "svg" ? `image/svg+xml` : `image/${ext}`
+    type: ext === "svg" ? "image/svg+xml" : ext === "ico" ? "image/vnd.microsoft.icon" : `image/${ext}`
   };
   if (!isIcon) {
     payload.width = width;
@@ -221,7 +215,9 @@ async function getImageMeta(base, path, isIcon = false) {
       payload.media = "(prefers-color-scheme: dark)";
     else if (path.includes(".light") || path.includes("-light"))
       payload.media = "(prefers-color-scheme: light)";
-    if (ext !== "svg") {
+    if (ext === "ico" && images?.length) {
+      payload.sizes = [...new Map(images.map((image) => [`${image.width}x${image.height}`, image])).values()].sort((a, b) => a.width * a.height - b.width * b.height).map((image) => `${image.width}x${image.height}`).join(" ");
+    } else if (ext !== "svg") {
       payload.sizes = `${width}x${height}`;
     } else {
       payload.sizes = "any";
@@ -235,47 +231,64 @@ async function getImageDimensions(absolutePath) {
 }
 
 const DIR_SUFFIX_RE = /\/_dir$/;
+function addGeneratedRouteRule(nuxt, route, generatedRule) {
+  nuxt.options.routeRules ||= {};
+  nuxt.options.nitro.routeRules ||= {};
+  const routeRules = nuxt.options.routeRules;
+  const rule = structuredClone(generatedRule);
+  routeRules[route] = defu(routeRules[route], rule);
+  const nitroRouteRules = nuxt.options.nitro.routeRules;
+  if (nitroRouteRules !== routeRules)
+    nitroRouteRules[route] = defu(nitroRouteRules[route], structuredClone(rule));
+}
 async function generateTagsFromPageDirImages(nuxt = useNuxt()) {
   const pagesDirs = nuxt.options._layers.map((layer) => resolve(layer.config.rootDir, layer.config.dir?.pages || "pages")).filter((dir) => fs.existsSync(dir));
   const appendRouteRules = {};
+  const registeredFiles = /* @__PURE__ */ new Set();
   const devMiddlewareMap = {};
   const nitroOutputMap = [];
   for (const pagesDir of pagesDirs) {
-    const files = await glob(MetaTagFileDeepGlobs, { cwd: pagesDir, onlyFiles: true });
+    const files = (await glob(MetaTagFileDeepGlobs, { cwd: pagesDir, onlyFiles: true })).filter((file) => isMetaTagFile(basename(file)));
     for (const file of files) {
       const fileName = basename(file);
       const keyword = fileName.split(".")[0] || "";
       let { path } = generateNuxtPageFromFile(resolve(pagesDir, dirname(file)), pagesDir);
-      const meta = await getImageMeta(pagesDir, file);
       if (path.endsWith("/_dir"))
         path = path.replace(DIR_SUFFIX_RE, "");
-      const src = joinURL(path, fileName);
-      if (appendRouteRules[`${path}/**`])
+      const registrationKey = `${path}:${fileName}`;
+      if (registeredFiles.has(registrationKey))
         continue;
-      if (["icon", "apple-touch-icon", "apple-icon"].includes(keyword) || keyword.startsWith("icon-")) {
-        appendRouteRules[`${path}/**`] = {
-          head: {
-            link: [
-              { rel: keyword, type: meta.type, href: src, sizes: meta.sizes }
-            ]
-          }
-        };
+      registeredFiles.add(registrationKey);
+      const routeAssetPath = joinURL(path, fileName);
+      const href = joinURL(nuxt.options.app.baseURL, routeAssetPath);
+      const iconRel = classifyIconFilename(fileName);
+      const meta = await getImageMeta(pagesDir, file, iconRel !== void 0);
+      const routeRule = appendRouteRules[path] ||= { head: { link: [] }, seoMeta: {} };
+      if (iconRel) {
+        routeRule.head.link.push({
+          rel: iconRel,
+          type: String(meta.type),
+          href,
+          sizes: String(meta.sizes),
+          media: meta.media ? String(meta.media) : void 0
+        });
       } else {
-        appendRouteRules[`${path}/**`] = {
-          seoMeta: {
-            [["opengraph-image", "og-image"].includes(keyword) ? "ogImage" : "twitterImage"]: [{ url: src, ...meta, sizes: void 0 }]
-          }
-        };
+        const property = ["opengraph-image", "og-image"].includes(keyword) ? "ogImage" : "twitterImage";
+        routeRule.seoMeta[property] ||= [];
+        routeRule.seoMeta[property].push({ url: href, ...meta, sizes: void 0 });
       }
-      devMiddlewareMap[src] = resolve(pagesDir, file);
+      devMiddlewareMap[routeAssetPath] = resolve(pagesDir, file);
       nitroOutputMap.push({
         src: resolve(pagesDir, file),
-        dest: src.slice(1)
+        dest: routeAssetPath.slice(1)
       });
     }
   }
-  for (const [route, rule] of Object.entries(appendRouteRules))
-    extendRouteRules(route, rule, { override: true });
+  for (const [route, rule] of Object.entries(appendRouteRules)) {
+    addGeneratedRouteRule(nuxt, route, rule);
+    if (route !== "/")
+      addGeneratedRouteRule(nuxt, `${route}/**`, rule);
+  }
   if (nuxt.options.dev) {
     nuxt.hooks.hook("nitro:config", async (nitroConfig) => {
       nitroConfig.virtual["#seo-utils-virtual/pageDirImages"] = `export const fileMapping = ${JSON.stringify(devMiddlewareMap)}`;
@@ -295,9 +308,54 @@ async function generateTagsFromPageDirImages(nuxt = useNuxt()) {
 }
 
 async function listMetaTagFiles(dir) {
-  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir(dir, { withFileTypes: true }).catch((error) => {
+    if (error.code === "ENOENT")
+      return [];
+    throw error;
+  });
   return entries.filter((e) => e.isFile() && isMetaTagFile(e.name)).map((e) => e.name);
 }
+function findLocalIcon(href, baseURL, iconEntries) {
+  if (typeof href !== "string" || /^(?:[a-z][a-z\d+.-]*:|\/\/|#)/i.test(href))
+    return;
+  const path = href.split(/[?#]/, 1)[0] || "";
+  const file = basename(path);
+  const entry = iconEntries.find((icon) => icon.file === file);
+  if (!entry)
+    return;
+  const validPaths = /* @__PURE__ */ new Set([entry.file, `/${entry.file}`, joinURL(baseURL, entry.file)]);
+  return validPaths.has(path) ? { entry, resolvedHref: `${joinURL(baseURL, entry.file)}${href.slice(path.length)}` } : void 0;
+}
+function enrichConfiguredIcon(link, baseURL, iconEntries, diagnostics) {
+  const iconLink = link;
+  const match = findLocalIcon(iconLink.href, baseURL, iconEntries);
+  if (!match)
+    return link;
+  const { entry, resolvedHref } = match;
+  if (iconLink.href !== resolvedHref) {
+    diagnostics.push({
+      _tag: "IconHrefNormalized",
+      configured: String(iconLink.href),
+      resolved: resolvedHref
+    });
+  }
+  const normalizedSizes = normalizeIconSizes(iconLink.sizes, entry.sizes);
+  if (normalizedSizes.normalized) {
+    diagnostics.push({
+      _tag: "IconSizesNormalized",
+      href: String(iconLink.href),
+      configured: String(iconLink.sizes),
+      resolved: entry.sizes
+    });
+  }
+  return {
+    ...iconLink,
+    href: resolvedHref,
+    type: iconLink.type || entry.type,
+    sizes: normalizedSizes.sizes,
+    media: iconLink.media || entry.media
+  };
+}
 async function generateTagsFromPublicFiles(nuxt = useNuxt()) {
   const publicDirs = nuxt.options._layers.map((layer) => resolve(layer.config.rootDir, layer.config.dir?.public || "public"));
   const seen = /* @__PURE__ */ new Set();
@@ -316,37 +374,33 @@ async function generateTagsFromPublicFiles(nuxt = useNuxt()) {
     link: [],
     meta: []
   });
-  if (!hasLinkRel(headConfig, "icon")) {
-    if (rootPublicFiles.includes("favicon.ico") && nuxt.options.app.baseURL !== "/") {
-      headConfig.link.push({
-        rel: "icon",
-        href: joinURL(nuxt.options.app.baseURL, "favicon.ico"),
-        sizes: "any"
-      });
-    }
-    const isIcon = (file) => file.includes("icon") && !file.endsWith(".ico");
-    const isAppleTouchIcon = (file) => file.includes("apple-icon") || file.includes("apple-touch-icon") || file.includes("apple-touch");
-    const resolveDir = (file) => fileEntries.find((e) => e.file === file).dir;
-    headConfig.link.push(
-      ...await Promise.all([
-        ...rootPublicFiles.filter((file) => isIcon(file) && !isAppleTouchIcon(file)).sort().map(async (iconFile) => {
-          const meta = await getImageMeta(resolveDir(iconFile), iconFile, true);
-          return {
-            rel: "icon",
-            href: joinURL(nuxt.options.app.baseURL, iconFile),
-            ...meta
-          };
-        }),
-        ...rootPublicFiles.filter((file) => isAppleTouchIcon(file)).sort().map(async (appleIconFile) => {
-          const meta = await getImageMeta(resolveDir(appleIconFile), appleIconFile, true);
-          return {
-            rel: "apple-touch-icon",
-            href: joinURL(nuxt.options.app.baseURL, appleIconFile),
-            ...meta
-          };
-        })
-      ])
-    );
+  const iconEntries = (await Promise.all(fileEntries.map(async ({ file, dir }) => {
+    const rel = classifyIconFilename(file);
+    if (!rel)
+      return;
+    const meta = await getImageMeta(dir, file, true);
+    return {
+      file,
+      dir,
+      rel,
+      type: String(meta.type),
+      sizes: String(meta.sizes),
+      media: meta.media ? String(meta.media) : void 0
+    };
+  }))).filter((entry) => entry !== void 0);
+  const diagnostics = [];
+  headConfig.link = headConfig.link.map((link) => enrichConfiguredIcon(link, nuxt.options.app.baseURL, iconEntries, diagnostics));
+  const configuredIconRels = new Set(headConfig.link.map((link) => getIconRel(link.rel)).filter((rel) => rel !== void 0));
+  for (const rel of ["icon", "apple-touch-icon"]) {
+    if (configuredIconRels.has(rel))
+      continue;
+    headConfig.link.push(...iconEntries.filter((entry) => entry.rel === rel).sort((a, b) => a.file.localeCompare(b.file)).map((entry) => ({
+      rel: entry.rel,
+      type: entry.type,
+      href: joinURL(nuxt.options.app.baseURL, entry.file),
+      sizes: entry.sizes,
+      media: entry.media
+    })));
   }
   let hasTwitterImage = hasMetaProperty(headConfig, "twitter:image");
   if (!hasTwitterImage) {
@@ -392,8 +446,8 @@ async function generateTagsFromPublicFiles(nuxt = useNuxt()) {
     }
   }
   nuxt.options.app.head = headConfig;
-  const hasIcons = rootPublicFiles.some((f) => f.includes("icon") || f === "favicon.ico");
-  return { hasIcons };
+  const hasIcons = iconEntries.length > 0 || configuredIconRels.size > 0;
+  return { hasIcons, diagnostics };
 }
 
 const logger = useLogger("nuxt-seo-utils");
@@ -490,6 +544,16 @@ function minifyStaticHead() {
   });
 }
 
+function resolveUnheadVitePluginSource(input, resolvePath) {
+  if (input.unheadMajor < 3)
+    return { _tag: "unsupported-v2" };
+  const path = resolvePath("@unhead/vue/vite", {
+    try: true,
+    from: [...input.hostImportPaths, ...input.importPaths]
+  });
+  return path ? { _tag: "vue", url: pathToFileURL(path).href } : { _tag: "missing-vue" };
+}
+
 function setupNuxtConfigAppHeadWithMoreDefaults(nuxt = useNuxt()) {
   const headConfig = nuxt.options.app.head;
   headConfig.link = headConfig.link || [];
@@ -551,7 +615,7 @@ const module$1 = defineNuxtModule({
     automaticOgAndTwitterTags: true,
     canonicalLowercase: true,
     tagPriority: "low",
-    minify: true
+    minify: { build: true, runtime: false }
   },
   async setup(config, nuxt) {
     const logger = useModuleLogger("nuxt-seo-utils", config, nuxt);
@@ -559,14 +623,22 @@ const module$1 = defineNuxtModule({
       logger.debug("The module is disabled, skipping setup.");
       return;
     }
+    const nitroCompatibility = setupNitroRuntimeCompatibility(nuxt);
     const { resolve } = createResolver(import.meta.url);
     const { version } = await readPackageJSON(resolve("../package.json"));
     await installNuxtSiteConfig();
     const runtimeDir = resolve("./runtime");
     if (config.metaDataFiles) {
-      const { hasIcons } = await generateTagsFromPublicFiles();
+      const { hasIcons, diagnostics } = await generateTagsFromPublicFiles();
       await generateTagsFromPageDirImages();
       if (nuxt.options.dev) {
+        diagnostics.forEach((diagnostic) => {
+          if (diagnostic._tag === "IconSizesNormalized") {
+            logger.warn(`Normalized icon sizes for ${diagnostic.href} from "${diagnostic.configured}" to "${diagnostic.resolved}" to match the local file.`);
+          } else if (diagnostic._tag === "IconHrefNormalized") {
+            logger.warn(`Normalized local icon href from "${diagnostic.configured}" to "${diagnostic.resolved}" to include app.baseURL.`);
+          }
+        });
         if (!hasIcons) {
           const publicDir = resolve(nuxt.options.rootDir, nuxt.options.dir.public);
           const logoPatterns = ["logo.svg", "logo.png", "icon.svg", "icon.png", "logo.jpg", "logo.webp"];
@@ -672,25 +744,17 @@ const module$1 = defineNuxtModule({
       filename: "module/nuxt-seo-utils.d.ts",
       getContents: (data) => {
         const typesPath = relative(resolve(data.nuxt.options.rootDir, data.nuxt.options.buildDir, "module"), resolve("runtime/types"));
-        const types = `  interface NitroRouteRules {
-     seoMeta?: import('${typesPath}').MetaFlatSerializable
-     head?: import('${typesPath}').Head
-  }
-  interface NitroRouteConfig {
-    seoMeta?: import('${typesPath}').MetaFlatSerializable
-    head?: import('${typesPath}').Head
-  }`;
+        const routeRuleTypes = `seoMeta?: import('${typesPath}').MetaFlatSerializable
+head?: import('${typesPath}').Head`;
+        const nitroTypes = renderNitroTypeAugmentations(nitroCompatibility, {
+          routeRules: routeRuleTypes,
+          routeConfig: routeRuleTypes
+        });
         return `// Generated by nuxt-seo-utils
 
 import type { RobotsContext } from '#robots/types'
 
-declare module 'nitropack/types' {
-${types}
-}
-
-declare module 'nitropack' {
-${types}
-}
+${nitroTypes}
 
 
 declare module '@nuxt/schema' {
@@ -709,6 +773,18 @@ export {}
       nuxt: true
     });
     const appRuntimeDir = resolve(runtimeDir, "./app");
+    nuxt.hook("modules:done", () => {
+      if (!hasNuxtModule("@nuxtjs/color-mode", nuxt))
+        return;
+      const headConfig = nuxt.options.app.head;
+      const result = partitionColorModeIconLinks(headConfig.link || []);
+      if (result._tag === "StaticIconLinks")
+        return;
+      headConfig.link = result.links;
+      const seoRuntimeConfig = nuxt.options.runtimeConfig.public["seo-utils"];
+      seoRuntimeConfig.colorModeIcons = result.icons;
+      addPlugin({ src: resolve(appRuntimeDir, "plugins", "colorModeIcons") });
+    });
     nuxt.options.unhead = defu(
       nuxt.options.unhead,
       { vite: config.treeShakeUseSeoMeta ? { validate: !nuxt.options.test } : false }
@@ -722,9 +798,12 @@ export {}
       const lightningcssPath = resolveModulePath("lightningcss", { try: true, from: importPaths });
       const rolldownURL = rolldownPath ? pathToFileURL(rolldownPath).href : void 0;
       const lightningcssURL = lightningcssPath ? pathToFileURL(lightningcssPath).href : void 0;
-      const bundlerPath = unheadMajor < 3 ? resolveModulePath("@unhead/bundler/vite", { try: true, from: importPaths }) : void 0;
-      const bundlerURL = bundlerPath ? pathToFileURL(bundlerPath).href : void 0;
-      const vitePluginSource = unheadMajor >= 3 ? { _tag: "vue" } : bundlerURL ? { _tag: "bundler", url: bundlerURL } : { _tag: "missing-bundler" };
+      const hostImportPaths = unheadMajor >= 3 ? [directoryToURL(dirname(await resolvePackageJSON("nuxt", { url: directoryToURL(nuxt.options.rootDir).href })))] : [];
+      const vitePluginSource = resolveUnheadVitePluginSource({
+        unheadMajor,
+        hostImportPaths,
+        importPaths
+      }, resolveModulePath);
       const minify = {
         js: rolldownURL ? async (code) => {
           const { minify: minify2 } = await import(rolldownURL);
@@ -739,22 +818,14 @@ export {}
           }).code).trim();
         } : void 0
       };
-      if (vitePluginSource._tag === "missing-bundler") {
-        logger.warn("`treeShakeUseSeoMeta` requires the optional `@unhead/bundler` peer on Unhead v2. Install it or disable `treeShakeUseSeoMeta`.");
+      if (vitePluginSource._tag === "unsupported-v2") {
+        logger.warn("`treeShakeUseSeoMeta` requires Unhead v3; skipping the transform on Unhead v2.");
+      } else if (vitePluginSource._tag === "missing-vue") {
+        logger.warn("`treeShakeUseSeoMeta` requires `@unhead/vue` with the `/vite` export. Install Unhead v3 or disable `treeShakeUseSeoMeta`.");
       } else {
         addVitePlugin(async () => {
-          if (vitePluginSource._tag === "vue") {
-            const v3Vite = "@unhead/vue/vite";
-            const { Unhead: Unhead2 } = await import(v3Vite);
-            return Unhead2({ minify, ...viteOpts });
-          }
           const { Unhead } = await import(vitePluginSource.url);
-          return Unhead({
-            _framework: "@unhead/vue",
-            minify,
-            validate: false,
-            devtools: false
-          });
+          return Unhead({ minify, ...viteOpts });
         }, {
           prepend: true
         });

package/dist/runtime/app/composables/useBreadcrumbItems.js

@@ -17,7 +17,7 @@ import {
 import { defineBreadcrumb, useI18n, useSchemaOrg } from "#imports";
 import { useSiteConfig } from "#site-config/app/composables/useSiteConfig";
 import { createSitePathResolver } from "#site-config/app/composables/utils";
-import { pathBreadcrumbSegments } from "../../shared/breadcrumbs.js";
+import { pathBreadcrumbSegments, resolveBreadcrumbRoot } from "../../shared/breadcrumbs.js";
 function withoutQuery(path) {
   return path.split("?")[0] || "";
 }
@@ -120,8 +120,11 @@ export function useBreadcrumbItems(_options = {}) {
     }, {});
     let rootNode = flatOptions.rootSegment || "/";
     if (i18n) {
-      if (i18n.strategy === "prefix" || i18n.strategy !== "no_prefix" && toValue(i18n.defaultLocale) !== toValue(i18n.locale))
-        rootNode = `${rootNode}${toValue(i18n.locale)}`;
+      rootNode = resolveBreadcrumbRoot(rootNode, {
+        locale: toValue(i18n.locale),
+        defaultLocale: toValue(i18n.defaultLocale),
+        strategy: i18n.strategy
+      });
     }
     const current = withoutQuery(withoutTrailingSlash(flatOptions.path || toRaw(route)?.path || rootNode)) || "";
     const segments = pathBreadcrumbSegments(current, rootNode).map((path, index) => {

package/dist/runtime/app/logic/colorModeIcons.d.ts

@@ -0,0 +1,3 @@
+import type { Link } from '@unhead/vue/types';
+import type { ColorModeIconLinks } from '../../types.js';
+export declare function selectColorModeIconLinks(icons: ColorModeIconLinks, colorMode: string): Link[];

package/dist/runtime/app/logic/colorModeIcons.js

@@ -0,0 +1,10 @@
+export function selectColorModeIconLinks(icons, colorMode) {
+  const selected = colorMode === "dark" ? icons.dark : icons.light;
+  return selected.map((link, index) => ({
+    ...link,
+    key: `nuxt-seo-utils:color-mode-icon:${getLinkKey(link, index)}`
+  }));
+}
+function getLinkKey(link, index) {
+  return `${link.rel}:${index}`;
+}

package/dist/runtime/app/plugins/0.routeRules.js

@@ -1,27 +1,25 @@
-import { injectHead, useSeoMeta } from "@unhead/vue";
-import { defineNuxtPlugin, getRouteRules, useRequestEvent, useRuntimeConfig, useState } from "nuxt/app";
+import { defineNuxtPlugin, useHead, useRequestEvent, useRuntimeConfig, useSeoMeta, useState } from "#imports";
+function parseRouteRuleState(context) {
+  const rules = context._nitro?.routeRules;
+  return {
+    head: rules?.head,
+    seoMeta: rules?.seoMeta
+  };
+}
 export default defineNuxtPlugin({
   enforce: "post",
   env: { islands: false },
-  async setup() {
-    const head = injectHead();
-    if (!head)
-      return;
+  setup() {
     const { tagPriority } = useRuntimeConfig().public["seo-utils"];
     const routeRuleState = useState("nuxt-seo-utils:routeRules", () => null);
     if (import.meta.server) {
       const event = useRequestEvent();
-      const routeRules = await getRouteRules(event);
-      const rules = routeRules;
-      routeRuleState.value = {
-        head: rules.head,
-        seoMeta: rules.seoMeta
-      };
+      routeRuleState.value = parseRouteRuleState(event?.context);
     }
     if (routeRuleState.value) {
       const { head: headInput, seoMeta } = routeRuleState.value;
       if (headInput)
-        head.push(headInput);
+        useHead(headInput);
       if (seoMeta)
         useSeoMeta(seoMeta, { tagPriority });
     }

package/dist/runtime/app/plugins/colorModeIcons.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/app/plugins/colorModeIcons.js

@@ -0,0 +1,17 @@
+import { defineNuxtPlugin, useHead, useNuxtApp, useRuntimeConfig } from "#imports";
+import { selectColorModeIconLinks } from "../logic/colorModeIcons.js";
+export default defineNuxtPlugin({
+  name: "nuxt-seo-utils:color-mode-icons",
+  enforce: "post",
+  setup() {
+    const runtimeConfig = useRuntimeConfig();
+    const seoConfig = runtimeConfig.public["seo-utils"];
+    const colorMode = useNuxtApp().$colorMode;
+    const icons = seoConfig.colorModeIcons;
+    if (!icons || !colorMode)
+      return;
+    useHead(() => ({
+      link: selectColorModeIconLinks(icons, colorMode.value)
+    }));
+  }
+});

package/dist/runtime/server/middleware/redirectCanonical.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<void> | undefined>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/middleware/redirectCanonical.js

@@ -1,5 +1,5 @@
-import { defineEventHandler, getRequestHost, sendRedirect, setHeader } from "h3";
 import { joinURL } from "ufo";
+import { defineEventHandler, getRequestHost, sendRedirect, setHeader } from "#nuxtseo/h3";
 import { getSiteConfig } from "#site-config/server/composables/getSiteConfig";
 export default defineEventHandler((e) => {
   if (import.meta.prerender) {

package/dist/runtime/server/middleware/resolveImagesInPagesDir.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<NonSharedBuffer | undefined>>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/middleware/resolveImagesInPagesDir.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
-import { defineEventHandler, setHeader } from "h3";
 import { parseURL } from "ufo";
+import { defineEventHandler, setHeader } from "#nuxtseo/h3";
 import { fileMapping } from "#seo-utils-virtual/pageDirImages";
 export default defineEventHandler(async (e) => {
   const path = parseURL(e.path).pathname;

package/dist/runtime/server/plugins/minifyHtml.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("nitropack/types").NitroAppPlugin;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/plugins/minifyHtml.js

@@ -1,4 +1,4 @@
-import { defineNitroPlugin } from "nitropack/runtime";
+import { defineNitroPlugin } from "#nuxtseo/nitro";
 import { JSON_TYPES, minifyCSS, minifyJS, minifyJSON, SKIP_JS_TYPES } from "../../shared/minify.js";
 const INLINE_SCRIPT_RE = /<script(?![^>]+\bsrc\b)([^>]*)>([\s\S]*?)<\/script\s*>/gi;
 const INLINE_STYLE_RE = /<style([^>]*)>([\s\S]*?)<\/style\s*>/gi;

package/dist/runtime/server/routes/__nuxt-seo-utils/debug.d.ts

@@ -1,18 +1,2 @@
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
-    runtimeConfig: any;
-    siteConfig: {
-        url: string;
-        name: any;
-        description: any;
-        env: any;
-        indexable: any;
-        trailingSlash: any;
-        titleSeparator: any;
-        defaultLocale: any;
-        currentLocale: any;
-        twitter: any;
-    };
-    headConfig: any;
-    path: string | number | true | Record<string, any> | import("ufo").QueryValue[];
-}>;
+declare const _default: any;
 export default _default;

package/dist/runtime/server/routes/__nuxt-seo-utils/debug.js

@@ -1,5 +1,5 @@
-import { defineEventHandler, getQuery } from "h3";
-import { useRuntimeConfig } from "nitropack/runtime";
+import { defineEventHandler, getQuery } from "#nuxtseo/h3";
+import { useRuntimeConfig } from "#nuxtseo/nitro";
 import { getSiteConfig } from "#site-config/server/composables";
 export default defineEventHandler((e) => {
   const siteConfig = getSiteConfig(e);
@@ -10,6 +10,7 @@ export default defineEventHandler((e) => {
   return {
     runtimeConfig: {
       version: runtimeConfig.public?.["nuxt-seo-utils-version"] || "unknown",
+      appBaseURL: runtimeConfig.app.baseURL,
       ...seoUtils
     },
     siteConfig: {

package/dist/runtime/shared/breadcrumbs.d.ts

@@ -1 +1,9 @@
+import type { RuntimeI18nConfig } from 'nuxtseo-shared/i18n-runtime';
+interface BreadcrumbLocaleContext {
+    locale?: string;
+    defaultLocale?: string;
+    strategy?: RuntimeI18nConfig['strategy'];
+}
+export declare function resolveBreadcrumbRoot(rootNode: string, context: BreadcrumbLocaleContext): string;
 export declare function pathBreadcrumbSegments(path: string, rootNode?: string): string[];
+export {};