nuxt-seo-utils 8.3.3 → 8.4.0

package/dist/cli.mjs

@@ -1,4 +1,3 @@
-import { Buffer } from 'node:buffer';
 import { existsSync } from 'node:fs';
 import { writeFile } from 'node:fs/promises';
 import process from 'node:process';
@@ -6,9 +5,11 @@ import { loadNuxtConfig } from '@nuxt/kit';
 import { defineCommand, runMain } from 'citty';
 import { colors } from 'consola/utils';
 import { resolve } from 'pathe';
+import { p as pngToIco } from './shared/nuxt-seo-utils.NAV2YNQn.mjs';
+import 'node:buffer';
 
 const name = "nuxt-seo-utils";
-const version = "8.3.3";
+const version = "8.4.0";
 const description = "SEO utilities to improve your Nuxt sites discoverability and shareability";
 
 const ICON_SIZES = [
@@ -27,33 +28,6 @@ const cwdArgs = {
     default: "."
   }
 };
-function pngToIco(pngBuffers) {
-  const count = pngBuffers.length;
-  const headerSize = 6;
-  const dirEntrySize = 16;
-  const dataOffset = headerSize + dirEntrySize * count;
-  const header = Buffer.alloc(headerSize);
-  header.writeUInt16LE(0, 0);
-  header.writeUInt16LE(1, 2);
-  header.writeUInt16LE(count, 4);
-  const dirEntries = [];
-  let offset = dataOffset;
-  for (const png of pngBuffers) {
-    const entry = Buffer.alloc(dirEntrySize);
-    const size = Math.min(256, 32);
-    entry.writeUInt8(size === 256 ? 0 : size, 0);
-    entry.writeUInt8(size === 256 ? 0 : size, 1);
-    entry.writeUInt8(0, 2);
-    entry.writeUInt8(0, 3);
-    entry.writeUInt16LE(1, 4);
-    entry.writeUInt16LE(32, 6);
-    entry.writeUInt32LE(png.length, 8);
-    entry.writeUInt32LE(offset, 12);
-    dirEntries.push(entry);
-    offset += png.length;
-  }
-  return Buffer.concat([header, ...dirEntries, ...pngBuffers]);
-}
 async function loadSharp() {
   const mod = await import('sharp').catch(() => {
     console.error(colors.red("sharp is required for icon generation. Install it with:"));
@@ -107,9 +81,14 @@ const main = defineCommand({
           await sharp(sourcePath).resize(icon.width, icon.height, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toFile(outputPath);
           console.log(colors.green(`  ${icon.name} (${icon.width}x${icon.height})`));
         }
-        const faviconPng = await sharp(sourcePath).resize(32, 32, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toBuffer();
-        await writeFile(resolve(publicDir, "favicon.ico"), pngToIco([faviconPng]));
-        console.log(colors.green("  favicon.ico (32x32)"));
+        const faviconSizes = [16, 32, 48];
+        const faviconPngs = await Promise.all(faviconSizes.map(async (size) => ({
+          buffer: await sharp(sourcePath).resize(size, size, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toBuffer(),
+          width: size,
+          height: size
+        })));
+        await writeFile(resolve(publicDir, "favicon.ico"), pngToIco(faviconPngs));
+        console.log(colors.green("  favicon.ico (16x16, 32x32, 48x48)"));
         console.log(colors.bold(colors.green("\nDone! Generated all icon variants.")));
       }
     })

package/dist/devtools/lib/seo-utils/state.ts

@@ -1,7 +1,7 @@
 import { ref, watch } from 'vue'
 
 export interface DebugData {
-  runtimeConfig: { version: string, [key: string]: any }
+  runtimeConfig: { version: string, appBaseURL: string, [key: string]: any }
   siteConfig: {
     url: string
     name: string

package/dist/devtools/lib/seo-utils/tools.test.ts

@@ -0,0 +1,31 @@
+// @vitest-environment happy-dom
+
+import { describe, expect, it } from 'vitest'
+import { getIconIssues, parseMetaTags, resolveAppUrl } from './tools'
+
+describe('identity icon inspection', () => {
+  it('finds semantic icon rel tokens case-insensitively', () => {
+    const parsed = parseMetaTags('<link rel="alternate ICON" href="/favicon.ico" sizes="any">')
+
+    expect(parsed.iconLinks).toEqual([{
+      rel: 'icon',
+      href: '/favicon.ico',
+      type: undefined,
+      sizes: 'any',
+      media: undefined,
+    }])
+  })
+
+  it('resolves inspected routes within the Nuxt baseURL', () => {
+    expect(resolveAppUrl('https://example.com', '/docs/', '/guide')).toBe('https://example.com/docs/guide')
+    expect(resolveAppUrl('https://example.com', '/docs/', '/docs/guide')).toBe('https://example.com/docs/guide')
+  })
+
+  it('reports invalid runtime bitmap metadata', () => {
+    expect(getIconIssues([{
+      rel: 'icon',
+      href: 'https://example.com/favicon.ico',
+      sizes: 'any',
+    }])).toEqual(['https://example.com/favicon.ico uses sizes="any", which is reserved for scalable icons.'])
+  })
+})

package/dist/devtools/lib/seo-utils/tools.ts

@@ -7,10 +7,41 @@ export const SEO_LIMITS = {
   DESC_MAX_PIXELS: 920,
 } as const
 
+export interface ParsedIconLink {
+  rel: string
+  href: string
+  type?: string
+  sizes?: string
+  media?: string
+}
+
 export function estimatePixelWidth(text: string, fontSize: number = 16): number {
   return Math.round(text.length * fontSize * 0.55)
 }
 
+export function resolveAppUrl(origin: string, appBaseURL: string, path: string): string {
+  const base = new URL(appBaseURL, origin)
+  if (!base.pathname.endsWith('/'))
+    base.pathname += '/'
+
+  const candidate = new URL(path, origin)
+  const basePath = base.pathname.replace(/\/$/, '')
+  if (candidate.pathname === basePath || candidate.pathname.startsWith(`${basePath}/`))
+    return candidate.href
+  return new URL(path.replace(/^\//, ''), base).href
+}
+
+export function getIconIssues(icons: ParsedIconLink[]): string[] {
+  return icons.flatMap((icon) => {
+    const isSvg = icon.type === 'image/svg+xml' || /\.svg(?:[?#]|$)/i.test(icon.href)
+    if (!icon.sizes)
+      return [`${icon.href} has no sizes attribute.`]
+    if (icon.sizes.toLowerCase().split(/\s+/).includes('any') && !isSvg)
+      return [`${icon.href} uses sizes="any", which is reserved for scalable icons.`]
+    return []
+  })
+}
+
 export function parseMetaTags(html: string) {
   const parser = new DOMParser()
   const doc = parser.parseFromString(html, 'text/html')
@@ -64,13 +95,21 @@ export function parseMetaTags(html: string) {
     }
   })
 
-  const iconLinks: Array<{ rel: string, href: string, type?: string, sizes?: string, media?: string }> = []
-  doc.querySelectorAll('link[rel="icon"], link[rel="apple-touch-icon"], link[rel="shortcut icon"]').forEach((el) => {
+  const iconLinks: ParsedIconLink[] = []
+  doc.querySelectorAll('link[rel][href]').forEach((el) => {
+    const relTokens = (el.getAttribute('rel') || '').toLowerCase().split(/\s+/)
+    const rel = relTokens.includes('apple-touch-icon')
+      ? 'apple-touch-icon'
+      : relTokens.includes('icon')
+        ? 'icon'
+        : null
+    if (!rel)
+      return
     const href = el.getAttribute('href')
     if (!href)
       return
     iconLinks.push({
-      rel: el.getAttribute('rel') || 'icon',
+      rel,
       href,
       type: el.getAttribute('type') || undefined,
       sizes: el.getAttribute('sizes') || undefined,

package/dist/devtools/pages/seo-utils/identity.vue

@@ -1,24 +1,17 @@
 <script setup lang="ts">
+import type { ParsedIconLink } from '../../lib/seo-utils/tools'
 import { useClipboard } from '@vueuse/core'
 import { computed, ref, watch } from 'vue'
 import { data } from '../../lib/seo-utils/state'
-import { parseMetaTags } from '../../lib/seo-utils/tools'
+import { getIconIssues, parseMetaTags, resolveAppUrl } from '../../lib/seo-utils/tools'
 
 const { copy } = useClipboard()
 
 const loading = ref(false)
 const error = ref<string | null>(null)
 
-interface IconLink {
-  rel: string
-  href: string
-  type?: string
-  sizes?: string
-  media?: string
-}
-
 interface ParsedIdentity {
-  icons: IconLink[]
+  icons: ParsedIconLink[]
   ogImages: Array<{ url: string, width?: string, height?: string, alt?: string }>
   twitterImages: Array<{ url: string, width?: string, height?: string }>
   themeColors: Array<{ color: string, media?: string, context: 'light' | 'dark' | 'default' }>
@@ -30,9 +23,10 @@ const parsedPage = ref<ParsedIdentity | null>(null)
 const siteConfig = computed(() => data.value?.siteConfig || null)
 const pageIcons = computed(() => parsedPage.value?.icons || [])
 const hasIcons = computed(() => pageIcons.value.length > 0)
+const iconIssues = computed(() => getIconIssues(pageIcons.value))
 
 const iconsByRel = computed(() => {
-  const groups: Record<string, IconLink[]> = {}
+  const groups: Record<string, ParsedIconLink[]> = {}
   pageIcons.value.forEach((link) => {
     const rel = link.rel || 'icon'
     if (!groups[rel])
@@ -110,7 +104,8 @@ async function checkIdentity() {
 
   try {
     const baseUrl = window.parent?.location?.origin || window.location.origin
-    const response = await fetch(`${baseUrl}${path.value}`, {
+    const pageUrl = resolveAppUrl(baseUrl, data.value?.runtimeConfig.appBaseURL || '/', path.value)
+    const response = await fetch(pageUrl, {
       headers: { Accept: 'text/html' },
     })
     if (!response.ok)
@@ -155,7 +150,7 @@ async function checkIdentity() {
     // Resolve relative icon URLs to absolute
     const icons = parsed.iconLinks.map(icon => ({
       ...icon,
-      href: icon.href.startsWith('http') ? icon.href : `${baseUrl}${icon.href.startsWith('/') ? '' : '/'}${icon.href}`,
+      href: new URL(icon.href, response.url).href,
     }))
 
     parsedPage.value = {
@@ -182,7 +177,7 @@ watch([() => data.value, path, refreshTime], () => {
 const cliCommand = 'npx nuxt-seo-utils icons --source <your-logo.svg>'
 
 const iconSizesGenerated = [
-  { name: 'favicon.ico', size: '32x32', desc: 'Browser tab' },
+  { name: 'favicon.ico', size: '16x16, 32x32, 48x48', desc: 'Browser tab' },
   { name: 'icon-16x16.png', size: '16x16', desc: 'Small favicon' },
   { name: 'icon-32x32.png', size: '32x32', desc: 'Standard favicon' },
   { name: 'apple-touch-icon.png', size: '180x180', desc: 'iOS home screen' },
@@ -258,6 +253,14 @@ const iconSizesGenerated = [
         </template>
 
         <template v-if="hasIcons">
+          <div v-if="iconIssues.length" class="hint-callout mb-4">
+            <UIcon name="carbon:warning" class="hint-callout-icon text-sm mt-0.5 shrink-0" />
+            <div class="text-xs text-[var(--color-text-muted)]">
+              <p v-for="issue in iconIssues" :key="issue">
+                {{ issue }}
+              </p>
+            </div>
+          </div>
           <div v-for="(icons, rel) in iconsByRel" :key="rel" class="mb-5 last:mb-0">
             <div class="id-group-header">
               <span>{{ iconRelLabels[rel]?.label || rel }}</span>

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.16.0"
   },
-  "version": "8.3.3",
+  "version": "8.4.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.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 || [];
@@ -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 {};

package/dist/runtime/shared/breadcrumbs.js

@@ -1,4 +1,14 @@
+import { localePath } from "nuxtseo-shared/i18n-runtime";
 import { hasTrailingSlash, parseURL, stringifyParsedURL, withTrailingSlash } from "ufo";
+export function resolveBreadcrumbRoot(rootNode, context) {
+  if (!context.locale || !context.strategy)
+    return rootNode;
+  return localePath(rootNode, context.locale, {
+    defaultLocale: context.defaultLocale || context.locale,
+    strategy: context.strategy,
+    locales: []
+  });
+}
 export function pathBreadcrumbSegments(path, rootNode = "/") {
   const startNode = parseURL(path);
   const appendsTrailingSlash = hasTrailingSlash(startNode.pathname);

package/dist/runtime/types.d.ts

@@ -1,4 +1,8 @@
-import type { Head, MetaFlat, RawInput } from '@unhead/vue/types';
+import type { Head, Link, MetaFlat, RawInput } from '@unhead/vue/types';
+export interface ColorModeIconLinks {
+    dark: Link[];
+    light: Link[];
+}
 export type MetaFlatSerializable = MetaFlat & {
     title?: RawInput<'title'>;
     titleTemplate?: RawInput<'titleTemplate'>;

package/dist/shared/nuxt-seo-utils.NAV2YNQn.mjs

@@ -0,0 +1,94 @@
+import { Buffer } from 'node:buffer';
+
+const APPLE_ICON_RE = /^(?:[^.]+\.)?apple-(?:icon|touch(?:-icon)?)(?:[.-][^.]+)?\.(?:jpe?g|png)$/i;
+const ICON_RE = /^(?:favicon(?:[.-][^.]+)?\.(?:ico|jpe?g|png|svg)|(?:[^.]+\.)?icon(?:[.-][^.]+)?\.(?:ico|jpe?g|png|svg))$/i;
+const SIZE_RE = /^\d+x\d+$/;
+const COLOR_SCHEME_MEDIA_RE = /^\(\s*prefers-color-scheme\s*:\s*(dark|light)\s*\)$/i;
+function classifyIconFilename(filename) {
+  if (APPLE_ICON_RE.test(filename))
+    return "apple-touch-icon";
+  if (ICON_RE.test(filename))
+    return "icon";
+}
+function getIconRel(rel) {
+  if (typeof rel !== "string")
+    return;
+  const tokens = rel.toLowerCase().split(/\s+/);
+  if (tokens.includes("apple-touch-icon"))
+    return "apple-touch-icon";
+  if (tokens.includes("icon"))
+    return "icon";
+}
+function getIconColorMode(media) {
+  if (typeof media !== "string")
+    return;
+  return COLOR_SCHEME_MEDIA_RE.exec(media.trim())?.[1]?.toLowerCase();
+}
+function partitionColorModeIconLinks(links) {
+  const candidates = links.map((link, index) => {
+    const iconLink = link;
+    return {
+      index,
+      link: iconLink,
+      mode: getIconColorMode(iconLink.media),
+      rel: getIconRel(iconLink.rel)
+    };
+  });
+  const reactiveRels = /* @__PURE__ */ new Set();
+  for (const rel of ["icon", "apple-touch-icon"]) {
+    const modes = new Set(candidates.filter((candidate) => candidate.rel === rel).map((candidate) => candidate.mode));
+    if (modes.has("dark") && modes.has("light"))
+      reactiveRels.add(rel);
+  }
+  if (reactiveRels.size === 0)
+    return { _tag: "StaticIconLinks", links };
+  const icons = { dark: [], light: [] };
+  const reactiveIndexes = /* @__PURE__ */ new Set();
+  for (const candidate of candidates) {
+    if (!candidate.rel || !candidate.mode || !reactiveRels.has(candidate.rel))
+      continue;
+    const { media: _, ...link } = candidate.link;
+    icons[candidate.mode].push(link);
+    reactiveIndexes.add(candidate.index);
+  }
+  return {
+    _tag: "ReactiveIconLinks",
+    links: links.filter((_, index) => !reactiveIndexes.has(index)),
+    icons
+  };
+}
+function normalizeIconSizes(configured, resolved) {
+  if (typeof configured !== "string" || !configured.trim())
+    return { sizes: resolved, normalized: false };
+  if (resolved === "any")
+    return { sizes: configured, normalized: false };
+  const resolvedSizes = new Set(resolved.split(/\s+/));
+  const configuredSizes = configured.toLowerCase().trim().split(/\s+/);
+  const isValidSubset = configuredSizes.every((size) => SIZE_RE.test(size) && resolvedSizes.has(size));
+  return isValidSubset ? { sizes: configured, normalized: false } : { sizes: resolved, normalized: true };
+}
+function pngToIco(images) {
+  const headerSize = 6;
+  const directoryEntrySize = 16;
+  const header = Buffer.alloc(headerSize);
+  header.writeUInt16LE(0, 0);
+  header.writeUInt16LE(1, 2);
+  header.writeUInt16LE(images.length, 4);
+  let offset = headerSize + directoryEntrySize * images.length;
+  const directoryEntries = images.map(({ buffer, width, height }) => {
+    const entry = Buffer.alloc(directoryEntrySize);
+    entry.writeUInt8(width === 256 ? 0 : width, 0);
+    entry.writeUInt8(height === 256 ? 0 : height, 1);
+    entry.writeUInt8(0, 2);
+    entry.writeUInt8(0, 3);
+    entry.writeUInt16LE(1, 4);
+    entry.writeUInt16LE(32, 6);
+    entry.writeUInt32LE(buffer.length, 8);
+    entry.writeUInt32LE(offset, 12);
+    offset += buffer.length;
+    return entry;
+  });
+  return Buffer.concat([header, ...directoryEntries, ...images.map((image) => image.buffer)]);
+}
+
+export { partitionColorModeIconLinks as a, classifyIconFilename as c, getIconRel as g, normalizeIconSizes as n, pngToIco as p };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nuxt-seo-utils",
   "type": "module",
-  "version": "8.3.3",
+  "version": "8.4.0",
   "description": "SEO utilities to improve your Nuxt sites discoverability and shareability",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
@@ -37,18 +37,14 @@
     ]
   },
   "peerDependencies": {
-    "@unhead/bundler": "^3.2.1",
     "@unhead/vue": "^2.0.7 || ^3.0.0",
     "esbuild": ">=0.17.0",
     "lightningcss": ">=1.20.0",
-    "nuxt": "^3.0.0 || ^4.0.0",
+    "nuxt": "^3.0.0 || ^4.0.0 || ^5.0.0",
     "rolldown": ">=1.0.0-beta.0",
     "unhead": "^2.0.7 || ^3.0.0"
   },
   "peerDependenciesMeta": {
-    "@unhead/bundler": {
-      "optional": true
-    },
     "@unhead/vue": {
       "optional": true
     },
@@ -73,8 +69,8 @@
     "escape-string-regexp": "^5.0.0",
     "exsolve": "^1.1.1",
     "image-size": "^2.0.2",
-    "nuxt-site-config": "^4.1.2",
-    "nuxtseo-shared": "^5.3.6",
+    "nuxt-site-config": "^4.1.4",
+    "nuxtseo-shared": "^5.3.11",
     "pathe": "^2.0.3",
     "pkg-types": "^2.3.1",
     "scule": "^1.3.0",
@@ -93,7 +89,6 @@
     "@nuxt/ui": "^4.10.0",
     "@nuxtjs/i18n": "^10.5.0",
     "@types/node": "^26.1.2",
-    "@unhead/bundler": "^3.2.3",
     "@unhead/vue": "3.2.3",
     "@vue/test-utils": "^2.4.11",
     "bumpp": "^12.0.0",
@@ -127,9 +122,10 @@
     "lint:fix": "eslint . --fix",
     "typecheck": "nuxt typecheck",
     "prepare:fixtures": "nuxt prepare test/fixtures/basic && nuxt prepare test/fixtures/i18n && nuxt prepare test/fixtures/csp",
-    "test": "vitest",
+    "test": "vitest && pnpm test:nuxt5",
     "test:run": "vitest run --exclude '**/\\_\\_runtime\\_\\_/**'",
     "test:runtime": "cd test/fixtures/basic && vitest --run",
+    "test:nuxt5": "pnpm pack --out test/fixtures/nuxt5/module.tgz && node test/fixtures/nuxt5/run.mjs",
     "release": "pnpm build && bumpp -x \"npx changelogen --output=CHANGELOG.md\"",
     "lint:docs": "markdownlint ./docs/content && case-police 'docs/content/**/*.md' *.md",
     "lint:docs:fix": "markdownlint ./docs/content --fix && case-police 'docs/content/**/*.md' *.md --fix",