astro 4.1.3 → 4.2.1

package/dist/core/routing/manifest/create.js

@@ -70,10 +70,6 @@ function getTrailingSlashPattern(addTrailingSlash) {
   }
   return "\\/?$";
 }
-function isSpread(str) {
-  const spreadPattern = /\[\.{3}/g;
-  return spreadPattern.test(str);
-}
 function validateSegment(segment, file = "") {
   if (!file)
     file = segment;
@@ -87,59 +83,50 @@ function validateSegment(segment, file = "") {
     throw new Error(`Invalid route ${file} \u2014 rest parameter must be a standalone segment`);
   }
 }
-function comparator(a, b) {
-  if (a.isIndex !== b.isIndex) {
-    if (a.isIndex)
-      return isSpread(a.file) ? 1 : -1;
-    return isSpread(b.file) ? -1 : 1;
+function isSemanticallyEqualSegment(segmentA, segmentB) {
+  if (segmentA.length !== segmentB.length) {
+    return false;
   }
-  const max = Math.max(a.parts.length, b.parts.length);
-  for (let i = 0; i < max; i += 1) {
-    const aSubPart = a.parts[i];
-    const bSubPart = b.parts[i];
-    if (!aSubPart)
-      return 1;
-    if (!bSubPart)
-      return -1;
-    if (aSubPart.spread && bSubPart.spread) {
-      return a.isIndex ? 1 : -1;
-    }
-    if (aSubPart.spread !== bSubPart.spread)
-      return aSubPart.spread ? 1 : -1;
-    if (aSubPart.dynamic !== bSubPart.dynamic) {
-      return aSubPart.dynamic ? 1 : -1;
+  for (const [index, partA] of segmentA.entries()) {
+    const partB = segmentB[index];
+    if (partA.dynamic !== partB.dynamic || partA.spread !== partB.spread) {
+      return false;
     }
-    if (!aSubPart.dynamic && aSubPart.content !== bSubPart.content) {
-      return bSubPart.content.length - aSubPart.content.length || (aSubPart.content < bSubPart.content ? -1 : 1);
+    if (!partA.dynamic && partA.content !== partB.content) {
+      return false;
     }
   }
-  if (a.isPage !== b.isPage) {
-    return a.isPage ? 1 : -1;
-  }
-  return a.file < b.file ? -1 : 1;
+  return true;
 }
-function injectedRouteToItem({ config, cwd }, { pattern, entrypoint }) {
-  let resolved;
-  try {
-    resolved = require2.resolve(entrypoint, { paths: [cwd || fileURLToPath(config.root)] });
-  } catch (e) {
-    resolved = fileURLToPath(new URL(entrypoint, config.root));
+function routeComparator(a, b) {
+  const aLength = a.isIndex ? a.segments.length + 1 : a.segments.length;
+  const bLength = b.isIndex ? b.segments.length + 1 : b.segments.length;
+  if (aLength !== bLength) {
+    return aLength > bLength ? -1 : 1;
   }
-  const ext = path.extname(pattern);
-  const type = resolved.endsWith(".astro") ? "page" : "endpoint";
-  const isPage = type === "page";
-  return {
-    basename: pattern,
-    ext,
-    parts: getParts(pattern, resolved),
-    file: resolved,
-    isDir: false,
-    isIndex: true,
-    isPage,
-    routeSuffix: pattern.slice(pattern.indexOf("."), -ext.length)
-  };
+  const aIsStatic = a.segments.every(
+    (segment) => segment.every((part) => !part.dynamic && !part.spread)
+  );
+  const bIsStatic = b.segments.every(
+    (segment) => segment.every((part) => !part.dynamic && !part.spread)
+  );
+  if (aIsStatic !== bIsStatic) {
+    return aIsStatic ? -1 : 1;
+  }
+  const aHasSpread = a.segments.some((segment) => segment.some((part) => part.spread));
+  const bHasSpread = b.segments.some((segment) => segment.some((part) => part.spread));
+  if (aHasSpread !== bHasSpread) {
+    return aHasSpread ? 1 : -1;
+  }
+  if (a.prerender !== b.prerender) {
+    return a.prerender ? -1 : 1;
+  }
+  if (a.type === "endpoint" !== (b.type === "endpoint")) {
+    return a.type === "endpoint" ? -1 : 1;
+  }
+  return a.route.localeCompare(b.route);
 }
-function createRouteManifest({ settings, cwd, fsMod }, logger) {
+function createFileBasedRoutes({ settings, cwd, fsMod }, logger) {
   const components = [];
   const routes = [];
   const validPageExtensions = /* @__PURE__ */ new Set([
@@ -152,17 +139,18 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
   const prerender = getPrerenderDefault(settings.config);
   function walk(fs, dir, parentSegments, parentParams) {
     let items = [];
-    fs.readdirSync(dir).forEach((basename) => {
+    const files = fs.readdirSync(dir);
+    for (const basename of files) {
       const resolved = path.join(dir, basename);
       const file = slash(path.relative(cwd || fileURLToPath(settings.config.root), resolved));
       const isDir = fs.statSync(resolved).isDirectory();
       const ext = path.extname(basename);
       const name = ext ? basename.slice(0, -ext.length) : basename;
       if (name[0] === "_") {
-        return;
+        continue;
       }
       if (basename[0] === "." && basename !== ".well-known") {
-        return;
+        continue;
       }
       if (!isDir && !validPageExtensions.has(ext) && !validEndpointExtensions.has(ext)) {
         logger.warn(
@@ -171,7 +159,7 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
             resolved
           )} found. Prefix filename with an underscore (\`_\`) to ignore.`
         );
-        return;
+        continue;
       }
       const segment = isDir ? basename : name;
       validateSegment(segment, file);
@@ -189,9 +177,8 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
         isPage,
         routeSuffix
       });
-    });
-    items = items.sort(comparator);
-    items.forEach((item) => {
+    }
+    for (const item of items) {
       const segments = parentSegments.slice();
       if (item.isIndex) {
         if (item.routeSuffix) {
@@ -233,6 +220,7 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
         const route = `/${segments.map(([{ dynamic, content }]) => dynamic ? `[${content}]` : content).join("/")}`.toLowerCase();
         routes.push({
           route,
+          isIndex: item.isIndex,
           type: item.isPage ? "page" : "endpoint",
           pattern,
           segments,
@@ -244,7 +232,7 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
           fallbackRoutes: []
         });
       }
-    });
+    }
   }
   const { config } = settings;
   const pages = resolvePages(config);
@@ -254,12 +242,18 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
     const pagesDirRootRelative = pages.href.slice(settings.config.root.href.length);
     logger.warn(null, `Missing pages directory: ${pagesDirRootRelative}`);
   }
-  settings.injectedRoutes?.sort(
-    (a, b) => (
-      // sort injected routes in the same way as user-defined routes
-      comparator(injectedRouteToItem({ config, cwd }, a), injectedRouteToItem({ config, cwd }, b))
-    )
-  ).reverse().forEach(({ pattern: name, entrypoint, prerender: prerenderInjected }) => {
+  return routes;
+}
+function createInjectedRoutes({ settings, cwd }) {
+  const { config } = settings;
+  const prerender = getPrerenderDefault(config);
+  const routes = {
+    normal: [],
+    legacy: []
+  };
+  const priority = computeRoutePriority(config);
+  for (const injectedRoute of settings.injectedRoutes) {
+    const { pattern: name, entrypoint, prerender: prerenderInjected } = injectedRoute;
     let resolved;
     try {
       resolved = require2.resolve(entrypoint, { paths: [cwd || fileURLToPath(config.root)] });
@@ -279,15 +273,10 @@ function createRouteManifest({ settings, cwd, fsMod }, logger) {
     const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
     const params = segments.flat().filter((p) => p.dynamic).map((p) => p.content);
     const route = `/${segments.map(([{ dynamic, content }]) => dynamic ? `[${content}]` : content).join("/")}`.toLowerCase();
-    const collision = routes.find(({ route: r }) => r === route);
-    if (collision) {
-      throw new Error(
-        `An integration attempted to inject a route that is already used in your project: "${route}" at "${component}". 
-This route collides with: "${collision.component}".`
-      );
-    }
-    routes.unshift({
+    routes[priority].push({
       type,
+      // For backwards compatibility, an injected route is never considered an index route.
+      isIndex: false,
       route,
       pattern,
       segments,
@@ -298,9 +287,18 @@ This route collides with: "${collision.component}".`
       prerender: prerenderInjected ?? prerender,
       fallbackRoutes: []
     });
-  });
-  Object.entries(settings.config.redirects).forEach(([from, to]) => {
-    const trailingSlash = config.trailingSlash;
+  }
+  return routes;
+}
+function createRedirectRoutes({ settings }, routeMap, logger) {
+  const { config } = settings;
+  const trailingSlash = config.trailingSlash;
+  const routes = {
+    normal: [],
+    legacy: []
+  };
+  const priority = computeRoutePriority(settings.config);
+  for (const [from, to] of Object.entries(settings.config.redirects)) {
     const segments = removeLeadingForwardSlash(from).split(path.posix.sep).filter(Boolean).map((s) => {
       validateSegment(s);
       return getParts(s, from);
@@ -310,22 +308,22 @@ This route collides with: "${collision.component}".`
     const pathname = segments.every((segment) => segment.length === 1 && !segment[0].dynamic) ? `/${segments.map((segment) => segment[0].content).join("/")}` : null;
     const params = segments.flat().filter((p) => p.dynamic).map((p) => p.content);
     const route = `/${segments.map(([{ dynamic, content }]) => dynamic ? `[${content}]` : content).join("/")}`.toLowerCase();
-    {
-      let destination;
-      if (typeof to === "string") {
-        destination = to;
-      } else {
-        destination = to.destination;
-      }
-      if (/^https?:\/\//.test(destination)) {
-        logger.warn(
-          "redirects",
-          `Redirecting to an external URL is not officially supported: ${from} -> ${destination}`
-        );
-      }
+    let destination;
+    if (typeof to === "string") {
+      destination = to;
+    } else {
+      destination = to.destination;
+    }
+    if (/^https?:\/\//.test(destination)) {
+      logger.warn(
+        "redirects",
+        `Redirecting to an external URL is not officially supported: ${from} -> ${destination}`
+      );
     }
-    const routeData = {
+    routes[priority].push({
       type: "redirect",
+      // For backwards compatibility, a redirect is never considered an index route.
+      isIndex: false,
       route,
       pattern,
       segments,
@@ -335,36 +333,82 @@ This route collides with: "${collision.component}".`
       pathname: pathname || void 0,
       prerender: false,
       redirect: to,
-      redirectRoute: routes.find((r) => {
-        if (typeof to === "object") {
-          return r.route === to.destination;
-        } else {
-          return r.route === to;
-        }
-      }),
+      redirectRoute: routeMap.get(destination),
       fallbackRoutes: []
-    };
-    const lastSegmentIsDynamic = (r) => !!r.segments.at(-1)?.at(-1)?.dynamic;
-    const redirBase = path.posix.dirname(route);
-    const dynamicRedir = lastSegmentIsDynamic(routeData);
-    let i = 0;
-    for (const existingRoute of routes) {
-      if (existingRoute.route === route) {
-        routes.splice(i + 1, 0, routeData);
-        return;
-      }
-      const base = path.posix.dirname(existingRoute.route);
-      if (base === redirBase && !dynamicRedir && lastSegmentIsDynamic(existingRoute)) {
-        routes.splice(i, 0, routeData);
-        return;
+    });
+  }
+  return routes;
+}
+function isStaticSegment(segment) {
+  return segment.every((part) => !part.dynamic && !part.spread);
+}
+function detectRouteCollision(a, b, config, logger) {
+  if (a.type === "fallback" || b.type === "fallback") {
+    return;
+  }
+  if (a.route === b.route && a.segments.every(isStaticSegment) && b.segments.every(isStaticSegment)) {
+    logger.warn(
+      "router",
+      `The route "${a.route}" is defined in both "${a.component}" and "${b.component}". A static route cannot be defined more than once.`
+    );
+    logger.warn(
+      "router",
+      "A collision will result in an hard error in following versions of Astro."
+    );
+    return;
+  }
+  if (a.prerender || b.prerender) {
+    return;
+  }
+  if (a.segments.length !== b.segments.length) {
+    return;
+  }
+  const segmentCount = a.segments.length;
+  for (let index = 0; index < segmentCount; index++) {
+    const segmentA = a.segments[index];
+    const segmentB = b.segments[index];
+    if (!isSemanticallyEqualSegment(segmentA, segmentB)) {
+      return;
+    }
+  }
+  logger.warn(
+    "router",
+    `The route "${a.route}" is defined in both "${a.component}" and "${b.component}" using SSR mode. A dynamic SSR route cannot be defined more than once.`
+  );
+  logger.warn("router", "A collision will result in an hard error in following versions of Astro.");
+}
+function createRouteManifest(params, logger) {
+  const { settings } = params;
+  const { config } = settings;
+  const routeMap = /* @__PURE__ */ new Map();
+  const fileBasedRoutes = createFileBasedRoutes(params, logger);
+  for (const route of fileBasedRoutes) {
+    routeMap.set(route.route, route);
+  }
+  const injectedRoutes = createInjectedRoutes(params);
+  for (const [, routes2] of Object.entries(injectedRoutes)) {
+    for (const route of routes2) {
+      routeMap.set(route.route, route);
+    }
+  }
+  const redirectRoutes = createRedirectRoutes(params, routeMap, logger);
+  const routes = [
+    ...injectedRoutes["legacy"].sort(routeComparator),
+    ...[...fileBasedRoutes, ...injectedRoutes["normal"], ...redirectRoutes["normal"]].sort(
+      routeComparator
+    ),
+    ...redirectRoutes["legacy"].sort(routeComparator)
+  ];
+  if (config.experimental.globalRoutePriority) {
+    for (const [index, higherRoute] of routes.entries()) {
+      for (const lowerRoute of routes.slice(index + 1)) {
+        detectRouteCollision(higherRoute, lowerRoute, config, logger);
       }
-      i++;
     }
-    routes.push(routeData);
-  });
+  }
   const i18n = settings.config.i18n;
   if (i18n) {
-    if (i18n.routing === "prefix-always") {
+    if (i18n.routing === "pathname-prefix-always") {
       let index = routes.find((route) => route.route === "/");
       if (!index) {
         let relativePath = path.relative(
@@ -415,7 +459,7 @@ This route collides with: "${collision.component}".`
       }
       setRoutes.delete(route);
     }
-    if (i18n.routing === "prefix-always") {
+    if (i18n.routing === "pathname-prefix-always") {
       const defaultLocaleRoutes = routesByLocale.get(i18n.defaultLocale);
       if (defaultLocaleRoutes) {
         const indexDefaultRoute = defaultLocaleRoutes.find((routeData) => {
@@ -465,7 +509,7 @@ This route collides with: "${collision.component}".`
             if (!hasRoute) {
               let pathname;
               let route;
-              if (fallbackToLocale === i18n.defaultLocale && i18n.routing === "prefix-other-locales") {
+              if (fallbackToLocale === i18n.defaultLocale && i18n.routing === "pathname-prefix-other-locales") {
                 if (fallbackToRoute.pathname) {
                   pathname = `/${fallbackFromLocale}${fallbackToRoute.pathname}`;
                 }
@@ -504,6 +548,12 @@ This route collides with: "${collision.component}".`
     routes
   };
 }
+function computeRoutePriority(config) {
+  if (config.experimental.globalRoutePriority) {
+    return "normal";
+  }
+  return "legacy";
+}
 export {
   createRouteManifest
 };

package/dist/core/sync/index.js

@@ -35,7 +35,7 @@ async function syncInternal(settings, { logger, fs }) {
     await createVite(
       {
         server: { middlewareMode: true, hmr: false, watch: null },
-        optimizeDeps: { disabled: true },
+        optimizeDeps: { noDiscovery: true },
         ssr: { external: [] },
         logLevel: "silent"
       },

package/dist/i18n/index.d.ts

@@ -1,11 +1,12 @@
 import type { AstroConfig, Locales } from '../@types/astro.js';
+import type { RoutingStrategies } from '../core/config/schema.js';
 type GetLocaleRelativeUrl = GetLocaleOptions & {
     locale: string;
     base: string;
     locales: Locales;
     trailingSlash: AstroConfig['trailingSlash'];
     format: AstroConfig['build']['format'];
-    routing?: 'prefix-always' | 'prefix-other-locales';
+    routing?: RoutingStrategies;
     defaultLocale: string;
 };
 export type GetLocaleOptions = {
@@ -39,7 +40,7 @@ type GetLocalesBaseUrl = GetLocaleOptions & {
     locales: Locales;
     trailingSlash: AstroConfig['trailingSlash'];
     format: AstroConfig['build']['format'];
-    routing?: 'prefix-always' | 'prefix-other-locales';
+    routing?: RoutingStrategies;
     defaultLocale: string;
 };
 export declare function getLocaleRelativeUrlList({ base, locales: _locales, trailingSlash, format, path, prependWith, normalizeLocale, routing, defaultLocale, }: GetLocalesBaseUrl): string[];

package/dist/i18n/index.js

@@ -11,7 +11,7 @@ function getLocaleRelativeUrl({
   path,
   prependWith,
   normalizeLocale = true,
-  routing = "prefix-other-locales",
+  routing = "pathname-prefix-other-locales",
   defaultLocale
 }) {
   const codeToUse = peekCodePathToUse(_locales, locale);
@@ -23,7 +23,7 @@ function getLocaleRelativeUrl({
   }
   const pathsToJoin = [base, prependWith];
   const normalizedLocale = normalizeLocale ? normalizeTheLocale(codeToUse) : codeToUse;
-  if (routing === "prefix-always") {
+  if (routing === "pathname-prefix-always") {
     pathsToJoin.push(normalizedLocale);
   } else if (locale !== defaultLocale) {
     pathsToJoin.push(normalizedLocale);
@@ -51,14 +51,14 @@ function getLocaleRelativeUrlList({
   path,
   prependWith,
   normalizeLocale = false,
-  routing = "prefix-other-locales",
+  routing = "pathname-prefix-other-locales",
   defaultLocale
 }) {
   const locales = toPaths(_locales);
   return locales.map((locale) => {
     const pathsToJoin = [base, prependWith];
     const normalizedLocale = normalizeLocale ? normalizeTheLocale(locale) : locale;
-    if (routing === "prefix-always") {
+    if (routing === "pathname-prefix-always") {
       pathsToJoin.push(normalizedLocale);
     } else if (locale !== defaultLocale) {
       pathsToJoin.push(normalizedLocale);

package/dist/i18n/middleware.js

@@ -35,25 +35,41 @@ function createI18nMiddleware(i18n, base, trailingSlash) {
     const response = await next();
     if (response instanceof Response) {
       const pathnameContainsDefaultLocale = url.pathname.includes(`/${defaultLocale}`);
-      if (i18n.routing === "prefix-other-locales" && pathnameContainsDefaultLocale) {
-        const newLocation = url.pathname.replace(`/${defaultLocale}`, "");
-        response.headers.set("Location", newLocation);
-        return new Response(null, {
-          status: 404,
-          headers: response.headers
-        });
-      } else if (i18n.routing === "prefix-always") {
-        if (url.pathname === base + "/" || url.pathname === base) {
-          if (trailingSlash === "always") {
-            return context.redirect(`${appendForwardSlash(joinPaths(base, i18n.defaultLocale))}`);
-          } else {
-            return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
+      switch (i18n.routing) {
+        case "pathname-prefix-other-locales": {
+          if (pathnameContainsDefaultLocale) {
+            const newLocation = url.pathname.replace(`/${defaultLocale}`, "");
+            response.headers.set("Location", newLocation);
+            return new Response(null, {
+              status: 404,
+              headers: response.headers
+            });
+          }
+          break;
+        }
+        case "pathname-prefix-always-no-redirect": {
+          const isRoot = url.pathname === base + "/" || url.pathname === base;
+          if (!(isRoot || pathnameHasLocale(url.pathname, i18n.locales))) {
+            return new Response(null, {
+              status: 404,
+              headers: response.headers
+            });
+          }
+          break;
+        }
+        case "pathname-prefix-always": {
+          if (url.pathname === base + "/" || url.pathname === base) {
+            if (trailingSlash === "always") {
+              return context.redirect(`${appendForwardSlash(joinPaths(base, i18n.defaultLocale))}`);
+            } else {
+              return context.redirect(`${joinPaths(base, i18n.defaultLocale)}`);
+            }
+          } else if (!pathnameHasLocale(url.pathname, i18n.locales)) {
+            return new Response(null, {
+              status: 404,
+              headers: response.headers
+            });
           }
-        } else if (!pathnameHasLocale(url.pathname, i18n.locales)) {
-          return new Response(null, {
-            status: 404,
-            headers: response.headers
-          });
         }
       }
       if (response.status >= 300 && fallback) {
@@ -75,7 +91,7 @@ function createI18nMiddleware(i18n, base, trailingSlash) {
           const fallbackLocale = fallback[urlLocale];
           const pathFallbackLocale = getPathByLocale(fallbackLocale, locales);
           let newPathname;
-          if (pathFallbackLocale === defaultLocale && routing === "prefix-other-locales") {
+          if (pathFallbackLocale === defaultLocale && routing === "pathname-prefix-other-locales") {
             newPathname = url.pathname.replace(`/${urlLocale}`, ``);
           } else {
             newPathname = url.pathname.replace(`/${urlLocale}`, `/${pathFallbackLocale}`);

package/dist/prefetch/index.js

@@ -4,6 +4,7 @@ const prefetchedUrls = /* @__PURE__ */ new Set();
 const listenedAnchors = /* @__PURE__ */ new WeakSet();
 let prefetchAll = __PREFETCH_PREFETCH_ALL__;
 let defaultStrategy = __PREFETCH_DEFAULT_STRATEGY__;
+let clientPrerender = __EXPERIMENTAL_CLIENT_PRERENDER__;
 let inited = false;
 function init(defaultOpts) {
   if (!inBrowser)
@@ -128,7 +129,9 @@ function prefetch(url, opts) {
   prefetchedUrls.add(url);
   const priority = opts?.with ?? "link";
   debug?.(`[astro] Prefetching ${url} with ${priority}`);
-  if (priority === "link") {
+  if (clientPrerender && HTMLScriptElement.supports && HTMLScriptElement.supports("speculationrules")) {
+    appendSpeculationRules(url);
+  } else if (priority === "link") {
     const link = document.createElement("link");
     link.rel = "prefetch";
     link.setAttribute("href", url);
@@ -188,6 +191,19 @@ function onPageLoad(cb) {
     cb();
   });
 }
+function appendSpeculationRules(url) {
+  const script = document.createElement("script");
+  script.type = "speculationrules";
+  script.textContent = JSON.stringify({
+    prerender: [
+      {
+        source: "list",
+        urls: [url]
+      }
+    ]
+  });
+  document.head.append(script);
+}
 export {
   init,
   prefetch

package/dist/prefetch/vite-plugin-prefetch.js

@@ -32,7 +32,10 @@ function astroPrefetch({ settings }) {
     },
     transform(code, id) {
       if (id.includes(prefetchInternalModuleFsSubpath)) {
-        return code.replace("__PREFETCH_PREFETCH_ALL__", JSON.stringify(prefetch?.prefetchAll)).replace("__PREFETCH_DEFAULT_STRATEGY__", JSON.stringify(prefetch?.defaultStrategy));
+        return code.replace("__PREFETCH_PREFETCH_ALL__", JSON.stringify(prefetch?.prefetchAll)).replace("__PREFETCH_DEFAULT_STRATEGY__", JSON.stringify(prefetch?.defaultStrategy)).replace(
+          "__EXPERIMENTAL_CLIENT_PRERENDER__",
+          JSON.stringify(settings.config.experimental.clientPrerender)
+        );
       }
     }
   };

package/dist/runtime/client/dev-toolbar/apps/audit/a11y.js

@@ -330,13 +330,61 @@ const a11y = [
   },
   {
     code: "a11y-missing-content",
-    title: "Missing content on element important for accessibility",
-    message: "Headings and anchors must have content to be accessible.",
+    title: "Missing content",
+    message: "Headings and anchors must have an accessible name, which can come from: inner text, aria-label, aria-labelledby, an img with alt property, or an svg with a tag <title></title>.",
     selector: a11y_required_content.join(","),
     match(element) {
       const innerText = element.innerText.trim();
-      if (innerText === "")
-        return true;
+      if (innerText !== "")
+        return false;
+      const ariaLabel = element.getAttribute("aria-label")?.trim();
+      if (ariaLabel && ariaLabel !== "")
+        return false;
+      const ariaLabelledby = element.getAttribute("aria-labelledby")?.trim();
+      if (ariaLabelledby) {
+        const ids = ariaLabelledby.split(" ");
+        for (const id of ids) {
+          const referencedElement = document.getElementById(id);
+          if (referencedElement && referencedElement.innerText.trim() !== "")
+            return false;
+        }
+      }
+      const imgElements = element.querySelectorAll("img");
+      for (const img of imgElements) {
+        const altAttribute = img.getAttribute("alt");
+        if (altAttribute && altAttribute.trim() !== "")
+          return false;
+      }
+      const svgElements = element.querySelectorAll("svg");
+      for (const svg of svgElements) {
+        const titleText = svg.querySelector("title");
+        if (titleText && titleText.textContent && titleText.textContent.trim() !== "")
+          return false;
+      }
+      const inputElements = element.querySelectorAll("input");
+      for (const input of inputElements) {
+        if (input.type === "image") {
+          const altAttribute = input.getAttribute("alt");
+          if (altAttribute && altAttribute.trim() !== "")
+            return false;
+        }
+        const inputAriaLabel = input.getAttribute("aria-label")?.trim();
+        if (inputAriaLabel && inputAriaLabel !== "")
+          return false;
+        const inputAriaLabelledby = input.getAttribute("aria-labelledby")?.trim();
+        if (inputAriaLabelledby) {
+          const ids = inputAriaLabelledby.split(" ");
+          for (const id of ids) {
+            const referencedElement = document.getElementById(id);
+            if (referencedElement && referencedElement.innerText.trim() !== "")
+              return false;
+          }
+        }
+        const title = input.getAttribute("title")?.trim();
+        if (title && title !== "")
+          return false;
+      }
+      return true;
     }
   },
   {