@vicacha-devs/strapi-plugin-seo 0.0.0-stage → 2.1.0

package/dist/admin/index-C8tiCtgn.cjs

@@ -0,0 +1,3490 @@
+"use strict";
+const icons = require("@strapi/icons");
+const jsxRuntime = require("react/jsx-runtime");
+const admin = require("@strapi/strapi/admin");
+const React = require("react");
+const designSystem = require("@strapi/design-system");
+const reactIntl = require("react-intl");
+const dateFns = require("date-fns");
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const React__namespace = /* @__PURE__ */ _interopNamespace(React);
+function freezeOptions(items) {
+  return Object.freeze(items.map((item) => Object.freeze({ ...item })));
+}
+freezeOptions([
+  { value: "es", label: "es — Español (Spanish)" },
+  { value: "en", label: "en — English" },
+  { value: "ar", label: "ar — العربية (Arabic)" },
+  { value: "tr", label: "tr — Türkçe (Turkish)" },
+  { value: "fr", label: "fr — Français (French)" },
+  { value: "de", label: "de — Deutsch (German)" },
+  { value: "pt", label: "pt — Português (Portuguese)" },
+  { value: "it", label: "it — Italiano (Italian)" },
+  { value: "nl", label: "nl — Nederlands (Dutch)" },
+  { value: "pl", label: "pl — Polski (Polish)" },
+  { value: "ru", label: "ru — Русский (Russian)" },
+  { value: "id", label: "id — Bahasa Indonesia" },
+  { value: "ur", label: "ur — اردو (Urdu)" },
+  { value: "zh", label: "zh — 中文 (Chinese)" }
+]);
+freezeOptions([
+  {
+    value: "islamic-umalqura",
+    label: "islamic-umalqura (Hijri Umm al-Qura)"
+  },
+  { value: "islamic-civil", label: "islamic-civil (Tabular Islamic Civil)" },
+  { value: "islamic-tbla", label: "islamic-tbla (Tabular Astronomical)" },
+  { value: "hebrew", label: "hebrew (Hebrew)" },
+  { value: "persian", label: "persian (Solar Hijri)" },
+  { value: "none", label: "none (Gregorian Only)" }
+]);
+const VALID_LOCALE_RE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,4}$/;
+function isTranslationRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function extractDictionary(loaded) {
+  if (!isTranslationRecord(loaded)) {
+    return void 0;
+  }
+  if ("default" in loaded) {
+    return isTranslationRecord(loaded.default) ? loaded.default : void 0;
+  }
+  return loaded;
+}
+function getLookupCandidates(locale, fallbackToLanguage) {
+  const trimmed = locale.trim();
+  if (!VALID_LOCALE_RE.test(trimmed)) {
+    return [];
+  }
+  if (!fallbackToLanguage || !trimmed.includes("-")) {
+    return [trimmed];
+  }
+  const base = trimmed.split("-")[0];
+  return base && base !== trimmed ? [trimmed, base] : [trimmed];
+}
+function prefixPluginTranslations(trad, pluginId2, options) {
+  const normalizedPluginId = typeof pluginId2 === "string" ? pluginId2.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const result = {};
+  if (options?.baseTranslations) {
+    for (const [key, value] of Object.entries(options.baseTranslations)) {
+      if (typeof value === "string") {
+        result[key] = value;
+      }
+    }
+  }
+  const prefix = `${normalizedPluginId}.`;
+  const explicitPrefixed = [];
+  for (const [key, value] of Object.entries(trad)) {
+    if (typeof value !== "string") {
+      continue;
+    }
+    if (options?.keepUnprefixed) {
+      result[key] = value;
+    }
+    if (key.startsWith(prefix)) {
+      explicitPrefixed.push([key, value]);
+    } else {
+      result[`${prefix}${key}`] = value;
+    }
+  }
+  for (const [key, value] of explicitPrefixed) {
+    result[key] = value;
+  }
+  return result;
+}
+function createRegisterTrads(options) {
+  const { pluginId: pluginId2, defaultLocales = ["en", "es", "ar", "tr"], supportedLocales, keepUnprefixed = true, fallbackToLanguageCode = true, loadTranslation, translations, getBaseTranslations, onLoaded } = options;
+  const normalizedPluginId = typeof pluginId2 === "string" ? pluginId2.trim() : "";
+  if (!normalizedPluginId) {
+    throw new TypeError("pluginId can't be empty");
+  }
+  const supportedSet = supportedLocales ? new Set(supportedLocales) : void 0;
+  const effectiveDefaults = supportedSet ? defaultLocales.filter((loc) => getLookupCandidates(loc, fallbackToLanguageCode).some((candidate) => supportedSet.has(candidate))) : defaultLocales;
+  return async function registerTrads({ locales = [] } = {}) {
+    const allLocales = effectiveDefaults.length > 0 ? Array.from(/* @__PURE__ */ new Set([...locales, ...effectiveDefaults])) : Array.from(new Set(locales));
+    return Promise.all(allLocales.map(async (locale) => {
+      const candidates = getLookupCandidates(locale, fallbackToLanguageCode);
+      if (candidates.length === 0) {
+        return { data: {}, locale };
+      }
+      if (supportedSet && !candidates.some((candidate) => supportedSet.has(candidate))) {
+        return { data: {}, locale };
+      }
+      let rawData;
+      for (const candidate of candidates) {
+        if (translations && Object.hasOwn(translations, candidate)) {
+          rawData = extractDictionary(translations[candidate]);
+          if (rawData) {
+            break;
+          }
+        }
+        if (loadTranslation) {
+          try {
+            const loaded = await loadTranslation(candidate);
+            rawData = extractDictionary(loaded);
+            if (rawData) {
+              break;
+            }
+          } catch {
+          }
+        }
+      }
+      const baseTranslations = getBaseTranslations?.(locale);
+      const hasBase = Boolean(baseTranslations) && Object.keys(baseTranslations).length > 0;
+      if (!rawData && !hasBase) {
+        return { data: {}, locale };
+      }
+      const prefixed = prefixPluginTranslations(rawData ?? {}, normalizedPluginId, {
+        keepUnprefixed,
+        baseTranslations
+      });
+      onLoaded?.(locale, prefixed);
+      return { data: prefixed, locale };
+    }));
+  };
+}
+const strapi = { "name": "seo" };
+const pluginPkg = {
+  strapi
+};
+const DEFAULT_SEO_CHECKS = {
+  metaTitle: true,
+  metaDescription: true,
+  metaRobots: true,
+  openGraph: true,
+  wordCount: true,
+  canonicalUrl: true,
+  keywordDensity: true,
+  structuredData: true,
+  alternativeText: true,
+  lastUpdatedAt: true
+};
+const pluginId = pluginPkg.strapi?.name;
+const useSettingsApi = () => {
+  const { get, post } = admin.useFetchClient();
+  const getSettings = async () => {
+    return get(`/${pluginId}/settings`);
+  };
+  const setSettings = async (settings) => {
+    return post(`/${pluginId}/settings`, settings);
+  };
+  return {
+    getSettings,
+    setSettings
+  };
+};
+const getTrad = (id) => `${pluginId}.${id}`;
+const qualityVerdict = {
+  good: "good",
+  improvements: "improvements",
+  bad: "bad"
+};
+const isEmptyValue = (value) => {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim().length === 0;
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") {
+    return Object.keys(value).length === 0;
+  }
+  return false;
+};
+const isSameCheckStatus = (a, b) => {
+  if (!a || !b) return false;
+  return a.qualityVerdict === b.qualityVerdict && a.message === b.message;
+};
+const getMetaTitleCheckPreview = (modifiedData) => {
+  const metaTitle = modifiedData?.seo?.metaTitle ?? null;
+  if (typeof metaTitle !== "string" || isEmptyValue(metaTitle)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  if (metaTitle.length > 60) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const getMetaDescriptionPreview = (modifiedData) => {
+  const metaDescription = modifiedData?.seo?.metaDescription ?? null;
+  if (typeof metaDescription !== "string" || isEmptyValue(metaDescription)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  if (metaDescription.length > 160 || metaDescription.length < 50) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const getAlternativeTextPreview = (emptyAltCount) => {
+  const intersections = emptyAltCount?.intersections ?? null;
+  const richTextAlts = Array.isArray(emptyAltCount?.richTextAlts) ? emptyAltCount.richTextAlts : [];
+  const blockTextAlts = Array.isArray(emptyAltCount?.blockTextAlts) ? emptyAltCount.blockTextAlts : [];
+  const altTexts = Array.isArray(emptyAltCount?.altTexts) ? emptyAltCount.altTexts : [];
+  const missingRichOrBlockAlt = [...richTextAlts, ...blockTextAlts].filter(
+    (x) => x.occurences !== 0
+  ).length;
+  if (intersections === 0) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  if (altTexts.includes("") || missingRichOrBlockAlt >= 1) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const getWordCountPreview = (wordCount) => {
+  if (typeof wordCount !== "number" || wordCount < 300) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const getKeywordDensityPreview = (keywordsDensity) => {
+  if (isEmptyValue(keywordsDensity)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  let hasUnused = false;
+  let hasUsedOnce = false;
+  Object.keys(keywordsDensity).forEach((keyword) => {
+    const count = keywordsDensity[keyword]?.count ?? 0;
+    if (count === 0) {
+      hasUnused = true;
+    } else if (count <= 1) {
+      hasUsedOnce = true;
+    }
+  });
+  if (hasUsedOnce) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  if (hasUnused) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const canonicalUrlPreview = (modifiedData) => {
+  const canonicalUrl = modifiedData?.seo?.canonicalURL ?? null;
+  if (typeof canonicalUrl !== "string" || isEmptyValue(canonicalUrl)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const lastUpdatedAtPreview = (modifiedData, fallbackUpdatedAt = null) => {
+  const updatedAt = fallbackUpdatedAt ?? modifiedData?.updatedAt ?? null;
+  if (typeof updatedAt !== "string" || isEmptyValue(updatedAt)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  const parsedUpdatedAt = Date.parse(updatedAt);
+  if (Number.isNaN(parsedUpdatedAt)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  const oneYearAgoDate = /* @__PURE__ */ new Date();
+  oneYearAgoDate.setFullYear(oneYearAgoDate.getFullYear() - 1);
+  if (parsedUpdatedAt >= oneYearAgoDate.getTime()) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.good
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.improvements
+  };
+};
+const metaRobotPreview = (modifiedData) => {
+  const metaRobots = modifiedData?.seo?.metaRobots ?? null;
+  if (typeof metaRobots !== "string" || isEmptyValue(metaRobots)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.good
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const openGraphPreview = (modifiedData) => {
+  const openGraph = modifiedData?.seo?.openGraph ?? null;
+  if (!openGraph || typeof openGraph !== "object") {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  if (isEmptyValue(openGraph.ogTitle) || isEmptyValue(openGraph.ogDescription) || !openGraph.ogImage) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.improvements
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const structuredDataPreview = (modifiedData) => {
+  const structuredData = modifiedData?.seo?.structuredData ?? null;
+  if (isEmptyValue(structuredData)) {
+    return {
+      message: "",
+      qualityVerdict: qualityVerdict.bad
+    };
+  }
+  return {
+    message: "",
+    qualityVerdict: qualityVerdict.good
+  };
+};
+const recursiveSearch = (obj, keyword, relations, results = [], allImageNames = [], visited = /* @__PURE__ */ new WeakSet()) => {
+  const alternativeTexts = results;
+  const imageNames = allImageNames;
+  if (!obj || typeof obj !== "object" || visited.has(obj)) {
+    return { alternativeTexts, imageNames };
+  }
+  visited.add(obj);
+  Object.keys(obj).forEach((key) => {
+    const value = obj[key];
+    if (key === keyword && (value === null || typeof value !== "object")) {
+      alternativeTexts.push(typeof value === "string" ? value : "");
+      imageNames.push(typeof obj.name === "string" ? obj.name : "");
+    } else if (value !== null && typeof value === "object" && !relations.includes(key)) {
+      recursiveSearch(
+        value,
+        keyword,
+        relations,
+        alternativeTexts,
+        imageNames,
+        visited
+      );
+    }
+  });
+  return { alternativeTexts, imageNames };
+};
+const getRegularImageAltTexts = (contentType, modifiedData) => {
+  const relations = ["localizations"];
+  const attributes = contentType?.attributes ?? {};
+  Object.keys(attributes).forEach((field) => {
+    if (attributes[field]?.type === "relation") {
+      relations.push(field);
+    }
+  });
+  const { alternativeTexts, imageNames } = recursiveSearch(
+    modifiedData ?? {},
+    "alternativeText",
+    relations
+  );
+  const alternativeTextCount = alternativeTexts.length;
+  const intersections = alternativeTexts.filter((altText) => imageNames.includes(altText)).length - alternativeTextCount;
+  return { intersections, altTexts: alternativeTexts };
+};
+const isPlainObject = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const matchesFieldType = (fieldProperties, fieldType) => {
+  if (!fieldProperties) return false;
+  if (fieldProperties.type === fieldType) return true;
+  if (fieldType === "richtext" && fieldProperties.type === "customField" && typeof fieldProperties.customField === "string" && fieldProperties.customField.toLowerCase().includes("richtext")) {
+    return true;
+  }
+  return false;
+};
+const collectFieldsByType = (contentType, components, fieldType) => {
+  const fields = [];
+  const attributes = contentType?.attributes ?? {};
+  const safeComponents = components ?? {};
+  Object.entries(attributes).forEach(([field, fieldProperties]) => {
+    if (matchesFieldType(fieldProperties, fieldType)) {
+      fields.push({ name: field, field: null });
+    } else if (fieldProperties?.type === "component" && fieldProperties.component) {
+      const compAttrs = safeComponents[fieldProperties.component]?.attributes ?? {};
+      Object.entries(compAttrs).forEach(([field2, fieldProperties2]) => {
+        if (matchesFieldType(fieldProperties2, fieldType)) {
+          fields.push({ name: field, field: field2 });
+        }
+      });
+    }
+  });
+  Object.entries(safeComponents).forEach(([componentName, componentData]) => {
+    const compAttrs = componentData?.attributes ?? {};
+    Object.entries(compAttrs).forEach(([field, fieldProperties]) => {
+      if (matchesFieldType(fieldProperties, fieldType)) {
+        fields.push({ name: componentName, field });
+      }
+    });
+  });
+  return fields;
+};
+const resolveAndDeduplicateFields = (fields, dynamicZones, modifiedData) => {
+  const updated = fields.map((entry) => ({ ...entry }));
+  const removedIndices = /* @__PURE__ */ new Set();
+  dynamicZones.forEach((dz) => {
+    const rawDz = modifiedData?.[dz];
+    const dynamicZoneData = Array.isArray(rawDz) ? rawDz.filter(isPlainObject) : [];
+    updated.forEach((field, index2) => {
+      if (removedIndices.has(index2)) return;
+      const componentExistsInDZ = dynamicZoneData.filter(
+        (x) => x.__component === field.name
+      );
+      if (componentExistsInDZ.length > 0 && !field.inDz && field.field && dynamicZoneData.some(
+        (x) => Object.prototype.hasOwnProperty.call(x, field.field)
+      )) {
+        updated[index2] = { ...field, inDz: dz };
+      } else if (componentExistsInDZ.length === 0 && field.inDz === dz) {
+        removedIndices.add(index2);
+      }
+    });
+  });
+  const seenKeys = /* @__PURE__ */ new Set();
+  const deduplicated = [];
+  updated.forEach((field, index2) => {
+    if (removedIndices.has(index2)) return;
+    if (field.field === null) {
+      const key2 = `root:${field.name}`;
+      if (!seenKeys.has(key2)) {
+        seenKeys.add(key2);
+        deduplicated.push(field);
+      }
+      return;
+    }
+    if (field.inDz) {
+      const key2 = `dz:${field.inDz}:${field.name}:${field.field}`;
+      if (!seenKeys.has(key2)) {
+        seenKeys.add(key2);
+        deduplicated.push(field);
+      }
+      return;
+    }
+    const compKey = field.name.split(".").pop() || field.name;
+    if (field.name.includes(".") && modifiedData?.[compKey] === void 0 && modifiedData?.[field.name] === void 0) {
+      return;
+    }
+    const key = `comp:${compKey}:${field.field}`;
+    if (!seenKeys.has(key)) {
+      seenKeys.add(key);
+      deduplicated.push(field);
+    }
+  });
+  return deduplicated;
+};
+const getRichTextAndBlocksFields = (contentType, components, modifiedData) => {
+  const dynamicZones = [];
+  Object.entries(modifiedData ?? {}).forEach(([fieldName, fieldValue]) => {
+    if (Array.isArray(fieldValue)) {
+      const isComponentField = fieldValue.some(
+        (subField) => isPlainObject(subField) && "__component" in subField
+      );
+      if (isComponentField) dynamicZones.push(fieldName);
+    }
+  });
+  const rawRichTextFields = collectFieldsByType(
+    contentType,
+    components,
+    "richtext"
+  );
+  const rawBlockFields = collectFieldsByType(contentType, components, "blocks");
+  return {
+    richTextFields: resolveAndDeduplicateFields(
+      rawRichTextFields,
+      dynamicZones,
+      modifiedData
+    ),
+    blockFields: resolveAndDeduplicateFields(
+      rawBlockFields,
+      dynamicZones,
+      modifiedData
+    )
+  };
+};
+const extractTextFromBlocks = (blocks) => {
+  let textContent = "";
+  blocks.forEach((block) => {
+    if (!block || typeof block !== "object") return;
+    if (block.type === "text" && typeof block.text === "string") {
+      textContent += `${block.text} `;
+    } else if (Array.isArray(block.children)) {
+      textContent += `${extractTextFromBlocks(block.children)} `;
+    } else if (Array.isArray(block.content)) {
+      textContent += `${extractTextFromBlocks(block.content)} `;
+    }
+  });
+  return textContent.trim();
+};
+const isImageElementMissingAlt = (element) => {
+  if (element.type !== "image" || !element.image) return false;
+  const alt = element.image.alternativeText;
+  return typeof alt !== "string" || alt.trim().length === 0;
+};
+const isMediaAttrElementMissingAlt = (element) => {
+  if (element.type === "image" && element.image) return false;
+  const isMediaType = element.type === "image" || element.type === "mediaLibraryImage";
+  if (!isMediaType || !element.attrs) return false;
+  const alt = element.attrs.alt ?? element.attrs.alternativeText;
+  return typeof alt !== "string" || alt.trim().length === 0;
+};
+const countMissingBlockImageAlts = (nodes) => {
+  let missingCount = 0;
+  nodes.forEach((element) => {
+    if (!element || typeof element !== "object") return;
+    if (isImageElementMissingAlt(element) || isMediaAttrElementMissingAlt(element)) {
+      missingCount += 1;
+    }
+    if (Array.isArray(element.children)) {
+      missingCount += countMissingBlockImageAlts(element.children);
+    }
+    if (Array.isArray(element.content)) {
+      missingCount += countMissingBlockImageAlts(element.content);
+    }
+  });
+  return missingCount;
+};
+const extractNodesFromParsedObject = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value && typeof value === "object") {
+    const obj = value;
+    if (Array.isArray(obj.content)) {
+      return obj.content;
+    }
+  }
+  return null;
+};
+const tryParseJsonStringNodes = (rawString) => {
+  const trimmed = rawString.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+    return null;
+  }
+  try {
+    return extractNodesFromParsedObject(JSON.parse(trimmed));
+  } catch {
+    return null;
+  }
+};
+const tryParseRichTextNodes = (rawValue) => {
+  if (typeof rawValue === "string") {
+    return tryParseJsonStringNodes(rawValue);
+  }
+  return extractNodesFromParsedObject(rawValue);
+};
+const formatAltFieldName = (field, name2) => {
+  if (!name2) return field;
+  if (name2.includes(".")) {
+    return `[dynamic-zone].${name2.split(".").pop()}.${field}`;
+  }
+  return `${name2}.${field}`;
+};
+const hasNonEmptyHtmlAlt = (imgTag) => {
+  const match = /\balt\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+))/i.exec(
+    imgTag
+  );
+  const val = match?.[1] ?? match?.[2] ?? match?.[3] ?? "";
+  return val.trim().length > 0;
+};
+const getEmptyAltCount = (richtext, field, name2, isBlock = false) => {
+  let htmlOccurrences = 0;
+  let markdownOccurrences = 0;
+  let blockOccurences = 0;
+  if (isBlock && Array.isArray(richtext)) {
+    blockOccurences = countMissingBlockImageAlts(
+      richtext
+    );
+  } else if (typeof richtext === "string" && richtext) {
+    const emptyMdImages = richtext.match(/!\[\s*\]\([^()[\]]*\)/g);
+    markdownOccurrences = emptyMdImages ? emptyMdImages.length : 0;
+    const htmlImages = richtext.match(/<img\b[^<>]*>/gi) || [];
+    htmlOccurrences = htmlImages.filter(
+      (image) => !hasNonEmptyHtmlAlt(image)
+    ).length;
+  }
+  return {
+    field: formatAltFieldName(field, name2),
+    occurences: markdownOccurrences + htmlOccurrences + blockOccurences
+  };
+};
+const stripMarkdownAndHtmlToWords = (input, isPlainTree) => {
+  const withoutMarkdown = isPlainTree ? input : input.replace(/!\[/g, " [").replace(/\[([^[\]]*)\]\([^()[\]]*\)/g, " $1 ").replace(/<[^<>]+>/g, " ").replace(/[#>*_`~-]+/g, " ");
+  return withoutMarkdown.replace(/\s+/g, " ").trim().toLowerCase().split(" ").filter((entry) => entry.length > 0);
+};
+const increaseCounter = (base, field, isBlock = false, name2 = null) => {
+  let richtext;
+  let emptyAlts;
+  let parsedAsTree = isBlock;
+  const rawValue = base?.[field];
+  const treeNodes = tryParseRichTextNodes(rawValue);
+  if (isBlock || treeNodes) {
+    const blocks = treeNodes ?? [];
+    richtext = extractTextFromBlocks(blocks);
+    emptyAlts = getEmptyAltCount(blocks, field, name2, true);
+    parsedAsTree = true;
+  } else {
+    richtext = typeof rawValue === "string" ? rawValue : "";
+    emptyAlts = getEmptyAltCount(richtext, field, name2);
+  }
+  if (richtext) {
+    const words = stripMarkdownAndHtmlToWords(richtext, parsedAsTree);
+    return { words, length: words.length, emptyAlts };
+  }
+  return { words: [], length: 0, emptyAlts };
+};
+const buildKeywordDensityObject = (keywords, words, keywordsDensity) => {
+  const tempKeywordsDensity = {};
+  Object.keys(keywordsDensity).forEach((key) => {
+    tempKeywordsDensity[key] = { count: keywordsDensity[key].count };
+  });
+  const joinedWords = words.join(" ");
+  keywords.forEach((keyword) => {
+    const trimmedKeyword = keyword.trim();
+    if (!trimmedKeyword) return;
+    const regex = new RegExp(
+      trimmedKeyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"),
+      "g"
+    );
+    const count = joinedWords ? (joinedWords.match(regex) || []).length : 0;
+    if (!Object.prototype.hasOwnProperty.call(tempKeywordsDensity, trimmedKeyword)) {
+      tempKeywordsDensity[trimmedKeyword] = { count };
+    } else {
+      tempKeywordsDensity[trimmedKeyword] = {
+        count: tempKeywordsDensity[trimmedKeyword].count + count
+      };
+    }
+  });
+  return tempKeywordsDensity;
+};
+const adjustIntersections = (data) => {
+  const { emptyAltCount } = data;
+  let occurrences = 0;
+  emptyAltCount.richTextAlts.forEach((alt) => {
+    occurrences += alt.occurences;
+  });
+  emptyAltCount.blockTextAlts.forEach((alt) => {
+    occurrences += alt.occurences;
+  });
+  emptyAltCount.intersections -= occurrences;
+  return data;
+};
+const recordIncrease = (acc, base, field, isBlock, name2 = null) => {
+  const { words, length, emptyAlts } = increaseCounter(
+    base,
+    field,
+    isBlock,
+    name2
+  );
+  acc.wordCount += length;
+  acc.targetAlts.push(emptyAlts);
+  acc.keywordsDensity = buildKeywordDensityObject(
+    acc.keywords,
+    words,
+    acc.keywordsDensity
+  );
+};
+const processComponentFieldItem = (acc, item, fallbackBase, field, isBlock, name2) => {
+  if (Array.isArray(item)) {
+    item.forEach((entry) => {
+      if (entry && typeof entry === "object") {
+        recordIncrease(
+          acc,
+          entry,
+          field,
+          isBlock,
+          name2
+        );
+      }
+    });
+  } else {
+    recordIncrease(acc, fallbackBase, field, isBlock, name2);
+  }
+};
+const processSingleFieldDescriptor = (acc, modifiedData, data, isBlock) => {
+  if (data.field === null) {
+    recordIncrease(acc, modifiedData, data.name, isBlock);
+    return;
+  }
+  if (!data.inDz) {
+    const compKey = data.name.split(".").pop() || "";
+    const item = modifiedData?.[compKey] ?? modifiedData?.[data.name];
+    if (item && typeof item === "object") {
+      processComponentFieldItem(
+        acc,
+        item,
+        item,
+        data.field,
+        isBlock,
+        data.name
+      );
+    }
+    return;
+  }
+  const rawDz = modifiedData?.[data.inDz];
+  const dzComponents = Array.isArray(rawDz) ? rawDz.filter(
+    (x) => Boolean(x) && typeof x === "object"
+  ) : [];
+  if (dzComponents.length === 0) return;
+  const matchingComponents = dzComponents.filter(
+    (x) => x.__component === data.name
+  );
+  matchingComponents.forEach((component) => {
+    const item = component?.[data.field] ?? [];
+    processComponentFieldItem(
+      acc,
+      item,
+      component,
+      data.field,
+      isBlock,
+      data.name
+    );
+  });
+};
+const getRichTextData = (modifiedData, components, contentType) => {
+  const { richTextFields, blockFields } = getRichTextAndBlocksFields(
+    contentType,
+    components,
+    modifiedData
+  );
+  const { intersections, altTexts } = getRegularImageAltTexts(
+    contentType,
+    modifiedData
+  );
+  const emptyAltCount = {
+    intersections,
+    richTextAlts: [],
+    blockTextAlts: [],
+    altTexts
+  };
+  const seoKeywords = modifiedData?.seo?.keywords ?? "";
+  const keywords = typeof seoKeywords === "string" && seoKeywords.trim().length > 0 ? seoKeywords.toLowerCase().split(",").map((k) => k.trim()).filter((k) => k.length > 0) : [];
+  const initialKeywordsDensity = {};
+  keywords.forEach((keyword) => {
+    initialKeywordsDensity[keyword] = { count: 0 };
+  });
+  const richTextAcc = {
+    wordCount: 0,
+    keywords,
+    keywordsDensity: initialKeywordsDensity,
+    targetAlts: emptyAltCount.richTextAlts
+  };
+  richTextFields.forEach((data) => {
+    processSingleFieldDescriptor(richTextAcc, modifiedData, data, false);
+  });
+  const blockAcc = {
+    wordCount: richTextAcc.wordCount,
+    keywords,
+    keywordsDensity: richTextAcc.keywordsDensity,
+    targetAlts: emptyAltCount.blockTextAlts
+  };
+  blockFields.forEach((data) => {
+    processSingleFieldDescriptor(blockAcc, modifiedData, data, true);
+  });
+  return adjustIntersections({
+    wordCount: blockAcc.wordCount,
+    keywordsDensity: blockAcc.keywordsDensity,
+    emptyAltCount
+  });
+};
+const BG_PATH = [
+  "M134.933 17.417C137.768 17.417 140.067 19.7153 140.067 22.5503",
+  "C140.067 25.3854 137.768 27.6837 134.933 27.6837H105.6",
+  "C108.435 27.6837 110.733 29.9819 110.733 32.817",
+  "C110.733 35.6521 108.435 37.9503 105.6 37.9503H121.733",
+  "C124.568 37.9503 126.867 40.2486 126.867 43.0837",
+  "C126.867 45.9187 124.568 48.217 121.733 48.217H114.272",
+  "C110.698 48.217 107.8 50.5153 107.8 53.3503",
+  "C107.8 55.2404 109.267 56.9515 112.2 58.4837",
+  "C115.035 58.4837 117.333 60.7819 117.333 63.617",
+  "C117.333 66.4521 115.035 68.7503 112.2 68.7503H51.3333",
+  "C48.4982 68.7503 46.2 66.4521 46.2 63.617",
+  "C46.2 60.7819 48.4982 58.4837 51.3333 58.4837H22.7333",
+  "C19.8982 58.4837 17.6 56.1854 17.6 53.3503",
+  "C17.6 50.5153 19.8982 48.217 22.7333 48.217H52.0666",
+  "C54.9017 48.217 57.2 45.9187 57.2 43.0837",
+  "C57.2 40.2486 54.9017 37.9503 52.0666 37.9503H33.7333",
+  "C30.8982 37.9503 28.6 35.6521 28.6 32.817",
+  "C28.6 29.9819 30.8982 27.6837 33.7333 27.6837H63.0666",
+  "C60.2316 27.6837 57.9333 25.3854 57.9333 22.5503",
+  "C57.9333 19.7153 60.2316 17.417 63.0666 17.417H134.933Z",
+  "M134.933 37.9503C137.768 37.9503 140.067 40.2486 140.067 43.0837",
+  "C140.067 45.9187 137.768 48.217 134.933 48.217",
+  "C132.098 48.217 129.8 45.9187 129.8 43.0837",
+  "C129.8 40.2486 132.098 37.9503 134.933 37.9503Z"
+].join("");
+const CARD_FILL_PATH = [
+  "M95.826 16.6834L102.647 66.4348L103.26 71.4261",
+  "C103.458 73.034 102.314 74.4976 100.706 74.695L57.7621 79.9679",
+  "C56.1542 80.1653 54.6906 79.0219 54.4932 77.4139L47.8816 23.5671",
+  "C47.7829 22.7631 48.3546 22.0313 49.1586 21.9326",
+  "C49.1637 21.932 49.1688 21.9313 49.1739 21.9307L52.7367 21.5311",
+  "L95.826 16.6834ZM55.6176 21.208L58.9814 20.8306Z"
+].join("");
+const CARD_STROKE_PATH = [
+  "M55.6176 21.208L58.9814 20.8306M95.826 16.6834L102.647 66.4348",
+  "L103.26 71.4261C103.458 73.034 102.314 74.4976 100.706 74.695",
+  "L57.7621 79.9679C56.1542 80.1653 54.6906 79.0219 54.4932 77.4139",
+  "L47.8816 23.5671C47.7829 22.7631 48.3546 22.0313 49.1586 21.9326",
+  "C49.1637 21.932 49.1688 21.9313 49.1739 21.9307L52.7367 21.5311",
+  "L95.826 16.6834Z"
+].join("");
+const INNER_CARD_PATH = [
+  "M93.9695 19.8144L100.144 64.9025L100.699 69.4258",
+  "C100.878 70.8831 99.8559 72.2077 98.416 72.3845L59.9585 77.1065",
+  "C58.5185 77.2833 57.2062 76.2453 57.0272 74.7881L51.0506 26.112",
+  "C50.9519 25.308 51.5236 24.5762 52.3276 24.4775L57.0851 23.8934"
+].join("");
+const DOC_PATH = [
+  "M97.701 7.33301H64.2927C63.7358 7.33301 63.2316 7.55873 62.8667 7.92368",
+  "C62.5017 8.28862 62.276 8.79279 62.276 9.34967V65.083",
+  "C62.276 65.6399 62.5017 66.1441 62.8667 66.509",
+  "C63.2316 66.874 63.7358 67.0997 64.2927 67.0997H107.559",
+  "C108.116 67.0997 108.62 66.874 108.985 66.509",
+  "C109.35 66.1441 109.576 65.6399 109.576 65.083V19.202",
+  "C109.576 18.6669 109.363 18.1537 108.985 17.7755L99.1265 7.92324",
+  "C98.7484 7.54531 98.2356 7.33301 97.701 7.33301Z"
+].join("");
+const FOLD_PATH = "M98.026 8.17871V16.6833C98.026 17.8983 99.011 18.8833 100.226 18.8833H106.044";
+const LINES_PATH = [
+  "M70.1594 56.2838H89.2261M70.1594 18.8838H89.2261H70.1594Z",
+  "M70.1594 27.6838H101.693H70.1594ZM70.1594 37.2171H101.693H70.1594Z",
+  "M70.1594 46.7505H101.693H70.1594Z"
+].join("");
+const Illo = () => /* @__PURE__ */ jsxRuntime.jsxs(
+  "svg",
+  {
+    width: "159",
+    height: "88",
+    viewBox: "0 0 159 88",
+    fill: "none",
+    xmlns: "http://www.w3.org/2000/svg",
+    children: [
+      /* @__PURE__ */ jsxRuntime.jsx("path", { fillRule: "evenodd", clipRule: "evenodd", d: BG_PATH, fill: "#DBDBFA" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: CARD_FILL_PATH,
+          fill: "white"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx("path", { d: CARD_STROKE_PATH, stroke: "#7E7BF6", strokeWidth: "2.5" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: INNER_CARD_PATH,
+          fill: "#F0F0FF"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          fillRule: "evenodd",
+          clipRule: "evenodd",
+          d: DOC_PATH,
+          fill: "white",
+          stroke: "#7F7CFA",
+          strokeWidth: "2.5"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: FOLD_PATH,
+          stroke: "#807EFA",
+          strokeWidth: "2.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "path",
+        {
+          d: LINES_PATH,
+          stroke: "#817FFA",
+          strokeWidth: "2.5",
+          strokeLinecap: "round",
+          strokeLinejoin: "round"
+        }
+      )
+    ]
+  }
+);
+const SEOAccordion = ({
+  title,
+  status,
+  component,
+  label
+}) => {
+  const getIcon = () => {
+    switch (status?.qualityVerdict) {
+      case qualityVerdict.good:
+        return icons.CheckCircle;
+      case qualityVerdict.improvements:
+        return icons.WarningCircle;
+      case qualityVerdict.bad:
+        return icons.CrossCircle;
+      default:
+        return icons.WarningCircle;
+    }
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Root, { children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Accordion.Item, { value: "acc-01", children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Accordion.Header, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Trigger, { icon: getIcon(), children: title }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Accordion.Actions, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.IconButton, { label, children: /* @__PURE__ */ jsxRuntime.jsx(icons.Information, {}) }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Accordion.Content, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, paddingLeft: 4, paddingBottom: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", children: status?.message }) }),
+      component
+    ] })
+  ] }) });
+};
+const AlternativeTextCheck = ({
+  intersections,
+  richTextAlts,
+  altTexts,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.alternativeTextCheck.default"),
+        defaultMessage: "All your images contain an alt attribute! Congrats!"
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    const missingRichTextAlt = richTextAlts.filter(
+      (x) => x.occurences !== 0
+    ).length;
+    if (intersections === 0) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.alternativeTextCheck.intersection-zero"),
+          defaultMessage: "The name and the alternative text of your images are all the same. Strapi automatically generate the alt attribute from the name by default if the field was empty during the media upload. Having alt attribute clearly describing images is a very good practice."
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    } else if (altTexts.includes("")) {
+      const count = Math.abs(intersections ?? 0);
+      status = {
+        message: `${count} ${formatMessage({
+          id: getTrad("SEOChecks.alternativeTextCheck.intersection-negative"),
+          defaultMessage: "Some images from a media field are missing an alt attribute."
+        })}`,
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else if (missingRichTextAlt >= 1) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.alternativeTextCheck.richtext-missing-one"),
+          defaultMessage: "At least one image in any 1st level richtext editor is missing an alt attribute."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    }
+    if (!isSameCheckStatus(status, checks.alternativeText) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "alternativeText" }
+      });
+    }
+  }, [intersections, richTextAlts, altTexts]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.alt-attributes"),
+        defaultMessage: "Alternative Text"
+      }),
+      status: checks.alternativeText,
+      label: formatMessage({
+        id: getTrad("SEOChecks.alternativeTextCheck.label"),
+        defaultMessage: "This will check if you have any missing alternative text for your images (media fields) and in your 1st level richtext editors."
+      }),
+      component: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 2, background: "neutral100", children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { spacing: 2, horizontal: true, padding: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { paddingLeft: 1, children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { fontWeight: "bold", children: [
+              altTexts.filter((item) => item === "").length,
+              " "
+            ] }),
+            formatMessage({
+              id: getTrad("SEOChecks.alternativeTextCheck.missing-image"),
+              defaultMessage: "missing on first level image fields or inside a component."
+            })
+          ] })
+        ] }),
+        richTextAlts.map((alt, index2) => /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { spacing: 2, horizontal: true, padding: 2, children: alt.occurences > 0 && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" }),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { paddingLeft: 1, children: [
+            /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { fontWeight: "bold", children: [
+              alt.occurences,
+              " "
+            ] }),
+            formatMessage({
+              id: getTrad(
+                "SEOChecks.alternativeTextCheck.missing-text"
+              ),
+              defaultMessage: "missing alt in the following richtext field:"
+            }),
+            /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { fontWeight: "bold", children: [
+              " ",
+              alt.field
+            ] })
+          ] })
+        ] }) }, index2)),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Flex,
+          {
+            spacing: 2,
+            paddingTop: 4,
+            paddingLeft: 2,
+            paddingRight: 2,
+            paddingBottom: 4,
+            children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Status, { variant: "secondary", showBullet: false, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { fontWeight: "bold", children: [
+                formatMessage({
+                  id: getTrad("SEOChecks.alternativeTextCheck.tip-label"),
+                  defaultMessage: "Tip:"
+                }),
+                " "
+              ] }),
+              formatMessage({
+                id: getTrad("SEOChecks.alternativeTextCheck.tip-before"),
+                defaultMessage: "Implement a rule in your front-end code that uses the name of your images if the"
+              }),
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { fontWeight: "bold", children: " alternativeText " }),
+              formatMessage({
+                id: getTrad("SEOChecks.alternativeTextCheck.tip-after"),
+                defaultMessage: "field is empty to further reduce the risk of an empty alt attribute on your website."
+              })
+            ] }) })
+          }
+        )
+      ] })
+    }
+  );
+};
+const CanonicalUrlCheck = ({
+  canonicalUrl,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.canonicalUrlCheck.found"),
+        defaultMessage: "A canonical URL has been found."
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (typeof canonicalUrl !== "string" || isEmptyValue(canonicalUrl)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.canonicalUrlCheck.default"),
+          defaultMessage: "No Canonical URL has been found."
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    }
+    if (!isSameCheckStatus(status, checks.canonicalUrl) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "canonicalUrl" }
+      });
+    }
+  }, [canonicalUrl]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.canonical-url"),
+        defaultMessage: "Canonical URL"
+      }),
+      status: checks.canonicalUrl,
+      label: formatMessage({
+        id: getTrad("SEOChecks.canonicalUrlCheck.label"),
+        defaultMessage: "This will check if you have a canonical URL."
+      }),
+      component: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: canonicalUrl ? 4 : 0, background: "neutral100", children: canonicalUrl && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "bold", children: canonicalUrl }) })
+    }
+  );
+};
+const KeywordDensityCheck = ({
+  keywordsDensity,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.keywordsDensityCheck.default"),
+        defaultMessage: "Every keywords are used more than 2 times."
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (isEmptyValue(keywordsDensity)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.keywordsDensityCheck.no-keywords"),
+          defaultMessage: "No keywords were found in your SEO component."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else {
+      let hasUnused = false;
+      let hasUsedOnce = false;
+      Object.keys(keywordsDensity).forEach((keyword) => {
+        const count = keywordsDensity[keyword]?.count ?? 0;
+        if (count === 0) {
+          hasUnused = true;
+        } else if (count <= 1) {
+          hasUsedOnce = true;
+        }
+      });
+      if (hasUsedOnce) {
+        status = {
+          message: formatMessage({
+            id: getTrad("SEOChecks.keywordsDensityCheck.one-used-once"),
+            defaultMessage: "One keyword is only used once in your content."
+          }),
+          qualityVerdict: qualityVerdict.bad
+        };
+      } else if (hasUnused) {
+        status = {
+          message: formatMessage({
+            id: getTrad("SEOChecks.keywordsDensityCheck.one-not-used"),
+            defaultMessage: "One keyword is not being used in your content."
+          }),
+          qualityVerdict: qualityVerdict.improvements
+        };
+      }
+    }
+    if (!isSameCheckStatus(status, checks.keywordsDensity) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "keywordsDensity" }
+      });
+    }
+  }, [keywordsDensity]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.word-densisty"),
+        defaultMessage: "Keyword Density"
+      }),
+      status: checks.keywordsDensity,
+      label: formatMessage({
+        id: getTrad("SEOChecks.keywordsDensityCheck.label"),
+        defaultMessage: "Define keywords you want to rank for in your SEO component. This will analyse the density of your keywords in your 1st level richtext editors."
+      }),
+      component: keywordsDensity && !isEmptyValue(keywordsDensity) && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 2, background: "neutral100", children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { wrap: "wrap", children: Object.keys(keywordsDensity).map((keyword) => {
+        const count = (keywordsDensity[keyword]?.count ?? 0).toString();
+        return /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { children: `${keyword}: ${count}` }) }, keyword);
+      }) }) })
+    }
+  );
+};
+const LastUpdatedAtCheck = ({
+  updatedAt,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  const parsedTimestamp = typeof updatedAt === "string" && !isEmptyValue(updatedAt) ? Date.parse(updatedAt) : Number.NaN;
+  const isValidUpdatedAt = !Number.isNaN(parsedTimestamp);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.lastUpdatedAtCheck.default"),
+        defaultMessage: "This content was modified over a year ago! Search engines love fresh content."
+      }),
+      qualityVerdict: qualityVerdict.improvements
+    };
+    if (!isValidUpdatedAt) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.lastUpdatedAtCheck.save-content"),
+          defaultMessage: "You must save this entry first."
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    } else {
+      const oneYearAgoDate = /* @__PURE__ */ new Date();
+      oneYearAgoDate.setFullYear(oneYearAgoDate.getFullYear() - 1);
+      if (parsedTimestamp >= oneYearAgoDate.getTime()) {
+        status = {
+          message: formatMessage({
+            id: getTrad("SEOChecks.lastUpdatedAtCheck.success"),
+            defaultMessage: "Awesome! This content was last modified in less than an year ago!"
+          }),
+          qualityVerdict: qualityVerdict.good
+        };
+      }
+    }
+    if (!isSameCheckStatus(status, checks.lastUpdatedAt) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "lastUpdatedAt" }
+      });
+    }
+  }, [updatedAt, isValidUpdatedAt, parsedTimestamp]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.last-updated-at"),
+        defaultMessage: "Last updated at"
+      }),
+      label: formatMessage({
+        id: getTrad("SEOChecks.lastUpdatedAtCheck.label"),
+        defaultMessage: "Search engines love fresh content. This will check if your entry was last modified in less than an year ago."
+      }),
+      status: checks.lastUpdatedAt,
+      component: isValidUpdatedAt && updatedAt && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, background: "neutral100", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "omega", children: [
+        formatMessage({
+          id: getTrad("SEOChecks.lastUpdatedAtCheck.last"),
+          defaultMessage: "Last updated at:"
+        }),
+        " ",
+        /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "omega", fontWeight: "bold", children: [
+          " ",
+          dateFns.formatDistance(new Date(updatedAt), /* @__PURE__ */ new Date(), {
+            addSuffix: true
+          })
+        ] })
+      ] }) })
+    }
+  );
+};
+const MetaDescriptionCheck = ({
+  metaDescription,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  const maxLength = 160;
+  const minimumLength = 50;
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.metaDescriptionCheck.default"),
+        defaultMessage: "A Meta Description has been found!"
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (typeof metaDescription !== "string" || isEmptyValue(metaDescription)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.metaDescriptionCheck.not-found"),
+          defaultMessage: "No Meta Description has been found."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else if (metaDescription.length > maxLength) {
+      status = {
+        message: formatMessage({
+          id: getTrad("Title-settings.metaDescription-too-long"),
+          defaultMessage: "Meta Description is too long"
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    } else if (metaDescription.length < minimumLength) {
+      status = {
+        message: formatMessage({
+          id: getTrad("Title-settings.metaDescription-too-short"),
+          defaultMessage: "Meta Description is too short"
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    }
+    if (!isSameCheckStatus(status, checks.metaDescription) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "metaDescription" }
+      });
+    }
+  }, [metaDescription]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.meta-description"),
+        defaultMessage: "Meta description"
+      }),
+      status: checks.metaDescription,
+      label: formatMessage({
+        id: getTrad("Title-settings.metaDescription-tooltip"),
+        defaultMessage: `A meta description is an HTML tag used to describe the content of a web page.
+ This description appears below the title and URL of your page as it appears in search engine results.
+ For it to remain visible in Google, it must not exceed 140-${maxLength} characters.`
+      }),
+      component: metaDescription && /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 4, background: "neutral100", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "semiBold", children: metaDescription }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { horizontal: true, spacing: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.ProgressBar,
+            {
+              value: metaDescription.length * 100 / maxLength > 100 ? 100 : metaDescription.length * 100 / maxLength
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "pi", padding: 2, children: [
+            "(",
+            metaDescription.length,
+            "/",
+            maxLength,
+            ")"
+          ] })
+        ] }) })
+      ] })
+    }
+  );
+};
+const robotTags = [
+  { name: "noindex", message: "Search engines will index this page." },
+  {
+    name: "nofollow",
+    message: "Search engines will follow links from this page"
+  },
+  { name: "noarchive", message: "Search engines will cache your page." },
+  {
+    name: "nosnippet",
+    message: "Search engines will show a snippet of this page in search results."
+  },
+  {
+    name: "noimageindex",
+    message: "Google will index the images on this page."
+  },
+  {
+    name: "nositelinkssearchbox",
+    message: "Google will show the search box in search results."
+  }
+];
+const MetaRobotCheck = ({ metaRobots, checks }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  const [tags, setTags] = React__namespace.useState([]);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.metaRobotsCheck.default"),
+        defaultMessage: "Robot meta tags have been found!"
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (typeof metaRobots !== "string" || isEmptyValue(metaRobots)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.metaRobotsCheck.not-found"),
+          defaultMessage: "No Robot meta tags have been found."
+        }),
+        qualityVerdict: qualityVerdict.good
+      };
+      setTags([]);
+    } else {
+      setTags(metaRobots.split(","));
+    }
+    if (!isSameCheckStatus(status, checks.metaRobots) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "metaRobots" }
+      });
+    }
+  }, [metaRobots]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.meta-robots"),
+        defaultMessage: "Meta Robots"
+      }),
+      status: checks.metaRobots,
+      label: formatMessage({
+        id: getTrad("SEOChecks.metaRobotsCheck.label"),
+        defaultMessage: "The robots meta tag informs search engines which pages on your site should be indexed and more."
+      }),
+      component: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 2, background: "neutral100", children: [
+        robotTags.map((tag, index2) => /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { spacing: 2, horizontal: true, padding: 2, children: [
+          tags.find((x) => x.trim() === tag.name) ? /* @__PURE__ */ jsxRuntime.jsx(icons.CheckCircle, { "aria-hidden": true, fill: "success600" }) : /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" }),
+          /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { paddingLeft: 1, children: tags.find((x) => x.trim() === tag.name) ? formatMessage(
+            {
+              id: getTrad("SEOChecks.metaRobotsCheck.activated"),
+              defaultMessage: "{tag} is activated: {message}"
+            },
+            {
+              tag: tag.name,
+              message: tag.message.replace("will", "will not")
+            }
+          ) : formatMessage(
+            {
+              id: getTrad("SEOChecks.metaRobotsCheck.disabled"),
+              defaultMessage: "{tag} is disabled: {message}"
+            },
+            {
+              tag: tag.name,
+              message: tag.message
+            }
+          ) })
+        ] }, index2)),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          designSystem.Flex,
+          {
+            spacing: 2,
+            paddingTop: 4,
+            paddingLeft: 2,
+            paddingRight: 2,
+            paddingBottom: 4,
+            children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Status, { variant: "secondary", showBullet: false, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { fontWeight: "bold", children: [
+                formatMessage({
+                  id: getTrad("SEOChecks.metaRobotsCheck.notice-label"),
+                  defaultMessage: "Notice:"
+                }),
+                " "
+              ] }),
+              formatMessage({
+                id: getTrad("SEOChecks.metaRobotsCheck.notice-before"),
+                defaultMessage: "In order to not index your entry and no follow, your MetaRobots field should contain the following:"
+              }),
+              " ",
+              /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { fontWeight: "bold", children: formatMessage({
+                id: getTrad("SEOChecks.metaRobotsCheck.notice-value"),
+                defaultMessage: "noindex, nofollow"
+              }) }),
+              formatMessage({
+                id: getTrad("SEOChecks.metaRobotsCheck.notice-after"),
+                defaultMessage: '. The rest should be handled by your front-end code logic. "If the field contains noindex, then you need to create the corresponding meta tag etc..."'
+              })
+            ] }) })
+          }
+        )
+      ] })
+    }
+  );
+};
+const MetaTitleCheck = ({ metaTitle, checks }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  const maxLength = 60;
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.metaTitleCheck.default"),
+        defaultMessage: "A Meta Title has been found!"
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (typeof metaTitle !== "string" || isEmptyValue(metaTitle)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.metaTitleCheck.not-found"),
+          defaultMessage: "No Meta Title has been found."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else if (metaTitle.length > maxLength) {
+      status = {
+        message: formatMessage({
+          id: getTrad("Title-settings.metaTitle-too-long"),
+          defaultMessage: "Meta Title is too long"
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    }
+    if (!isSameCheckStatus(status, checks.metaTitle) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "metaTitle" }
+      });
+    }
+  }, [metaTitle]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.meta-title"),
+        defaultMessage: "Meta title"
+      }),
+      status: checks.metaTitle,
+      label: formatMessage({
+        id: getTrad("Title-settings.metaTitle-tooltip"),
+        defaultMessage: "The title tag is the clickable title of a webpage that appears with the result on the SERP (search engine page results page).\n You should aim to make your SEO titles around 60 characters long. Clear title tags will go a long way towards making your website easy to read and understand."
+      }),
+      component: metaTitle && /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 4, background: "neutral100", children: [
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "omega", fontWeight: "semiBold", children: metaTitle }),
+        /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { horizontal: true, spacing: 2, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            designSystem.ProgressBar,
+            {
+              size: "M",
+              value: metaTitle.length * 100 / maxLength > 100 ? 100 : metaTitle.length * 100 / maxLength
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "pi", padding: 2, children: [
+            "(",
+            metaTitle.length,
+            "/",
+            maxLength,
+            ")"
+          ] })
+        ] }) })
+      ] })
+    }
+  );
+};
+const OpenGraphCheck = ({ openGraph, checks }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status;
+    if (!openGraph || typeof openGraph !== "object") {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.openGraphCheck.not-found"),
+          defaultMessage: "No OpenGraph tags have been found."
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    } else if (isEmptyValue(openGraph.ogTitle) || isEmptyValue(openGraph.ogDescription) || !openGraph.ogImage) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.openGraphCheck.not-configured"),
+          defaultMessage: "OpenGraph minimum required tags are not configured."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.openGraphCheck.configured"),
+          defaultMessage: "OpenGraph tags are configured"
+        }),
+        qualityVerdict: qualityVerdict.good
+      };
+    }
+    if (!isSameCheckStatus(status, checks.openGraph) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "openGraph" }
+      });
+    }
+  }, [openGraph]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.open-graph"),
+        defaultMessage: "OpenGraph Tags"
+      }),
+      status: checks.openGraph,
+      label: formatMessage({
+        id: getTrad("SEOChecks.openGraphCheck.label"),
+        defaultMessage: "OpenGraph tags allow you to manage the title, description & image of your posts."
+      })
+    }
+  );
+};
+const StructuredDataCheck = ({
+  structuredData,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.structuredDataCheck.default"),
+        defaultMessage: "A Structured Data json has been found! However we can validate the accuracy of its content."
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (isEmptyValue(structuredData)) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.structuredDataCheck.not-found"),
+          defaultMessage: "No Structured Data json has been found."
+        }),
+        qualityVerdict: qualityVerdict.bad
+      };
+    }
+    if (!isSameCheckStatus(status, checks.structuredData) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "structuredData" }
+      });
+    }
+  }, [structuredData]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.structured-data"),
+        defaultMessage: "JSON Structured Data"
+      }),
+      status: checks.structuredData,
+      label: formatMessage({
+        id: getTrad("SEOChecks.structuredDataCheck.label"),
+        defaultMessage: "Structured data is a standardized format for providing information about a page and classifying the page content."
+      })
+    }
+  );
+};
+const WordCountCheck = ({ wordCount, checks }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const dispatch = React__namespace.useContext(SeoCheckerContext);
+  React__namespace.useEffect(() => {
+    let status = {
+      message: formatMessage({
+        id: getTrad("SEOChecks.wordCountCheck.default"),
+        defaultMessage: "You have more than 300 words. The word counter is not a direct ranking factor. But your content should be as high quality as possible, with relevant and unique information. To meet these conditions, your content requires a minimum of paragraphs, and therefore of words."
+      }),
+      qualityVerdict: qualityVerdict.good
+    };
+    if (typeof wordCount !== "number") {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.wordCountCheck.not-found"),
+          defaultMessage: "No Richtext content have been found."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    } else if (wordCount < 300) {
+      status = {
+        message: formatMessage({
+          id: getTrad("SEOChecks.wordCountCheck.300"),
+          defaultMessage: "Your 1st level Richtext contents have less than 300 words."
+        }),
+        qualityVerdict: qualityVerdict.improvements
+      };
+    }
+    if (!isSameCheckStatus(status, checks.wordCount) && dispatch) {
+      dispatch({
+        type: "UPDATE_PONCTUAL",
+        value: { ...status, entity: "wordCount" }
+      });
+    }
+  }, [wordCount]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    SEOAccordion,
+    {
+      title: formatMessage({
+        id: getTrad("SEOModal.summary-title.word-counter"),
+        defaultMessage: "Word Counter"
+      }),
+      status: checks.wordCount,
+      label: formatMessage({
+        id: getTrad("SEOChecks.wordCountCheck.label"),
+        defaultMessage: "Your content should be as high quality as possible, with relevant and unique information. You entry requires a minimum of paragraphs, and therefore of words."
+      }),
+      component: typeof wordCount === "number" && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { padding: 4, background: "neutral100", children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { variant: "omega", fontWeight: "bold", children: [
+        formatMessage({
+          id: getTrad("SEOChecks.wordCountCheck.words"),
+          defaultMessage: "Words:"
+        }),
+        " ",
+        wordCount
+      ] }) })
+    }
+  );
+};
+const BasicMetaChecksSection = ({
+  seo,
+  checks,
+  wordCount,
+  keywordsDensity
+}) => /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+  checks?.metaTitle && /* @__PURE__ */ jsxRuntime.jsx(MetaTitleCheck, { metaTitle: seo.metaTitle ?? null, checks }),
+  checks?.metaDescription && /* @__PURE__ */ jsxRuntime.jsx(
+    MetaDescriptionCheck,
+    {
+      metaDescription: seo.metaDescription ?? null,
+      checks
+    }
+  ),
+  checks?.wordCount && /* @__PURE__ */ jsxRuntime.jsx(WordCountCheck, { wordCount, checks }),
+  checks?.keywordsDensity && /* @__PURE__ */ jsxRuntime.jsx(KeywordDensityCheck, { keywordsDensity, checks })
+] });
+const TechnicalMetaChecksSection = ({
+  seo,
+  checks
+}) => /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+  checks?.openGraph && /* @__PURE__ */ jsxRuntime.jsx(OpenGraphCheck, { openGraph: seo.openGraph ?? null, checks }),
+  checks?.canonicalUrl && /* @__PURE__ */ jsxRuntime.jsx(
+    CanonicalUrlCheck,
+    {
+      canonicalUrl: seo.canonicalURL ?? null,
+      checks
+    }
+  ),
+  checks?.structuredData && /* @__PURE__ */ jsxRuntime.jsx(
+    StructuredDataCheck,
+    {
+      structuredData: seo.structuredData ?? null,
+      checks
+    }
+  ),
+  checks?.metaRobots && /* @__PURE__ */ jsxRuntime.jsx(MetaRobotCheck, { metaRobots: seo.metaRobots ?? null, checks })
+] });
+const MediaAndFreshnessChecksSection = ({
+  checks,
+  emptyAltCount,
+  updatedAt
+}) => /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+  checks?.alternativeText && /* @__PURE__ */ jsxRuntime.jsx(
+    AlternativeTextCheck,
+    {
+      intersections: emptyAltCount?.intersections ?? null,
+      richTextAlts: [
+        ...emptyAltCount?.richTextAlts ?? [],
+        ...emptyAltCount?.blockTextAlts ?? []
+      ],
+      altTexts: emptyAltCount?.altTexts ?? [],
+      checks
+    }
+  ),
+  checks?.lastUpdatedAt && /* @__PURE__ */ jsxRuntime.jsx(LastUpdatedAtCheck, { updatedAt, checks })
+] });
+const SeoChecks = ({
+  updatedAt,
+  modifiedData,
+  components,
+  contentType,
+  checks
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const { wordCount, keywordsDensity, emptyAltCount } = getRichTextData(
+    modifiedData,
+    components,
+    contentType
+  );
+  const seo = modifiedData?.seo ?? null;
+  const hasSeo = Boolean(seo && Object.keys(seo).length > 0);
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Content, { labelledBy: "title", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Typography,
+      {
+        fontWeight: "bold",
+        textColor: "neutral800",
+        tag: "h2",
+        id: "title",
+        children: formatMessage({
+          id: getTrad("Button.seo-analyze"),
+          defaultMessage: "SEO Analyze"
+        })
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: hasSeo && seo ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        BasicMetaChecksSection,
+        {
+          seo,
+          checks,
+          wordCount,
+          keywordsDensity
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(TechnicalMetaChecksSection, { seo, checks }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        MediaAndFreshnessChecksSection,
+        {
+          checks,
+          emptyAltCount,
+          updatedAt
+        }
+      )
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.EmptyStateLayout,
+      {
+        icon: /* @__PURE__ */ jsxRuntime.jsx(Illo, {}),
+        content: formatMessage({
+          id: getTrad("Modal.seo-component-empty"),
+          defaultMessage: "Your SEO component is empty..."
+        })
+      }
+    ) }) })
+  ] });
+};
+const KeywordCheck = ({ item, keywords, label }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const normalizedKeywords = keywords.split(",").map((x) => x.trim()).filter((x) => x.length > 0);
+  const matches = normalizedKeywords.filter(
+    (x) => item.toLowerCase().includes(x.toLowerCase())
+  );
+  const getIcon = () => {
+    if (matches.length === 0) {
+      return /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(icons.CheckCircle, { "aria-hidden": true, fill: "success600" });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { spacing: 1, horizontal: true, children: [
+    getIcon(),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: formatMessage(
+      {
+        id: getTrad("SEOSocialPreview.keyword-check"),
+        defaultMessage: "You use {count} keyword(s) in your {label} ({matches})"
+      },
+      {
+        count: matches.length,
+        label,
+        matches: matches.join(", ").trim()
+      }
+    ) })
+  ] });
+};
+const MetaChecks = ({
+  item,
+  max,
+  label,
+  minLimit = false
+}) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const getIcon = () => {
+    if (item.length >= max || label === "title" && item.length === 0 || minLimit && label === "description" && item.length <= 50) {
+      return /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(icons.CheckCircle, { "aria-hidden": true, fill: "success600" });
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { spacing: 1, horizontal: true, children: [
+    getIcon(),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { children: formatMessage(
+      {
+        id: getTrad("SEOSocialPreview.meta-length-check"),
+        defaultMessage: "Your {label} is {length} characters long (max {max})"
+      },
+      {
+        label,
+        length: item.length || 0,
+        max
+      }
+    ) })
+  ] });
+};
+const Serp = ({ metaTitle, metaDescription }) => {
+  const metaTitleToDisplay = metaTitle.length > 60 ? `${metaTitle.substring(0, 56)} ...` : metaTitle;
+  const metaDescriptionToDisplay = metaDescription.length > 160 ? `${metaDescription.substring(0, 156)} ...` : metaDescription;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { padding: 4, background: "neutral100", width: "100%", maxWidth: "580px", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "beta", textColor: "primary600", children: metaTitleToDisplay }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { marginTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Typography, { variant: "pi", textColor: "neutral600", children: metaDescriptionToDisplay }) })
+  ] });
+};
+const BrowserPreview = ({ modifiedData }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const seo = modifiedData?.seo ?? null;
+  const metaTitle = seo?.metaTitle ?? null;
+  const metaDescription = seo?.metaDescription ?? null;
+  const keywords = seo?.keywords ?? null;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Content, { labelledBy: "title", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Typography,
+      {
+        fontWeight: "bold",
+        textColor: "neutral800",
+        tag: "h2",
+        id: "title",
+        children: formatMessage({
+          id: getTrad("Button.browser-preview"),
+          defaultMessage: "Browser Preview"
+        })
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: seo ? /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { direction: "column", gap: 2, alignItems: "flex-start", children: [
+      metaTitle && metaDescription && /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingBottom: 6, children: /* @__PURE__ */ jsxRuntime.jsx(Serp, { metaTitle, metaDescription }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Divider, { marginBottom: 4, width: "100%" }),
+      metaTitle && /* @__PURE__ */ jsxRuntime.jsx(MetaChecks, { item: metaTitle, max: 60, label: "title" }),
+      metaDescription && /* @__PURE__ */ jsxRuntime.jsx(
+        MetaChecks,
+        {
+          item: metaDescription,
+          max: 160,
+          label: "description",
+          minLimit: true
+        }
+      ),
+      keywords && /* @__PURE__ */ jsxRuntime.jsxs(React__namespace.Fragment, { children: [
+        metaTitle && /* @__PURE__ */ jsxRuntime.jsx(
+          KeywordCheck,
+          {
+            item: metaTitle,
+            keywords,
+            label: "title"
+          }
+        ),
+        metaDescription && /* @__PURE__ */ jsxRuntime.jsx(
+          KeywordCheck,
+          {
+            item: metaDescription,
+            keywords,
+            label: "description"
+          }
+        )
+      ] })
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.EmptyStateLayout,
+      {
+        icon: /* @__PURE__ */ jsxRuntime.jsx(Illo, {}),
+        content: formatMessage({
+          id: getTrad("Modal.seo-component-empty"),
+          defaultMessage: "Your SEO component is empty..."
+        })
+      }
+    ) }) })
+  ] });
+};
+const toSafeImageUrl$2 = (rawUrl) => {
+  if (typeof rawUrl !== "string") return "";
+  const trimmed = rawUrl.trim();
+  if (trimmed.startsWith("https://") || trimmed.startsWith("http://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return "";
+};
+const FacebookOGPreview = ({
+  image,
+  title,
+  description
+}) => {
+  const safeSrc = toSafeImageUrl$2(image?.url);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        maxWidth: "500px",
+        border: "1px solid #dadde1",
+        fontFamily: "Helvetica, Arial, sans-serif",
+        cursor: "pointer",
+        margin: "auto",
+        marginBottom: "40px"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              borderBottom: "1px solid #dadde1",
+              backgroundSize: "cover",
+              backgroundPosition: "center"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: { width: "100%", position: "relative", paddingTop: "52.5%" },
+                children: safeSrc ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "img",
+                  {
+                    src: safeSrc,
+                    alt: title,
+                    style: {
+                      position: "absolute",
+                      top: 0,
+                      left: 0,
+                      width: "100%",
+                      height: "100%",
+                      objectFit: "cover"
+                    }
+                  }
+                ) : null
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              backgroundColor: "#f2f3f5",
+              padding: "12px 10px",
+              lineHeight: "1.4"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "12px",
+                    textTransform: "uppercase",
+                    color: "#606770",
+                    marginBottom: "4px",
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis"
+                  },
+                  children: "your-site.io"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "16px",
+                    fontWeight: "bold",
+                    color: "#1d2129",
+                    marginBottom: "4px",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap"
+                  },
+                  children: title.substring(0, 65)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "14px",
+                    color: "#606770",
+                    maxHeight: "40px",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    WebkitLineClamp: 2,
+                    WebkitBoxOrient: "vertical",
+                    display: "-webkit-box"
+                  },
+                  children: description.substring(0, 150)
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+const toSafeImageUrl$1 = (rawUrl) => {
+  if (typeof rawUrl !== "string") return "";
+  const trimmed = rawUrl.trim();
+  if (trimmed.startsWith("https://") || trimmed.startsWith("http://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return "";
+};
+const LinkedInOGPreview = ({ image, title }) => {
+  const safeSrc = toSafeImageUrl$1(image?.url);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        maxWidth: "500px",
+        borderRadius: "2px",
+        boxShadow: "0 0 0 1px rgba(0,0,0,.15),0 2px 3px rgba(0,0,0,.2)",
+        fontFamily: "Arial, sans-serif",
+        overflow: "hidden",
+        cursor: "pointer",
+        margin: "auto",
+        marginBottom: "40px"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              backgroundSize: "cover",
+              backgroundPosition: "center",
+              backgroundRepeat: "no-repeat"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: { width: "100%", position: "relative", paddingTop: "52.5%" },
+                children: safeSrc ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "img",
+                  {
+                    src: safeSrc,
+                    alt: title,
+                    style: {
+                      position: "absolute",
+                      top: 0,
+                      left: 0,
+                      width: "100%",
+                      height: "100%",
+                      objectFit: "cover"
+                    }
+                  }
+                ) : null
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              backgroundColor: "#ffffff",
+              padding: "12px 16px",
+              lineHeight: "1.5",
+              borderTop: "1px solid #ccd0d5"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "18px",
+                    fontWeight: "bold",
+                    color: "#333333",
+                    marginBottom: "2px",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap"
+                  },
+                  children: title.substring(0, 70)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "12px",
+                    color: "#666666",
+                    marginBottom: "4px",
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis"
+                  },
+                  children: "your-site.io"
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+const toSafeImageUrl = (rawUrl) => {
+  if (typeof rawUrl !== "string") return "";
+  const trimmed = rawUrl.trim();
+  if (trimmed.startsWith("https://") || trimmed.startsWith("http://") || trimmed.startsWith("/")) {
+    return trimmed;
+  }
+  return "";
+};
+const TwitterOGPreview = ({
+  image,
+  title,
+  description
+}) => {
+  const safeSrc = toSafeImageUrl(image?.url);
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      style: {
+        width: "100%",
+        maxWidth: "500px",
+        border: "1px solid #e1e8ed",
+        fontFamily: "Arial, sans-serif",
+        borderRadius: "8px",
+        overflow: "hidden",
+        cursor: "pointer",
+        margin: "auto",
+        marginBottom: "40px"
+      },
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              backgroundSize: "cover",
+              backgroundPosition: "center",
+              backgroundRepeat: "no-repeat"
+            },
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              "div",
+              {
+                style: { width: "100%", position: "relative", paddingTop: "52.5%" },
+                children: safeSrc ? /* @__PURE__ */ jsxRuntime.jsx(
+                  "img",
+                  {
+                    src: safeSrc,
+                    alt: title,
+                    style: {
+                      position: "absolute",
+                      top: 0,
+                      left: 0,
+                      width: "100%",
+                      height: "100%",
+                      objectFit: "cover"
+                    }
+                  }
+                ) : null
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          "div",
+          {
+            style: {
+              backgroundColor: "#ffffff",
+              padding: "12px 10px",
+              lineHeight: "1.4",
+              borderTop: "1px solid #e1e8ed"
+            },
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "12px",
+                    color: "#657786",
+                    marginBottom: "4px",
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis"
+                  },
+                  children: "your-site.io"
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "16px",
+                    fontWeight: "bold",
+                    color: "#14171A",
+                    marginBottom: "4px",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap"
+                  },
+                  children: title.substring(0, 70)
+                }
+              ),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                "div",
+                {
+                  style: {
+                    fontSize: "14px",
+                    color: "#657786",
+                    maxHeight: "40px",
+                    overflow: "hidden",
+                    textOverflow: "ellipsis",
+                    WebkitLineClamp: 2,
+                    WebkitBoxOrient: "vertical",
+                    display: "-webkit-box"
+                  },
+                  children: description.substring(0, 200)
+                }
+              )
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+const OpenGraphPreview = ({ modifiedData }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const openGraph = modifiedData?.seo?.openGraph;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Content, { labelledBy: "title", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Header, { children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Typography,
+      {
+        fontWeight: "bold",
+        textColor: "neutral800",
+        tag: "h2",
+        id: "title",
+        children: formatMessage({
+          id: getTrad("Button.open-graph-preview"),
+          defaultMessage: "Open Graph Preview"
+        })
+      }
+    ) }),
+    /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Body, { children: openGraph?.ogTitle && openGraph?.ogDescription && openGraph?.ogImage?.url ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "flex-start", direction: "column", gap: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { gap: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "neutral150", textColor: "neutral600", children: formatMessage({
+        id: getTrad("Social-network.platform.facebook"),
+        defaultMessage: "Facebook"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        FacebookOGPreview,
+        {
+          title: openGraph.ogTitle,
+          description: openGraph.ogDescription,
+          image: openGraph.ogImage
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "flex-start", direction: "column", gap: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { gap: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "neutral150", textColor: "neutral600", children: formatMessage({
+        id: getTrad("Social-network.platform.twitter"),
+        defaultMessage: "X (Twitter)"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        TwitterOGPreview,
+        {
+          title: openGraph.ogTitle,
+          description: openGraph.ogDescription,
+          image: openGraph.ogImage
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { alignItems: "flex-start", direction: "column", gap: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Flex, { gap: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Badge, { backgroundColor: "neutral150", textColor: "neutral600", children: formatMessage({
+        id: getTrad("Social-network.platform.linkedin"),
+        defaultMessage: "LinkedIn"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        LinkedInOGPreview,
+        {
+          title: openGraph.ogTitle,
+          description: openGraph.ogDescription,
+          image: openGraph.ogImage
+        }
+      )
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingLeft: 4, children: /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.EmptyStateLayout,
+      {
+        icon: /* @__PURE__ */ jsxRuntime.jsx(Illo, {}),
+        content: formatMessage({
+          id: getTrad("Modal.seo-component-empty-open-graph"),
+          defaultMessage: "The Open Graph metadata is empty..."
+        })
+      }
+    ) }) })
+  ] });
+};
+const PreviewChecks = ({ checks }) => {
+  const { formatMessage } = reactIntl.useIntl();
+  const values = Object.values(checks || {}).filter(
+    (c) => Boolean(c && typeof c === "object" && "qualityVerdict" in c)
+  );
+  const good = values.filter(
+    (check) => check.qualityVerdict === qualityVerdict.good
+  ).length;
+  const improvements = values.filter(
+    (check) => check.qualityVerdict === qualityVerdict.improvements
+  ).length;
+  const bad = values.filter(
+    (check) => check.qualityVerdict === qualityVerdict.bad
+  ).length;
+  return /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { paddingTop: 2, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(icons.CheckCircle, { "aria-hidden": true, fill: "success600" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+        formatMessage({
+          id: getTrad("Good"),
+          defaultMessage: "Good"
+        }),
+        `: ${good}`
+      ] })
+    ] }, qualityVerdict.good),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(icons.WarningCircle, { "aria-hidden": true, fill: "warning600" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+        formatMessage({
+          id: getTrad("Improvements"),
+          defaultMessage: "Improvements"
+        }),
+        `: ${improvements}`
+      ] })
+    ] }, qualityVerdict.improvements),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Flex, { gap: 2, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(icons.CrossCircle, { "aria-hidden": true, fill: "danger600" }),
+      /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Typography, { children: [
+        formatMessage({
+          id: getTrad("Bad"),
+          defaultMessage: "Bad"
+        }),
+        `: ${bad}`
+      ] })
+    ] }, qualityVerdict.bad)
+  ] });
+};
+function reducer(state, action) {
+  switch (action.type) {
+    case "UPDATE_PONCTUAL":
+      return {
+        ...state,
+        [action.value.entity]: {
+          qualityVerdict: action.value.qualityVerdict,
+          message: action.value.message
+        }
+      };
+    case "UPDATE_FOR_PREVIEW":
+      return action.value;
+    default:
+      return state;
+  }
+}
+const initialState = {
+  preview: true
+};
+const SeoCheckerContext = React__namespace.createContext(null);
+const buildMetaChecksPreview = (seoChecks, currentModifiedData, updatedAt) => ({
+  ...seoChecks.metaTitle && {
+    metaTitle: getMetaTitleCheckPreview(currentModifiedData)
+  },
+  ...seoChecks.metaDescription && {
+    metaDescription: getMetaDescriptionPreview(currentModifiedData)
+  },
+  ...seoChecks.metaRobots && {
+    metaRobots: metaRobotPreview(currentModifiedData)
+  },
+  ...seoChecks.openGraph && {
+    openGraph: openGraphPreview(currentModifiedData)
+  },
+  ...seoChecks.canonicalUrl && {
+    canonicalUrl: canonicalUrlPreview(currentModifiedData)
+  },
+  ...seoChecks.structuredData && {
+    structuredData: structuredDataPreview(currentModifiedData)
+  },
+  ...seoChecks.lastUpdatedAt && {
+    lastUpdatedAt: lastUpdatedAtPreview(currentModifiedData, updatedAt)
+  }
+});
+const computeAllChecks = (seoChecks, currentModifiedData, currentComponents, currentContentType, updatedAt) => {
+  const { wordCount, keywordsDensity, emptyAltCount } = getRichTextData(
+    currentModifiedData,
+    currentComponents,
+    currentContentType
+  );
+  return {
+    ...buildMetaChecksPreview(seoChecks, currentModifiedData, updatedAt),
+    ...seoChecks.wordCount && {
+      wordCount: getWordCountPreview(wordCount)
+    },
+    ...seoChecks.alternativeText && {
+      alternativeText: getAlternativeTextPreview(emptyAltCount)
+    },
+    ...seoChecks.keywordDensity && {
+      keywordsDensity: getKeywordDensityPreview(keywordsDensity)
+    }
+  };
+};
+const Summary = () => {
+  const { formatMessage } = reactIntl.useIntl();
+  const { getSettings } = useSettingsApi();
+  const [isLoading, setIsLoading] = React__namespace.useState(true);
+  const [seoChecksConfig, setSeoChecksConfig] = React__namespace.useState(DEFAULT_SEO_CHECKS);
+  const [checks, dispatch] = React__namespace.useReducer(reducer, initialState);
+  const { model, collectionType, id, form, contentType, components } = admin.unstable_useContentManagerContext();
+  const { values: modifiedData } = form;
+  const { metaTitle, metaDescription, openGraph } = modifiedData.seo ?? {};
+  const { document } = admin.unstable_useDocument({
+    model,
+    collectionType,
+    documentId: id
+  });
+  const updatedAt = document?.updatedAt ?? modifiedData?.updatedAt ?? null;
+  const uid = contentType?.uid ?? "";
+  React__namespace.useEffect(() => {
+    let isMounted = true;
+    void getSettings().then(({ data: defaultSettings }) => {
+      if (!isMounted) return;
+      const resolved = defaultSettings?.[uid]?.seoChecks ?? DEFAULT_SEO_CHECKS;
+      setSeoChecksConfig(resolved);
+    }).catch(() => {
+      if (!isMounted) return;
+      setSeoChecksConfig(DEFAULT_SEO_CHECKS);
+    }).finally(() => {
+      if (isMounted) {
+        setIsLoading(false);
+      }
+    });
+    return () => {
+      isMounted = false;
+    };
+  }, [uid]);
+  React__namespace.useEffect(() => {
+    const status = computeAllChecks(
+      seoChecksConfig,
+      modifiedData,
+      components,
+      contentType,
+      updatedAt
+    );
+    dispatch({
+      type: "UPDATE_FOR_PREVIEW",
+      value: status
+    });
+  }, [seoChecksConfig, modifiedData, components, contentType, updatedAt]);
+  return /* @__PURE__ */ jsxRuntime.jsx(SeoCheckerContext.Provider, { value: dispatch, children: /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Box, { paddingTop: 4, width: "100%", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      designSystem.Typography,
+      {
+        tag: "h2",
+        variant: "sigma",
+        textTransform: "uppercase",
+        textColor: "neutral600",
+        children: formatMessage({
+          id: getTrad("Plugin.name"),
+          defaultMessage: "SEO Plugin"
+        })
+      }
+    ),
+    metaTitle && metaDescription && /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Root, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 1, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { fullWidth: true, variant: "secondary", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Eye, {}), children: formatMessage({
+        id: getTrad("Button.browser-preview"),
+        defaultMessage: "Browser Preview"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(BrowserPreview, { modifiedData })
+    ] }),
+    openGraph && /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Root, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 2, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Button, { fullWidth: true, variant: "secondary", startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.Eye, {}), children: formatMessage({
+        id: getTrad("Button.open-graph-preview"),
+        defaultMessage: "Open Graph Preview"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(OpenGraphPreview, { modifiedData })
+    ] }),
+    !isLoading && /* @__PURE__ */ jsxRuntime.jsx(PreviewChecks, { checks }),
+    /* @__PURE__ */ jsxRuntime.jsxs(designSystem.Modal.Root, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(designSystem.Modal.Trigger, { children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.Box, { paddingTop: 4, children: /* @__PURE__ */ jsxRuntime.jsx(designSystem.TextButton, { startIcon: /* @__PURE__ */ jsxRuntime.jsx(icons.ArrowRight, {}), children: formatMessage({
+        id: getTrad("Button.see-details"),
+        defaultMessage: "SEE DETAILS"
+      }) }) }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        SeoChecks,
+        {
+          updatedAt: document?.updatedAt ?? null,
+          modifiedData,
+          components,
+          contentType,
+          checks
+        }
+      )
+    ] })
+  ] }) });
+};
+const SeoChecker = () => {
+  const {
+    form: { values }
+  } = admin.unstable_useContentManagerContext();
+  if (values?.seo) {
+    return /* @__PURE__ */ jsxRuntime.jsx(Summary, {});
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(React__namespace.Fragment, {});
+};
+const Initializer = ({ setPlugin }) => {
+  const ref = React__namespace.useRef(void 0);
+  ref.current = setPlugin;
+  React__namespace.useEffect(() => {
+    if (ref.current) {
+      ref.current(pluginId);
+    }
+  }, []);
+  return null;
+};
+const pluginPermissions = {
+  main: [{ action: "plugin::seo.read", subject: null }]
+};
+const Good$5 = "جيد";
+const Improvements$5 = "تحسينات ممكنة";
+const Bad$5 = "ضعيف";
+const Information$5 = "معلومات";
+const ar = {
+  "Plugin.name": "إضافة تحسين محركات البحث (SEO)",
+  "SEOPage.header.button.edit-component": "تعديل مكوّن SEO",
+  "SEOPage.header.button.back": "رجوع",
+  "SEOPage.header.title": "تحسين محركات البحث (SEO)",
+  "SEOPage.header.subtitle": "حسّن محتواك ليكون متوافقاً مع محركات البحث",
+  "SEOPage.empty-component-layout.github-error": "مستودع GitHub هذا لا يحتوي على مكوّن shared.seo أو shared.open-graph",
+  "SEOPage.empty-component-layout.regexp-error": "يرجى تقديم رابط مستودع GitHub صالح",
+  "SEOPage.empty-component-layout.no-component": "ليس لديك أي مكوّن SEO حتى الآن",
+  "SEOPage.empty-component-layout.input.tooltip": "يحتوي مستودع strapi/components على GitHub على مكوّن SEO الافتراضي",
+  "SEOPage.info.information": "تأكد من استخدام المكوّن المستورد shared.seo وتسميته 'seo' وإضافته في المستوى الجذري لنوع المحتوى الخاص بك.",
+  "SEOPage.info.no-collection-types": "ليس لديك أي أنواع مجموعات (Collection Types) حتى الآن...",
+  "SEOPage.info.no-single-types": "ليس لديك أي أنواع فردية (Single Types) حتى الآن...",
+  "SEOPage.info.no-plugin-content-type": "ليس لديك أي نوع محتوى تابع لإضافة حتى الآن...",
+  "SEOPage.info.create-collection-type": "أنشئ أول نوع مجموعة",
+  "SEOPage.info.create-single-type": "أنشئ أول نوع فردي",
+  "SEOPage.info.added": "تمت الإضافة",
+  "SEOPage.info.add": "إضافة مكوّن",
+  "SEOPage.info.settings": "الإعدادات",
+  "SEOPage.info.settings.meta-title-check": "العنوان الوصفي (Meta Title)",
+  "SEOPage.info.settings.meta-description-check": "الوصف التعريفي (Meta Description)",
+  "SEOPage.info.settings.meta-robots-check": "وسوم الروبوتات (Meta Robots)",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "عدد الكلمات",
+  "SEOPage.info.settings.canonical-url-check": "الرابط الأساسي (Canonical URL)",
+  "SEOPage.info.settings.keyword-density-check": "كثافة الكلمات المفتاحية",
+  "SEOPage.info.settings.structured-data-check": "البيانات المنظمة (Structured Data)",
+  "SEOPage.info.settings.alternative-text-check": "النص البديل (Alt Text)",
+  "SEOPage.info.settings.last-updated-at-check": "تاريخ آخر تحديث",
+  "SEOPage.info.settings.cancel.button": "إلغاء",
+  "SEOPage.info.settings.save.button": "حفظ",
+  "SEOPage.info.settings.information": "تعطيل فحوصات SEO لنوع المحتوى المحدد هذا.",
+  "SEOPage.tab.collection-type-title": "أنواع المجموعات",
+  "SEOPage.tab.single-type-title": "الأنواع الفردية",
+  "SEOPage.tab.plugin-title": "الإضافات",
+  "SEOPage.tab-panel.column-name": "الاسم",
+  "SEOSocialPreview.website-url": "url-of-your-website.io",
+  "SEOSocialPreview.keyword-check": "أنت تستخدم {count} كلمة (كلمات) مفتاحية في {label} ({matches})",
+  "SEOSocialPreview.meta-length-check": "طول {label} هو {length} حرفاً (الحد الأقصى {max})",
+  "SEOModal.summary-title.meta-title": "العنوان الوصفي (Meta Title)",
+  "SEOModal.summary-title.meta-description": "الوصف التعريفي (Meta Description)",
+  "SEOModal.summary-title.word-counter": "عداد الكلمات",
+  "SEOModal.summary-title.word-densisty": "كثافة الكلمات المفتاحية",
+  "SEOModal.summary-title.open-graph": "وسوم Open Graph",
+  "SEOModal.summary-title.canonical-url": "الرابط الأساسي (Canonical URL)",
+  "SEOModal.summary-title.structured-data": "بيانات JSON المنظمة",
+  "SEOModal.summary-title.meta-robots": "وسوم الروبوتات (Meta Robots)",
+  "SEOModal.summary-title.alt-attributes": "النصوص البديلة للصور",
+  "SEOModal.summary-title.last-updated-at": "آخر تحديث في",
+  "SEOChecks.keywordsDensityCheck.default": "يتم استخدام كل كلمة مفتاحية أكثر من مرتين.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "لم يتم العثور على كلمات مفتاحية في مكوّن SEO الخاص بك.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "كلمة مفتاحية واحدة على الأقل غير مستخدمة في محتواك.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "كلمة مفتاحية واحدة مستخدمة مرة واحدة فقط في محتواك.",
+  "SEOChecks.keywordsDensityCheck.label": "حدد الكلمات المفتاحية التي تريد التصدر بها في مكوّن SEO. سيقوم هذا بتحليل كثافة الكلمات المفتاحية في حقول النص المنسق.",
+  "SEOChecks.alternativeTextCheck.default": "جميع صورك تحتوي على نص بديل (alt)! تهانينا!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "اسم الصور والنص البديل متطابقان. يقوم Strapi تلقائياً بتوليد سمة alt من اسم الملف إذا تُرك الحقل فارغاً أثناء الرفع. كتابة نص بديل يصف الصورة بوضوح ممارسة ممتازة.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "صورة (أو صور) في حقل الوسائط تفتقر إلى سمة النص البديل alt.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "صورة واحدة على الأقل في محرر النص المنسق تفتقر إلى سمة alt.",
+  "SEOChecks.alternativeTextCheck.label": "سيتحقق هذا مما إذا كان هناك أي نص بديل مفقود لصورك في حقول الوسائط ومحررات النص المنسق.",
+  "SEOChecks.alternativeTextCheck.missing-text": "نص بديل مفقود في حقل النص المنسق التالي:",
+  "SEOChecks.alternativeTextCheck.missing-image": "مفقود في حقول الصور الأساسية أو داخل مكوّن.",
+  "SEOChecks.alternativeTextCheck.tip-label": "نصيحة:",
+  "SEOChecks.alternativeTextCheck.tip-before": "طبّق قاعدة في كود الواجهة الأمامية تستخدم اسم الصور إذا كان حقل",
+  "SEOChecks.alternativeTextCheck.tip-after": "فارغاً لتقليل خطر وجود سمة alt فارغة في موقعك.",
+  "SEOChecks.canonicalUrlCheck.default": "لم يتم العثور على رابط أساسي (Canonical URL).",
+  "SEOChecks.canonicalUrlCheck.found": "تم العثور على رابط أساسي (Canonical URL)!",
+  "SEOChecks.canonicalUrlCheck.label": "سيتحقق هذا مما إذا كان لديك رابط أساسي (Canonical URL).",
+  "SEOChecks.canonicalUrlCheck.url": "الرابط الأساسي:",
+  "SEOChecks.lastUpdatedAtCheck.default": "تم تعديل هذا المحتوى منذ أكثر من عام! محركات البحث تفضل المحتوى المتجدد.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "يجب حفظ هذا السجل أولاً.",
+  "SEOChecks.lastUpdatedAtCheck.success": "رائع! تم تعديل هذا المحتوى خلال أقل من عام!",
+  "SEOChecks.lastUpdatedAtCheck.label": "محركات البحث تحب المحتوى المتجدد. سيتحقق هذا مما إذا تم تعديل السجل خلال أقل من عام.",
+  "SEOChecks.lastUpdatedAtCheck.last": "آخر تحديث في:",
+  "SEOChecks.metaDescriptionCheck.default": "تم العثور على الوصف التعريفي (Meta Description)!",
+  "SEOChecks.metaDescriptionCheck.not-found": "لم يتم العثور على الوصف التعريفي (Meta Description).",
+  "SEOChecks.metaRobotsCheck.default": "تم العثور على وسوم الروبوتات (Meta Robots)!",
+  "SEOChecks.metaRobotsCheck.not-found": "لم يتم العثور على وسوم الروبوتات (Meta Robots).",
+  "SEOChecks.metaRobotsCheck.label": "يُعلم وسم الروبوتات محركات البحث بالصفحات التي يجب فهرستها في موقعك والمزيد.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} مفعّل: {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} معطّل: {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "ملاحظة:",
+  "SEOChecks.metaRobotsCheck.notice-before": "لعدم فهرسة هذا السجل وعدم تتبع روابطه، يجب أن يحتوي حقل MetaRobots على التالي:",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": ". يجب التعامل مع الباقي بواسطة منطق كود الواجهة الأمامية لديك.",
+  "SEOChecks.openGraphCheck.not-found": "لم يتم العثور على وسوم Open Graph.",
+  "SEOChecks.openGraphCheck.not-configured": "الحد الأدنى من وسوم OpenGraph المطلوبة غير مُعد.",
+  "SEOChecks.openGraphCheck.configured": "تم إعداد وسوم Open Graph",
+  "SEOChecks.openGraphCheck.label": "تتيح لك وسوم Open Graph إدارة العنوان والوصف والصورة الخاصة بمنشوراتك عند مشاركتها.",
+  "SEOChecks.metaTitleCheck.default": "تم العثور على العنوان الوصفي (Meta Title)!",
+  "SEOChecks.metaTitleCheck.not-found": "لم يتم العثور على العنوان الوصفي (Meta Title).",
+  "SEOChecks.structuredDataCheck.default": "تم العثور على بيانات JSON المنظمة! ومع ذلك، لا يمكننا التحقق التلقائي من دقة محتواها.",
+  "SEOChecks.structuredDataCheck.not-found": "لم يتم العثور على بيانات JSON المنظمة.",
+  "SEOChecks.structuredDataCheck.label": "البيانات المنظمة هي تنسيق قياسي لتوفير معلومات حول الصفحة وتصنيف محتواها لمحركات البحث.",
+  "SEOChecks.wordCountCheck.default": "لديك أكثر من 300 كلمة. عدد الكلمات ليس عامل ترتيب مباشر، ولكن يجب أن يكون محتواك عالي الجودة ومفصلاً.",
+  "SEOChecks.wordCountCheck.not-found": "لم يتم العثور على محتوى نص منسق.",
+  "SEOChecks.wordCountCheck.300": "يحتوي النص المنسق في المستوى الأول على أقل من 300 كلمة.",
+  "SEOChecks.wordCountCheck.label": "يجب أن يكون محتواك بأعلى جودة ممكنة مع معلومات مفيدة وفريدة، مما يتطلب حداً أدنى من الفقرات والكلمات.",
+  "SEOChecks.wordCountCheck.words": "الكلمات:",
+  "Modal.seo-component-empty": "مكوّن SEO الخاص بك فارغ...",
+  "Modal.seo-component-empty-open-graph": "بيانات Open Graph الوصفية فارغة...",
+  "Tabs.title-settings": "إعدادات العنوان",
+  "Tabs.social-network": "الشبكات الاجتماعية",
+  "Tabs.seo-analyse": "تحليل SEO",
+  "Title-settings.metaTitle-too-long": "العنوان الوصفي طويل جداً",
+  "Title-settings.metaTitle-tooltip": "وسم العنوان هو أول ما يلاحظه المستخدمون في نتائج البحث، ويقدم معاينة لمحتوى صفحتك.",
+  "Title-settings.metaDescription-too-long": "الوصف التعريفي طويل جداً",
+  "Title-settings.metaDescription-too-short": "الوصف التعريفي قصير جداً",
+  "Title-settings.metaDescription-tooltip": "الوصف التعريفي لا يقل أهمية عن العنوان، فهو المقتطف الذي يظهر أسفل العنوان في نتائج البحث.",
+  "Title-settings.metaTitle-hint": "/60 حرفاً (الحد الأقصى الموصى به)",
+  "Title-settings.metaDescription-hint": "/160 حرفاً (الحد الأقصى الموصى به)",
+  "Social-network.metaTitle-hint": "/60 حرفاً (الحد الأقصى الموصى به)",
+  "Social-network.metaDescription-hint": "/65 حرفاً (الحد الأقصى الموصى به)",
+  "Social-network.accordion.description": "شاهد كيف سيبدو محتواك عند نشره على",
+  "Social-network.no-tags": "ليس لديك أي وسوم Open Graph حتى الآن.",
+  "Social-network.platform.facebook": "فيسبوك (Facebook)",
+  "Social-network.platform.twitter": "إكس (X / Twitter)",
+  "Social-network.platform.linkedin": "لينكدإن (LinkedIn)",
+  "Modal.cancel": "إلغاء",
+  "Button.see-details": "عرض التفاصيل",
+  "Button.open-graph-preview": "معاينة Open Graph",
+  "Button.browser-preview": "معاينة المتصفح",
+  "Button.seo-analyze": "تحليل SEO",
+  Good: Good$5,
+  Improvements: Improvements$5,
+  Bad: Bad$5,
+  "Social-preview.alert": "أكمل مكوّن الشبكات الاجتماعية لرؤية المعاينة",
+  Information: Information$5,
+  "notification.success.settings": "تم حفظ الإعدادات لنوع المحتوى {collectionName}.",
+  "notification.error.settings": "فشل في حفظ إعدادات SEO."
+};
+const Good$4 = "Good";
+const Improvements$4 = "Improvements";
+const Bad$4 = "Bad";
+const Information$4 = "Information";
+const en = {
+  "Plugin.name": "SEO Plugin",
+  "SEOPage.header.button.edit-component": "Edit SEO component",
+  "SEOPage.header.button.back": "Back",
+  "SEOPage.header.title": "SEO",
+  "SEOPage.header.subtitle": "Optimize your content to be SEO friendly",
+  "SEOPage.empty-component-layout.github-error": "This GitHub repository doesn't contains shared.seo or shared.open-graph component",
+  "SEOPage.empty-component-layout.regexp-error": "Please provide a valid GitHub repository URL",
+  "SEOPage.empty-component-layout.no-component": "You don't have any SEO component yet",
+  "SEOPage.empty-component-layout.input.tooltip": "The strapi/components GitHub repository contains the default SEO component",
+  "SEOPage.info.information": "Make sure to use the imported shared.seo component, name it 'seo' and to add it in the root of your Content-Type.",
+  "SEOPage.info.no-collection-types": "You don't have any collection-types yet...",
+  "SEOPage.info.no-single-types": "You don't have any single-types yet...",
+  "SEOPage.info.no-plugin-content-type": "You don't have any plugin content-type yet...",
+  "SEOPage.info.create-collection-type": "Create your first collection-type",
+  "SEOPage.info.create-single-type": "Create your first single-type",
+  "SEOPage.info.added": "Added",
+  "SEOPage.info.add": "Add component",
+  "SEOPage.info.settings": "Settings",
+  "SEOPage.info.settings.meta-title-check": "Meta Title",
+  "SEOPage.info.settings.meta-description-check": "Meta Description",
+  "SEOPage.info.settings.meta-robots-check": "Meta Robots",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "Word Count",
+  "SEOPage.info.settings.canonical-url-check": "Canonical URL",
+  "SEOPage.info.settings.keyword-density-check": "Keyword Density",
+  "SEOPage.info.settings.structured-data-check": "Structured Data",
+  "SEOPage.info.settings.alternative-text-check": "Alt Text",
+  "SEOPage.info.settings.last-updated-at-check": "Last Updated At",
+  "SEOPage.info.settings.cancel.button": "Cancel",
+  "SEOPage.info.settings.save.button": "Save",
+  "SEOPage.info.settings.information": "Disable SEO checks for this specific content-type.",
+  "SEOPage.tab.collection-type-title": "Collection Types",
+  "SEOPage.tab.single-type-title": "Single Types",
+  "SEOPage.tab.plugin-title": "Plugins",
+  "SEOPage.tab-panel.column-name": "Name",
+  "SEOSocialPreview.website-url": "url-of-your-website.io",
+  "SEOSocialPreview.keyword-check": "You use {count} keyword(s) in your {label} ({matches})",
+  "SEOSocialPreview.meta-length-check": "Your {label} is {length} characters long (max {max})",
+  "SEOModal.summary-title.meta-title": "Meta Title",
+  "SEOModal.summary-title.meta-description": "Meta Description",
+  "SEOModal.summary-title.word-counter": "Word Counter",
+  "SEOModal.summary-title.word-densisty": "Keyword Density",
+  "SEOModal.summary-title.open-graph": "Open Graph Tags",
+  "SEOModal.summary-title.canonical-url": "Canonical URL",
+  "SEOModal.summary-title.structured-data": "JSON Structured Data",
+  "SEOModal.summary-title.meta-robots": "Meta Robots",
+  "SEOModal.summary-title.alt-attributes": "Alternative Texts",
+  "SEOModal.summary-title.last-updated-at": "Last updated at",
+  "SEOChecks.keywordsDensityCheck.default": "Every keyword are used more than 2 times.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "No keywords were found in your SEO component.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "One keyword is not being used in your content.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "One keyword is only used once in your content.",
+  "SEOChecks.keywordsDensityCheck.label": "Define keywords you want to rank for in your SEO component. This will analyze the density of your keywords in your 1st level richtext editors.",
+  "SEOChecks.alternativeTextCheck.default": "All your images contain an alt attribute! Congrats!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "The name and the alternative text of your images are all the same. Strapi automatically generates the alt attribute from the name by default if the field was empty during the media upload. Having alt attribute clearly describing images is a very good practice.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "image(s) from a media field is/are missing an alt attribute.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "At least one image in any 1st level richtext editor is missing an alt attribute.",
+  "SEOChecks.alternativeTextCheck.label": "This will check if you have any missing alternative text for your images (media field) and in your 1st level richtext editors.",
+  "SEOChecks.alternativeTextCheck.missing-text": "missing alt in the following richtext field:",
+  "SEOChecks.alternativeTextCheck.missing-image": "missing on first level image fields or inside a component.",
+  "SEOChecks.alternativeTextCheck.tip-label": "Tip:",
+  "SEOChecks.alternativeTextCheck.tip-before": "Implement a rule in your front-end code that uses the name of your images if the",
+  "SEOChecks.alternativeTextCheck.tip-after": "field is empty to further reduce the risk of an empty alt attribute on your website.",
+  "SEOChecks.canonicalUrlCheck.default": "No canonical URL has been found.",
+  "SEOChecks.canonicalUrlCheck.found": "A Canonical URL has been found!",
+  "SEOChecks.canonicalUrlCheck.label": "This will check if you have a canonical URL.",
+  "SEOChecks.canonicalUrlCheck.url": "Canonical URL:",
+  "SEOChecks.lastUpdatedAtCheck.default": "This content was modified over a year ago! Search engines love fresh content.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "You must save this entry first.",
+  "SEOChecks.lastUpdatedAtCheck.success": "Awesome! This content was last modified less than a year ago!",
+  "SEOChecks.lastUpdatedAtCheck.label": "Search engines love fresh content. This will check if your entry was last modified less than a year ago.",
+  "SEOChecks.lastUpdatedAtCheck.last": "Last updated at:",
+  "SEOChecks.metaDescriptionCheck.default": "A Meta Description has been found!",
+  "SEOChecks.metaDescriptionCheck.not-found": "No Meta Description has been found.",
+  "SEOChecks.metaRobotsCheck.default": "Robot meta tags have been found!",
+  "SEOChecks.metaRobotsCheck.not-found": "No Robot meta tags have been found.",
+  "SEOChecks.metaRobotsCheck.label": "The robot's meta tag informs search engines which pages on your site should be indexed and more.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} is activated: {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} is disabled: {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "Notice:",
+  "SEOChecks.metaRobotsCheck.notice-before": "In order to not index your entry and no follow, your MetaRobots field should contain the following:",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": '. The rest should be handled by your front-end code logic. "If the field contains noindex, then you need to create the corresponding meta tag etc..."',
+  "SEOChecks.openGraphCheck.not-found": "No Open Graph tags have been found.",
+  "SEOChecks.openGraphCheck.not-configured": "OpenGraph minimum required tags are not configured.",
+  "SEOChecks.openGraphCheck.configured": "Open Graph tags are configured",
+  "SEOChecks.openGraphCheck.label": "Open Graph tags allow you to manage the title, description & image of your posts.",
+  "SEOChecks.metaTitleCheck.default": "A Meta Title has been found!",
+  "SEOChecks.metaTitleCheck.not-found": "No Meta Title has been found.",
+  "SEOChecks.structuredDataCheck.default": "A Structured Data JSON has been found! However, we can't validate the accuracy of its content.",
+  "SEOChecks.structuredDataCheck.not-found": "No Structured Data JSON has been found.",
+  "SEOChecks.structuredDataCheck.label": "Structured data is a standardized format for providing information about a page and classifying the page content.",
+  "SEOChecks.wordCountCheck.default": "You have more than 300 words. The word count is not a direct ranking factor. But your content should be as high quality as possible, with relevant and unique information. To meet these conditions, your content requires a minimum of paragraphs, and therefore of words.",
+  "SEOChecks.wordCountCheck.not-found": "No Richtext content have been found.",
+  "SEOChecks.wordCountCheck.300": "Your 1st level Richtext contents have less than 300 words.",
+  "SEOChecks.wordCountCheck.label": "Your content should be as high quality as possible, with relevant and unique information. Your entry requires a minimum of paragraphs, and therefore of words.",
+  "SEOChecks.wordCountCheck.words": "Words:",
+  "Modal.seo-component-empty": "Your SEO component is empty...",
+  "Modal.seo-component-empty-open-graph": "The Open Graph metadata is empty...",
+  "Tabs.title-settings": "Title settings",
+  "Tabs.social-network": "Social networks",
+  "Tabs.seo-analyse": "SEO analyze",
+  "Title-settings.metaTitle-too-long": "Meta Title is too long",
+  "Title-settings.metaTitle-tooltip": "The title tag is one of the first things that users notice in the SERPs. It’s the title of your page that offers a preview of what your content is about.",
+  "Title-settings.metaDescription-too-long": "Meta Description is too long",
+  "Title-settings.metaDescription-too-short": "Meta Description is too short",
+  "Title-settings.metaDescription-tooltip": "The meta description is of equal importance to the title tag. If the title tag is the title that appears at the top of a search result, the meta description is the snippet that displays underneath.",
+  "Title-settings.metaTitle-hint": "/60 characters (recommended maximum limit)",
+  "Title-settings.metaDescription-hint": "/160 characters (recommended maximum limit)",
+  "Social-network.metaTitle-hint": "/60 characters (recommended maximum limit)",
+  "Social-network.metaDescription-hint": "/65 characters (recommended maximum limit)",
+  "Social-network.accordion.description": "See how your content will look like posted on",
+  "Social-network.no-tags": "You don't have any Open Graph tags yet.",
+  "Social-network.platform.facebook": "Facebook",
+  "Social-network.platform.twitter": "X (Twitter)",
+  "Social-network.platform.linkedin": "LinkedIn",
+  "Modal.cancel": "Cancel",
+  "Button.see-details": "SEE DETAILS",
+  "Button.open-graph-preview": "Open Graph Preview",
+  "Button.browser-preview": "Browser Preview",
+  "Button.seo-analyze": "SEO Analyze",
+  Good: Good$4,
+  Improvements: Improvements$4,
+  Bad: Bad$4,
+  "Social-preview.alert": "Complete your social component to see the preview",
+  Information: Information$4,
+  "notification.success.settings": "Settings saved for {collectionName} content-type.",
+  "notification.error.settings": "Failed to save SEO settings."
+};
+const Good$3 = "Bueno";
+const Improvements$3 = "Mejoras";
+const Bad$3 = "Malo";
+const Information$3 = "Información";
+const es = {
+  "Plugin.name": "Complemento SEO",
+  "SEOPage.header.button.edit-component": "Editar componente SEO",
+  "SEOPage.header.button.back": "Volver",
+  "SEOPage.header.title": "SEO",
+  "SEOPage.header.subtitle": "Optimiza tu contenido para motores de búsqueda (SEO)",
+  "SEOPage.empty-component-layout.github-error": "Este repositorio de GitHub no contiene el componente shared.seo o shared.open-graph",
+  "SEOPage.empty-component-layout.regexp-error": "Por favor proporciona una URL válida de repositorio de GitHub",
+  "SEOPage.empty-component-layout.no-component": "Aún no tienes ningún componente SEO",
+  "SEOPage.empty-component-layout.input.tooltip": "El repositorio de GitHub strapi/components contiene el componente SEO predeterminado",
+  "SEOPage.info.information": "Asegúrate de usar el componente shared.seo importado, nombrarlo 'seo' y añadirlo en la raíz de tu tipo de contenido.",
+  "SEOPage.info.no-collection-types": "Aún no tienes ningún tipo de colección...",
+  "SEOPage.info.no-single-types": "Aún no tienes ningún tipo único...",
+  "SEOPage.info.no-plugin-content-type": "Aún no tienes ningún tipo de contenido de plugin...",
+  "SEOPage.info.create-collection-type": "Crea tu primer tipo de colección",
+  "SEOPage.info.create-single-type": "Crea tu primer tipo único",
+  "SEOPage.info.added": "Añadido",
+  "SEOPage.info.add": "Añadir componente",
+  "SEOPage.info.settings": "Configuración",
+  "SEOPage.info.settings.meta-title-check": "Título Meta",
+  "SEOPage.info.settings.meta-description-check": "Descripción Meta",
+  "SEOPage.info.settings.meta-robots-check": "Meta Robots",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "Recuento de palabras",
+  "SEOPage.info.settings.canonical-url-check": "URL Canónica",
+  "SEOPage.info.settings.keyword-density-check": "Densidad de palabras clave",
+  "SEOPage.info.settings.structured-data-check": "Datos estructurados",
+  "SEOPage.info.settings.alternative-text-check": "Texto alternativo (Alt)",
+  "SEOPage.info.settings.last-updated-at-check": "Última actualización",
+  "SEOPage.info.settings.cancel.button": "Cancelar",
+  "SEOPage.info.settings.save.button": "Guardar",
+  "SEOPage.info.settings.information": "Desactivar comprobaciones SEO para este tipo de contenido específico.",
+  "SEOPage.tab.collection-type-title": "Tipos de Colección",
+  "SEOPage.tab.single-type-title": "Tipos Únicos",
+  "SEOPage.tab.plugin-title": "Plugins",
+  "SEOPage.tab-panel.column-name": "Nombre",
+  "SEOSocialPreview.website-url": "url-de-tu-sitio-web.org",
+  "SEOSocialPreview.keyword-check": "Usas {count} palabra(s) clave en tu {label} ({matches})",
+  "SEOSocialPreview.meta-length-check": "Tu {label} tiene {length} caracteres (máx. {max})",
+  "SEOModal.summary-title.meta-title": "Título Meta",
+  "SEOModal.summary-title.meta-description": "Descripción Meta",
+  "SEOModal.summary-title.word-counter": "Contador de palabras",
+  "SEOModal.summary-title.word-densisty": "Densidad de palabras clave",
+  "SEOModal.summary-title.open-graph": "Etiquetas Open Graph",
+  "SEOModal.summary-title.canonical-url": "URL Canónica",
+  "SEOModal.summary-title.structured-data": "Datos Estructurados JSON",
+  "SEOModal.summary-title.meta-robots": "Meta Robots",
+  "SEOModal.summary-title.alt-attributes": "Textos alternativos",
+  "SEOModal.summary-title.last-updated-at": "Última actualización",
+  "SEOChecks.keywordsDensityCheck.default": "Cada palabra clave se utiliza más de 2 veces.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "No se encontraron palabras clave en tu componente SEO.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "Una palabra clave no se está utilizando en tu contenido.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "Una palabra clave solo se utiliza una vez en tu contenido.",
+  "SEOChecks.keywordsDensityCheck.label": "Define las palabras clave por las que deseas posicionar en tu componente SEO. Esto analizará la densidad de tus palabras clave en los editores de texto enriquecido de primer nivel.",
+  "SEOChecks.alternativeTextCheck.default": "¡Todas tus imágenes contienen un atributo alt! ¡Felicidades!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "El nombre y el texto alternativo de tus imágenes son iguales. Strapi genera automáticamente el atributo alt a partir del nombre por defecto si el campo estaba vacío al subir el archivo. Tener un atributo alt que describa claramente las imágenes es una excelente práctica.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "imagen(es) de un campo multimedia no tienen atributo alt.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "Al menos una imagen en algún editor de texto enriquecido de primer nivel no tiene atributo alt.",
+  "SEOChecks.alternativeTextCheck.label": "Esto comprobará si falta texto alternativo en tus imágenes (campo multimedia) y en tus editores de texto enriquecido de primer nivel.",
+  "SEOChecks.alternativeTextCheck.missing-text": "falta alt en el siguiente campo de texto enriquecido:",
+  "SEOChecks.alternativeTextCheck.missing-image": "falta en campos de imagen de primer nivel o dentro de un componente.",
+  "SEOChecks.alternativeTextCheck.tip-label": "Consejo:",
+  "SEOChecks.alternativeTextCheck.tip-before": "Implementa una regla en tu código front-end que utilice el nombre de tus imágenes si el campo",
+  "SEOChecks.alternativeTextCheck.tip-after": "está vacío para reducir aún más el riesgo de tener un atributo alt vacío en tu sitio web.",
+  "SEOChecks.canonicalUrlCheck.default": "No se ha encontrado ninguna URL canónica.",
+  "SEOChecks.canonicalUrlCheck.found": "¡Se ha encontrado una URL canónica!",
+  "SEOChecks.canonicalUrlCheck.label": "Esto comprobará si tienes una URL canónica configurada.",
+  "SEOChecks.canonicalUrlCheck.url": "URL Canónica:",
+  "SEOChecks.lastUpdatedAtCheck.default": "¡Este contenido fue modificado hace más de un año! A los motores de búsqueda les encanta el contenido fresco.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "Primero debes guardar esta entrada.",
+  "SEOChecks.lastUpdatedAtCheck.success": "¡Excelente! ¡Este contenido fue modificado hace menos de un año!",
+  "SEOChecks.lastUpdatedAtCheck.label": "A los motores de búsqueda les encanta el contenido actualizado. Esto comprobará si tu entrada fue modificada hace menos de un año.",
+  "SEOChecks.lastUpdatedAtCheck.last": "Última actualización:",
+  "SEOChecks.metaDescriptionCheck.default": "¡Se ha encontrado una Descripción Meta!",
+  "SEOChecks.metaDescriptionCheck.not-found": "No se ha encontrado ninguna Descripción Meta.",
+  "SEOChecks.metaRobotsCheck.default": "¡Se han encontrado etiquetas Meta Robots!",
+  "SEOChecks.metaRobotsCheck.not-found": "No se han encontrado etiquetas Meta Robots.",
+  "SEOChecks.metaRobotsCheck.label": "La etiqueta meta robots informa a los motores de búsqueda qué páginas de tu sitio deben indexarse y más.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} está activado: {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} está desactivado: {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "Aviso:",
+  "SEOChecks.metaRobotsCheck.notice-before": "Para no indexar tu entrada ni seguir enlaces, tu campo MetaRobots debe contener lo siguiente:",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": '. El resto debe manejarse en la lógica de tu código front-end. "Si el campo contiene noindex, debes crear la etiqueta meta correspondiente, etc."',
+  "SEOChecks.openGraphCheck.not-found": "No se han encontrado etiquetas Open Graph.",
+  "SEOChecks.openGraphCheck.not-configured": "Las etiquetas mínimas requeridas de OpenGraph no están configuradas.",
+  "SEOChecks.openGraphCheck.configured": "Las etiquetas Open Graph están configuradas",
+  "SEOChecks.openGraphCheck.label": "Las etiquetas Open Graph te permiten gestionar el título, la descripción y la imagen de tus publicaciones en redes sociales.",
+  "SEOChecks.metaTitleCheck.default": "¡Se ha encontrado un Título Meta!",
+  "SEOChecks.metaTitleCheck.not-found": "No se ha encontrado ningún Título Meta.",
+  "SEOChecks.structuredDataCheck.default": "¡Se ha encontrado un JSON de Datos Estructurados! Sin embargo, no podemos validar la exactitud de su contenido.",
+  "SEOChecks.structuredDataCheck.not-found": "No se ha encontrado ningún JSON de Datos Estructurados.",
+  "SEOChecks.structuredDataCheck.label": "Los datos estructurados son un formato estandarizado para proporcionar información sobre una página y clasificar su contenido.",
+  "SEOChecks.wordCountCheck.default": "Tienes más de 300 palabras. El recuento de palabras no es un factor directo de posicionamiento, pero tu contenido debe ser de la más alta calidad posible, con información relevante y única.",
+  "SEOChecks.wordCountCheck.not-found": "No se ha encontrado contenido de texto enriquecido.",
+  "SEOChecks.wordCountCheck.300": "Tu contenido de texto enriquecido de primer nivel tiene menos de 300 palabras.",
+  "SEOChecks.wordCountCheck.label": "Tu contenido debe ser de la más alta calidad posible, con información relevante y única. Tu entrada requiere un mínimo de párrafos y palabras.",
+  "SEOChecks.wordCountCheck.words": "Palabras:",
+  "Modal.seo-component-empty": "Tu componente SEO está vacío...",
+  "Modal.seo-component-empty-open-graph": "Los metadatos de Open Graph están vacíos...",
+  "Tabs.title-settings": "Ajustes de título",
+  "Tabs.social-network": "Redes sociales",
+  "Tabs.seo-analyse": "Análisis SEO",
+  "Title-settings.metaTitle-too-long": "El Título Meta es demasiado largo",
+  "Title-settings.metaTitle-tooltip": "La etiqueta de título es una de las primeras cosas que los usuarios notan en los resultados de búsqueda. Ofrece una vista previa de qué trata tu contenido.",
+  "Title-settings.metaDescription-too-long": "La Descripción Meta es demasiado larga",
+  "Title-settings.metaDescription-too-short": "La Descripción Meta es demasiado corta",
+  "Title-settings.metaDescription-tooltip": "La descripción meta tiene la misma importancia que la etiqueta de título. Es el fragmento descriptivo que se muestra debajo del título en los resultados de búsqueda.",
+  "Title-settings.metaTitle-hint": "/60 caracteres (límite máximo recomendado)",
+  "Title-settings.metaDescription-hint": "/160 caracteres (límite máximo recomendado)",
+  "Social-network.metaTitle-hint": "/60 caracteres (límite máximo recomendado)",
+  "Social-network.metaDescription-hint": "/65 caracteres (límite máximo recomendado)",
+  "Social-network.accordion.description": "Mira cómo se verá tu contenido publicado en",
+  "Social-network.no-tags": "Aún no tienes ninguna etiqueta Open Graph.",
+  "Social-network.platform.facebook": "Facebook",
+  "Social-network.platform.twitter": "X (Twitter)",
+  "Social-network.platform.linkedin": "LinkedIn",
+  "Modal.cancel": "Cancelar",
+  "Button.see-details": "VER DETALLES",
+  "Button.open-graph-preview": "Vista previa Open Graph",
+  "Button.browser-preview": "Vista previa del navegador",
+  "Button.seo-analyze": "Análisis SEO",
+  Good: Good$3,
+  Improvements: Improvements$3,
+  Bad: Bad$3,
+  "Social-preview.alert": "Completa tu componente social para ver la vista previa",
+  Information: Information$3,
+  "notification.success.settings": "Configuración guardada para el tipo de contenido {collectionName}.",
+  "notification.error.settings": "No se pudo guardar la configuración SEO."
+};
+const Good$2 = "Bien";
+const Improvements$2 = "Améliorations";
+const Bad$2 = "Problèmes";
+const Information$2 = "Information";
+const fr = {
+  "Plugin.name": "Plugin SEO",
+  "SEOPage.header.button.edit-component": "Editer le composant SEO",
+  "SEOPage.header.button.back": "Retour",
+  "SEOPage.header.title": "SEO",
+  "SEOPage.header.subtitle": "Optimisez votre contenu pour le référencement",
+  "SEOPage.empty-component-layout.github-error": "Cette repository GitHub ne contient pas de composant shared.seo ou shared.open-graph",
+  "SEOPage.empty-component-layout.regexp-error": "Veuillez fournir une URL de repository GitHub valide",
+  "SEOPage.empty-component-layout.no-component": "Vous n'avez pas encore de composant SEO",
+  "SEOPage.empty-component-layout.input.tooltip": "Le repository GitHub strapi/components contient le composant SEO par défaut",
+  "SEOPage.info.information": "Assurez-vous d'utiliser le composant importé shared.seo, de le nommer 'seo' et de l'inclure à la racine de votre Content-Type.",
+  "SEOPage.info.no-collection-types": "Vous n'avez pas encore de collection-types...",
+  "SEOPage.info.no-single-types": "Vous n'avez pas enore de single-types...",
+  "SEOPage.info.no-plugin-content-type": "Vous n'avez pas encore de content-type de plugin...",
+  "SEOPage.info.create-collection-type": "Créer votre premier collection-type",
+  "SEOPage.info.create-single-type": "Créer votre premier single-type",
+  "SEOPage.info.added": "Ajouté",
+  "SEOPage.info.add": "Ajouter le composant",
+  "SEOPage.info.settings": "Paramètres",
+  "SEOPage.info.settings.meta-title-check": "Meta Titre",
+  "SEOPage.info.settings.meta-description-check": "Meta Description",
+  "SEOPage.info.settings.meta-robots-check": "Meta Robots",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "Compteur de mots",
+  "SEOPage.info.settings.canonical-url-check": "URL Canonique",
+  "SEOPage.info.settings.keyword-density-check": "Densité de mots-clés",
+  "SEOPage.info.settings.structured-data-check": "Données Structurées",
+  "SEOPage.info.settings.alternative-text-check": "Alt text",
+  "SEOPage.info.settings.last-updated-at-check": "Date de dernière mise à jour",
+  "SEOPage.info.settings.cancel.button": "Annuler",
+  "SEOPage.info.settings.save.button": "Enregistrer",
+  "SEOPage.info.settings.information": "Désactiver des verifications SEO pour ce content-type.",
+  "SEOPage.tab.collection-type-title": "Types de collections",
+  "SEOPage.tab.single-type-title": "Types simples",
+  "SEOPage.tab.plugin-title": "Plugins",
+  "SEOPage.tab-panel.column-name": "Nom",
+  "SEOSocialPreview.website-url": "url-of-your-website.io",
+  "SEOSocialPreview.keyword-check": "Vous utilisez {count} mot(s)-clé(s) dans votre {label} ({matches})",
+  "SEOSocialPreview.meta-length-check": "Votre {label} contient {length} caractères (max {max})",
+  "SEOModal.summary-title.meta-title": "Meta Titre",
+  "SEOModal.summary-title.meta-description": "Meta Description",
+  "SEOModal.summary-title.word-counter": "Word Counter",
+  "SEOModal.summary-title.word-densisty": "Densité des mots-clés",
+  "SEOModal.summary-title.open-graph": "Balise Open Graph",
+  "SEOModal.summary-title.canonical-url": "URL canonique",
+  "SEOModal.summary-title.structured-data": "Données Structurées JSON",
+  "SEOModal.summary-title.meta-robots": "Meta Robots",
+  "SEOModal.summary-title.alt-attributes": "Texte d'images",
+  "SEOModal.summary-title.last-updated-at": "Dernière mise à jour",
+  "SEOChecks.keywordsDensityCheck.default": "Chaque mot-clé est utilisé plus de 2 fois.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "Aucun mot-clé n'a été trouvé dans votre composant SEO.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "Un mot-clé n'est pas utilisé dans votre contenu.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "Un mot-clé n'est utilisé qu'une seule fois dans votre contenu.",
+  "SEOChecks.keywordsDensityCheck.label": "Définissez les mots clés pour lesquels vous souhaitez vous ranker dans votre composant SEO. Cela analysera la densité de vos mots-clés dans vos éditeurs de texte enrichi.",
+  "SEOChecks.alternativeTextCheck.default": "Toutes vos images contiennent un attribut alt ! Félicitations!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "Le nom et le texte alternatif de vos images sont identiques. Strapi génère automatiquement l'attribut alt à partir du nom par défaut si le champ était vide lors du téléchargement du média. Avoir un attribut alt décrivant clairement l'image est une très bonne pratique.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "images ne dispose(nt) pas d'attribut alt.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "Il manque un attribut alt à au moins une image dans n'importe quel éditeur de texte enrichi de 1er niveau.",
+  "SEOChecks.alternativeTextCheck.label": "Cela vérifiera s'il vous manque du texte alternatif pour vos images (champ média) et dans vos éditeurs de texte enrichi de 1er niveau.",
+  "SEOChecks.alternativeTextCheck.missing-text": "alt manquant dans le champ de texte enrichi suivant :",
+  "SEOChecks.alternativeTextCheck.missing-image": "images sont manquants au premier niveau ou bien dans un composant.",
+  "SEOChecks.alternativeTextCheck.tip-label": "Astuce :",
+  "SEOChecks.alternativeTextCheck.tip-before": "Implémentez une règle dans votre code front-end qui utilise le nom de vos images si le champ",
+  "SEOChecks.alternativeTextCheck.tip-after": "est vide afin de réduire davantage le risque d'un attribut alt vide sur votre site web.",
+  "SEOChecks.canonicalUrlCheck.default": "Aucune URL canonique n'a été trouvée.",
+  "SEOChecks.canonicalUrlCheck.found": "Une URL canonique a été trouvée !",
+  "SEOChecks.canonicalUrlCheck.label": "Cela vérifiera si vous avez une URL canonique.",
+  "SEOChecks.canonicalUrlCheck.url": "URL canonique:",
+  "SEOChecks.lastUpdatedAtCheck.default": "Ce contenu a été modifié il y a plus d'un an ! Les moteurs de recherche aiment le contenu récent.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "Vous devez d'abord enregistrer cette entité.",
+  "SEOChecks.lastUpdatedAtCheck.success": "Super! Ce contenu a été modifié pour la dernière fois il y a moins d'un an !",
+  "SEOChecks.lastUpdatedAtCheck.label": "Les moteurs de recherche aiment le contenu récent. Cela vérifiera si votre contenu a été modifié pour la dernière fois il y a moins d'un an.",
+  "SEOChecks.lastUpdatedAtCheck.last": "Dernière mise à jour :",
+  "SEOChecks.metaDescriptionCheck.default": "Une meta description a été trouvée !",
+  "SEOChecks.metaDescriptionCheck.not-found": "Aucune meta description n'a été trouvée.",
+  "SEOChecks.metaRobotsCheck.default": "Des balises meta robot ont été trouvées !",
+  "SEOChecks.metaRobotsCheck.not-found": "Aucune balise meta robot n'a été trouvée.",
+  "SEOChecks.metaRobotsCheck.label": "La balise meta du robot informe les moteurs de recherche des pages de votre site qui doivent être indexées et plus encore.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} est activé : {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} est désactivé : {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "Remarque :",
+  "SEOChecks.metaRobotsCheck.notice-before": "Pour ne pas indexer votre entrée et ne pas suivre les liens, votre champ MetaRobots doit contenir :",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": '. Le reste doit être géré par votre logique front-end. "Si le champ contient noindex, vous devez créer la balise meta correspondante, etc."',
+  "SEOChecks.openGraphCheck.not-found": "Aucune balise Open Graph n'a été trouvée.",
+  "SEOChecks.openGraphCheck.not-configured": "Les balises OpenGraph nécessaires ne sont pas configurés.",
+  "SEOChecks.openGraphCheck.configured": "Les balises Open Graph sont configurées.",
+  "SEOChecks.openGraphCheck.label": "Les balises Open Graph vous permettent de gérer le titre, la description et l'image de vos publications.",
+  "SEOChecks.metaTitleCheck.default": "Un Meta Title a été trouvé !",
+  "SEOChecks.metaTitleCheck.not-found": "Aucune meta title n'a été trouvée.",
+  "SEOChecks.structuredDataCheck.default": "Un JSON de données structurées a été trouvé ! Cependant, nous pouvons valider l'exactitude de son contenu.",
+  "SEOChecks.structuredDataCheck.not-found": "Aucun JSON de données structurées n'a été trouvé.",
+  "SEOChecks.structuredDataCheck.label": "Les données structurées sont un format standardisé pour fournir des informations sur une page et classer le contenu de la page.",
+  "SEOChecks.wordCountCheck.default": "Vous avez plus de 300 mots dans vos editeurs de texte enrichi. Le nombre de mots n'est pas un facteur de classement direct. Mais votre contenu doit être de la plus haute qualité possible, avec des informations pertinentes et uniques. Pour répondre à ces conditions, votre contenu nécessite un minimum de paragraphes, et donc de mots",
+  "SEOChecks.wordCountCheck.not-found": "Aucun contenu Richtext n'a été trouvé.",
+  "SEOChecks.wordCountCheck.300": "Votre contenu Richtext de 1er niveau contient moins de 300 mots.",
+  "SEOChecks.wordCountCheck.label": "Votre contenu doit être de la plus haute qualité possible, avec des informations pertinentes et uniques. Votre contenu nécessite un minimum de paragraphes, et donc de mots.",
+  "SEOChecks.wordCountCheck.words": "Mots:",
+  "Modal.seo-component-empty": "Votre composant SEO est vide...",
+  "Modal.seo-component-empty-open-graph": "Les métadonnées Open Graph sont vides...",
+  "Tabs.title-settings": "Paramètres de titres",
+  "Tabs.social-network": "Réseaux sociaux",
+  "Tabs.seo-analyse": "Analyse SEO",
+  "Title-settings.metaTitle-too-long": "La balise meta title est trop long",
+  "Title-settings.metaTitle-tooltip": "La balise de titre est l'une des premières choses que les utilisateurs remarquent dans le SERP. C'est le titre de votre page qui offre un aperçu de ce dont parle votre contenu.",
+  "Title-settings.metaDescription-too-long": "La balise meta description est trop longue",
+  "Title-settings.metaDescription-too-short": "La balise meta description est trop courte",
+  "Title-settings.metaDescription-tooltip": "La méta description est d'une importance égale à la balise de titre. Si la balise de titre est le titre qui apparaît en haut d'un résultat de recherche, la méta description est l'extrait qui s'affiche en dessous.",
+  "Title-settings.metaTitle-hint": "/60 caractères (limite maximale recommandée)",
+  "Title-settings.metaDescription-hint": "/160 caractères (limite maximale recommandée)",
+  "Social-network.metaTitle-hint": "/60 caractères (limite maximale recommandée)",
+  "Social-network.metaDescription-hint": "/65 caractères (limite maximale recommandée)",
+  "Social-network.accordion.description": "Voyez à quoi ressemblera votre contenu posté sur",
+  "Social-network.no-tags": "Vous n'avez pas encore de balises Open Graph.",
+  "Social-network.platform.facebook": "Facebook",
+  "Social-network.platform.twitter": "X (Twitter)",
+  "Social-network.platform.linkedin": "LinkedIn",
+  "Modal.cancel": "Annulez",
+  "Button.see-details": "PLUS DE DETAILS",
+  "Button.open-graph-preview": "Aperçu Open Graph",
+  "Button.browser-preview": "Aperçu Navigateurs",
+  "Button.seo-analyze": "Analyse SEO",
+  Good: Good$2,
+  Improvements: Improvements$2,
+  Bad: Bad$2,
+  "Social-preview.alert": "Complétez votre composant afin d'obtenir un aperçu",
+  Information: Information$2,
+  "notification.success.settings": "Paramètres enregistrés pour le content-type {collectionName}.",
+  "notification.error.settings": "Impossible d'enregistrer les paramètres SEO."
+};
+const Good$1 = "Bom";
+const Improvements$1 = "Pode melhorar";
+const Bad$1 = "Ruim";
+const Information$1 = "Informações";
+const ptBR = {
+  "Plugin.name": "Plugin SEO",
+  "SEOPage.header.button.edit-component": "Editar componente SEO",
+  "SEOPage.header.button.back": "Voltar",
+  "SEOPage.header.title": "SEO",
+  "SEOPage.header.subtitle": "Otimize o seu conteúdo para ser amigável aos mecanismos de busca.",
+  "SEOPage.empty-component-layout.github-error": "Este repositório GitHub não contém componente shared.seo ou shared.open-graph",
+  "SEOPage.empty-component-layout.regexp-error": "Favor fornecer um URL válido do repositório GitHub",
+  "SEOPage.empty-component-layout.no-component": "Você não tem nenhum componente SEO ainda",
+  "SEOPage.empty-component-layout.input.tooltip": "O repositório strapi/components no GitHub contém o componente SEO padrão",
+  "SEOPage.info.information": "Certifique-se de utilizar o componente shared.seo criado, nomeá-lo como 'seo' e adicioná-lo na raiz do seu Content-Type .",
+  "SEOPage.info.no-collection-types": "Você não tem nenhum tipo de coleção ainda...",
+  "SEOPage.info.no-single-types": "Você não tem nenhum tipo singular ainda...",
+  "SEOPage.info.no-plugin-content-type": "Você ainda não tem nenhum tipo de conteúdo de plugin...",
+  "SEOPage.info.create-collection-type": "Criar seu primeiro tipo de coleção",
+  "SEOPage.info.create-single-type": "Criar seu primeiro tipo singular",
+  "SEOPage.info.added": "Adicionado",
+  "SEOPage.info.add": "Adicionar componente",
+  "SEOPage.info.settings": "Configurações",
+  "SEOPage.info.settings.meta-title-check": "Meta Título",
+  "SEOPage.info.settings.meta-description-check": "Meta Descrição",
+  "SEOPage.info.settings.meta-robots-check": "Meta Robots",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "Contagem de Palavras",
+  "SEOPage.info.settings.canonical-url-check": "URL Canônico",
+  "SEOPage.info.settings.keyword-density-check": "Densidade de Palavras-chave",
+  "SEOPage.info.settings.structured-data-check": "Dados Estruturados",
+  "SEOPage.info.settings.alternative-text-check": "Texto Alternativo (Alt)",
+  "SEOPage.info.settings.last-updated-at-check": "Última Atualização",
+  "SEOPage.info.settings.cancel.button": "Cancelar",
+  "SEOPage.info.settings.save.button": "Salvar",
+  "SEOPage.info.settings.information": "Desativar verificações de SEO para este tipo de conteúdo específico.",
+  "SEOPage.tab.collection-type-title": "Tipo de coleção",
+  "SEOPage.tab.single-type-title": "Tipo simples",
+  "SEOPage.tab.plugin-title": "Plugins",
+  "SEOPage.tab-panel.column-name": "Nome",
+  "SEOSocialPreview.website-url": "url-do-seu-site.com.br",
+  "SEOSocialPreview.keyword-check": "Você usa {count} palavra(s)-chave em seu {label} ({matches})",
+  "SEOSocialPreview.meta-length-check": "Seu {label} tem {length} caracteres (máx. {max})",
+  "SEOModal.summary-title.meta-title": "Meta título",
+  "SEOModal.summary-title.meta-description": "Meta descrição",
+  "SEOModal.summary-title.word-counter": "Contador de palavras",
+  "SEOModal.summary-title.word-densisty": "Densidade de palavras-chave",
+  "SEOModal.summary-title.open-graph": "Tag Open Graph",
+  "SEOModal.summary-title.canonical-url": "URL canónico",
+  "SEOModal.summary-title.structured-data": "Dados estruturados JSON",
+  "SEOModal.summary-title.meta-robots": "Meta Robots",
+  "SEOModal.summary-title.alt-attributes": "Atributo alt",
+  "SEOModal.summary-title.last-updated-at": "Última atualização de conteúdo",
+  "SEOChecks.keywordsDensityCheck.default": "Cada palavra-chave é usada mais de 2 vezes.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "Não foram encontradas palavras-chave no seu componente SEO.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "Uma palavra-chave não está sendo utilizada no seu conteúdo.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "Uma palavra-chave só é usada uma vez no seu conteúdo.",
+  "SEOChecks.keywordsDensityCheck.label": "Defina palavras-chave para as quais quer ser classificado no seu componente SEO. Isto irá analisar a densidade das suas palavras-chave nos seus editores (campos richtext) de 1º nível.",
+  "SEOChecks.alternativeTextCheck.default": "Todas as suas imagens contêm um atributo alt! Parabéns!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "O nome e o texto alternativo das suas imagens são todos iguais. Strapi gera automaticamente o atributo alt a partir do nome por padrão se o campo estiver vazio durante o carregamento do arquivo. Ter o atributo alt nas imagens descrito claramente é uma prática muito boa.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "Um ou mais campos de mídia está/estão sem o atributo alt.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "Pelo menos uma imagem em algum editor (campo richtext) de 1º nível está com o atributo alt faltando.",
+  "SEOChecks.alternativeTextCheck.label": "Isto verificará se tem algum texto alternativo em falta para as suas imagens (campo de media) e nos seus editores (campo richtext) de 1º nível.",
+  "SEOChecks.alternativeTextCheck.missing-text": "alteração em falta no seguinte campo richtext:",
+  "SEOChecks.alternativeTextCheck.missing-image": "faltando nos campos de imagem de primeiro nível ou dentro de um componente.",
+  "SEOChecks.alternativeTextCheck.tip-label": "Dica:",
+  "SEOChecks.alternativeTextCheck.tip-before": "Implemente uma regra no seu código front-end que utilize o nome das suas imagens caso o campo",
+  "SEOChecks.alternativeTextCheck.tip-after": "esteja vazio para reduzir ainda mais o risco de um atributo alt vazio no seu site.",
+  "SEOChecks.canonicalUrlCheck.default": "Não foi encontrado nenhum URL canónico.",
+  "SEOChecks.canonicalUrlCheck.found": "Foi encontrado um URL canónico!",
+  "SEOChecks.canonicalUrlCheck.label": "Isto irá verificar se tem um URL canónico.",
+  "SEOChecks.canonicalUrlCheck.url": "URL canónico:",
+  "SEOChecks.lastUpdatedAtCheck.default": "Este conteúdo foi modificado há mais de um ano! Os motores de busca adoram conteúdo atualizados.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "Deve salvar esta entrada primeiro.",
+  "SEOChecks.lastUpdatedAtCheck.success": "Fantástico! Este conteúdo foi modificado pela última vez há menos de um ano!",
+  "SEOChecks.lastUpdatedAtCheck.label": "Os motores de busca adoram conteúdo atualizado. Isto irá verificar se a sua entrada foi modificada pela última vez há menos de um ano.",
+  "SEOChecks.lastUpdatedAtCheck.last": "Última atualização em:",
+  "SEOChecks.metaDescriptionCheck.default": "Foi encontrada uma Meta Descrição!",
+  "SEOChecks.metaDescriptionCheck.not-found": "Não foi encontrada nenhuma Meta Descrição.",
+  "SEOChecks.metaRobotsCheck.default": "Foram encontrado meta tags Robot!",
+  "SEOChecks.metaRobotsCheck.not-found": "Nenhuma meta tag Robot foi encontrada.",
+  "SEOChecks.metaRobotsCheck.label": "A meta tag Robot informa os motores de busca que páginas do seu site devem ser indexadas e muito mais.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} está ativado: {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} está desativado: {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "Aviso:",
+  "SEOChecks.metaRobotsCheck.notice-before": "Para não indexar sua entrada e não seguir links, seu campo MetaRobots deve conter o seguinte:",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": '. O restante deve ser tratado pela lógica do seu código front-end. "Se o campo contiver noindex, você precisará criar a meta tag correspondente, etc."',
+  "SEOChecks.openGraphCheck.not-found": "Não foram encontradas tags Open Graph.",
+  "SEOChecks.openGraphCheck.not-configured": "As tags mínimas obrigatórias do OpenGraph não estão configuradas.",
+  "SEOChecks.openGraphCheck.configured": "Tags Open Graph estão configuradas",
+  "SEOChecks.openGraphCheck.label": "Tags Open Graph permite você manipular o título, descrição e imagens dos seus posts",
+  "SEOChecks.metaTitleCheck.default": "Uma Meta Título foi encontrada!",
+  "SEOChecks.metaTitleCheck.not-found": "Nenhuma Meta Título foi encontrada.",
+  "SEOChecks.structuredDataCheck.default": "Um Dados estruturados JSON foi encontrado! Entretanto, não podemos validar a exatidão de seu conteúdo.",
+  "SEOChecks.structuredDataCheck.not-found": "Nenhum Dados estruturados JSON foi encontrada.",
+  "SEOChecks.structuredDataCheck.label": "Dados estruturados JSON é um formato padronizado para fornecer informações sobre uma página e classificar o conteúdo da página.",
+  "SEOChecks.wordCountCheck.default": "Você tem mais de 300 palavras. A contagem de palavras não é um fator de classificação direta. Mas seu conteúdo deve ser da mais alta qualidade possível, com informações relevantes e únicas. Para atender a estas condições, seu conteúdo requer um mínimo de parágrafos e, portanto, de palavras.",
+  "SEOChecks.wordCountCheck.not-found": "nenhum conteúdo rico(campo Richtext) foi encontrado.",
+  "SEOChecks.wordCountCheck.300": "Seu conteúdo rico (campo Richtext) de 1º nível tem menos de 300 palavras.",
+  "SEOChecks.wordCountCheck.label": "Seu conteúdo deve ser da mais alta qualidade possível, com informações relevantes e únicas. Sua entrada requer um mínimo de parágrafos e, portanto, de palavras.",
+  "SEOChecks.wordCountCheck.words": "Palavras:",
+  "Modal.seo-component-empty": "Seu componente SEO está vazio...",
+  "Modal.seo-component-empty-open-graph": "Os metadados do Open Graph estão vazios...",
+  "Tabs.title-settings": "Configurações de Título",
+  "Tabs.social-network": "Redes Sociais",
+  "Tabs.seo-analyse": "Analizador de SEO",
+  "Title-settings.metaTitle-too-long": "Meta Título é muito grande.",
+  "Title-settings.metaTitle-tooltip": "A tag de título é uma das primeiras coisas que os usuários notam nos SERPs. É o título de sua página que oferece uma prévia do que se trata seu conteúdo.",
+  "Title-settings.metaDescription-too-long": "Meta Descrição é muito longa.",
+  "Title-settings.metaDescription-too-short": "Meta Descrição é muito curta",
+  "Title-settings.metaDescription-tooltip": "A Meta Descrição é tão importante quanto o título. O título é a informação que aparece no topo de um resultado de busca e a Meta Description é a informação complementar que aparece logo abaixo.",
+  "Title-settings.metaTitle-hint": "/60 caracteres (limite máximo recomendado)",
+  "Title-settings.metaDescription-hint": "/160 caracteres (limite máximo recomendado)",
+  "Social-network.metaTitle-hint": "/60 caracteres (limite máximo recomendado)",
+  "Social-network.metaDescription-hint": "/65 caracteres (limite máximo recomendado)",
+  "Social-network.accordion.description": "Veja como será seu conteúdo publicado em",
+  "Social-network.no-tags": "Você ainda não tem nenhuma tag Open Graph.",
+  "Social-network.platform.facebook": "Facebook",
+  "Social-network.platform.twitter": "X (Twitter)",
+  "Social-network.platform.linkedin": "LinkedIn",
+  "Modal.cancel": "Cancelar",
+  "Button.see-details": "VER DETALHES",
+  "Button.open-graph-preview": "Pré-visualização Open Graph",
+  "Button.browser-preview": "Visualização no Navegador",
+  "Button.seo-analyze": "Analizador SEO",
+  Good: Good$1,
+  Improvements: Improvements$1,
+  Bad: Bad$1,
+  "Social-preview.alert": "Complete as informações do componente de rede social para ver a prévia",
+  Information: Information$1,
+  "notification.success.settings": "Configurações salvas para o tipo de conteúdo {collectionName}.",
+  "notification.error.settings": "Falha ao salvar as configurações de SEO."
+};
+const Good = "İyi";
+const Improvements = "Geliştirilebilir";
+const Bad = "Kötü";
+const Information = "Bilgi";
+const tr = {
+  "Plugin.name": "SEO Eklentisi",
+  "SEOPage.header.button.edit-component": "SEO bileşenini düzenle",
+  "SEOPage.header.button.back": "Geri",
+  "SEOPage.header.title": "SEO",
+  "SEOPage.header.subtitle": "İçeriğinizi arama motorları (SEO) için optimize edin",
+  "SEOPage.empty-component-layout.github-error": "Bu GitHub deposu shared.seo veya shared.open-graph bileşenini içermiyor",
+  "SEOPage.empty-component-layout.regexp-error": "Lütfen geçerli bir GitHub depo URL'si girin",
+  "SEOPage.empty-component-layout.no-component": "Henüz bir SEO bileşeniniz yok",
+  "SEOPage.empty-component-layout.input.tooltip": "strapi/components GitHub deposu varsayılan SEO bileşenini içerir",
+  "SEOPage.info.information": "İçe aktarılan shared.seo bileşenini kullandığınızdan, adını 'seo' olarak belirlediğinizden ve İçerik Türünüzün kök dizinine eklediğinizden emin olun.",
+  "SEOPage.info.no-collection-types": "Henüz hiç koleksiyon türünüz yok...",
+  "SEOPage.info.no-single-types": "Henüz hiç tekil türünüz yok...",
+  "SEOPage.info.no-plugin-content-type": "Henüz hiç eklenti içerik türünüz yok...",
+  "SEOPage.info.create-collection-type": "İlk koleksiyon türünüzü oluşturun",
+  "SEOPage.info.create-single-type": "İlk tekil türünüzü oluşturun",
+  "SEOPage.info.added": "Eklendi",
+  "SEOPage.info.add": "Bileşen ekle",
+  "SEOPage.info.settings": "Ayarlar",
+  "SEOPage.info.settings.meta-title-check": "Meta Başlığı",
+  "SEOPage.info.settings.meta-description-check": "Meta Açıklaması",
+  "SEOPage.info.settings.meta-robots-check": "Meta Robots",
+  "SEOPage.info.settings.open-graph-check": "Open Graph",
+  "SEOPage.info.settings.word-count-check": "Kelime Sayısı",
+  "SEOPage.info.settings.canonical-url-check": "Kanonik URL",
+  "SEOPage.info.settings.keyword-density-check": "Anahtar Kelime Yoğunluğu",
+  "SEOPage.info.settings.structured-data-check": "Yapılandırılmış Veri",
+  "SEOPage.info.settings.alternative-text-check": "Alternatif Metin (Alt)",
+  "SEOPage.info.settings.last-updated-at-check": "Son Güncelleme Tarihi",
+  "SEOPage.info.settings.cancel.button": "İptal",
+  "SEOPage.info.settings.save.button": "Kaydet",
+  "SEOPage.info.settings.information": "Bu içerik türü için belirli SEO kontrollerini devre dışı bırakın.",
+  "SEOPage.tab.collection-type-title": "Koleksiyon Türleri",
+  "SEOPage.tab.single-type-title": "Tekil Türler",
+  "SEOPage.tab.plugin-title": "Eklentiler",
+  "SEOPage.tab-panel.column-name": "Ad",
+  "SEOSocialPreview.website-url": "web-sitenizin-adresi.org",
+  "SEOSocialPreview.keyword-check": "{label} içinde {count} anahtar kelime kullanıyorsunuz ({matches})",
+  "SEOSocialPreview.meta-length-check": "{label} uzunluğunuz {length} karakter (maks. {max})",
+  "SEOModal.summary-title.meta-title": "Meta Başlığı",
+  "SEOModal.summary-title.meta-description": "Meta Açıklaması",
+  "SEOModal.summary-title.word-counter": "Kelime Sayacı",
+  "SEOModal.summary-title.word-densisty": "Anahtar Kelime Yoğunluğu",
+  "SEOModal.summary-title.open-graph": "Open Graph Etiketleri",
+  "SEOModal.summary-title.canonical-url": "Kanonik URL",
+  "SEOModal.summary-title.structured-data": "JSON Yapılandırılmış Veri",
+  "SEOModal.summary-title.meta-robots": "Meta Robots",
+  "SEOModal.summary-title.alt-attributes": "Alternatif Metinler",
+  "SEOModal.summary-title.last-updated-at": "Son güncelleme",
+  "SEOChecks.keywordsDensityCheck.default": "Her anahtar kelime 2 defadan fazla kullanılmış.",
+  "SEOChecks.keywordsDensityCheck.no-keywords": "SEO bileşeninizde anahtar kelime bulunamadı.",
+  "SEOChecks.keywordsDensityCheck.one-not-used": "Bir anahtar kelime içeriğinizde hiç kullanılmıyor.",
+  "SEOChecks.keywordsDensityCheck.one-used-once": "Bir anahtar kelime içeriğinizde yalnızca bir kez kullanılmış.",
+  "SEOChecks.keywordsDensityCheck.label": "SEO bileşeninizde sıralamaya girmek istediğiniz anahtar kelimeleri tanımlayın. Bu, 1. seviye zengin metin düzenleyicilerinizdeki anahtar kelime yoğunluğunu analiz edecektir.",
+  "SEOChecks.alternativeTextCheck.default": "Tüm görselleriniz alt özniteliği içeriyor! Tebrikler!",
+  "SEOChecks.alternativeTextCheck.intersection-zero": "Görsellerinizin dosya adı ve alternatif metni aynı. Medya yükleme sırasında alan boş bırakılırsa Strapi varsayılan olarak dosya adından alt özniteliği oluşturur. Görselleri açıkça tanımlayan alt metinler kullanmak çok iyi bir uygulamadır.",
+  "SEOChecks.alternativeTextCheck.intersection-negative": "medya alanındaki görsel(ler)de alt özniteliği eksik.",
+  "SEOChecks.alternativeTextCheck.richtext-missing-one": "seviye zengin metin düzenleyicilerindeki en az bir görselde alt özniteliği eksik.",
+  "SEOChecks.alternativeTextCheck.label": "Görsellerinizde (medya alanı) ve 1. seviye zengin metin düzenleyicilerinizde eksik alternatif metin olup olmadığını kontrol eder.",
+  "SEOChecks.alternativeTextCheck.missing-text": "aşağıdaki zengin metin alanında alt özniteliği eksik:",
+  "SEOChecks.alternativeTextCheck.missing-image": "birinci seviye görsel alanlarında veya bir bileşen içinde eksik.",
+  "SEOChecks.alternativeTextCheck.tip-label": "İpucu:",
+  "SEOChecks.alternativeTextCheck.tip-before": "Web sitenizde boş bir alt özniteliği riskini azaltmak için",
+  "SEOChecks.alternativeTextCheck.tip-after": "alanı boşsa görsellerinizin adını kullanan bir kuralı ön yüz kodunuzda uygulayın.",
+  "SEOChecks.canonicalUrlCheck.default": "Kanonik URL bulunamadı.",
+  "SEOChecks.canonicalUrlCheck.found": "Bir Kanonik URL bulundu!",
+  "SEOChecks.canonicalUrlCheck.label": "Kanonik URL'nizin olup olmadığını kontrol eder.",
+  "SEOChecks.canonicalUrlCheck.url": "Kanonik URL:",
+  "SEOChecks.lastUpdatedAtCheck.default": "Bu içerik bir yıldan daha uzun süre önce değiştirilmiş! Arama motorları güncel içeriği sever.",
+  "SEOChecks.lastUpdatedAtCheck.save-content": "Önce bu kaydı kaydetmelisiniz.",
+  "SEOChecks.lastUpdatedAtCheck.success": "Harika! Bu içerik bir yıldan daha kısa süre önce güncellendi!",
+  "SEOChecks.lastUpdatedAtCheck.label": "Arama motorları güncel içeriği sever. Bu kontrol, kaydınızın son bir yıl içinde güncellenip güncellenmediğini denetler.",
+  "SEOChecks.lastUpdatedAtCheck.last": "Son güncelleme:",
+  "SEOChecks.metaDescriptionCheck.default": "Meta Açıklaması bulundu!",
+  "SEOChecks.metaDescriptionCheck.not-found": "Meta Açıklaması bulunamadı.",
+  "SEOChecks.metaRobotsCheck.default": "Robot meta etiketleri bulundu!",
+  "SEOChecks.metaRobotsCheck.not-found": "Robot meta etiketi bulunamadı.",
+  "SEOChecks.metaRobotsCheck.label": "Robots meta etiketi, arama motorlarına sitenizdeki hangi sayfaların dizine eklenmesi gerektiğini bildirir.",
+  "SEOChecks.metaRobotsCheck.activated": "{tag} etkinleştirildi: {message}",
+  "SEOChecks.metaRobotsCheck.disabled": "{tag} devre dışı bırakıldı: {message}",
+  "SEOChecks.metaRobotsCheck.notice-label": "Bilgi:",
+  "SEOChecks.metaRobotsCheck.notice-before": "Kaydınızın dizine eklenmemesi ve bağlantıların takip edilmemesi için MetaRobots alanınız şunları içermelidir:",
+  "SEOChecks.metaRobotsCheck.notice-value": "noindex, nofollow",
+  "SEOChecks.metaRobotsCheck.notice-after": ". Geri kalanı ön yüz kod mantığınız tarafından işlenmelidir.",
+  "SEOChecks.openGraphCheck.not-found": "Open Graph etiketi bulunamadı.",
+  "SEOChecks.openGraphCheck.not-configured": "Gerekli minimum OpenGraph etiketleri yapılandırılmamış.",
+  "SEOChecks.openGraphCheck.configured": "Open Graph etiketleri yapılandırıldı",
+  "SEOChecks.openGraphCheck.label": "Open Graph etiketleri, gönderilerinizin başlığını, açıklamasını ve görselini yönetmenize olanak tanır.",
+  "SEOChecks.metaTitleCheck.default": "Meta Başlığı bulundu!",
+  "SEOChecks.metaTitleCheck.not-found": "Meta Başlığı bulunamadı.",
+  "SEOChecks.structuredDataCheck.default": "Yapılandırılmış Veri JSON'u bulundu! Ancak içeriğinin doğruluğunu otomatik olarak doğrulayamıyoruz.",
+  "SEOChecks.structuredDataCheck.not-found": "Yapılandırılmış Veri JSON'u bulunamadı.",
+  "SEOChecks.structuredDataCheck.label": "Yapılandırılmış veri, bir sayfa hakkında bilgi sağlamak ve sayfa içeriğini sınıflandırmak için standartlaştırılmış bir biçimdir.",
+  "SEOChecks.wordCountCheck.default": "300'den fazla kelimeniz var. Kelime sayısı doğrudan bir sıralama faktörü değildir, ancak içeriğiniz ilgili ve benzersiz bilgilerle mümkün olduğunca yüksek kalitede olmalıdır.",
+  "SEOChecks.wordCountCheck.not-found": "Zengin metin içeriği bulunamadı.",
+  "SEOChecks.wordCountCheck.300": "seviye zengin metin içerikleriniz 300 kelimeden az.",
+  "SEOChecks.wordCountCheck.label": "İçeriğiniz ilgili ve benzersiz bilgilerle mümkün olduğunca yüksek kalitede olmalıdır. Kaydınız minimum sayıda paragraf ve kelime gerektirir.",
+  "SEOChecks.wordCountCheck.words": "Kelime sayısı:",
+  "Modal.seo-component-empty": "SEO bileşeniniz boş...",
+  "Modal.seo-component-empty-open-graph": "Open Graph meta verileri boş...",
+  "Tabs.title-settings": "Başlık ayarları",
+  "Tabs.social-network": "Sosyal ağlar",
+  "Tabs.seo-analyse": "SEO analizi",
+  "Title-settings.metaTitle-too-long": "Meta Başlığı çok uzun",
+  "Title-settings.metaTitle-tooltip": "Başlık etiketi, kullanıcıların arama sonuçlarında fark ettiği ilk şeylerden biridir ve içeriğinizin ne hakkında olduğunun önizlemesini sunar.",
+  "Title-settings.metaDescription-too-long": "Meta Açıklaması çok uzun",
+  "Title-settings.metaDescription-too-short": "Meta Açıklaması çok kısa",
+  "Title-settings.metaDescription-tooltip": "Meta açıklaması da başlık etiketi kadar önemlidir. Arama sonuçlarında başlığın hemen altında görüntülenen özet metindir.",
+  "Title-settings.metaTitle-hint": "/60 karakter (önerilen maksimum sınır)",
+  "Title-settings.metaDescription-hint": "/160 karakter (önerilen maksimum sınır)",
+  "Social-network.metaTitle-hint": "/60 karakter (önerilen maksimum sınır)",
+  "Social-network.metaDescription-hint": "/65 karakter (önerilen maksimum sınır)",
+  "Social-network.accordion.description": "İçeriğinizin şu platformda paylaşıldığında nasıl görüneceğini inceleyin:",
+  "Social-network.no-tags": "Henüz hiç Open Graph etiketiniz yok.",
+  "Social-network.platform.facebook": "Facebook",
+  "Social-network.platform.twitter": "X (Twitter)",
+  "Social-network.platform.linkedin": "LinkedIn",
+  "Modal.cancel": "İptal",
+  "Button.see-details": "DETAYLARI GÖR",
+  "Button.open-graph-preview": "Open Graph Önizlemesi",
+  "Button.browser-preview": "Tarayıcı Önizlemesi",
+  "Button.seo-analyze": "SEO Analizi",
+  Good,
+  Improvements,
+  Bad,
+  "Social-preview.alert": "Önizlemeyi görmek için sosyal ağ bileşeninizi tamamlayın",
+  Information,
+  "notification.success.settings": "{collectionName} içerik türü için ayarlar kaydedildi.",
+  "notification.error.settings": "SEO ayarları kaydedilemedi."
+};
+const name = pluginPkg.strapi.name;
+const TRAD_MAP = {
+  en,
+  es,
+  ar,
+  tr,
+  fr,
+  "pt-BR": ptBR
+};
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `${pluginId}`,
+      icon: icons.Search,
+      permissions: pluginPermissions.main,
+      intlLabel: {
+        id: `${pluginId}.Plugin.name`,
+        defaultMessage: "SEO"
+      },
+      Component: () => Promise.resolve().then(() => require("./index-CZ4VBOGS.cjs"))
+    });
+    app.registerPlugin({
+      id: pluginId,
+      initializer: Initializer,
+      isReady: false,
+      name
+    });
+  },
+  bootstrap(app) {
+    app.getPlugin("content-manager").injectComponent("editView", "right-links", {
+      name: "SeoChecker",
+      Component: SeoChecker
+    });
+  },
+  registerTrads: createRegisterTrads({
+    pluginId,
+    defaultLocales: [],
+    keepUnprefixed: false,
+    translations: TRAD_MAP
+  })
+};
+exports.Illo = Illo;
+exports.getTrad = getTrad;
+exports.index = index;
+exports.pluginId = pluginId;
+exports.pluginPermissions = pluginPermissions;
+exports.useSettingsApi = useSettingsApi;