@zoyth/simple-site-framework 1.0.0

package/dist/index.js

@@ -0,0 +1,1713 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/i18n/config.ts
+var config_exports = {};
+__export(config_exports, {
+  __resetI18nConfig__: () => __resetI18nConfig__,
+  defaultLocale: () => defaultLocale,
+  getDefaultLocale: () => getDefaultLocale,
+  getI18nConfig: () => getI18nConfig,
+  getLocaleCookieConfig: () => getLocaleCookieConfig,
+  getLocaleLabel: () => getLocaleLabel,
+  getLocaleLabels: () => getLocaleLabels,
+  getLocaleName: () => getLocaleName,
+  getLocaleNames: () => getLocaleNames,
+  getLocalePrefix: () => getLocalePrefix,
+  getLocales: () => getLocales,
+  getRtlLocales: () => getRtlLocales,
+  isI18nConfigInitialized: () => isI18nConfigInitialized,
+  isLocaleDetectionEnabled: () => isLocaleDetectionEnabled,
+  isSupportedLocale: () => isSupportedLocale,
+  localeLabels: () => localeLabels,
+  localeNames: () => localeNames,
+  locales: () => locales,
+  setI18nConfig: () => setI18nConfig
+});
+function setI18nConfig(config) {
+  if (!config.locales || config.locales.length === 0) {
+    throw new Error("i18n config must define at least one locale");
+  }
+  if (!config.defaultLocale) {
+    throw new Error("i18n config must define a default locale");
+  }
+  if (!config.locales.includes(config.defaultLocale)) {
+    throw new Error(
+      `Default locale "${config.defaultLocale}" must be included in locales array: [${config.locales.join(", ")}]`
+    );
+  }
+  const configWithDefaults = {
+    ...config,
+    localePrefix: config.localePrefix || "as-needed",
+    localeDetection: config.localeDetection !== false,
+    // Default to true
+    localeNames: config.localeNames || {},
+    localeLabels: config.localeLabels || {},
+    rtlLocales: config.rtlLocales || [],
+    localeCookie: {
+      name: config.localeCookie?.name || "NEXT_LOCALE",
+      maxAge: config.localeCookie?.maxAge || 365 * 24 * 60 * 60,
+      // 1 year
+      sameSite: config.localeCookie?.sameSite || "lax"
+    },
+    slugTranslations: config.slugTranslations || {}
+  };
+  globalI18nConfig = configWithDefaults;
+}
+function getI18nConfig() {
+  if (!globalI18nConfig) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn(
+        "\u26A0\uFE0F  i18n configuration not initialized. Using legacy defaults.\nCall setI18nConfig() in your layout before using i18n features.\nSee docs/i18n/MIGRATION.md for setup instructions."
+      );
+    }
+    return {
+      locales: ["fr", "en"],
+      defaultLocale: "fr",
+      localePrefix: "as-needed",
+      localeDetection: true,
+      localeNames: { fr: "Fran\xE7ais", en: "English" },
+      localeLabels: { fr: "FR", en: "EN" },
+      rtlLocales: [],
+      localeCookie: {
+        name: "NEXT_LOCALE",
+        maxAge: 365 * 24 * 60 * 60,
+        sameSite: "lax"
+      },
+      slugTranslations: {}
+    };
+  }
+  return globalI18nConfig;
+}
+function isI18nConfigInitialized() {
+  return globalI18nConfig !== null;
+}
+function __resetI18nConfig__() {
+  globalI18nConfig = null;
+}
+function getLocales() {
+  return getI18nConfig().locales;
+}
+function getDefaultLocale() {
+  return getI18nConfig().defaultLocale;
+}
+function getLocalePrefix() {
+  return getI18nConfig().localePrefix || "as-needed";
+}
+function getLocaleNames() {
+  return getI18nConfig().localeNames || {};
+}
+function getLocaleLabels() {
+  return getI18nConfig().localeLabels || {};
+}
+function getRtlLocales() {
+  return getI18nConfig().rtlLocales || [];
+}
+function isLocaleDetectionEnabled() {
+  return getI18nConfig().localeDetection !== false;
+}
+function getLocaleCookieConfig() {
+  const config = getI18nConfig();
+  return {
+    name: config.localeCookie?.name || "NEXT_LOCALE",
+    maxAge: config.localeCookie?.maxAge || 365 * 24 * 60 * 60,
+    sameSite: config.localeCookie?.sameSite || "lax"
+  };
+}
+function isSupportedLocale(locale) {
+  return getLocales().includes(locale);
+}
+function getLocaleName(locale) {
+  const names = getLocaleNames();
+  return names[locale] || locale;
+}
+function getLocaleLabel(locale) {
+  const labels2 = getLocaleLabels();
+  return labels2[locale] || locale.toUpperCase();
+}
+var globalI18nConfig, locales, defaultLocale, localeNames, localeLabels;
+var init_config = __esm({
+  "src/lib/i18n/config.ts"() {
+    "use strict";
+    globalI18nConfig = null;
+    locales = ["fr", "en"];
+    defaultLocale = "fr";
+    localeNames = {
+      fr: "Fran\xE7ais",
+      en: "English"
+    };
+    localeLabels = {
+      fr: "FR",
+      en: "EN"
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FeaturesGrid: () => FeaturesGrid,
+  LOCALE_COOKIE_NAME: () => LOCALE_COOKIE_NAME,
+  TrackedLink: () => TrackedLink,
+  cn: () => cn,
+  createArticle: () => createArticle,
+  createBreadcrumbList: () => createBreadcrumbList,
+  createFAQPage: () => createFAQPage,
+  createI18nMiddleware: () => createI18nMiddleware,
+  createMultiLanguageEntries: () => createMultiLanguageEntries,
+  createOrganization: () => createOrganization,
+  createProduct: () => createProduct,
+  createSitemapEntry: () => createSitemapEntry,
+  createWebSite: () => createWebSite,
+  creditCardSchema: () => creditCardSchema,
+  dateString: () => dateString,
+  defaultLocale: () => defaultLocale,
+  defaultSlugTranslations: () => defaultSlugTranslations,
+  emailSchema: () => emailSchema,
+  fileSchema: () => fileSchema,
+  formErrorMessages: () => formErrorMessages,
+  formatCurrency: () => formatCurrency,
+  formatDate: () => formatDate,
+  formatDateRange: () => formatDateRange,
+  formatFileSize: () => formatFileSize,
+  formatList: () => formatList,
+  formatLocaleDisplay: () => formatLocaleDisplay,
+  formatNumber: () => formatNumber,
+  formatRelativeTime: () => formatRelativeTime,
+  generateArticleMetadata: () => generateArticleMetadata,
+  generateDesignTokens: () => generateDesignTokens,
+  generateMetadata: () => generateMetadata,
+  generateSitemap: () => generateSitemap,
+  generateThemeCSS: () => generateThemeCSS,
+  getAllPolicies: () => getAllPolicies,
+  getAlternateLocales: () => getAlternateLocales,
+  getDefaultLocale: () => getDefaultLocale,
+  getErrorMessage: () => getErrorMessage,
+  getFontConfig: () => getFontConfig,
+  getFontVariables: () => getFontVariables,
+  getI18nConfig: () => getI18nConfig,
+  getLocaleAutonym: () => getLocaleAutonym,
+  getLocaleCookieConfig: () => getLocaleCookieConfig,
+  getLocaleFromCookie: () => getLocaleFromCookie,
+  getLocaleLabel: () => getLocaleLabel,
+  getLocaleLabels: () => getLocaleLabels,
+  getLocaleName: () => getLocaleName,
+  getLocaleNames: () => getLocaleNames,
+  getLocalePrefix: () => getLocalePrefix,
+  getLocales: () => getLocales,
+  getLocalizedString: () => getLocalizedString,
+  getNavigationString: () => getNavigationString,
+  getPolicyLocales: () => getPolicyLocales,
+  getPolicySlugs: () => getPolicySlugs,
+  getRelativeTime: () => getRelativeTime,
+  getRtlLocales: () => getRtlLocales,
+  getTextDirection: () => getTextDirection,
+  imageSchema: () => imageSchema,
+  isI18nConfigInitialized: () => isI18nConfigInitialized,
+  isLocaleDetectionEnabled: () => isLocaleDetectionEnabled,
+  isRtlLocale: () => isRtlLocale,
+  isSupportedLocale: () => isSupportedLocale,
+  loadPolicy: () => loadPolicy,
+  locales: () => locales,
+  matchLocale: () => matchLocale,
+  mustBeTrue: () => mustBeTrue,
+  normalizeLocale: () => normalizeLocale,
+  numericString: () => numericString,
+  optionalString: () => optionalString,
+  passwordSchema: () => passwordSchema,
+  phoneSchema: () => phoneSchema,
+  postalCodeSchema: () => postalCodeSchema,
+  replaceVariables: () => replaceVariables,
+  requiredString: () => requiredString,
+  serializeStructuredData: () => serializeStructuredData,
+  setI18nConfig: () => setI18nConfig,
+  setLocaleCookie: () => setLocaleCookie,
+  trackABTestEvent: () => trackABTestEvent,
+  trackCTAClick: () => trackCTAClick,
+  trackConversion: () => trackConversion,
+  trackError: () => trackError,
+  trackEvent: () => trackEvent,
+  trackFeatureEngagement: () => trackFeatureEngagement,
+  trackFormEvent: () => trackFormEvent,
+  trackNavigation: () => trackNavigation,
+  trackOutboundLink: () => trackOutboundLink,
+  trackPageView: () => trackPageView,
+  trackPricingEvent: () => trackPricingEvent,
+  trackResourceDownload: () => trackResourceDownload,
+  trackScrollDepth: () => trackScrollDepth,
+  trackSearch: () => trackSearch,
+  trackVideoEvent: () => trackVideoEvent,
+  translateSlug: () => translateSlug,
+  urlSchema: () => urlSchema,
+  validateLocale: () => validateLocale,
+  validateSitemap: () => validateSitemap,
+  validateSitemapEntry: () => validateSitemapEntry
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/lib/theme/generate-css.ts
+function generateThemeCSS(theme) {
+  return `
+    /* Brand Colors */
+    --color-primary: ${theme.brand.colors.primary};
+    --color-primary-hover: ${theme.brand.colors.primaryHover};
+    --color-primary-light: ${theme.brand.colors.primaryLight};
+    --color-primary-dark: ${theme.brand.colors.primaryDark};
+    --color-primary-gradient-start: ${theme.brand.colors.primaryGradientStart};
+    --color-primary-gradient-end: ${theme.brand.colors.primaryGradientEnd};
+    --color-hero-gradient-start: ${theme.brand.colors.heroGradientStart};
+    --color-hero-gradient-end: ${theme.brand.colors.heroGradientEnd};
+    --color-footer-gradient-start: ${theme.brand.colors.footerGradientStart};
+    --color-footer-gradient-end: ${theme.brand.colors.footerGradientEnd};
+
+    /* Fonts */
+    --font-heading: ${theme.brand.fonts.heading.family}, ${theme.brand.fonts.heading.fallback};
+    --font-body: ${theme.brand.fonts.body.family}, ${theme.brand.fonts.body.fallback};
+    --font-serif: ${theme.brand.fonts.heading.family}, ${theme.brand.fonts.heading.fallback};
+    --font-sans: ${theme.brand.fonts.body.family}, ${theme.brand.fonts.body.fallback};
+
+    /* Slate Colors */
+    --color-slate-50: ${theme.colors.slate[50]};
+    --color-slate-100: ${theme.colors.slate[100]};
+    --color-slate-200: ${theme.colors.slate[200]};
+    --color-slate-300: ${theme.colors.slate[300]};
+    --color-slate-400: ${theme.colors.slate[400]};
+    --color-slate-500: ${theme.colors.slate[500]};
+    --color-slate-600: ${theme.colors.slate[600]};
+    --color-slate-700: ${theme.colors.slate[700]};
+    --color-slate-800: ${theme.colors.slate[800]};
+    --color-slate-900: ${theme.colors.slate[900]};
+  `.trim();
+}
+function generateDesignTokens(theme) {
+  const radiusMap = {
+    sharp: "0",
+    rounded: "0.375rem",
+    pill: "9999px"
+  };
+  const shadowMap = {
+    flat: "none",
+    subtle: "0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1)",
+    prominent: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)"
+  };
+  const spacingMap = {
+    compact: {
+      section: "3rem",
+      element: "1rem"
+    },
+    comfortable: {
+      section: "6rem",
+      element: "1.5rem"
+    },
+    spacious: {
+      section: "8rem",
+      element: "2rem"
+    }
+  };
+  const spacing = spacingMap[theme.design.spacing];
+  return `
+    /* Design Tokens */
+    --radius-default: ${radiusMap[theme.design.borderRadius]};
+    --shadow-default: ${shadowMap[theme.design.shadows]};
+    --space-section: ${spacing.section};
+    --space-element: ${spacing.element};
+  `.trim();
+}
+
+// src/lib/theme/load-fonts.ts
+function getFontConfig(theme) {
+  return {
+    heading: {
+      family: theme.brand.fonts.heading.family,
+      weights: theme.brand.fonts.heading.weights.map(String),
+      variable: "--font-heading"
+    },
+    body: {
+      family: theme.brand.fonts.body.family,
+      weights: theme.brand.fonts.body.weights.map(String),
+      variable: "--font-body"
+    }
+  };
+}
+function getFontVariables(theme) {
+  const headingFamily = theme.brand.fonts.heading.family.replace(/\s+/g, "-").toLowerCase();
+  const bodyFamily = theme.brand.fonts.body.family.replace(/\s+/g, "-").toLowerCase();
+  return `var(--font-${headingFamily}) var(--font-${bodyFamily})`;
+}
+
+// src/lib/content/utils.ts
+function getLocalizedString(localizedString, locale) {
+  return localizedString[locale] || localizedString["en"] || "";
+}
+
+// src/lib/content/policies.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_rsc = require("next-mdx-remote/rsc");
+var import_rehype_slug = __toESM(require("rehype-slug"));
+async function loadPolicy(slug, locale, contentDir = "src/content/policies") {
+  const filePath = import_path.default.join(process.cwd(), contentDir, `${slug}.${locale}.md`);
+  if (!import_fs.default.existsSync(filePath)) {
+    throw new Error(
+      `Policy file not found: ${slug}.${locale}.md in ${contentDir}
+Looking for: ${filePath}`
+    );
+  }
+  const source = import_fs.default.readFileSync(filePath, "utf8");
+  const { content, frontmatter } = await (0, import_rsc.compileMDX)({
+    source,
+    options: {
+      parseFrontmatter: true,
+      mdxOptions: {
+        rehypePlugins: [import_rehype_slug.default]
+      }
+    }
+  });
+  if (!frontmatter.title) {
+    throw new Error(`Policy ${slug}.${locale}.md is missing required frontmatter field: title`);
+  }
+  if (!frontmatter.lastUpdated) {
+    throw new Error(
+      `Policy ${slug}.${locale}.md is missing required frontmatter field: lastUpdated`
+    );
+  }
+  return {
+    content,
+    metadata: frontmatter,
+    slug,
+    locale
+  };
+}
+function getPolicySlugs(contentDir = "src/content/policies") {
+  const policiesDir = import_path.default.join(process.cwd(), contentDir);
+  if (!import_fs.default.existsSync(policiesDir)) {
+    console.warn(`Policies directory not found: ${policiesDir}`);
+    return [];
+  }
+  const files = import_fs.default.readdirSync(policiesDir);
+  const slugs = Array.from(
+    new Set(
+      files.filter((file) => file.endsWith(".md") || file.endsWith(".mdx")).map((file) => {
+        return file.replace(/\.[a-z]{2}(-[A-Z]{2})?\.mdx?$/, "");
+      })
+    )
+  );
+  return slugs;
+}
+async function getAllPolicies(locale, contentDir = "src/content/policies") {
+  const slugs = getPolicySlugs(contentDir);
+  const policies = await Promise.all(
+    slugs.map(async (slug) => {
+      try {
+        const policy = await loadPolicy(slug, locale, contentDir);
+        return {
+          slug: policy.slug,
+          locale: policy.locale,
+          metadata: policy.metadata
+        };
+      } catch (error) {
+        console.warn(`Skipping ${slug} for locale ${locale}:`, error);
+        return null;
+      }
+    })
+  );
+  return policies.filter((p) => p !== null);
+}
+function getPolicyLocales(slug, contentDir = "src/content/policies") {
+  const policiesDir = import_path.default.join(process.cwd(), contentDir);
+  if (!import_fs.default.existsSync(policiesDir)) {
+    return [];
+  }
+  const files = import_fs.default.readdirSync(policiesDir);
+  const locales2 = files.filter((file) => {
+    const pattern = new RegExp(`^${slug}\\.[a-z]{2}(-[A-Z]{2})?\\.mdx?$`);
+    return pattern.test(file);
+  }).map((file) => {
+    const match = file.match(/\.([a-z]{2}(-[A-Z]{2})?)\.mdx?$/);
+    return match ? match[1] : null;
+  }).filter((locale) => locale !== null);
+  return locales2;
+}
+
+// src/lib/navigation/utils.ts
+function getNavigationString(localizedString, locale) {
+  return localizedString[locale] || localizedString["en"] || "";
+}
+function replaceVariables(text, variables) {
+  let result = text;
+  Object.entries(variables).forEach(([key, value]) => {
+    result = result.replace(`{${key}}`, value);
+  });
+  return result;
+}
+
+// src/lib/i18n/index.ts
+init_config();
+init_config();
+
+// src/lib/i18n/locale-cookie.ts
+init_config();
+var LOCALE_COOKIE_NAME = "NEXT_LOCALE";
+function getLocaleFromCookie() {
+  if (typeof document === "undefined") return null;
+  try {
+    const cookieConfig = getLocaleCookieConfig();
+    const cookieName = cookieConfig.name;
+    const cookie = document.cookie.split("; ").find((row) => row.startsWith(`${cookieName}=`));
+    if (!cookie) return null;
+    const value = cookie.split("=")[1];
+    if (isSupportedLocale(value)) {
+      return value;
+    }
+    return null;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("getLocaleFromCookie: i18n config not initialized");
+    }
+    return null;
+  }
+}
+function setLocaleCookie(locale) {
+  if (typeof document === "undefined") return;
+  try {
+    if (!isSupportedLocale(locale)) {
+      console.warn(`Attempted to set unsupported locale: ${locale}`);
+      return;
+    }
+    const cookieConfig = getLocaleCookieConfig();
+    document.cookie = `${cookieConfig.name}=${locale}; max-age=${cookieConfig.maxAge}; path=/; SameSite=${cookieConfig.sameSite}`;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("setLocaleCookie: i18n config not initialized");
+    }
+  }
+}
+
+// src/lib/i18n/slug-translations.ts
+var defaultSlugTranslations = {
+  fr: {
+    "/marketing-par-courriel": "/email-marketing",
+    "/courriels-transactionnels": "/transactional-emails",
+    "/forfaits": "/pricing",
+    "/nous-contacter": "/contact",
+    "/a-propos": "/about",
+    "/politique-de-confidentialite": "/privacy-policy",
+    "/conditions-dutilisation": "/terms-of-service",
+    "/politique-anti-pourriel": "/anti-spam-policy"
+  },
+  en: {
+    "/email-marketing": "/marketing-par-courriel",
+    "/transactional-emails": "/courriels-transactionnels",
+    "/pricing": "/forfaits",
+    "/contact": "/nous-contacter",
+    "/about": "/a-propos",
+    "/privacy-policy": "/politique-de-confidentialite",
+    "/terms-of-service": "/conditions-dutilisation",
+    "/anti-spam-policy": "/politique-anti-pourriel"
+  }
+};
+function translateSlug(path2, fromLocale, toLocale, customTranslations) {
+  let configTranslations = {};
+  try {
+    const { getI18nConfig: getI18nConfig2 } = (init_config(), __toCommonJS(config_exports));
+    const config = getI18nConfig2();
+    configTranslations = config.slugTranslations || {};
+  } catch {
+  }
+  const translations = mergeTranslations(
+    defaultSlugTranslations,
+    configTranslations,
+    customTranslations || {}
+  );
+  const translationMap = translations[fromLocale];
+  if (!translationMap) {
+    return path2;
+  }
+  if (translationMap[path2]) {
+    return translationMap[path2];
+  }
+  for (const [fromSlug, toSlug] of Object.entries(translationMap)) {
+    if (path2.startsWith(fromSlug + "/")) {
+      return path2.replace(fromSlug, toSlug);
+    }
+  }
+  return path2;
+}
+function mergeTranslations(...translations) {
+  const merged = {};
+  for (const trans of translations) {
+    for (const [locale, slugs] of Object.entries(trans)) {
+      if (!merged[locale]) {
+        merged[locale] = {};
+      }
+      Object.assign(merged[locale], slugs);
+    }
+  }
+  return merged;
+}
+
+// src/lib/i18n/formatters.ts
+function formatDate(date, locale, options) {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+function formatNumber(value, locale, options) {
+  return new Intl.NumberFormat(locale, options).format(value);
+}
+function formatCurrency(amount, locale, currency, options) {
+  return new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency,
+    ...options
+  }).format(amount);
+}
+function formatRelativeTime(value, unit, locale, options) {
+  return new Intl.RelativeTimeFormat(locale, options).format(value, unit);
+}
+function formatDateRange(startDate, endDate, locale, options) {
+  const formatter = new Intl.DateTimeFormat(locale, options);
+  if ("formatRange" in formatter) {
+    return formatter.formatRange(startDate, endDate);
+  }
+  return `${formatter.format(startDate)} \u2013 ${formatter.format(endDate)}`;
+}
+function formatList(items, locale) {
+  if (typeof Intl !== "undefined" && "ListFormat" in Intl) {
+    return new Intl.ListFormat(locale).format(items);
+  }
+  if (items.length === 0) return "";
+  if (items.length === 1) return items[0];
+  if (items.length === 2) {
+    const connector2 = locale === "fr" ? " et " : " and ";
+    return items.join(connector2);
+  }
+  const last = items[items.length - 1];
+  const rest = items.slice(0, -1);
+  const connector = locale === "fr" ? " et " : ", and ";
+  return rest.join(", ") + connector + last;
+}
+function formatFileSize(bytes, locale, decimals = 2) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const value = bytes / Math.pow(k, i);
+  return `${formatNumber(value, locale, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  })} ${sizes[i]}`;
+}
+function getRelativeTime(date, locale, options) {
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = date.getTime() - now.getTime();
+  const diffSecs = Math.round(diffMs / 1e3);
+  const diffMins = Math.round(diffSecs / 60);
+  const diffHours = Math.round(diffMins / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffWeeks = Math.round(diffDays / 7);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  if (Math.abs(diffSecs) < 60) {
+    return formatRelativeTime(diffSecs, "second", locale, options);
+  } else if (Math.abs(diffMins) < 60) {
+    return formatRelativeTime(diffMins, "minute", locale, options);
+  } else if (Math.abs(diffHours) < 24) {
+    return formatRelativeTime(diffHours, "hour", locale, options);
+  } else if (Math.abs(diffDays) < 7) {
+    return formatRelativeTime(diffDays, "day", locale, options);
+  } else if (Math.abs(diffWeeks) < 4) {
+    return formatRelativeTime(diffWeeks, "week", locale, options);
+  } else if (Math.abs(diffMonths) < 12) {
+    return formatRelativeTime(diffMonths, "month", locale, options);
+  } else {
+    return formatRelativeTime(diffYears, "year", locale, options);
+  }
+}
+
+// src/lib/i18n/middleware.ts
+var import_server = require("next/server");
+function createI18nMiddleware(config) {
+  return function middleware(request) {
+    const { pathname } = request.nextUrl;
+    const pathnameLocale = getLocaleFromPathname(pathname, config);
+    if (pathnameLocale) {
+      if (!config.locales.includes(pathnameLocale)) {
+        return redirectToLocale(request, config.defaultLocale, pathname, config);
+      }
+      const response = import_server.NextResponse.next();
+      setLocaleCookie2(response, pathnameLocale, config);
+      return response;
+    }
+    const detectedLocale = detectLocale(request, config);
+    const prefixMode = config.localePrefix || "as-needed";
+    if (prefixMode === "always") {
+      return redirectToLocale(request, detectedLocale, pathname, config);
+    } else if (prefixMode === "as-needed") {
+      if (detectedLocale !== config.defaultLocale) {
+        return redirectToLocale(request, detectedLocale, pathname, config);
+      }
+      const response = import_server.NextResponse.next();
+      setLocaleCookie2(response, config.defaultLocale, config);
+      return response;
+    } else {
+      const response = import_server.NextResponse.next();
+      setLocaleCookie2(response, detectedLocale, config);
+      return response;
+    }
+  };
+}
+function getLocaleFromPathname(pathname, config) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return null;
+  }
+  const firstSegment = segments[0];
+  if (config.locales.includes(firstSegment)) {
+    return firstSegment;
+  }
+  return null;
+}
+function detectLocale(request, config) {
+  const cookieName = config.localeCookie?.name || "NEXT_LOCALE";
+  const cookieLocale = request.cookies.get(cookieName)?.value;
+  if (cookieLocale && config.locales.includes(cookieLocale)) {
+    return cookieLocale;
+  }
+  if (config.localeDetection !== false) {
+    const acceptLanguage = request.headers.get("accept-language");
+    const browserLocale = negotiateLanguage(acceptLanguage, config.locales);
+    if (browserLocale) {
+      return browserLocale;
+    }
+  }
+  return config.defaultLocale;
+}
+function negotiateLanguage(acceptLanguage, supportedLocales) {
+  if (!acceptLanguage) {
+    return null;
+  }
+  const preferences = parseAcceptLanguage(acceptLanguage);
+  for (const pref of preferences) {
+    if (supportedLocales.includes(pref.locale)) {
+      return pref.locale;
+    }
+    const languageCode = pref.locale.split("-")[0];
+    if (supportedLocales.includes(languageCode)) {
+      return languageCode;
+    }
+    const match = supportedLocales.find(
+      (locale) => locale.startsWith(languageCode + "-") || locale === languageCode
+    );
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+function parseAcceptLanguage(header) {
+  const preferences = [];
+  const parts = header.split(",").map((p) => p.trim());
+  for (const part of parts) {
+    const [locale, ...rest] = part.split(";").map((p) => p.trim());
+    let quality = 1;
+    const qParam = rest.find((p) => p.startsWith("q="));
+    if (qParam) {
+      const qValue = parseFloat(qParam.substring(2));
+      if (!isNaN(qValue)) {
+        quality = qValue;
+      }
+    }
+    preferences.push({
+      locale: locale.toLowerCase(),
+      quality
+    });
+  }
+  preferences.sort((a, b) => b.quality - a.quality);
+  return preferences;
+}
+function redirectToLocale(request, locale, pathname, config) {
+  const url = request.nextUrl.clone();
+  const pathWithoutLocale = removeLocalePrefix(pathname, config);
+  url.pathname = `/${locale}${pathWithoutLocale}`;
+  const response = import_server.NextResponse.redirect(url);
+  setLocaleCookie2(response, locale, config);
+  return response;
+}
+function removeLocalePrefix(pathname, config) {
+  const segments = pathname.split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "/";
+  }
+  const firstSegment = segments[0];
+  if (config.locales.includes(firstSegment)) {
+    const remaining = segments.slice(1);
+    return remaining.length > 0 ? `/${remaining.join("/")}` : "/";
+  }
+  return pathname;
+}
+function setLocaleCookie2(response, locale, config) {
+  const cookieConfig = config.localeCookie || {};
+  response.cookies.set({
+    name: cookieConfig.name || "NEXT_LOCALE",
+    value: locale,
+    maxAge: cookieConfig.maxAge || 365 * 24 * 60 * 60,
+    // 1 year
+    path: "/",
+    sameSite: cookieConfig.sameSite || "lax"
+  });
+}
+
+// src/lib/i18n/utils.ts
+init_config();
+function isRtlLocale(locale) {
+  const rtlLocales = getRtlLocales();
+  return rtlLocales.includes(locale);
+}
+function getTextDirection(locale) {
+  return isRtlLocale(locale) ? "rtl" : "ltr";
+}
+function validateLocale(locale) {
+  return isSupportedLocale(locale);
+}
+function getAlternateLocales(currentLocale) {
+  try {
+    const config = getI18nConfig();
+    return config.locales.filter((l) => l !== currentLocale);
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("getAlternateLocales: i18n config not initialized, returning []");
+    }
+    return [];
+  }
+}
+function normalizeLocale(locale) {
+  return locale.toLowerCase().split("-")[0];
+}
+function matchLocale(locale) {
+  try {
+    const config = getI18nConfig();
+    const normalized = normalizeLocale(locale);
+    if (config.locales.includes(locale)) {
+      return locale;
+    }
+    if (config.locales.includes(normalized)) {
+      return normalized;
+    }
+    const match = config.locales.find((l) => l.startsWith(normalized));
+    if (match) {
+      return match;
+    }
+    return null;
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("matchLocale: i18n config not initialized, returning null");
+    }
+    return null;
+  }
+}
+function getLocaleAutonym(locale) {
+  const autonyms = {
+    en: "English",
+    fr: "Fran\xE7ais",
+    es: "Espa\xF1ol",
+    de: "Deutsch",
+    it: "Italiano",
+    pt: "Portugu\xEAs",
+    ru: "\u0420\u0443\u0441\u0441\u043A\u0438\u0439",
+    ja: "\u65E5\u672C\u8A9E",
+    ko: "\uD55C\uAD6D\uC5B4",
+    zh: "\u4E2D\u6587",
+    ar: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629",
+    he: "\u05E2\u05D1\u05E8\u05D9\u05EA",
+    hi: "\u0939\u093F\u0928\u094D\u0926\u0940",
+    tr: "T\xFCrk\xE7e",
+    pl: "Polski",
+    nl: "Nederlands",
+    sv: "Svenska",
+    da: "Dansk",
+    no: "Norsk",
+    fi: "Suomi",
+    cs: "\u010Ce\u0161tina",
+    el: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC",
+    th: "\u0E44\u0E17\u0E22",
+    vi: "Ti\u1EBFng Vi\u1EC7t",
+    id: "Bahasa Indonesia",
+    ms: "Bahasa Melayu",
+    uk: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430"
+  };
+  try {
+    const { getLocaleNames: getLocaleNames2 } = (init_config(), __toCommonJS(config_exports));
+    const names = getLocaleNames2();
+    if (names[locale]) {
+      return names[locale];
+    }
+  } catch {
+  }
+  return autonyms[locale] || locale.toUpperCase();
+}
+function formatLocaleDisplay(locale, format = "name") {
+  if (format === "code") {
+    return locale;
+  }
+  if (format === "label") {
+    try {
+      const { getLocaleLabel: getLocaleLabel2 } = (init_config(), __toCommonJS(config_exports));
+      return getLocaleLabel2(locale);
+    } catch {
+      return locale.toUpperCase();
+    }
+  }
+  return getLocaleAutonym(locale);
+}
+
+// src/lib/utils/cn.ts
+var import_clsx = require("clsx");
+var import_tailwind_merge = require("tailwind-merge");
+function cn(...inputs) {
+  return (0, import_tailwind_merge.twMerge)((0, import_clsx.clsx)(inputs));
+}
+
+// src/lib/analytics.ts
+function pushToDataLayer(data) {
+  if (typeof window === "undefined") return;
+  window.dataLayer = window.dataLayer || [];
+  window.dataLayer.push(data);
+  if (process.env.NODE_ENV === "development") {
+    console.log("[Analytics]", data);
+  }
+}
+function trackEvent(eventName, properties) {
+  pushToDataLayer({
+    event: eventName,
+    ...properties
+  });
+}
+function trackCTAClick(ctaLocation, ctaText, ctaType = "other") {
+  pushToDataLayer({
+    event: "cta_click",
+    event_category: "cta",
+    event_label: `${ctaLocation}_${ctaType}`,
+    cta_location: ctaLocation,
+    cta_text: ctaText,
+    cta_type: ctaType
+  });
+}
+function trackFormEvent(formName, action, metadata) {
+  pushToDataLayer({
+    event: `form_${action}`,
+    event_category: "form",
+    event_label: formName,
+    form_name: formName,
+    form_action: action,
+    ...metadata
+  });
+}
+function trackPageView(pagePath, pageTitle) {
+  pushToDataLayer({
+    event: "page_view",
+    page_path: pagePath,
+    page_title: pageTitle
+  });
+}
+function trackPricingEvent(action, metadata) {
+  pushToDataLayer({
+    event: "pricing_interaction",
+    event_category: "engagement",
+    event_label: action,
+    pricing_action: action,
+    ...metadata
+  });
+}
+function trackFeatureEngagement(featureName, action, metadata) {
+  pushToDataLayer({
+    event: "feature_engagement",
+    event_category: "engagement",
+    event_label: `${featureName}_${action}`,
+    feature_name: featureName,
+    feature_action: action,
+    ...metadata
+  });
+}
+function trackResourceDownload(resourceName, resourceType) {
+  pushToDataLayer({
+    event: "resource_download",
+    event_category: "engagement",
+    event_label: resourceName,
+    resource_name: resourceName,
+    resource_type: resourceType
+  });
+}
+function trackVideoEvent(videoTitle, action, metadata) {
+  pushToDataLayer({
+    event: "video_interaction",
+    event_category: "engagement",
+    event_label: `${videoTitle}_${action}`,
+    video_title: videoTitle,
+    video_action: action,
+    ...metadata
+  });
+}
+function trackNavigation(linkText, linkUrl, linkLocation) {
+  pushToDataLayer({
+    event: "navigation_click",
+    event_category: "navigation",
+    event_label: linkText,
+    link_text: linkText,
+    link_url: linkUrl,
+    link_location: linkLocation
+  });
+}
+function trackABTestEvent(testId, variant, eventName, metadata) {
+  pushToDataLayer({
+    event: "ab_test_event",
+    event_category: "ab_test",
+    event_label: `${testId}_${variant}_${eventName}`,
+    test_id: testId,
+    variant,
+    test_event: eventName,
+    ...metadata
+  });
+}
+function trackConversion(conversionType, value, metadata) {
+  pushToDataLayer({
+    event: "conversion",
+    event_category: "conversion",
+    event_label: conversionType,
+    conversion_type: conversionType,
+    value,
+    ...metadata
+  });
+}
+function trackScrollDepth(percentage, pagePath) {
+  pushToDataLayer({
+    event: "scroll_depth",
+    event_category: "engagement",
+    event_label: `${percentage}%`,
+    scroll_percentage: percentage,
+    page_path: pagePath
+  });
+}
+function trackSearch(searchTerm, resultCount) {
+  pushToDataLayer({
+    event: "search",
+    event_category: "engagement",
+    event_label: searchTerm,
+    search_term: searchTerm,
+    result_count: resultCount
+  });
+}
+function trackOutboundLink(url, linkText) {
+  pushToDataLayer({
+    event: "outbound_link",
+    event_category: "navigation",
+    event_label: url,
+    outbound_url: url,
+    link_text: linkText
+  });
+}
+function trackError(errorType, errorMessage) {
+  pushToDataLayer({
+    event: "error",
+    event_category: "engagement",
+    event_label: errorType,
+    error_type: errorType,
+    error_message: errorMessage
+  });
+}
+
+// src/lib/utils/forms.tsx
+var React = __toESM(require("react"));
+var import_jsx_runtime = require("react/jsx-runtime");
+function hasZod() {
+  try {
+    require.resolve("zod");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getZod() {
+  if (hasZod()) {
+    return require("zod");
+  }
+  return null;
+}
+
+// src/lib/forms/schemas.ts
+var z = getZod();
+var emailSchema = z?.string().email();
+var phoneSchema = z?.string().regex(
+  /^\+?[1-9]\d{1,14}$/,
+  "Invalid phone number format"
+);
+var postalCodeSchema = z?.string().regex(
+  /^(\d{5}(-\d{4})?|[A-Z]\d[A-Z] ?\d[A-Z]\d)$/i,
+  "Invalid postal code"
+);
+var passwordSchema = z?.string().min(8, "Password must be at least 8 characters").regex(/[A-Z]/, "Password must contain at least one uppercase letter").regex(/[a-z]/, "Password must contain at least one lowercase letter").regex(/[0-9]/, "Password must contain at least one number");
+var urlSchema = z?.string().url();
+var creditCardSchema = z?.string().refine((value) => {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length < 13 || digits.length > 19) return false;
+  let sum = 0;
+  let isEven = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let digit = parseInt(digits[i]);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}, "Invalid credit card number");
+function fileSchema(acceptedTypes, maxSizeMB) {
+  return z?.instanceof(File).refine(
+    (file) => acceptedTypes.includes(file.type),
+    `File must be one of: ${acceptedTypes.join(", ")}`
+  ).refine(
+    (file) => file.size <= maxSizeMB * 1024 * 1024,
+    `File size must be less than ${maxSizeMB}MB`
+  );
+}
+function imageSchema(maxSizeMB = 5) {
+  return fileSchema(["image/jpeg", "image/png", "image/webp"], maxSizeMB);
+}
+var requiredString = z?.string().min(1, "This field is required");
+var optionalString = z?.string().optional().or(z?.literal(""));
+var numericString = z?.string().regex(/^\d+$/, "Must contain only numbers");
+var dateString = z?.string().datetime();
+var mustBeTrue = z?.literal(true, {
+  errorMap: () => ({ message: "You must accept to continue" })
+});
+
+// src/lib/forms/errors.ts
+var formErrorMessages = {
+  required: {
+    en: "This field is required",
+    fr: "Ce champ est obligatoire"
+  },
+  email: {
+    en: "Please enter a valid email address",
+    fr: "Veuillez entrer une adresse e-mail valide"
+  },
+  phone: {
+    en: "Please enter a valid phone number",
+    fr: "Veuillez entrer un num\xE9ro de t\xE9l\xE9phone valide"
+  },
+  url: {
+    en: "Please enter a valid URL",
+    fr: "Veuillez entrer une URL valide"
+  },
+  password: {
+    tooShort: {
+      en: "Password must be at least 8 characters",
+      fr: "Le mot de passe doit contenir au moins 8 caract\xE8res"
+    },
+    noUppercase: {
+      en: "Password must contain at least one uppercase letter",
+      fr: "Le mot de passe doit contenir au moins une lettre majuscule"
+    },
+    noLowercase: {
+      en: "Password must contain at least one lowercase letter",
+      fr: "Le mot de passe doit contenir au moins une lettre minuscule"
+    },
+    noNumber: {
+      en: "Password must contain at least one number",
+      fr: "Le mot de passe doit contenir au moins un chiffre"
+    }
+  },
+  postalCode: {
+    en: "Invalid postal code",
+    fr: "Code postal invalide"
+  },
+  creditCard: {
+    en: "Invalid credit card number",
+    fr: "Num\xE9ro de carte de cr\xE9dit invalide"
+  },
+  file: {
+    tooLarge: {
+      en: (maxSize) => `File size must be less than ${maxSize}MB`,
+      fr: (maxSize) => `La taille du fichier doit \xEAtre inf\xE9rieure \xE0 ${maxSize}Mo`
+    },
+    invalidType: {
+      en: (types) => `File must be one of: ${types.join(", ")}`,
+      fr: (types) => `Le fichier doit \xEAtre de type : ${types.join(", ")}`
+    }
+  },
+  mustAccept: {
+    en: "You must accept to continue",
+    fr: "Vous devez accepter pour continuer"
+  },
+  minLength: {
+    en: (min) => `Must be at least ${min} characters`,
+    fr: (min) => `Doit contenir au moins ${min} caract\xE8res`
+  },
+  maxLength: {
+    en: (max) => `Must be no more than ${max} characters`,
+    fr: (max) => `Ne doit pas d\xE9passer ${max} caract\xE8res`
+  },
+  min: {
+    en: (min) => `Must be at least ${min}`,
+    fr: (min) => `Doit \xEAtre au moins ${min}`
+  },
+  max: {
+    en: (max) => `Must be no more than ${max}`,
+    fr: (max) => `Ne doit pas d\xE9passer ${max}`
+  },
+  invalidFormat: {
+    en: "Invalid format",
+    fr: "Format invalide"
+  }
+};
+function getErrorMessage(key, locale = "en", params) {
+  const message = formErrorMessages[key];
+  if (!message) return "";
+  const localized = message[locale];
+  if (typeof localized === "function") {
+    return localized(params);
+  }
+  return localized || "";
+}
+
+// src/lib/seo/metadata.ts
+function generateMetadata({
+  title,
+  description,
+  url,
+  image,
+  imageAlt,
+  type = "website",
+  article,
+  twitterCard = "summary_large_image",
+  twitterSite,
+  twitterCreator,
+  locale = "en",
+  alternateLocales,
+  siteName,
+  robots,
+  keywords,
+  author,
+  other
+}) {
+  const metadata = {
+    title,
+    description,
+    ...keywords && { keywords: keywords.join(", ") },
+    ...author && { authors: [{ name: author }] },
+    // Open Graph
+    openGraph: {
+      title,
+      description,
+      type,
+      ...url && { url },
+      ...siteName && { siteName },
+      ...locale && { locale },
+      ...image && {
+        images: [
+          {
+            url: image,
+            ...imageAlt && { alt: imageAlt }
+          }
+        ]
+      },
+      ...type === "article" && article && {
+        publishedTime: article.publishedTime,
+        modifiedTime: article.modifiedTime,
+        authors: article.author ? [article.author] : void 0,
+        tags: article.tags
+      }
+    },
+    // Twitter Card
+    twitter: {
+      card: twitterCard,
+      title,
+      description,
+      ...twitterSite && { site: `@${twitterSite}` },
+      ...twitterCreator && { creator: `@${twitterCreator}` },
+      ...image && {
+        images: [image]
+      }
+    },
+    // Robots
+    ...robots && { robots },
+    // Alternates for i18n
+    ...url && alternateLocales && {
+      alternates: {
+        canonical: url,
+        languages: Object.fromEntries(
+          alternateLocales.map((loc) => [
+            loc,
+            url.replace(`/${locale}`, `/${loc}`)
+          ])
+        )
+      }
+    },
+    // Additional metadata
+    ...other && { other }
+  };
+  return metadata;
+}
+function generateArticleMetadata({
+  title,
+  description,
+  image,
+  publishedTime,
+  modifiedTime,
+  author,
+  tags,
+  url,
+  siteName,
+  twitterSite
+}) {
+  return generateMetadata({
+    title,
+    description,
+    image,
+    url,
+    siteName,
+    twitterSite,
+    type: "article",
+    article: {
+      publishedTime,
+      modifiedTime,
+      author,
+      tags
+    }
+  });
+}
+
+// src/lib/seo/structured-data.ts
+function createOrganization(data) {
+  return {
+    "@type": "Organization",
+    ...data
+  };
+}
+function createWebSite(data) {
+  const website = {
+    "@type": "WebSite",
+    name: data.name,
+    url: data.url,
+    description: data.description,
+    publisher: data.publisher
+  };
+  if (data.searchUrlTemplate) {
+    website.potentialAction = {
+      "@type": "SearchAction",
+      target: {
+        "@type": "EntryPoint",
+        urlTemplate: data.searchUrlTemplate
+      },
+      "query-input": "required name=search_term_string"
+    };
+  }
+  return website;
+}
+function createProduct(data) {
+  return {
+    "@type": "Product",
+    ...data
+  };
+}
+function createFAQPage(faqs) {
+  return {
+    "@type": "FAQPage",
+    mainEntity: faqs.map(({ question, answer }) => ({
+      "@type": "Question",
+      name: question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: answer
+      }
+    }))
+  };
+}
+function createArticle(data) {
+  return {
+    "@type": data.type || "Article",
+    headline: data.headline,
+    description: data.description,
+    image: data.image,
+    author: typeof data.author === "string" ? data.author : data.author,
+    publisher: data.publisher,
+    datePublished: data.datePublished,
+    dateModified: data.dateModified,
+    mainEntityOfPage: data.mainEntityOfPage
+  };
+}
+function createBreadcrumbList(items) {
+  return {
+    "@type": "BreadcrumbList",
+    itemListElement: items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name,
+      item: item.url
+    }))
+  };
+}
+function serializeStructuredData(data) {
+  const jsonLd = Array.isArray(data) ? { "@context": "https://schema.org", "@graph": data } : { "@context": "https://schema.org", ...data };
+  return JSON.stringify(jsonLd);
+}
+
+// src/lib/seo/sitemap.ts
+function generateSitemap(config) {
+  const { entries, prettyPrint = false } = config;
+  const indent = prettyPrint ? "  " : "";
+  const newline = prettyPrint ? "\n" : "";
+  const urlEntries = entries.map((entry) => {
+    const parts = [];
+    parts.push(`${indent}<url>${newline}`);
+    parts.push(`${indent}${indent}<loc>${escapeXml(entry.url)}</loc>${newline}`);
+    if (entry.lastModified) {
+      const date = entry.lastModified instanceof Date ? entry.lastModified.toISOString() : entry.lastModified;
+      parts.push(`${indent}${indent}<lastmod>${date}</lastmod>${newline}`);
+    }
+    if (entry.changeFrequency) {
+      parts.push(`${indent}${indent}<changefreq>${entry.changeFrequency}</changefreq>${newline}`);
+    }
+    if (entry.priority !== void 0) {
+      const priority = Math.max(0, Math.min(1, entry.priority)).toFixed(1);
+      parts.push(`${indent}${indent}<priority>${priority}</priority>${newline}`);
+    }
+    if (entry.alternates && entry.alternates.length > 0) {
+      entry.alternates.forEach((alternate) => {
+        parts.push(
+          `${indent}${indent}<xhtml:link rel="alternate" hreflang="${escapeXml(
+            alternate.hreflang
+          )}" href="${escapeXml(alternate.href)}" />${newline}`
+        );
+      });
+    }
+    parts.push(`${indent}</url>${newline}`);
+    return parts.join("");
+  }).join("");
+  const xml = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    newline,
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">',
+    newline,
+    urlEntries,
+    "</urlset>"
+  ].join("");
+  return xml;
+}
+function createMultiLanguageEntries(baseUrl, path2, locales2, defaultLocale2, options) {
+  const cleanPath = path2.startsWith("/") ? path2 : `/${path2}`;
+  return locales2.map((locale) => {
+    const alternates = locales2.map((altLocale) => ({
+      hreflang: altLocale,
+      href: `${baseUrl}/${altLocale}${cleanPath}`
+    }));
+    if (defaultLocale2) {
+      alternates.push({
+        hreflang: "x-default",
+        href: `${baseUrl}/${defaultLocale2}${cleanPath}`
+      });
+    }
+    return {
+      url: `${baseUrl}/${locale}${cleanPath}`,
+      alternates,
+      ...options
+    };
+  });
+}
+function createSitemapEntry(baseUrl, path2, options) {
+  const cleanPath = path2.startsWith("/") ? path2 : `/${path2}`;
+  const url = path2 === "/" ? baseUrl : `${baseUrl}${cleanPath}`;
+  return {
+    url,
+    ...options
+  };
+}
+function escapeXml(unsafe) {
+  return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function validateSitemapEntry(entry) {
+  const errors = [];
+  if (!entry.url.startsWith("http://") && !entry.url.startsWith("https://")) {
+    errors.push(`URL must be absolute: ${entry.url}`);
+  }
+  if (entry.priority !== void 0 && (entry.priority < 0 || entry.priority > 1)) {
+    errors.push(`Priority must be between 0 and 1: ${entry.priority}`);
+  }
+  if (entry.alternates) {
+    entry.alternates.forEach((alt, index) => {
+      if (!alt.href.startsWith("http://") && !alt.href.startsWith("https://")) {
+        errors.push(`Alternate ${index} href must be absolute: ${alt.href}`);
+      }
+    });
+  }
+  return errors;
+}
+function validateSitemap(config) {
+  const errors = [];
+  if (!config.baseUrl.startsWith("http://") && !config.baseUrl.startsWith("https://")) {
+    errors.push({ messages: ["Base URL must be absolute"] });
+  }
+  config.entries.forEach((entry) => {
+    const entryErrors = validateSitemapEntry(entry);
+    if (entryErrors.length > 0) {
+      errors.push({ entry, messages: entryErrors });
+    }
+  });
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+// src/components/TrackedLink.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function TrackedLink({
+  href,
+  children,
+  className,
+  trackingType = "auto",
+  ctaLocation,
+  ctaType = "other",
+  navLocation = "content",
+  onClick,
+  ...props
+}) {
+  const handleClick = () => {
+    const linkText = typeof children === "string" ? children : href;
+    let type = trackingType;
+    if (type === "auto") {
+      if (href.startsWith("http") && !href.includes("courrielleur.com")) {
+        type = "outbound";
+      } else if (href.includes("signup") || href.includes("trial")) {
+        type = "cta";
+      } else {
+        type = "navigation";
+      }
+    }
+    switch (type) {
+      case "cta":
+        trackCTAClick(ctaLocation || "unknown", linkText, ctaType);
+        break;
+      case "outbound":
+        trackOutboundLink(href, linkText);
+        break;
+      case "navigation":
+        trackNavigation(linkText, href, navLocation);
+        break;
+    }
+    onClick?.();
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("a", { href, className, onClick: handleClick, ...props, children });
+}
+
+// src/components/FeaturesGrid.tsx
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var labels = {
+  keyBenefits: {
+    fr: "Avantages cl\xE9s :",
+    en: "Key Benefits:"
+  },
+  useCases: {
+    fr: "Cas d'usage :",
+    en: "Use Cases:"
+  },
+  learnMore: {
+    fr: "En savoir plus",
+    en: "Learn more"
+  }
+};
+function FeaturesGrid({ categories, className = "", locale = "en" }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: `py-20 ${className}`, children: categories.map((category, categoryIndex) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "section",
+    {
+      className: `${categoryIndex % 2 === 0 ? "bg-white" : "bg-warm-gray"} py-16`,
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "container mx-auto px-6", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "max-w-3xl mb-12", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h2", { className: "text-3xl md:text-4xl font-bold text-charcoal mb-4", children: category.name }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-lg text-charcoal/80", children: category.description })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-8", children: category.features.map((feature) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+          "div",
+          {
+            className: "bg-white rounded-lg p-6 shadow-sm hover:shadow-md transition-shadow duration-200",
+            children: [
+              feature.icon && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "w-12 h-12 mb-4 text-primary", children: feature.icon }),
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h3", { className: "text-xl font-semibold text-charcoal mb-3", children: feature.name }),
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-charcoal/80 mb-4", children: feature.description }),
+              feature.benefits && feature.benefits.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "mb-4", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm font-semibold text-charcoal/60 mb-2", children: labels.keyBenefits[locale] }),
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ul", { className: "space-y-1", children: feature.benefits.map((benefit, idx) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+                  "li",
+                  {
+                    className: "text-sm text-charcoal/70 flex items-start gap-2",
+                    children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "text-primary mt-1", children: "\u2713" }),
+                      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { children: benefit })
+                    ]
+                  },
+                  idx
+                )) })
+              ] }),
+              feature.useCases && feature.useCases.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "mb-4", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "text-sm font-semibold text-charcoal/60 mb-2", children: labels.useCases[locale] }),
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ul", { className: "space-y-1", children: feature.useCases.map((useCase, idx) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+                  "li",
+                  {
+                    className: "text-sm text-charcoal/70 flex items-start gap-2",
+                    children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "text-charcoal/40", children: "\u2022" }),
+                      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { children: useCase })
+                    ]
+                  },
+                  idx
+                )) })
+              ] }),
+              feature.learnMoreHref && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+                "a",
+                {
+                  href: feature.learnMoreHref,
+                  className: "text-primary hover:text-primary-hover text-sm font-medium inline-flex items-center gap-1 group",
+                  children: [
+                    labels.learnMore[locale],
+                    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "group-hover:translate-x-1 transition-transform duration-200", children: "\u2192" })
+                  ]
+                }
+              )
+            ]
+          },
+          feature.id
+        )) })
+      ] })
+    },
+    category.id
+  )) });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FeaturesGrid,
+  LOCALE_COOKIE_NAME,
+  TrackedLink,
+  cn,
+  createArticle,
+  createBreadcrumbList,
+  createFAQPage,
+  createI18nMiddleware,
+  createMultiLanguageEntries,
+  createOrganization,
+  createProduct,
+  createSitemapEntry,
+  createWebSite,
+  creditCardSchema,
+  dateString,
+  defaultLocale,
+  defaultSlugTranslations,
+  emailSchema,
+  fileSchema,
+  formErrorMessages,
+  formatCurrency,
+  formatDate,
+  formatDateRange,
+  formatFileSize,
+  formatList,
+  formatLocaleDisplay,
+  formatNumber,
+  formatRelativeTime,
+  generateArticleMetadata,
+  generateDesignTokens,
+  generateMetadata,
+  generateSitemap,
+  generateThemeCSS,
+  getAllPolicies,
+  getAlternateLocales,
+  getDefaultLocale,
+  getErrorMessage,
+  getFontConfig,
+  getFontVariables,
+  getI18nConfig,
+  getLocaleAutonym,
+  getLocaleCookieConfig,
+  getLocaleFromCookie,
+  getLocaleLabel,
+  getLocaleLabels,
+  getLocaleName,
+  getLocaleNames,
+  getLocalePrefix,
+  getLocales,
+  getLocalizedString,
+  getNavigationString,
+  getPolicyLocales,
+  getPolicySlugs,
+  getRelativeTime,
+  getRtlLocales,
+  getTextDirection,
+  imageSchema,
+  isI18nConfigInitialized,
+  isLocaleDetectionEnabled,
+  isRtlLocale,
+  isSupportedLocale,
+  loadPolicy,
+  locales,
+  matchLocale,
+  mustBeTrue,
+  normalizeLocale,
+  numericString,
+  optionalString,
+  passwordSchema,
+  phoneSchema,
+  postalCodeSchema,
+  replaceVariables,
+  requiredString,
+  serializeStructuredData,
+  setI18nConfig,
+  setLocaleCookie,
+  trackABTestEvent,
+  trackCTAClick,
+  trackConversion,
+  trackError,
+  trackEvent,
+  trackFeatureEngagement,
+  trackFormEvent,
+  trackNavigation,
+  trackOutboundLink,
+  trackPageView,
+  trackPricingEvent,
+  trackResourceDownload,
+  trackScrollDepth,
+  trackSearch,
+  trackVideoEvent,
+  translateSlug,
+  urlSchema,
+  validateLocale,
+  validateSitemap,
+  validateSitemapEntry
+});
+//# sourceMappingURL=index.js.map