@react-lgpd-consent/core 0.5.0

package/dist/index.cjs

@@ -0,0 +1,2623 @@
+'use strict';
+
+var React4 = require('react');
+var Cookies = require('js-cookie');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React4__namespace = /*#__PURE__*/_interopNamespace(React4);
+var Cookies__default = /*#__PURE__*/_interopDefault(Cookies);
+
+// @react-lgpd-consent/core - Tree-shakeable ESM build
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/utils/categoryUtils.ts
+function createProjectPreferences(config, defaultValue = false) {
+  const preferences = {
+    necessary: true
+    // Sempre presente e true (essencial)
+  };
+  const enabledCategories = config?.enabledCategories || [];
+  enabledCategories.forEach((category) => {
+    if (category !== "necessary") {
+      preferences[category] = defaultValue;
+    }
+  });
+  const customCategories = config?.customCategories || [];
+  customCategories.forEach((cat) => {
+    if (cat.id && cat.id !== "necessary") {
+      preferences[cat.id] = defaultValue;
+    }
+  });
+  return preferences;
+}
+function validateProjectPreferences(preferences, config) {
+  const validPreferences = {
+    necessary: true
+    // Sempre válida
+  };
+  const enabledCategories = config?.enabledCategories || [];
+  enabledCategories.forEach((category) => {
+    if (category !== "necessary" && preferences[category] !== void 0) {
+      validPreferences[category] = preferences[category];
+    }
+  });
+  const customCategories = config?.customCategories || [];
+  customCategories.forEach((cat) => {
+    const id = cat.id;
+    if (id && id !== "necessary" && preferences[id] !== void 0) {
+      validPreferences[id] = preferences[id];
+    }
+  });
+  return validPreferences;
+}
+function getAllProjectCategories(config) {
+  const allCategories = [
+    {
+      id: "necessary",
+      name: "Necess\xE1rios",
+      description: "Cookies essenciais para funcionamento b\xE1sico do site",
+      essential: true
+    }
+  ];
+  const enabledCategories = config?.enabledCategories || [];
+  enabledCategories.forEach((category) => {
+    if (category !== "necessary") {
+      allCategories.push(getDefaultCategoryDefinition(category));
+    }
+  });
+  const customCategories = config?.customCategories || [];
+  customCategories.forEach((cat) => {
+    if (cat.id && cat.id !== "necessary") {
+      allCategories.push({ ...cat, essential: !!cat.essential });
+    }
+  });
+  return allCategories;
+}
+function getDefaultCategoryDefinition(category) {
+  const definitions = {
+    necessary: {
+      id: "necessary",
+      name: "Necess\xE1rios",
+      description: "Cookies essenciais para funcionamento b\xE1sico do site",
+      essential: true
+    },
+    analytics: {
+      id: "analytics",
+      name: "An\xE1lise e Estat\xEDsticas",
+      description: "Cookies para an\xE1lise de uso e estat\xEDsticas do site",
+      essential: false
+    },
+    functional: {
+      id: "functional",
+      name: "Funcionalidades",
+      description: "Cookies para funcionalidades extras como prefer\xEAncias e idioma",
+      essential: false
+    },
+    marketing: {
+      id: "marketing",
+      name: "Marketing e Publicidade",
+      description: "Cookies para publicidade direcionada e marketing",
+      essential: false
+    },
+    social: {
+      id: "social",
+      name: "Redes Sociais",
+      description: "Cookies para integra\xE7\xE3o com redes sociais e compartilhamento",
+      essential: false
+    },
+    personalization: {
+      id: "personalization",
+      name: "Personaliza\xE7\xE3o",
+      description: "Cookies para personaliza\xE7\xE3o de conte\xFAdo e experi\xEAncia",
+      essential: false
+    }
+  };
+  return definitions[category];
+}
+
+// src/utils/logger.ts
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["ERROR"] = 0] = "ERROR";
+  LogLevel2[LogLevel2["WARN"] = 1] = "WARN";
+  LogLevel2[LogLevel2["INFO"] = 2] = "INFO";
+  LogLevel2[LogLevel2["DEBUG"] = 3] = "DEBUG";
+  return LogLevel2;
+})(LogLevel || {});
+var _ConsentLogger = class _ConsentLogger {
+  constructor() {
+    this.enabled = _ConsentLogger.IS_DEVELOPMENT;
+    this.level = 2 /* INFO */;
+  }
+  /**
+   * Habilita ou desabilita o sistema de logging.
+   * @param {boolean} enabled Se `true`, os logs serão exibidos; caso contrário, serão suprimidos.
+   */
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Define o nível mínimo de severidade para os logs.
+   * Mensagens com severidade menor que o nível definido não serão exibidas.
+   * @param {LogLevel} level O nível mínimo de severidade (ex: `LogLevel.DEBUG` para ver todos os logs).
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * Registra uma mensagem de erro.
+   * @param {...unknown[]} args Argumentos a serem logados.
+   */
+  error(...args) {
+    if (this.enabled && this.level >= 0 /* ERROR */) {
+      console.error(_ConsentLogger.LOG_PREFIX, "[ERROR]", ...args);
+    }
+  }
+  /**
+   * Registra uma mensagem de aviso.
+   * Suprimido em produção por padrão (apenas se logging estiver explicitamente habilitado).
+   * @param {...unknown[]} args Argumentos a serem logados.
+   */
+  warn(...args) {
+    if (this.enabled && this.level >= 1 /* WARN */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.warn(_ConsentLogger.LOG_PREFIX, "[WARN]", ...args);
+    }
+  }
+  /**
+   * Registra uma mensagem informativa.
+   * Suprimido em produção por padrão.
+   * @param {...unknown[]} args Argumentos a serem logados.
+   */
+  info(...args) {
+    if (this.enabled && this.level >= 2 /* INFO */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.info(_ConsentLogger.LOG_PREFIX, "[INFO]", ...args);
+    }
+  }
+  /**
+   * Registra uma mensagem de depuração.
+   * Sempre suprimido em produção.
+   * @param {...unknown[]} args Argumentos a serem logados.
+   */
+  debug(...args) {
+    if (this.enabled && this.level >= 3 /* DEBUG */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.debug(_ConsentLogger.LOG_PREFIX, "[DEBUG]", ...args);
+    }
+  }
+  /**
+   * Inicia um grupo de logs no console.
+   * Suprimido em produção.
+   * @param {...unknown[]} args Argumentos para o título do grupo.
+   */
+  group(...args) {
+    if (this.enabled && this.level >= 3 /* DEBUG */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.group(_ConsentLogger.LOG_PREFIX, ...args);
+    }
+  }
+  /**
+   * Finaliza o grupo de logs mais recente no console.
+   * Suprimido em produção.
+   */
+  groupEnd() {
+    if (this.enabled && this.level >= 3 /* DEBUG */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.groupEnd();
+    }
+  }
+  /**
+   * Exibe dados tabulares no console.
+   * Suprimido em produção.
+   * @param {unknown} tabularData Dados a serem exibidos na tabela.
+   * @param {string[]} [properties] Propriedades opcionais para exibir.
+   */
+  table(tabularData, properties) {
+    if (this.enabled && this.level >= 3 /* DEBUG */ && !_ConsentLogger.IS_PRODUCTION) {
+      console.table(tabularData, properties);
+    }
+  }
+  /**
+   * Registra informações sobre a compatibilidade do tema Material-UI.
+   * @param {unknown} themeInfo Objeto potencialmente parcial do tema (inspeção segura).
+   */
+  themeCompatibility(themeInfo) {
+    const isRecord = (v) => typeof v === "object" && v !== null;
+    const theme = isRecord(themeInfo) ? themeInfo : void 0;
+    const palette = theme && isRecord(theme["palette"]) ? theme["palette"] : void 0;
+    const primary = palette && isRecord(palette["primary"]);
+    const transitions = theme && isRecord(theme["transitions"]) ? theme["transitions"] : void 0;
+    const duration = transitions && isRecord(transitions["duration"]);
+    this.debug("Theme compatibility check:", {
+      hasTheme: !!theme,
+      hasPalette: !!palette,
+      hasPrimary: !!primary,
+      hasTransitions: !!transitions,
+      hasDuration: !!duration
+    });
+  }
+  /**
+   * Registra mudanças no estado de consentimento.
+   * @param {string} action Ação que causou a mudança de estado.
+   * @param {{ consented?: boolean; isModalOpen?: boolean; preferences?: Record<string, unknown> }} state Estado atual.
+   */
+  consentState(action, state) {
+    this.debug(`Consent state change [${action}]:`, {
+      consented: state.consented,
+      isModalOpen: state.isModalOpen,
+      preferencesCount: Object.keys(state.preferences || {}).length
+    });
+  }
+  /**
+   * Registra operações de cookie (leitura, escrita, remoção).
+   * @param {'read' | 'write' | 'delete'} operation Tipo de operação.
+   * @param {string} cookieName Nome do cookie.
+   * @param {unknown} [data] Dados associados, se aplicável.
+   */
+  cookieOperation(operation, cookieName, data) {
+    this.debug(`Cookie ${operation}:`, {
+      name: cookieName,
+      hasData: !!data,
+      dataSize: data ? JSON.stringify(data).length : 0
+    });
+  }
+  /**
+   * Registra a renderização de um componente.
+   * @param {string} componentName Nome do componente.
+   * @param {Record<string, unknown>} [props] Propriedades do componente.
+   */
+  componentRender(componentName, props) {
+    this.debug(`Component render [${componentName}]:`, {
+      hasProps: !!props,
+      propsKeys: props ? Object.keys(props) : []
+    });
+  }
+  /**
+   * Registra o status de carregamento de scripts de integração.
+   * @param {string} scriptName O nome do script.
+   * @param {'load' | 'remove'} action A ação realizada (carregar ou remover).
+   * @param {boolean} success Se a operação foi bem-sucedida.
+   */
+  scriptIntegration(scriptName, action, success) {
+    this.info(`Script ${action} [${scriptName}]:`, success ? "SUCCESS" : "FAILED");
+  }
+  /**
+   * Registra chamadas à API interna da biblioteca.
+   * @param {string} method Nome do método da API chamado.
+   * @param {unknown} [params] Parâmetros passados para o método.
+   */
+  apiUsage(method, params) {
+    this.debug(`API call [${method}]:`, params);
+  }
+};
+_ConsentLogger.IS_DEVELOPMENT = typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV === "development";
+_ConsentLogger.IS_PRODUCTION = typeof globalThis !== "undefined" && globalThis.process?.env?.NODE_ENV === "production";
+_ConsentLogger.LOG_PREFIX = "[react-lgpd-consent]";
+var ConsentLogger = _ConsentLogger;
+var logger = new ConsentLogger();
+function setDebugLogging(enabled, level = 2 /* INFO */) {
+  logger.setEnabled(enabled);
+  logger.setLevel(level);
+  logger.info(`Debug logging ${enabled ? "enabled" : "disabled"} with level ${LogLevel[level]}`);
+}
+
+// src/utils/cookieUtils.ts
+var DEFAULT_COOKIE_OPTS = {
+  name: "cookieConsent",
+  maxAgeDays: 365,
+  sameSite: "Lax",
+  secure: typeof window !== "undefined" ? window.location.protocol === "https:" : false,
+  path: "/"
+};
+var COOKIE_SCHEMA_VERSION = "1.0";
+function readConsentCookie(name = DEFAULT_COOKIE_OPTS.name) {
+  logger.debug("Reading consent cookie", { name });
+  if (typeof document === "undefined") {
+    logger.debug("Cookie read skipped: server-side environment");
+    return null;
+  }
+  const raw = Cookies__default.default.get(name);
+  if (!raw) {
+    logger.debug("No consent cookie found");
+    return null;
+  }
+  try {
+    const data = JSON.parse(raw);
+    logger.cookieOperation("read", name, data);
+    if (!data.version) {
+      logger.debug("Migrating legacy cookie format");
+      return migrateLegacyCookie(data);
+    }
+    if (data.version !== COOKIE_SCHEMA_VERSION) {
+      logger.warn(`Cookie version mismatch: ${data.version} != ${COOKIE_SCHEMA_VERSION}`);
+      return null;
+    }
+    return data;
+  } catch (error) {
+    logger.error("Error parsing consent cookie", error);
+    return null;
+  }
+}
+function migrateLegacyCookie(legacyData) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      version: COOKIE_SCHEMA_VERSION,
+      consented: Boolean(legacyData.consented) || false,
+      preferences: legacyData.preferences && typeof legacyData.preferences === "object" ? legacyData.preferences : { necessary: true },
+      consentDate: now,
+      lastUpdate: now,
+      source: "banner",
+      isModalOpen: false
+    };
+  } catch {
+    return null;
+  }
+}
+function writeConsentCookie(state, config, opts, source = "banner") {
+  if (typeof document === "undefined") {
+    logger.debug("Cookie write skipped: server-side environment");
+    return;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const o = { ...DEFAULT_COOKIE_OPTS, ...opts };
+  const cookieData = {
+    version: COOKIE_SCHEMA_VERSION,
+    consented: state.consented,
+    preferences: state.preferences,
+    consentDate: state.consentDate || now,
+    lastUpdate: now,
+    source,
+    projectConfig: config
+  };
+  logger.cookieOperation("write", o.name, cookieData);
+  Cookies__default.default.set(o.name, JSON.stringify(cookieData), {
+    expires: o.maxAgeDays,
+    sameSite: o.sameSite,
+    secure: o.secure,
+    path: o.path
+  });
+  logger.info("Consent cookie saved", {
+    consented: cookieData.consented,
+    source: cookieData.source,
+    preferencesCount: Object.keys(cookieData.preferences).length
+  });
+}
+function removeConsentCookie(opts) {
+  if (typeof document === "undefined") {
+    logger.debug("Cookie removal skipped: server-side environment");
+    return;
+  }
+  const o = { ...DEFAULT_COOKIE_OPTS, ...opts };
+  logger.cookieOperation("delete", o.name);
+  Cookies__default.default.remove(o.name, { path: o.path });
+  logger.info("Consent cookie removed");
+}
+
+// src/utils/dataLayerEvents.ts
+var LIBRARY_VERSION = "0.5.0";
+function ensureDataLayer() {
+  if (typeof window === "undefined") return;
+  if (!window.dataLayer) {
+    window.dataLayer = [];
+  }
+}
+function pushConsentInitializedEvent(categories) {
+  if (typeof window === "undefined") return;
+  ensureDataLayer();
+  const event = {
+    event: "consent_initialized",
+    consent_version: LIBRARY_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    categories
+  };
+  window.dataLayer?.push(event);
+}
+function pushConsentUpdatedEvent(categories, origin, previousCategories) {
+  if (typeof window === "undefined") return;
+  ensureDataLayer();
+  const changedCategories = previousCategories ? Object.keys(categories).filter((key) => categories[key] !== previousCategories[key]) : [];
+  const event = {
+    event: "consent_updated",
+    consent_version: LIBRARY_VERSION,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    origin,
+    categories,
+    changed_categories: changedCategories
+  };
+  window.dataLayer?.push(event);
+}
+function useDataLayerEvents() {
+  return {
+    pushInitialized: pushConsentInitializedEvent,
+    pushUpdated: pushConsentUpdatedEvent
+  };
+}
+
+// src/hooks/useConsent.ts
+function useConsent() {
+  const state = useConsentStateInternal();
+  const actions = useConsentActionsInternal();
+  return {
+    consented: state.consented,
+    preferences: state.preferences,
+    isModalOpen: state.isModalOpen,
+    acceptAll: actions.acceptAll,
+    rejectAll: actions.rejectAll,
+    setPreference: actions.setPreference,
+    setPreferences: actions.setPreferences,
+    openPreferences: actions.openPreferences,
+    closePreferences: actions.closePreferences,
+    resetConsent: actions.resetConsent
+  };
+}
+function useConsentTexts() {
+  return useConsentTextsInternal();
+}
+function useConsentHydration() {
+  return useConsentHydrationInternal();
+}
+var globalOpenPreferences = null;
+function _registerGlobalOpenPreferences(openPreferences) {
+  globalOpenPreferences = openPreferences;
+}
+function _unregisterGlobalOpenPreferences() {
+  globalOpenPreferences = null;
+}
+function useOpenPreferencesModal() {
+  const actions = useConsentActionsInternal();
+  if (!actions) {
+    throw new Error(
+      "[LGPD-CONSENT] useOpenPreferencesModal deve ser usado dentro do ConsentProvider. Envolva seu componente com <ConsentProvider>."
+    );
+  }
+  return actions.openPreferences;
+}
+function openPreferencesModal() {
+  if (globalOpenPreferences) {
+    globalOpenPreferences();
+  } else {
+    logger.warn(
+      "openPreferencesModal called but no ConsentProvider is mounted. Make sure ConsentProvider is rendered before calling this function."
+    );
+  }
+}
+
+// src/utils/cookieRegistry.ts
+var COOKIE_PATTERNS_BY_CATEGORY = {
+  necessary: ["cookieConsent"],
+  analytics: ["_ga", "_ga_*", "_gid", "_gcl_au", "_hj*", "mp_*", "_clck", "_clsk"],
+  functional: ["intercom-*", "__zlcmid", "_zendesk_shared_session", "_userway_*"],
+  marketing: ["_fbp", "fr"],
+  social: [],
+  personalization: []
+};
+var COOKIE_INFO_BY_INTEGRATION = {
+  "google-analytics": [
+    {
+      name: "_ga",
+      purpose: "Identifica\xE7\xE3o \xFAnica de visitantes para an\xE1lise de tr\xE1fego",
+      duration: "2 anos",
+      provider: "Google Analytics"
+    },
+    {
+      name: "_ga_*",
+      purpose: "Rastreamento de sess\xF5es e eventos espec\xEDficos do stream GA4",
+      duration: "2 anos",
+      provider: "Google Analytics"
+    },
+    {
+      name: "_gid",
+      purpose: "Distin\xE7\xE3o de visitantes \xFAnicos em per\xEDodo de 24h",
+      duration: "24 horas",
+      provider: "Google Analytics"
+    }
+  ],
+  "google-tag-manager": [
+    {
+      name: "_gcl_au",
+      purpose: "Rastreamento de convers\xF5es de an\xFAncios",
+      duration: "90 dias",
+      provider: "Google"
+    }
+  ],
+  hotjar: [
+    {
+      name: "_hjSession_*",
+      purpose: "Rastreamento de sess\xE3o",
+      duration: "30 minutos",
+      provider: "Hotjar"
+    },
+    {
+      name: "_hjSessionUser_*",
+      purpose: "Persist\xEAncia de usu\xE1rio entre sess\xF5es",
+      duration: "365 dias",
+      provider: "Hotjar"
+    },
+    {
+      name: "_hjFirstSeen",
+      purpose: "Detec\xE7\xE3o da primeira visita do usu\xE1rio",
+      duration: "Sess\xE3o",
+      provider: "Hotjar"
+    }
+  ],
+  mixpanel: [
+    {
+      name: "mp_*",
+      purpose: "Rastreamento de eventos e propriedades do usu\xE1rio para analytics",
+      duration: "1 ano",
+      provider: "Mixpanel"
+    }
+  ],
+  clarity: [
+    {
+      name: "_clck",
+      purpose: "Identificador de usu\xE1rio",
+      duration: "365 dias",
+      provider: "Microsoft"
+    },
+    { name: "_clsk", purpose: "Rastreamento de sess\xE3o", duration: "1 dia", provider: "Microsoft" }
+  ],
+  intercom: [
+    {
+      name: "intercom-id-*",
+      purpose: "Identificador do usu\xE1rio",
+      duration: "9 meses",
+      provider: "Intercom"
+    },
+    {
+      name: "intercom-session-*",
+      purpose: "Gerenciamento de sess\xE3o",
+      duration: "1 semana",
+      provider: "Intercom"
+    }
+  ],
+  "zendesk-chat": [
+    {
+      name: "__zlcmid",
+      purpose: "Identificador de sess\xE3o de chat",
+      duration: "1 ano",
+      provider: "Zendesk"
+    },
+    {
+      name: "_zendesk_shared_session",
+      purpose: "Gerenciamento de sess\xE3o",
+      duration: "Sess\xE3o",
+      provider: "Zendesk"
+    }
+  ],
+  userway: [
+    {
+      name: "_userway_*",
+      purpose: "Prefer\xEAncias de acessibilidade",
+      duration: "1 ano",
+      provider: "UserWay"
+    }
+  ],
+  "facebook-pixel": [
+    { name: "_fbp", purpose: "Rastreamento de an\xFAncios", duration: "90 dias", provider: "Meta" },
+    { name: "fr", purpose: "Direcionamento de an\xFAncios", duration: "90 dias", provider: "Meta" }
+  ]
+};
+var INTEGRATION_DEFAULT_CATEGORY = {
+  "google-analytics": "analytics",
+  "google-tag-manager": "analytics",
+  hotjar: "analytics",
+  mixpanel: "analytics",
+  clarity: "analytics",
+  intercom: "functional",
+  "zendesk-chat": "functional",
+  userway: "functional",
+  "facebook-pixel": "marketing"
+};
+var COOKIE_CATALOG_OVERRIDES = {};
+var COOKIE_CATEGORY_OVERRIDES = {};
+function setCookieCatalogOverrides(overrides) {
+  COOKIE_CATALOG_OVERRIDES = {
+    byCategory: { ...COOKIE_CATALOG_OVERRIDES.byCategory || {}, ...overrides.byCategory || {} },
+    byIntegration: {
+      ...COOKIE_CATALOG_OVERRIDES.byIntegration || {},
+      ...overrides.byIntegration || {}
+    }
+  };
+}
+function setCookieCategoryOverrides(map) {
+  COOKIE_CATEGORY_OVERRIDES = { ...COOKIE_CATEGORY_OVERRIDES, ...map };
+}
+function matchPattern(name, pattern) {
+  if (pattern.endsWith("*")) return name.startsWith(pattern.slice(0, -1));
+  return name === pattern;
+}
+function getCookiesInfoForCategory(categoryId, usedIntegrations) {
+  const result = [];
+  usedIntegrations.forEach((id) => {
+    const defaultCat = INTEGRATION_DEFAULT_CATEGORY[id];
+    const defaults = COOKIE_INFO_BY_INTEGRATION[id] || [];
+    const list = COOKIE_CATALOG_OVERRIDES.byIntegration?.[id] || defaults;
+    list.forEach((desc) => {
+      const overrideCat = Object.entries(COOKIE_CATEGORY_OVERRIDES).find(
+        ([pattern]) => matchPattern(desc.name, pattern)
+      )?.[1];
+      const finalCat = overrideCat ?? defaultCat;
+      if (finalCat === categoryId && !result.find((d) => d.name === desc.name)) result.push(desc);
+    });
+  });
+  const catOverride = COOKIE_CATALOG_OVERRIDES.byCategory?.[categoryId];
+  if (catOverride) {
+    catOverride.forEach((d) => {
+      const idx = result.findIndex((x) => x.name === d.name);
+      if (idx >= 0) result[idx] = d;
+      else result.push(d);
+    });
+  }
+  if (categoryId === "necessary") {
+    if (!result.find((d) => d.name === "cookieConsent")) {
+      result.push({
+        name: "cookieConsent",
+        purpose: "Armazena suas prefer\xEAncias de consentimento",
+        duration: "365 dias",
+        provider: "Este site"
+      });
+    }
+  }
+  return result;
+}
+
+// src/utils/developerGuidance.ts
+var DEFAULT_PROJECT_CATEGORIES = {
+  enabledCategories: ["analytics"]
+};
+function calculateComplianceScore(guidance) {
+  let score = 0;
+  const maxScore = 100;
+  if (!guidance.usingDefaults) score += 30;
+  const totalCategories = guidance.activeCategoriesInfo.length;
+  const toggleableCategories = guidance.activeCategoriesInfo.filter((c) => c.uiRequired).length;
+  if (totalCategories > 1) score += 20;
+  if (toggleableCategories >= 2 && toggleableCategories <= 4) score += 25;
+  const criticalWarnings = guidance.messages.filter((m) => m.severity === "error").length;
+  const warnings = guidance.messages.filter((m) => m.severity === "warning").length;
+  if (criticalWarnings === 0) score += 15;
+  if (warnings === 0) score += 10;
+  return Math.min(score, maxScore);
+}
+function analyzeDeveloperConfiguration(config) {
+  const guidance = {
+    warnings: [],
+    suggestions: [],
+    messages: [],
+    activeCategoriesInfo: [],
+    usingDefaults: !config,
+    complianceScore: 0
+  };
+  const addMessage = (severity, message, category, actionable = true) => {
+    const guidanceMessage = { severity, message, category, actionable };
+    guidance.messages.push(guidanceMessage);
+    if (severity === "warning" || severity === "error") {
+      guidance.warnings.push(message);
+    } else {
+      guidance.suggestions.push(message);
+    }
+  };
+  const finalConfig = config || DEFAULT_PROJECT_CATEGORIES;
+  if (!config) {
+    addMessage(
+      "warning",
+      'LGPD-CONSENT: Nenhuma configura\xE7\xE3o de categorias especificada. Usando padr\xE3o: necessary + analytics. Para produ\xE7\xE3o, especifique explicitamente as categorias via prop "categories".',
+      "configuration"
+    );
+  }
+  guidance.activeCategoriesInfo.push({
+    id: "necessary",
+    name: "Cookies Necess\xE1rios",
+    description: "Essenciais para funcionamento b\xE1sico do site",
+    essential: true,
+    uiRequired: false,
+    cookies: COOKIE_PATTERNS_BY_CATEGORY["necessary"]
+  });
+  const enabled = finalConfig.enabledCategories || [];
+  const NAMES = {
+    analytics: { name: "Cookies Anal\xEDticos", description: "Medem uso e performance do site" },
+    functional: {
+      name: "Cookies Funcionais",
+      description: "Melhoram experi\xEAncia e funcionalidades"
+    },
+    marketing: { name: "Cookies de Marketing", description: "Publicidade direcionada e campanhas" },
+    social: { name: "Cookies de Redes Sociais", description: "Integra\xE7\xE3o com plataformas sociais" },
+    personalization: { name: "Cookies de Personaliza\xE7\xE3o", description: "Adapta\xE7\xE3o de conte\xFAdo" }
+  };
+  enabled.forEach((id) => {
+    const info = NAMES[id];
+    if (info) {
+      guidance.activeCategoriesInfo.push({
+        id,
+        name: info.name,
+        description: info.description,
+        essential: false,
+        uiRequired: true,
+        cookies: COOKIE_PATTERNS_BY_CATEGORY[id]
+      });
+    }
+  });
+  const custom = finalConfig.customCategories || [];
+  custom.forEach((cat) => {
+    if (!cat?.id || cat.id === "necessary") return;
+    guidance.activeCategoriesInfo.push({
+      id: cat.id,
+      name: cat.name,
+      description: cat.description,
+      essential: !!cat.essential,
+      uiRequired: !cat.essential,
+      cookies: cat.cookies
+    });
+  });
+  try {
+    const gt = globalThis;
+    const implied = (gt.__LGPD_REQUIRED_CATEGORIES__ || []).filter(Boolean);
+    implied.forEach((id) => {
+      if (!guidance.activeCategoriesInfo.find((c) => c.id === id)) {
+        const info = NAMES[id];
+        if (info) {
+          guidance.activeCategoriesInfo.push({
+            id,
+            name: info.name,
+            description: info.description,
+            essential: false,
+            uiRequired: true,
+            cookies: COOKIE_PATTERNS_BY_CATEGORY[id]
+          });
+          if (!enabled.includes(id)) {
+            addMessage(
+              "info",
+              `Integra\xE7\xF5es detectadas requerem a categoria '${id}'. Adicione-a em categories.enabledCategories.`,
+              "integration"
+            );
+          }
+        }
+      }
+    });
+  } catch {
+  }
+  try {
+    const gt2 = globalThis;
+    const used = gt2.__LGPD_USED_INTEGRATIONS__ || [];
+    guidance.activeCategoriesInfo = guidance.activeCategoriesInfo.map((c) => {
+      const info = getCookiesInfoForCategory(c.id, used);
+      const names = Array.from(/* @__PURE__ */ new Set([...c.cookies || [], ...info.map((d) => d.name)]));
+      return { ...c, cookies: names };
+    });
+  } catch {
+  }
+  const totalToggleable = guidance.activeCategoriesInfo.filter((c) => c.uiRequired).length;
+  if (totalToggleable === 0) {
+    addMessage(
+      "info",
+      'Apenas cookies necess\xE1rios est\xE3o configurados. Para compliance LGPD, considere adicionar categorias como "analytics" ou "functional" conforme uso real.',
+      "compliance"
+    );
+  }
+  if (totalToggleable > 5) {
+    addMessage(
+      "warning",
+      `${totalToggleable} categorias opcionais detectadas. UI com muitas op\xE7\xF5es pode prejudicar a experi\xEAncia. Considere agrupar categorias similares.`,
+      "usability"
+    );
+  }
+  guidance.complianceScore = calculateComplianceScore(guidance);
+  return guidance;
+}
+var GUIDANCE_CACHE = /* @__PURE__ */ new Set();
+var SESSION_LOGGED = {
+  intro: false,
+  bestPractices: false
+};
+function getComplianceScoreColor(score) {
+  if (score >= 80) return "#4caf50";
+  if (score >= 60) return "#ff9800";
+  return "#f44336";
+}
+function logComplianceScore(prefix, score) {
+  const color = getComplianceScoreColor(score);
+  console.log(
+    `%c${prefix} Score de Conformidade LGPD: ${score}/100`,
+    `color: ${color}; font-weight: bold; font-size: 14px;`
+  );
+}
+function logMessagesByType(prefix, messages, type, config) {
+  const filteredMessages = messages.filter((m) => m.severity === type);
+  if (filteredMessages.length === 0) return false;
+  const typeConfig = {
+    error: {
+      show: config.showWarnings,
+      title: "Erros Cr\xEDticos",
+      color: "#d32f2f",
+      method: console.error
+    },
+    warning: {
+      show: config.showWarnings,
+      title: "Avisos de Configura\xE7\xE3o",
+      color: "#f57c00",
+      method: console.warn
+    },
+    info: {
+      show: config.showSuggestions,
+      title: "Sugest\xF5es",
+      color: "#2196f3",
+      method: console.info
+    }
+  };
+  const typeSettings = typeConfig[type];
+  if (!typeSettings.show) return false;
+  console.group(
+    `%c${prefix} ${typeSettings.title}`,
+    `color: ${typeSettings.color}; font-weight: bold;`
+  );
+  filteredMessages.forEach(
+    (msg) => typeSettings.method(
+      `%c${prefix}%c ${msg.message}`,
+      `color: ${typeSettings.color};`,
+      "color: #333;"
+    )
+  );
+  console.groupEnd();
+  return true;
+}
+function getGuidanceHash(guidance) {
+  const sortedWarnings = [...guidance.warnings].sort((a, b) => a.localeCompare(b));
+  const sortedSuggestions = [...guidance.suggestions].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  const sortedCategories = guidance.activeCategoriesInfo.map((c) => c.id).sort((a, b) => a.localeCompare(b));
+  return JSON.stringify({
+    warnings: sortedWarnings,
+    suggestions: sortedSuggestions,
+    categories: sortedCategories,
+    usingDefaults: guidance.usingDefaults
+  });
+}
+function logIntroOnce() {
+  if (SESSION_LOGGED.intro) return;
+  SESSION_LOGGED.intro = true;
+  console.log(
+    `%c\u{1F36A} LGPD-CONSENT %c- Sistema de Consentimento Ativo`,
+    "background: #4caf50; color: white; padding: 4px 8px; border-radius: 4px; font-weight: bold;",
+    "color: #2e7d32; font-weight: 500;"
+  );
+}
+function logServerSideIfAvailable(guidance) {
+  try {
+    const gt = globalThis;
+    if (gt.process?.stdout?.write) {
+      const prefix = "\x1B[36m[LGPD-CONSENT]\x1B[0m";
+      const warnings = guidance.warnings.length;
+      const suggestions = guidance.suggestions.length;
+      const stdout = gt.process.stdout;
+      if (warnings > 0 || suggestions > 0) {
+        stdout.write(`${prefix} \u{1F527} Config: ${warnings} avisos, ${suggestions} sugest\xF5es
+`);
+        if (warnings > 0) {
+          guidance.warnings.forEach((w) => {
+            stdout.write(`${prefix} \x1B[33m\u26A0\uFE0F  ${w}\x1B[0m
+`);
+          });
+        }
+        if (suggestions > 0) {
+          guidance.suggestions.forEach((s) => {
+            stdout.write(`${prefix} \x1B[36m\u{1F4A1} ${s}\x1B[0m
+`);
+          });
+        }
+      }
+    }
+  } catch {
+  }
+}
+function logDeveloperGuidance(guidance, disableGuidanceProp, config) {
+  const gt = globalThis;
+  const nodeEnv = typeof gt.process !== "undefined" ? gt.process?.env?.NODE_ENV : void 0;
+  const isProd = nodeEnv === "production" || gt.__LGPD_PRODUCTION__ === true;
+  if (isProd || disableGuidanceProp) return;
+  const guidanceHash = getGuidanceHash(guidance);
+  if (GUIDANCE_CACHE.has(guidanceHash)) return;
+  GUIDANCE_CACHE.add(guidanceHash);
+  logServerSideIfAvailable(guidance);
+  const guidanceConfig = {
+    showWarnings: true,
+    showSuggestions: true,
+    showCategoriesTable: true,
+    showBestPractices: true,
+    showComplianceScore: true,
+    minimumSeverity: "info",
+    ...config
+  };
+  if (guidanceConfig.messageProcessor) {
+    guidanceConfig.messageProcessor(guidance.messages);
+    return;
+  }
+  logIntroOnce();
+  const PREFIX = "\u{1F36A}";
+  let hasImportantInfo = false;
+  const filteredMessages = guidance.messages.filter((msg) => {
+    const severityLevels = { info: 0, warning: 1, error: 2 };
+    const minLevel = severityLevels[guidanceConfig.minimumSeverity || "info"];
+    const msgLevel = severityLevels[msg.severity];
+    return msgLevel >= minLevel;
+  });
+  hasImportantInfo = logMessagesByType(PREFIX, filteredMessages, "error", guidanceConfig) || hasImportantInfo;
+  hasImportantInfo = logMessagesByType(PREFIX, filteredMessages, "warning", guidanceConfig) || hasImportantInfo;
+  if (hasImportantInfo || guidance.usingDefaults) {
+    hasImportantInfo = logMessagesByType(PREFIX, filteredMessages, "info", guidanceConfig) || hasImportantInfo;
+  }
+  if (guidanceConfig.showComplianceScore && guidance.complianceScore !== void 0) {
+    logComplianceScore(PREFIX, guidance.complianceScore);
+  }
+  if (guidanceConfig.showCategoriesTable && (hasImportantInfo || guidance.usingDefaults)) {
+    const rows = guidance.activeCategoriesInfo.map((cat) => ({
+      "\u{1F4CA} Categoria": cat.id,
+      "\u{1F3F7}\uFE0F  Nome": cat.name,
+      "\u{1F39B}\uFE0F  UI": cat.uiRequired ? "\u2705" : "\u{1F512}",
+      "\u{1F36A} Cookies": (cat.cookies || []).slice(0, 3).join(", ") + (cat.cookies && cat.cookies.length > 3 ? ` (+${cat.cookies.length - 3})` : "")
+    }));
+    if (typeof console.table === "function") {
+      console.group(`%c${PREFIX} Configura\xE7\xE3o Ativa`, "color: #4caf50; font-weight: bold;");
+      console.table(rows);
+      console.groupEnd();
+    }
+  }
+  if (!SESSION_LOGGED.bestPractices && hasImportantInfo) {
+    SESSION_LOGGED.bestPractices = true;
+    console.group(`%c${PREFIX} LGPD - Boas Pr\xE1ticas`, "color: #9c27b0; font-weight: bold;");
+    console.info(
+      `%c${PREFIX}%c Necessary: sempre ativo \u2022 Demais: opt-out por padr\xE3o`,
+      "color: #9c27b0;",
+      "color: #7b1fa2;"
+    );
+    console.info(
+      `%c${PREFIX}%c Documente pol\xEDticas claras por categoria`,
+      "color: #9c27b0;",
+      "color: #7b1fa2;"
+    );
+    console.info(
+      `%c${PREFIX}%c Registre consentimento com data/hora/origem`,
+      "color: #9c27b0;",
+      "color: #7b1fa2;"
+    );
+    console.groupEnd();
+  }
+}
+function useDeveloperGuidance(config, disableGuidanceProp, guidanceConfig) {
+  const guidance = React4__namespace.default.useMemo(() => analyzeDeveloperConfiguration(config), [config]);
+  React4__namespace.default.useEffect(() => {
+    if (!disableGuidanceProp) logDeveloperGuidance(guidance, disableGuidanceProp, guidanceConfig);
+  }, [guidance, disableGuidanceProp, guidanceConfig]);
+  return guidance;
+}
+var GUIDANCE_PRESETS = {
+  /** Configuração completa para desenvolvimento */
+  development: {
+    showWarnings: true,
+    showSuggestions: true,
+    showCategoriesTable: true,
+    showBestPractices: true,
+    showComplianceScore: true,
+    minimumSeverity: "info"
+  },
+  /** Configuração silenciosa para produção */
+  production: {
+    showWarnings: false,
+    showSuggestions: false,
+    showCategoriesTable: false,
+    showBestPractices: false,
+    showComplianceScore: false,
+    minimumSeverity: "error"
+  },
+  /** Apenas erros críticos */
+  minimal: {
+    showWarnings: true,
+    showSuggestions: false,
+    showCategoriesTable: false,
+    showBestPractices: false,
+    showComplianceScore: false,
+    minimumSeverity: "error"
+  },
+  /** Focado em conformidade LGPD */
+  compliance: {
+    showWarnings: true,
+    showSuggestions: true,
+    showCategoriesTable: true,
+    showBestPractices: true,
+    showComplianceScore: true,
+    minimumSeverity: "warning"
+  }
+};
+
+// src/utils/validation.ts
+var isDev = () => typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+function validateConsentProviderProps(props) {
+  const warnings = [];
+  const errors = [];
+  const sanitized = {};
+  if (!isDev()) {
+    if (props.categories) {
+      const enabled = Array.from(/* @__PURE__ */ new Set([...props.categories.enabledCategories ?? []]));
+      const sanitizedEnabled = enabled.filter((c) => c !== "necessary");
+      sanitized.categories = {
+        enabledCategories: sanitizedEnabled,
+        customCategories: props.categories.customCategories
+      };
+    }
+    return { sanitized, warnings, errors };
+  }
+  let z;
+  try {
+    z = __require("zod");
+  } catch {
+    z = void 0;
+  }
+  const issues = [];
+  if (z) {
+    const CustomCategorySchema = z.object({
+      id: z.string().min(1, "customCategories[].id deve ser uma string n\xE3o vazia"),
+      name: z.string().min(1, "customCategories[].name deve ser uma string n\xE3o vazia"),
+      description: z.string().min(1, "customCategories[].description deve ser uma string n\xE3o vazia"),
+      essential: z.boolean().optional(),
+      cookies: z.array(z.string().min(1)).optional()
+    });
+    const ProjectCategoriesConfigSchema = z.object({
+      enabledCategories: z.array(z.string().min(1)).optional(),
+      customCategories: z.array(CustomCategorySchema).optional()
+    }).strict();
+    const res = ProjectCategoriesConfigSchema.safeParse(props.categories);
+    if (!res.success) {
+      res.error.issues.forEach(
+        (issue) => issues.push({ path: `categories.${issue.path.join(".")}`, message: issue.message })
+      );
+    }
+  }
+  if (!props.categories) {
+    warnings.push(
+      "Prop 'categories' n\xE3o fornecida. A lib aplicar\xE1 um padr\xE3o seguro, mas recomenda-se definir 'categories.enabledCategories' explicitamente para clareza e auditoria."
+    );
+  } else {
+    const cat = props.categories;
+    const enabled = Array.from(/* @__PURE__ */ new Set([...cat.enabledCategories ?? []]));
+    if (enabled.includes("necessary")) {
+      warnings.push("'necessary' \xE9 sempre inclu\xEDda automaticamente \u2014 remova de enabledCategories.");
+    }
+    const sanitizedEnabled = enabled.filter((c) => c !== "necessary");
+    const invalidEnabled = sanitizedEnabled.filter((c) => typeof c !== "string" || c.trim() === "");
+    if (invalidEnabled.length > 0) {
+      warnings.push(
+        `enabledCategories cont\xE9m valores inv\xE1lidos: ${invalidEnabled.map((v) => String(v)).join(", ")} \u2014 remova ou corrija os IDs de categoria`
+      );
+    }
+    const custom = cat.customCategories ?? [];
+    if (z) {
+      const CustomCategorySchema = z.object({
+        id: z.string().min(1),
+        name: z.string().min(1),
+        description: z.string().min(1),
+        essential: z.boolean().optional(),
+        cookies: z.array(z.string().min(1)).optional()
+      });
+      const customParse = z.array(CustomCategorySchema).safeParse(custom);
+      if (!customParse.success) {
+        customParse.error.issues.forEach(
+          (issue) => issues.push({ path: `customCategories.${issue.path.join(".")}`, message: issue.message })
+        );
+      }
+    }
+    const ids = /* @__PURE__ */ new Set();
+    const dupes = [];
+    ["necessary", ...sanitizedEnabled].forEach((id) => {
+      if (ids.has(id)) dupes.push(id);
+      ids.add(id);
+    });
+    custom.forEach((c) => {
+      if (ids.has(c.id)) dupes.push(c.id);
+      ids.add(c.id);
+    });
+    if (dupes.length > 0) {
+      warnings.push(
+        `IDs de categoria duplicados detectados: ${Array.from(new Set(dupes)).join(
+          ", "
+        )} \u2014 verifique 'enabledCategories' e 'customCategories'.`
+      );
+    }
+    sanitized.categories = {
+      enabledCategories: sanitizedEnabled,
+      customCategories: custom
+    };
+  }
+  if (warnings.length > 0) {
+    logger.warn("Valida\xE7\xE3o do ConsentProvider:", ...warnings);
+  }
+  if (errors.length > 0 || issues.length > 0) {
+    issues.forEach((i) => errors.push(`Prop inv\xE1lida: ${i.path} \u2014 ${i.message}`));
+    logger.error("Erros de configura\xE7\xE3o do ConsentProvider:", ...errors);
+  }
+  return { sanitized, warnings, errors };
+}
+
+// src/utils/cookieDiscovery.ts
+function discoverRuntimeCookies() {
+  if (typeof document === "undefined" || !document.cookie) return [];
+  const names = Array.from(
+    new Set(
+      document.cookie.split(";").map((s) => s.trim()).filter(Boolean).map((s) => s.split("=")[0])
+    )
+  );
+  const list = names.map((name) => ({ name }));
+  try {
+    ;
+    globalThis.__LGPD_DISCOVERED_COOKIES__ = list;
+  } catch {
+  }
+  return list;
+}
+function detectConsentCookieName() {
+  if (typeof document === "undefined" || !document.cookie) return null;
+  try {
+    const pairs = document.cookie.split(";").map((s) => s.trim()).filter(Boolean);
+    for (const p of pairs) {
+      const [name, ...rest] = p.split("=");
+      const raw = rest.join("=");
+      if (!raw) continue;
+      let val = raw;
+      try {
+        val = decodeURIComponent(raw);
+      } catch {
+      }
+      if (val.startsWith("{")) {
+        try {
+          const obj = JSON.parse(val);
+          if (obj && typeof obj === "object" && "preferences" in obj && "version" in obj) {
+            return name;
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function categorizeDiscoveredCookies(discovered, registerOverrides = false) {
+  const list = discovered || globalThis.__LGPD_DISCOVERED_COOKIES__ || [];
+  const out = {};
+  function matchPattern2(name, pattern) {
+    if (pattern.endsWith("*")) return name.startsWith(pattern.slice(0, -1));
+    return name === pattern;
+  }
+  list.filter((d) => d.name && d.name !== "cookieConsent").forEach((d) => {
+    let assigned = null;
+    Object.keys(COOKIE_PATTERNS_BY_CATEGORY).forEach((cat2) => {
+      if (assigned) return;
+      const patterns = COOKIE_PATTERNS_BY_CATEGORY[cat2] || [];
+      if (patterns.some((p) => matchPattern2(d.name, p))) assigned = cat2;
+    });
+    const cat = assigned || "analytics";
+    out[cat] = out[cat] || [];
+    if (!out[cat].find((x) => x.name === d.name)) out[cat].push(d);
+  });
+  if (registerOverrides) {
+    const byCategory = {};
+    Object.entries(out).forEach(([cat, cookies]) => {
+      byCategory[cat] = cookies;
+    });
+    setCookieCatalogOverrides({ byCategory });
+  }
+  return out;
+}
+var CategoriesContext = React4__namespace.createContext(null);
+function CategoriesProvider({
+  children,
+  config,
+  disableDeveloperGuidance,
+  disableDiscoveryLog
+}) {
+  const [impliedVersion, setImpliedVersion] = React4__namespace.useState(0);
+  React4__namespace.useEffect(() => {
+    const handler = () => setImpliedVersion((v) => v + 1);
+    if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+      window.addEventListener("lgpd:requiredCategories", handler);
+      return () => window.removeEventListener("lgpd:requiredCategories", handler);
+    }
+    return () => {
+    };
+  }, []);
+  const contextValue = React4__namespace.useMemo(() => {
+    const finalConfig = config || DEFAULT_PROJECT_CATEGORIES;
+    const guidance = analyzeDeveloperConfiguration(config);
+    const toggleableCategories = guidance.activeCategoriesInfo.filter((cat) => cat.uiRequired);
+    return {
+      config: finalConfig,
+      guidance,
+      toggleableCategories,
+      allCategories: guidance.activeCategoriesInfo
+    };
+  }, [config, impliedVersion]);
+  React4__namespace.useEffect(() => {
+    logDeveloperGuidance(contextValue.guidance, disableDeveloperGuidance);
+  }, [contextValue.guidance, disableDeveloperGuidance]);
+  React4__namespace.useEffect(() => {
+    try {
+      const gt = globalThis;
+      const env = typeof gt.process !== "undefined" ? gt.process?.env?.NODE_ENV : void 0;
+      const isDev2 = env === "development";
+      if (!isDev2 || gt.__LGPD_DISCOVERY_LOGGED__ === true || disableDiscoveryLog) return;
+      const discovered = discoverRuntimeCookies();
+      const consentName = detectConsentCookieName() || DEFAULT_COOKIE_OPTS.name;
+      const PREFIX = "[\u{1F36A} LGPD-CONSENT]";
+      if (typeof console !== "undefined") {
+        try {
+          console.group(`${PREFIX} \u{1F50E} Descoberta de cookies (experimental)`);
+          const names = Array.from(
+            new Set([consentName, ...discovered.map((d) => d.name)].filter(Boolean))
+          );
+          const rows = names.map((n) => ({ Cookie: n }));
+          if (typeof console.table === "function") console.table(rows);
+          else console.log(rows);
+          console.info(
+            `${PREFIX} \u2139\uFE0F  Estes nomes s\xE3o detectados em tempo de execu\xE7\xE3o. Ajuste ou categorize via APIs de override se necess\xE1rio.`
+          );
+          console.groupEnd();
+        } catch {
+        }
+      }
+      gt.__LGPD_DISCOVERY_LOGGED__ = true;
+    } catch {
+    }
+  }, [disableDiscoveryLog]);
+  return /* @__PURE__ */ jsxRuntime.jsx(CategoriesContext.Provider, { value: contextValue, children });
+}
+function useCategories() {
+  const context = React4__namespace.useContext(CategoriesContext);
+  if (!context) {
+    throw new Error(
+      "useCategories deve ser usado dentro de CategoriesProvider. Certifique-se de que o ConsentProvider est\xE1 envolvendo seu componente."
+    );
+  }
+  return context;
+}
+function useCategoryStatus(categoryId) {
+  const { allCategories } = useCategories();
+  const category = allCategories.find((cat) => cat.id === categoryId);
+  return {
+    isActive: !!category,
+    isEssential: category?.essential || false,
+    needsToggle: category?.uiRequired || false,
+    name: category?.name,
+    description: category?.description
+  };
+}
+var DesignContext = React4__namespace.createContext(void 0);
+function DesignProvider({
+  tokens,
+  children
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(DesignContext.Provider, { value: tokens, children });
+}
+function useDesignTokens() {
+  return React4__namespace.useContext(DesignContext);
+}
+function createFullConsentState(consented, preferences, source, projectConfig, isModalOpen = false, existingState) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: "1.0",
+    consented,
+    preferences,
+    consentDate: existingState?.consentDate || now,
+    lastUpdate: now,
+    source,
+    projectConfig,
+    isModalOpen
+  };
+}
+var DEFAULT_TEXTS = {
+  // Textos básicos
+  bannerMessage: "Utilizamos cookies para melhorar sua experi\xEAncia.",
+  acceptAll: "Aceitar todos",
+  declineAll: "Recusar",
+  preferences: "Prefer\xEAncias",
+  policyLink: "Saiba mais",
+  modalTitle: "Prefer\xEAncias de Cookies",
+  modalIntro: "Ajuste as categorias de cookies. Cookies necess\xE1rios s\xE3o sempre utilizados para funcionalidades b\xE1sicas.",
+  save: "Salvar prefer\xEAncias",
+  necessaryAlwaysOn: "Cookies necess\xE1rios (sempre ativos)",
+  // Textos adicionais para UI customizada
+  preferencesButton: "Configurar Cookies",
+  preferencesTitle: "Gerenciar Prefer\xEAncias de Cookies",
+  preferencesDescription: "Escolha quais tipos de cookies voc\xEA permite que sejam utilizados.",
+  close: "Fechar",
+  accept: "Aceitar",
+  reject: "Rejeitar",
+  // Textos ANPD expandidos (opcionais)
+  brandingPoweredBy: "fornecido por",
+  controllerInfo: void 0,
+  // Exibido se definido
+  dataTypes: void 0,
+  // Exibido se definido
+  thirdPartySharing: void 0,
+  // Exibido se definido
+  userRights: void 0,
+  // Exibido se definido
+  contactInfo: void 0,
+  // Exibido se definido
+  retentionPeriod: void 0,
+  // Exibido se definido
+  lawfulBasis: void 0,
+  // Exibido se definido
+  transferCountries: void 0
+  // Exibido se definido
+};
+function reducer(state, action) {
+  logger.consentState(action.type, state);
+  switch (action.type) {
+    case "ACCEPT_ALL": {
+      const prefs = createProjectPreferences(action.config, true);
+      const newState = createFullConsentState(true, prefs, "banner", action.config, false, state);
+      logger.info("User accepted all cookies", {
+        preferences: newState.preferences
+      });
+      return newState;
+    }
+    case "REJECT_ALL": {
+      const prefs = createProjectPreferences(action.config, false);
+      const newState = createFullConsentState(true, prefs, "banner", action.config, false, state);
+      logger.info("User rejected all cookies", {
+        preferences: newState.preferences
+      });
+      return newState;
+    }
+    case "SET_CATEGORY":
+      logger.debug("Category preference changed", {
+        category: action.category,
+        value: action.value
+      });
+      return {
+        ...state,
+        preferences: {
+          ...state.preferences,
+          [action.category]: action.value
+        },
+        lastUpdate: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    case "SET_PREFERENCES":
+      logger.info("Preferences saved", { preferences: action.preferences });
+      return createFullConsentState(true, action.preferences, "modal", action.config, false, state);
+    case "OPEN_MODAL":
+      return { ...state, isModalOpen: true };
+    case "CLOSE_MODAL":
+      return createFullConsentState(true, state.preferences, "modal", action.config, false, state);
+    case "RESET": {
+      return createFullConsentState(
+        false,
+        createProjectPreferences(action.config),
+        "programmatic",
+        action.config,
+        false
+      );
+    }
+    case "HYDRATE": {
+      const validatedPreferences = validateProjectPreferences(
+        action.state.preferences,
+        action.config
+      );
+      return {
+        ...action.state,
+        preferences: validatedPreferences,
+        isModalOpen: false
+      };
+    }
+    default:
+      return state;
+  }
+}
+var StateCtx = React4__namespace.createContext(null);
+var ActionsCtx = React4__namespace.createContext(null);
+var TextsCtx = React4__namespace.createContext(DEFAULT_TEXTS);
+var HydrationCtx = React4__namespace.createContext(false);
+function ConsentProvider({
+  initialState,
+  categories,
+  texts: textsProp,
+  designTokens,
+  PreferencesModalComponent,
+  preferencesModalProps = {},
+  CookieBannerComponent,
+  cookieBannerProps = {},
+  FloatingPreferencesButtonComponent,
+  floatingPreferencesButtonProps = {},
+  disableFloatingPreferencesButton = false,
+  blocking = false,
+  blockingStrategy = "auto",
+  hideBranding: _hideBranding = false,
+  onConsentGiven,
+  onPreferencesSaved,
+  cookie: cookieOpts,
+  disableDeveloperGuidance,
+  guidanceConfig,
+  children,
+  disableDiscoveryLog
+}) {
+  const texts = React4__namespace.useMemo(() => ({ ...DEFAULT_TEXTS, ...textsProp ?? {} }), [textsProp]);
+  const cookie = React4__namespace.useMemo(
+    () => ({ ...DEFAULT_COOKIE_OPTS, ...cookieOpts ?? {} }),
+    [cookieOpts]
+  );
+  const finalCategoriesConfig = React4__namespace.useMemo(() => {
+    const isProd = typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+    if (!categories) return DEFAULT_PROJECT_CATEGORIES;
+    if (isProd) return categories;
+    const { sanitized } = validateConsentProviderProps({ categories });
+    return sanitized.categories ?? categories;
+  }, [categories]);
+  React4__namespace.useEffect(() => {
+    const isProd = typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+    if (!isProd && !categories) {
+      logger.warn(
+        "Prop 'categories' n\xE3o fornecida. A lib aplicar\xE1 um padr\xE3o seguro, mas recomenda-se definir 'categories.enabledCategories' explicitamente para clareza e auditoria."
+      );
+    }
+  }, [categories]);
+  const didWarnAboutMissingUI = React4__namespace.useRef(false);
+  useDeveloperGuidance(finalCategoriesConfig, disableDeveloperGuidance, guidanceConfig);
+  React4__namespace.useEffect(() => {
+    const isProd = typeof process !== "undefined" && process.env?.NODE_ENV === "production";
+    if (!isProd && PreferencesModalComponent) {
+      console.info(
+        "[LGPD-CONSENT] Dica: seu PreferencesModal \xE9 customizado. Garanta exibir os detalhes dos cookies por categoria (nome, finalidade, dura\xE7\xE3o) usando as APIs setCookieCatalogOverrides / setCookieCategoryOverrides e getCookiesInfoForCategory. Consulte QUICKSTART e INTEGRACOES.md."
+      );
+    }
+  }, [PreferencesModalComponent]);
+  const boot = React4__namespace.useMemo(() => {
+    if (initialState) return { ...initialState, isModalOpen: false };
+    return createFullConsentState(
+      false,
+      createProjectPreferences(finalCategoriesConfig),
+      "banner",
+      finalCategoriesConfig,
+      false
+    );
+  }, [initialState, finalCategoriesConfig]);
+  const [state, dispatch] = React4__namespace.useReducer(reducer, boot);
+  const [isHydrated, setIsHydrated] = React4__namespace.useState(false);
+  const previousPreferencesRef = React4__namespace.useRef(state.preferences);
+  React4__namespace.useEffect(() => {
+    if (!initialState) {
+      const saved = readConsentCookie(cookie.name);
+      if (saved?.consented) {
+        dispatch({
+          type: "HYDRATE",
+          state: saved,
+          config: finalCategoriesConfig
+        });
+      }
+    }
+    setIsHydrated(true);
+  }, [cookie.name, initialState, finalCategoriesConfig]);
+  React4__namespace.useEffect(() => {
+    if (isHydrated) {
+      pushConsentInitializedEvent(state.preferences);
+      logger.info("DataLayer: consent_initialized event dispatched", {
+        preferences: state.preferences
+      });
+    }
+  }, [isHydrated]);
+  React4__namespace.useEffect(() => {
+    if (state.consented) writeConsentCookie(state, finalCategoriesConfig, cookie);
+  }, [state, cookie, finalCategoriesConfig]);
+  const prevConsented = React4__namespace.useRef(state.consented);
+  React4__namespace.useEffect(() => {
+    if (!prevConsented.current && state.consented && onConsentGiven) {
+      setTimeout(() => onConsentGiven(state), 150);
+    }
+    prevConsented.current = state.consented;
+  }, [state, onConsentGiven]);
+  React4__namespace.useEffect(() => {
+    if (!isHydrated) return;
+    const hasChanged = Object.keys(state.preferences).some(
+      (key) => state.preferences[key] !== previousPreferencesRef.current[key]
+    );
+    if (hasChanged) {
+      const origin = state.source === "programmatic" ? "reset" : state.source;
+      pushConsentUpdatedEvent(state.preferences, origin, previousPreferencesRef.current);
+      logger.info("DataLayer: consent_updated event dispatched", {
+        origin,
+        preferences: state.preferences,
+        consented: state.consented
+      });
+      previousPreferencesRef.current = state.preferences;
+    }
+  }, [state.preferences, state.consented, state.source, isHydrated]);
+  const api = React4__namespace.useMemo(() => {
+    const acceptAll = () => dispatch({ type: "ACCEPT_ALL", config: finalCategoriesConfig });
+    const rejectAll = () => dispatch({ type: "REJECT_ALL", config: finalCategoriesConfig });
+    const setPreference = (category, value) => dispatch({ type: "SET_CATEGORY", category, value });
+    const setPreferences = (preferences) => {
+      dispatch({
+        type: "SET_PREFERENCES",
+        preferences,
+        config: finalCategoriesConfig
+      });
+      if (onPreferencesSaved) {
+        setTimeout(() => onPreferencesSaved(preferences), 150);
+      }
+    };
+    const openPreferences = () => dispatch({ type: "OPEN_MODAL" });
+    const closePreferences = () => dispatch({ type: "CLOSE_MODAL", config: finalCategoriesConfig });
+    const resetConsent = () => {
+      removeConsentCookie(cookie);
+      dispatch({ type: "RESET", config: finalCategoriesConfig });
+    };
+    return {
+      consented: !!state.consented,
+      preferences: state.preferences,
+      isModalOpen: state.isModalOpen,
+      acceptAll,
+      rejectAll,
+      setPreference,
+      setPreferences,
+      openPreferences,
+      closePreferences,
+      resetConsent
+    };
+  }, [state, cookie, finalCategoriesConfig, onPreferencesSaved]);
+  React4__namespace.useEffect(() => {
+    _registerGlobalOpenPreferences(api.openPreferences);
+    return () => _unregisterGlobalOpenPreferences();
+  }, [api.openPreferences]);
+  const providerBackdropColor = React4__namespace.useMemo(() => {
+    const backdrop = designTokens?.layout?.backdrop;
+    if (backdrop === false) return "transparent";
+    if (typeof backdrop === "string") return backdrop;
+    return "rgba(0, 0, 0, 0.4)";
+  }, [designTokens]);
+  const content = /* @__PURE__ */ jsxRuntime.jsx(StateCtx.Provider, { value: state, children: /* @__PURE__ */ jsxRuntime.jsx(ActionsCtx.Provider, { value: api, children: /* @__PURE__ */ jsxRuntime.jsx(TextsCtx.Provider, { value: texts, children: /* @__PURE__ */ jsxRuntime.jsx(HydrationCtx.Provider, { value: isHydrated, children: /* @__PURE__ */ jsxRuntime.jsx(DesignProvider, { tokens: designTokens, children: /* @__PURE__ */ jsxRuntime.jsxs(
+    CategoriesProvider,
+    {
+      config: finalCategoriesConfig,
+      disableDeveloperGuidance,
+      disableDiscoveryLog,
+      children: [
+        children,
+        PreferencesModalComponent ? /* @__PURE__ */ jsxRuntime.jsx(
+          PreferencesModalComponent,
+          {
+            preferences: api.preferences,
+            setPreferences: api.setPreferences,
+            closePreferences: api.closePreferences,
+            isModalOpen: api.isModalOpen,
+            texts,
+            ...preferencesModalProps
+          }
+        ) : (
+          // Aviso de desenvolvimento: usuário pode estar esquecendo de fornecer componentes UI
+          process.env.NODE_ENV === "development" && typeof window !== "undefined" && !didWarnAboutMissingUI.current && !CookieBannerComponent && !FloatingPreferencesButtonComponent && (() => {
+            didWarnAboutMissingUI.current = true;
+            console.warn(
+              "%c[@react-lgpd-consent/core] Aviso: Nenhum componente UI fornecido",
+              "color: #ff9800; font-weight: bold; font-size: 14px",
+              `
+
+\u26A0\uFE0F  O ConsentProvider do core \xE9 HEADLESS (sem interface visual).
+    Usu\xE1rios n\xE3o ver\xE3o banner de consentimento nem conseguir\xE3o gerenciar prefer\xEAncias.
+
+\u{1F4E6} Componentes UI ausentes:
+   \u2022 CookieBanner - Banner de consentimento inicial
+   \u2022 PreferencesModal - Modal de gerenciamento de prefer\xEAncias
+   \u2022 FloatingPreferencesButton - Bot\xE3o para reabrir prefer\xEAncias
+
+\u2705 Solu\xE7\xF5es:
+
+   1\uFE0F\u20E3  Usar pacote MUI (RECOMENDADO - componentes prontos):
+       import { ConsentProvider } from '@react-lgpd-consent/mui'
+       // Modal, banner e bot\xE3o injetados automaticamente!
+
+   2\uFE0F\u20E3  Fornecer seus pr\xF3prios componentes:
+       <ConsentProvider
+         CookieBannerComponent={YourBanner}
+         PreferencesModalComponent={YourModal}
+         FloatingPreferencesButtonComponent={YourButton}
+       />
+
+   3\uFE0F\u20E3  Usar headless (sem UI - intencional):
+       // Use hooks como useConsent() para criar UI customizada
+       // Ignore este aviso se for intencional
+
+\u{1F4DA} Docs: https://github.com/lucianoedipo/react-lgpd-consent#usage
+`
+            );
+            return null;
+          })()
+        ),
+        blocking && isHydrated && !state.consented && blockingStrategy === "provider" && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            style: {
+              position: "fixed",
+              top: 0,
+              left: 0,
+              right: 0,
+              bottom: 0,
+              backgroundColor: providerBackdropColor,
+              zIndex: 1299
+            },
+            "data-testid": "lgpd-provider-overlay",
+            "aria-hidden": true
+          }
+        ),
+        !state.consented && isHydrated && CookieBannerComponent && /* @__PURE__ */ jsxRuntime.jsx(
+          CookieBannerComponent,
+          {
+            consented: api.consented,
+            acceptAll: api.acceptAll,
+            rejectAll: api.rejectAll,
+            openPreferences: api.openPreferences,
+            texts,
+            blocking,
+            ...cookieBannerProps
+          }
+        ),
+        state.consented && !disableFloatingPreferencesButton && FloatingPreferencesButtonComponent && /* @__PURE__ */ jsxRuntime.jsx(
+          FloatingPreferencesButtonComponent,
+          {
+            openPreferences: api.openPreferences,
+            consented: api.consented,
+            ...floatingPreferencesButtonProps
+          }
+        )
+      ]
+    }
+  ) }) }) }) }) });
+  return content;
+}
+function useConsentStateInternal() {
+  const ctx = React4__namespace.useContext(StateCtx);
+  if (!ctx) throw new Error("useConsentState must be used within ConsentProvider");
+  return ctx;
+}
+function useConsentActionsInternal() {
+  const ctx = React4__namespace.useContext(ActionsCtx);
+  if (!ctx) throw new Error("useConsentActions must be used within ConsentProvider");
+  return ctx;
+}
+function useConsentTextsInternal() {
+  const ctx = React4__namespace.useContext(TextsCtx);
+  return ctx;
+}
+function useConsentHydrationInternal() {
+  return React4__namespace.useContext(HydrationCtx);
+}
+var defaultTexts = DEFAULT_TEXTS;
+function ConsentGate(props) {
+  const { preferences } = useConsent();
+  if (!preferences[props.category]) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: props.children });
+}
+
+// src/utils/scriptLoader.ts
+function loadScript(id, src, category = null, attrs = {}) {
+  if (typeof document === "undefined") return Promise.resolve();
+  if (document.getElementById(id)) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    const checkConsent = () => {
+      const consentCookie = document.cookie.split("; ").find((row) => row.startsWith("cookieConsent="))?.split("=")[1];
+      if (!consentCookie) {
+        setTimeout(checkConsent, 100);
+        return;
+      }
+      try {
+        const consent = JSON.parse(decodeURIComponent(consentCookie));
+        if (!consent.consented || consent.isModalOpen) {
+          setTimeout(checkConsent, 100);
+          return;
+        }
+        if (category && !consent.preferences[category]) {
+          reject(new Error(`Consent not given for ${category} scripts`));
+          return;
+        }
+        const s = document.createElement("script");
+        s.id = id;
+        s.src = src;
+        s.async = true;
+        for (const [k, v] of Object.entries(attrs)) s.setAttribute(k, v);
+        s.onload = () => resolve();
+        s.onerror = () => reject(new Error(`Failed to load script: ${src}`));
+        document.body.appendChild(s);
+      } catch {
+        setTimeout(checkConsent, 100);
+      }
+    };
+    checkConsent();
+  });
+}
+
+// src/utils/autoConfigureCategories.ts
+var FORBIDDEN_NECESSARY_SCRIPTS = /* @__PURE__ */ new Set([
+  // Analytics & Performance
+  "google-analytics",
+  "google-tag-manager",
+  "hotjar",
+  "mixpanel",
+  "clarity",
+  "amplitude",
+  "segment",
+  // Marketing & Advertising
+  "facebook-pixel",
+  "twitter-pixel",
+  "linkedin-insight",
+  "pinterest-tag",
+  "snapchat-pixel",
+  "tiktok-pixel",
+  "reddit-pixel",
+  // Communication & Support
+  "intercom",
+  "zendesk-chat",
+  "drift",
+  "crisp",
+  "freshchat",
+  // A/B Testing & Optimization
+  "optimizely",
+  "vwo",
+  "google-optimize",
+  "unbounce",
+  // Social & Content
+  "youtube-embed",
+  "vimeo-embed",
+  "twitter-widget",
+  "facebook-widget",
+  "instagram-widget",
+  // Accessibility (exceto scripts críticos)
+  "userway"
+]);
+function analyzeIntegrationCategories(integrations) {
+  const categoryMap = {};
+  integrations.forEach((integration) => {
+    const category = integration.category;
+    if (!categoryMap[category]) {
+      categoryMap[category] = [];
+    }
+    categoryMap[category].push(integration.id);
+  });
+  return categoryMap;
+}
+function autoConfigureCategories(originalConfig, integrations, options = {}) {
+  const { warningOnly = false, silent = false } = options;
+  const config = originalConfig || { enabledCategories: ["analytics"] };
+  const categoryIntegrations = analyzeIntegrationCategories(integrations);
+  const requiredCategories = Object.keys(categoryIntegrations);
+  const currentCategories = new Set(config.enabledCategories || []);
+  const missingCategories = requiredCategories.filter((cat) => !currentCategories.has(cat));
+  let adjustedConfig = { ...config };
+  let autoEnabledCategories = [];
+  if (missingCategories.length > 0) {
+    if (warningOnly) {
+      if (!silent) {
+        logMissingCategoriesWarning(missingCategories, categoryIntegrations);
+      }
+    } else {
+      autoEnabledCategories = [...missingCategories];
+      adjustedConfig = {
+        ...config,
+        enabledCategories: [...currentCategories, ...missingCategories]
+      };
+      if (!silent) {
+        logAutoEnabledCategories(autoEnabledCategories, categoryIntegrations);
+      }
+    }
+  }
+  return {
+    originalConfig: config,
+    adjustedConfig,
+    autoEnabledCategories,
+    missingCategories,
+    wasAdjusted: autoEnabledCategories.length > 0,
+    categoryIntegrations
+  };
+}
+function logMissingCategoriesWarning(missingCategories, categoryIntegrations) {
+  const isDev2 = process.env.NODE_ENV !== "production";
+  if (!isDev2) return;
+  const PREFIX = "[\u{1F36A} LGPD-CONSENT AUTO-CONFIG]";
+  console.group(`${PREFIX} \u26A0\uFE0F Categorias Requeridas N\xE3o Habilitadas`);
+  missingCategories.forEach((category) => {
+    const integrations = categoryIntegrations[category] || [];
+    console.warn(
+      `${PREFIX} Categoria '${category}' requerida por integra\xE7\xF5es: ${integrations.join(", ")}`
+    );
+  });
+  const categoriesCode = missingCategories.map((c) => `'${c}'`).join(", ");
+  console.warn(
+    `${PREFIX} Para corrigir, adicione estas categorias ao ConsentProvider:`,
+    `categories={{ enabledCategories: [...existingCategories, ${categoriesCode}] }}`
+  );
+  console.groupEnd();
+}
+function logAutoEnabledCategories(autoEnabledCategories, categoryIntegrations) {
+  const isDev2 = process.env.NODE_ENV !== "production";
+  if (!isDev2) return;
+  const PREFIX = "[\u{1F36A} LGPD-CONSENT AUTO-CONFIG]";
+  console.group(`${PREFIX} \u2705 Categorias Auto-Habilitadas`);
+  autoEnabledCategories.forEach((category) => {
+    const integrations = categoryIntegrations[category] || [];
+    console.info(
+      `${PREFIX} Categoria '${category}' auto-habilitada para integra\xE7\xF5es: ${integrations.join(", ")}`
+    );
+  });
+  console.info(`${PREFIX} \u{1F4A1} Essas categorias foram automaticamente adicionadas \xE0 configura\xE7\xE3o.`);
+  console.info(`${PREFIX} \u{1F527} Para controle manual, especifique explicitamente no ConsentProvider.`);
+  console.groupEnd();
+}
+function validateIntegrationCategories(integrations, enabledCategories) {
+  const requiredCategories = integrations.map((i) => i.category);
+  const enabledSet = new Set(enabledCategories);
+  return requiredCategories.every((category) => enabledSet.has(category));
+}
+function extractCategoriesFromIntegrations(integrations) {
+  const categories = /* @__PURE__ */ new Set();
+  integrations.forEach((integration) => {
+    categories.add(integration.category);
+  });
+  return Array.from(categories);
+}
+function validateNecessaryClassification(integrations, enabledCategories) {
+  const warnings = [];
+  const hasNecessaryCategory = enabledCategories.includes("necessary");
+  if (!hasNecessaryCategory) {
+    return warnings;
+  }
+  const problematicIntegrations = integrations.filter(
+    (integration) => integration.category === "necessary" && FORBIDDEN_NECESSARY_SCRIPTS.has(integration.id)
+  );
+  if (problematicIntegrations.length > 0) {
+    warnings.push(
+      `\u26A0\uFE0F ATEN\xC7\xC3O GDPR/LGPD: As seguintes integra\xE7\xF5es NUNCA devem ser classificadas como 'necessary':`
+    );
+    problematicIntegrations.forEach((integration) => {
+      warnings.push(
+        `   \u2022 '${integration.id}' (categoria: ${integration.category}) - Requer consentimento expl\xEDcito`
+      );
+    });
+    warnings.push(
+      `\u{1F4A1} Scripts 'necessary' executam SEM consentimento e podem resultar em multas.`,
+      `\u{1F4DA} Apenas scripts de seguran\xE7a, autentica\xE7\xE3o ou core do site se qualificam.`,
+      `\u{1F527} Mova estes scripts para categorias apropriadas (analytics, marketing, etc.)`
+    );
+  }
+  return warnings;
+}
+
+// src/utils/ConsentScriptLoader.tsx
+function ConsentScriptLoader({
+  integrations,
+  reloadOnChange = false
+}) {
+  const { preferences, consented } = useConsent();
+  const categories = useCategories();
+  const loadedScripts = React4__namespace.useRef(/* @__PURE__ */ new Set());
+  React4__namespace.useEffect(() => {
+    try {
+      const ids = (integrations || []).map((i) => i.id);
+      const gt = globalThis;
+      const current = Array.isArray(gt.__LGPD_USED_INTEGRATIONS__) ? gt.__LGPD_USED_INTEGRATIONS__ : [];
+      const merged = Array.from(/* @__PURE__ */ new Set([...current, ...ids]));
+      gt.__LGPD_USED_INTEGRATIONS__ = merged;
+      try {
+        const gmap = globalThis;
+        const map = gmap.__LGPD_INTEGRATIONS_MAP__ || {};
+        (integrations || []).forEach((i) => {
+          map[i.id] = i.category;
+        });
+        gmap.__LGPD_INTEGRATIONS_MAP__ = map;
+      } catch {
+      }
+    } catch {
+    }
+  }, [integrations]);
+  React4__namespace.useEffect(() => {
+    try {
+      const required = Array.from(new Set((integrations || []).map((i) => i.category))).filter(
+        Boolean
+      );
+      const gt = globalThis;
+      const current = Array.isArray(gt.__LGPD_REQUIRED_CATEGORIES__) ? gt.__LGPD_REQUIRED_CATEGORIES__ : [];
+      const merged = Array.from(/* @__PURE__ */ new Set([...current, ...required]));
+      gt.__LGPD_REQUIRED_CATEGORIES__ = merged;
+      if (typeof window !== "undefined" && typeof window.dispatchEvent === "function") {
+        window.dispatchEvent(new CustomEvent("lgpd:requiredCategories"));
+      }
+    } catch {
+    }
+  }, [integrations]);
+  React4__namespace.useEffect(() => {
+    const isDev2 = process.env.NODE_ENV !== "production";
+    if (!isDev2 || integrations.length === 0) return;
+    const enabledCategories = categories.allCategories.map((cat) => cat.id);
+    const isValid = validateIntegrationCategories(integrations, enabledCategories);
+    if (!isValid) {
+      autoConfigureCategories({ enabledCategories }, integrations, {
+        warningOnly: true,
+        silent: false
+      });
+    }
+    const necessaryWarnings = validateNecessaryClassification(integrations, enabledCategories);
+    if (necessaryWarnings.length > 0) {
+      console.group("\u{1F6A8} [LGPD-CONSENT] VALIDA\xC7\xC3O DE COMPLIANCE");
+      necessaryWarnings.forEach((warning) => {
+        if (warning.startsWith("\u26A0\uFE0F")) {
+          console.error(warning);
+        } else if (warning.startsWith("\u{1F4A1}") || warning.startsWith("\u{1F4DA}") || warning.startsWith("\u{1F527}")) {
+          console.warn(warning);
+        } else {
+          console.log(warning);
+        }
+      });
+      console.groupEnd();
+    }
+  }, [integrations, categories]);
+  React4__namespace.useEffect(() => {
+    if (!consented) return;
+    integrations.forEach(async (integration) => {
+      const shouldLoad = preferences[integration.category];
+      const alreadyLoaded = loadedScripts.current.has(integration.id);
+      if (shouldLoad && (!alreadyLoaded || reloadOnChange)) {
+        try {
+          await loadScript(integration.id, integration.src, integration.category, integration.attrs);
+          if (integration.init) {
+            integration.init();
+          }
+          loadedScripts.current.add(integration.id);
+        } catch (error) {
+          logger.error(`\u274C Failed to load script: ${integration.id}`, error);
+        }
+      }
+    });
+  }, [preferences, consented, integrations, reloadOnChange]);
+  return null;
+}
+function useConsentScriptLoader() {
+  const { preferences, consented } = useConsent();
+  return React4__namespace.useCallback(
+    async (integration) => {
+      if (!consented) {
+        logger.warn(`\u26A0\uFE0F Cannot load script ${integration.id}: No consent given`);
+        return false;
+      }
+      const shouldLoad = preferences[integration.category];
+      if (!shouldLoad) {
+        logger.warn(
+          `\u26A0\uFE0F Cannot load script ${integration.id}: Category '${integration.category}' not consented`
+        );
+        return false;
+      }
+      try {
+        await loadScript(integration.id, integration.src, integration.category, integration.attrs);
+        if (integration.init) {
+          integration.init();
+        }
+        return true;
+      } catch (error) {
+        logger.error(`\u274C Failed to load script: ${integration.id}`, error);
+        return false;
+      }
+    },
+    [preferences, consented]
+  );
+}
+
+// src/utils/scriptIntegrations.ts
+function createGoogleAnalyticsIntegration(config) {
+  const src = config.scriptUrl ?? `https://www.googletagmanager.com/gtag/js?id=${config.measurementId}`;
+  return {
+    id: "google-analytics",
+    category: "analytics",
+    src,
+    cookies: ["_ga", "_ga_*", "_gid"],
+    cookiesInfo: [
+      {
+        name: "_ga",
+        purpose: "Identifica\xE7\xE3o \xFAnica de visitantes para an\xE1lise de tr\xE1fego",
+        duration: "2 anos",
+        provider: "Google Analytics"
+      },
+      {
+        name: "_ga_*",
+        purpose: "Rastreamento de sess\xF5es e eventos espec\xEDficos do stream GA4",
+        duration: "2 anos",
+        provider: "Google Analytics"
+      },
+      {
+        name: "_gid",
+        purpose: "Distin\xE7\xE3o de visitantes \xFAnicos em per\xEDodo de 24h",
+        duration: "24 horas",
+        provider: "Google Analytics"
+      }
+    ],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        w.dataLayer = w.dataLayer ?? [];
+        const gtag = (...args) => {
+          w.dataLayer.push(...args);
+        };
+        w.gtag = gtag;
+        gtag("js", /* @__PURE__ */ new Date());
+        gtag("config", config.measurementId, config.config ?? {});
+      }
+    },
+    attrs: { async: "true" }
+  };
+}
+function createGoogleTagManagerIntegration(config) {
+  const src = config.scriptUrl ?? `https://www.googletagmanager.com/gtm.js?id=${config.containerId}`;
+  return {
+    id: "google-tag-manager",
+    category: "analytics",
+    src,
+    cookies: ["_gcl_au"],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const dataLayerName = config.dataLayerName || "dataLayer";
+        const w = window;
+        const layer = w[dataLayerName] ?? [];
+        w[dataLayerName] = layer;
+        layer.push({ "gtm.start": (/* @__PURE__ */ new Date()).getTime(), event: "gtm.js" });
+      }
+    }
+  };
+}
+function createUserWayIntegration(config) {
+  const src = config.scriptUrl ?? "https://cdn.userway.org/widget.js";
+  return {
+    id: "userway",
+    category: "functional",
+    src,
+    cookies: ["_userway_*"],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        w.UserWayWidgetApp = w.UserWayWidgetApp || {};
+        w.UserWayWidgetApp.accountId = config.accountId;
+      }
+    },
+    attrs: { "data-account": config.accountId }
+  };
+}
+var COMMON_INTEGRATIONS = {
+  googleAnalytics: createGoogleAnalyticsIntegration,
+  googleTagManager: createGoogleTagManagerIntegration,
+  userway: createUserWayIntegration
+};
+function createFacebookPixelIntegration(config) {
+  const src = config.scriptUrl ?? "https://connect.facebook.net/en_US/fbevents.js";
+  return {
+    id: "facebook-pixel",
+    category: "marketing",
+    src,
+    cookies: ["_fbp", "fr"],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (!w.fbq) {
+          const fbq = (...args) => {
+            if (w.fbq && typeof w.fbq.callMethod === "function") {
+              w.fbq.callMethod(...args);
+            } else {
+              fbq.queue = fbq.queue || [];
+              fbq.queue.push(args);
+            }
+          };
+          fbq.loaded = true;
+          w.fbq = fbq;
+        }
+        w.fbq("init", config.pixelId, config.advancedMatching ?? {});
+        if (config.autoTrack !== false) w.fbq("track", "PageView");
+      }
+    }
+  };
+}
+function createHotjarIntegration(config) {
+  const v = config.version ?? 6;
+  const src = config.scriptUrl ?? `https://static.hotjar.com/c/hotjar-${config.siteId}.js?sv=${v}`;
+  return {
+    id: "hotjar",
+    category: "analytics",
+    src,
+    cookies: [
+      "_hjSession_*",
+      "_hjSessionUser_*",
+      "_hjFirstSeen",
+      "_hjIncludedInSessionSample",
+      "_hjAbsoluteSessionInProgress"
+    ],
+    cookiesInfo: [
+      {
+        name: "_hjSession_*",
+        purpose: "Identifica\xE7\xE3o \xFAnica da sess\xE3o de grava\xE7\xE3o e heatmaps",
+        duration: "30 minutos",
+        provider: "Hotjar"
+      },
+      {
+        name: "_hjSessionUser_*",
+        purpose: "Identifica\xE7\xE3o persistente do usu\xE1rio entre sess\xF5es",
+        duration: "365 dias",
+        provider: "Hotjar"
+      },
+      {
+        name: "_hjFirstSeen",
+        purpose: "Detec\xE7\xE3o de primeira visita do usu\xE1rio ao site",
+        duration: "Sess\xE3o",
+        provider: "Hotjar"
+      },
+      {
+        name: "_hjIncludedInSessionSample",
+        purpose: "Indica se a sess\xE3o est\xE1 inclu\xEDda na amostra de grava\xE7\xE3o",
+        duration: "30 minutos",
+        provider: "Hotjar"
+      },
+      {
+        name: "_hjAbsoluteSessionInProgress",
+        purpose: "Detecta se uma sess\xE3o absoluta est\xE1 em progresso",
+        duration: "30 minutos",
+        provider: "Hotjar"
+      }
+    ],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        w._hjSettings = { hjid: config.siteId, hjsv: v };
+        if (!w.hj) {
+          const hj = (...args) => {
+            hj.q = hj.q || [];
+            hj.q.push(args);
+          };
+          w.hj = hj;
+        }
+        if (config.debug && typeof console !== "undefined" && typeof console.info === "function") {
+          console.info("[Hotjar] initialized with siteId", config.siteId);
+        }
+      }
+    }
+  };
+}
+function createMixpanelIntegration(config) {
+  const src = config.scriptUrl ?? "https://cdn.mxpnl.com/libs/mixpanel-2-latest.min.js";
+  return {
+    id: "mixpanel",
+    category: "analytics",
+    src,
+    cookies: ["mp_*"],
+    cookiesInfo: [
+      {
+        name: "mp_*",
+        purpose: "Rastreamento de eventos e propriedades do usu\xE1rio para analytics",
+        duration: "1 ano",
+        provider: "Mixpanel"
+      }
+    ],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        w.mixpanel = w.mixpanel || { init: () => void 0 };
+        if (w.mixpanel && typeof w.mixpanel.init === "function") {
+          try {
+            w.mixpanel.init(config.token, config.config ?? {}, config.api_host);
+          } catch (error) {
+            if (typeof console !== "undefined" && typeof console.warn === "function") {
+              console.warn("[Mixpanel] Failed to initialize:", error);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createClarityIntegration(config) {
+  const src = config.scriptUrl ?? `https://www.clarity.ms/tag/${config.projectId}`;
+  return {
+    id: "clarity",
+    category: "analytics",
+    src,
+    cookies: ["_clck", "_clsk", "CLID", "ANONCHK", "MR", "MUID", "SM"],
+    init: () => {
+      if (typeof window !== "undefined" && typeof config.upload !== "undefined") {
+        const w = window;
+        if (typeof w.clarity === "function") {
+          try {
+            w.clarity("set", "upload", config.upload);
+          } catch (error) {
+            if (typeof console !== "undefined" && typeof console.warn === "function") {
+              console.warn("[Clarity] Failed to configure upload setting:", error);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createIntercomIntegration(config) {
+  const src = config.scriptUrl ?? `https://widget.intercom.io/widget/${config.app_id}`;
+  return {
+    id: "intercom",
+    category: "functional",
+    src,
+    cookies: ["intercom-id-*", "intercom-session-*"],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (typeof w.Intercom === "function") {
+          try {
+            w.Intercom("boot", { app_id: config.app_id });
+          } catch (error) {
+            if (typeof console !== "undefined" && typeof console.warn === "function") {
+              console.warn("[Intercom] Failed to boot:", error);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createZendeskChatIntegration(config) {
+  const src = config.scriptUrl ?? `https://static.zdassets.com/ekr/snippet.js?key=${config.key}`;
+  return {
+    id: "zendesk-chat",
+    category: "functional",
+    src,
+    cookies: ["__zlcmid", "_zendesk_shared_session"],
+    init: () => {
+      if (typeof window !== "undefined") {
+        const w = window;
+        if (typeof w.zE === "function") {
+          try {
+            w.zE("webWidget", "identify", { key: config.key });
+          } catch (error) {
+            if (typeof console !== "undefined" && typeof console.warn === "function") {
+              console.warn("[Zendesk] Failed to identify:", error);
+            }
+          }
+        }
+      }
+    }
+  };
+}
+function createECommerceIntegrations(cfg) {
+  const list = [];
+  if (cfg.googleAnalytics) list.push(createGoogleAnalyticsIntegration(cfg.googleAnalytics));
+  if (cfg.facebookPixel) list.push(createFacebookPixelIntegration(cfg.facebookPixel));
+  if (cfg.hotjar) list.push(createHotjarIntegration(cfg.hotjar));
+  if (cfg.userway) list.push(createUserWayIntegration(cfg.userway));
+  return list;
+}
+function createSaaSIntegrations(cfg) {
+  const list = [];
+  if (cfg.googleAnalytics) list.push(createGoogleAnalyticsIntegration(cfg.googleAnalytics));
+  if (cfg.mixpanel) list.push(createMixpanelIntegration(cfg.mixpanel));
+  if (cfg.intercom) list.push(createIntercomIntegration(cfg.intercom));
+  if (cfg.hotjar) list.push(createHotjarIntegration(cfg.hotjar));
+  return list;
+}
+function createCorporateIntegrations(cfg) {
+  const list = [];
+  if (cfg.googleAnalytics) list.push(createGoogleAnalyticsIntegration(cfg.googleAnalytics));
+  if (cfg.clarity) list.push(createClarityIntegration(cfg.clarity));
+  if (cfg.zendesk) list.push(createZendeskChatIntegration(cfg.zendesk));
+  if (cfg.userway) list.push(createUserWayIntegration(cfg.userway));
+  return list;
+}
+var INTEGRATION_TEMPLATES = {
+  ecommerce: {
+    essential: ["google-analytics", "facebook-pixel"],
+    optional: ["hotjar", "userway"],
+    categories: ["analytics", "marketing", "functional"]
+  },
+  saas: {
+    essential: ["google-analytics", "mixpanel"],
+    optional: ["intercom", "hotjar"],
+    categories: ["analytics", "functional"]
+  },
+  corporate: {
+    essential: ["google-analytics"],
+    optional: ["userway", "zendesk-chat", "clarity"],
+    categories: ["analytics", "functional"]
+  }
+};
+function suggestCategoryForScript(name) {
+  const n = name.toLowerCase();
+  if (n.includes("facebook") || n.includes("pixel") || n.includes("ads")) return ["marketing"];
+  if (n.includes("hotjar") || n.includes("mixpanel") || n.includes("clarity")) return ["analytics"];
+  if (n.includes("intercom") || n.includes("zendesk") || n.includes("chat")) return ["functional"];
+  return ["analytics"];
+}
+
+// src/types/advancedTexts.ts
+var EXPANDED_DEFAULT_TEXTS = {
+  // Textos adicionais
+  confirm: "Confirmar",
+  cancel: "Cancelar",
+  loading: "Carregando...",
+  // Feedback
+  feedback: {
+    saveSuccess: "Prefer\xEAncias salvas com sucesso!",
+    saveError: "Erro ao salvar prefer\xEAncias. Tente novamente.",
+    consentUpdated: "Consentimento atualizado.",
+    cookiesRejected: "Cookies opcionais rejeitados.",
+    settingsReset: "Configura\xE7\xF5es resetadas."
+  },
+  // Acessibilidade
+  accessibility: {
+    bannerLabel: "Banner de consentimento de cookies",
+    modalLabel: "Modal de prefer\xEAncias de cookies",
+    keyboardNavigation: "Use Tab para navegar, Enter para selecionar",
+    toggleState: {
+      enabled: "Habilitado",
+      disabled: "Desabilitado"
+    },
+    liveRegion: "Regi\xE3o de an\xFAncios din\xE2micos"
+  },
+  // Categorias
+  categories: {
+    necessary: {
+      name: "Cookies Necess\xE1rios",
+      description: "Essenciais para o funcionamento b\xE1sico do site",
+      examples: "Sess\xE3o, seguran\xE7a, prefer\xEAncias de idioma"
+    },
+    analytics: {
+      name: "Cookies de Analytics",
+      description: "Ajudam a entender como os visitantes usam o site",
+      examples: "Google Analytics, contadores de p\xE1gina"
+    },
+    marketing: {
+      name: "Cookies de Marketing",
+      description: "Usados para personalizar an\xFAncios e ofertas",
+      examples: "Facebook Pixel, Google Ads, remarketing"
+    },
+    functional: {
+      name: "Cookies Funcionais",
+      description: "Melhoram a funcionalidade e personaliza\xE7\xE3o",
+      examples: "Chat, mapas, v\xEDdeos embarcados"
+    },
+    performance: {
+      name: "Cookies de Performance",
+      description: "Coletam informa\xE7\xF5es sobre velocidade e estabilidade",
+      examples: "Monitoramento de erro, otimiza\xE7\xE3o de velocidade"
+    }
+  },
+  // Contextos específicos
+  contexts: {
+    ecommerce: {
+      cartAbandonment: "Lembramos dos produtos no seu carrinho",
+      personalizedOffers: "Ofertas personalizadas baseadas no seu hist\xF3rico",
+      paymentSecurity: "Seguran\xE7a adicional no processo de pagamento",
+      productRecommendations: "Sugest\xF5es de produtos relevantes"
+    },
+    saas: {
+      userAnalytics: "An\xE1lise de uso para melhorar funcionalidades",
+      performanceMonitoring: "Monitoramento de performance da aplica\xE7\xE3o",
+      featureUsage: "Estat\xEDsticas de uso de recursos",
+      customerSupport: "Suporte ao cliente mais eficiente"
+    },
+    government: {
+      citizenServices: "Melhoria dos servi\xE7os ao cidad\xE3o",
+      dataProtection: "Prote\xE7\xE3o rigorosa dos dados pessoais",
+      transparency: "Transpar\xEAncia no uso de dados",
+      accessibility: "Recursos de acessibilidade digital"
+    },
+    education: {
+      studentProgress: "Acompanhamento do progresso educacional",
+      learningAnalytics: "Analytics para melhorar o aprendizado",
+      accessibility: "Recursos educacionais acess\xEDveis",
+      parentalConsent: "Consentimento parental quando necess\xE1rio"
+    }
+  },
+  // Variações de tom
+  variants: {
+    formal: {
+      bannerMessage: "Este s\xEDtio eletr\xF4nico utiliza cookies para otimizar a experi\xEAncia de navega\xE7\xE3o.",
+      acceptAll: "Concordar com todos os cookies",
+      declineAll: "Recusar cookies opcionais",
+      modalTitle: "Configura\xE7\xE3o de Cookies"
+    },
+    casual: {
+      bannerMessage: "\u{1F36A} Ei! Usamos cookies para tornar sua experi\xEAncia ainda melhor!",
+      acceptAll: "Aceitar tudo",
+      declineAll: "S\xF3 o essencial",
+      modalTitle: "Seus Cookies"
+    },
+    concise: {
+      bannerMessage: "Usamos cookies. Voc\xEA aceita?",
+      acceptAll: "Sim",
+      declineAll: "N\xE3o",
+      modalTitle: "Cookies"
+    },
+    detailed: {
+      bannerMessage: "Utilizamos cookies e tecnologias similares para melhorar sua experi\xEAncia de navega\xE7\xE3o, personalizar conte\xFAdo, analisar tr\xE1fego e oferecer funcionalidades de redes sociais.",
+      acceptAll: "Aceitar todos os cookies e tecnologias",
+      declineAll: "Recusar todos os cookies opcionais",
+      modalTitle: "Centro de Prefer\xEAncias de Privacidade"
+    }
+  },
+  // Internacionalização simplificada (apenas textos básicos)
+  i18n: {
+    en: {
+      bannerMessage: "We use cookies to enhance your experience.",
+      acceptAll: "Accept All",
+      declineAll: "Decline",
+      preferences: "Preferences",
+      modalTitle: "Cookie Preferences",
+      modalIntro: "Customize your cookie preferences below.",
+      save: "Save Preferences",
+      necessaryAlwaysOn: "Necessary cookies (always active)"
+    },
+    es: {
+      bannerMessage: "Utilizamos cookies para mejorar su experiencia.",
+      acceptAll: "Aceptar Todo",
+      declineAll: "Rechazar",
+      preferences: "Preferencias",
+      modalTitle: "Preferencias de Cookies",
+      modalIntro: "Personalice sus preferencias de cookies a continuaci\xF3n.",
+      save: "Guardar Preferencias",
+      necessaryAlwaysOn: "Cookies necess\xE1rias (sempre ativas)"
+    },
+    fr: {
+      bannerMessage: "Nous utilisons des cookies pour am\xE9liorer votre exp\xE9rience.",
+      acceptAll: "Tout Accepter",
+      declineAll: "Refuser",
+      preferences: "Pr\xE9f\xE9rences",
+      modalTitle: "Pr\xE9f\xE9rences des Cookies",
+      modalIntro: "Personnalisez vos pr\xE9f\xE9rences de cookies ci-dessous.",
+      save: "Enregistrer les Pr\xE9f\xE9rences",
+      necessaryAlwaysOn: "Cookies n\xE9cessaires (toujours actifs)"
+    }
+  },
+  // Textos técnicos
+  technical: {
+    sessionCookies: "Cookies de sess\xE3o s\xE3o tempor\xE1rios e expiram quando voc\xEA fecha o navegador.",
+    persistentCookies: "Cookies persistentes permanecem no seu dispositivo at\xE9 expirarem ou serem removidos.",
+    thirdPartyCookies: "Cookies de terceiros s\xE3o definidos por dom\xEDnios diferentes do site que voc\xEA est\xE1 visitando.",
+    browserSettings: "Voc\xEA pode gerenciar cookies nas configura\xE7\xF5es do seu navegador.",
+    disablingImpact: "Desabilitar cookies pode afetar a funcionalidade do site."
+  },
+  // Cookie details
+  cookieDetails: {
+    tableHeaders: {
+      name: "Nome",
+      purpose: "Finalidade",
+      duration: "Dura\xE7\xE3o",
+      provider: "Fornecedor",
+      type: "Tipo"
+    },
+    noCookies: "Nenhum cookie encontrado para esta categoria.",
+    toggleDetails: {
+      expand: "Ver detalhes",
+      collapse: "Ocultar detalhes"
+    }
+  }
+};
+function resolveTexts(texts, options = {}) {
+  const { language = "pt", variant } = options;
+  let resolved = { ...texts };
+  if (variant && texts.variants?.[variant]) {
+    resolved = { ...resolved, ...texts.variants[variant] };
+  }
+  if (language !== "pt" && texts.i18n?.[language]) {
+    resolved = { ...resolved, ...texts.i18n[language] };
+  }
+  return resolved;
+}
+var TEXT_TEMPLATES = {
+  ecommerce: {
+    ...EXPANDED_DEFAULT_TEXTS,
+    bannerMessage: "Utilizamos cookies para personalizar ofertas e melhorar sua experi\xEAncia de compra.",
+    acceptAll: "Aceitar e continuar",
+    variants: {
+      casual: {
+        bannerMessage: "\u{1F6D2} Usamos cookies para encontrar as melhores ofertas para voc\xEA!",
+        acceptAll: "Quero ofertas personalizadas!"
+      }
+    }
+  },
+  saas: {
+    ...EXPANDED_DEFAULT_TEXTS,
+    bannerMessage: "Utilizamos cookies para otimizar o desempenho da aplica\xE7\xE3o e sua experi\xEAncia.",
+    acceptAll: "Aceitar e otimizar",
+    variants: {
+      formal: {
+        bannerMessage: "Esta aplica\xE7\xE3o utiliza cookies para an\xE1lise de performance e melhoria cont\xEDnua da experi\xEAncia do usu\xE1rio.",
+        acceptAll: "Autorizar coleta de dados de uso"
+      }
+    }
+  },
+  government: {
+    ...EXPANDED_DEFAULT_TEXTS,
+    bannerMessage: "Este portal utiliza cookies em conformidade com a LGPD para melhorar os servi\xE7os p\xFAblicos.",
+    acceptAll: "Aceitar em conformidade",
+    variants: {
+      formal: {
+        bannerMessage: "Este s\xEDtio eletr\xF4nico do governo utiliza cookies estritamente necess\xE1rios e opcionais, em conformidade com a Lei Geral de Prote\xE7\xE3o de Dados.",
+        acceptAll: "Concordar com o uso de cookies"
+      }
+    }
+  }
+};
+
+exports.COMMON_INTEGRATIONS = COMMON_INTEGRATIONS;
+exports.ConsentGate = ConsentGate;
+exports.ConsentProvider = ConsentProvider;
+exports.ConsentScriptLoader = ConsentScriptLoader;
+exports.DEFAULT_PROJECT_CATEGORIES = DEFAULT_PROJECT_CATEGORIES;
+exports.DesignProvider = DesignProvider;
+exports.EXPANDED_DEFAULT_TEXTS = EXPANDED_DEFAULT_TEXTS;
+exports.GUIDANCE_PRESETS = GUIDANCE_PRESETS;
+exports.INTEGRATION_TEMPLATES = INTEGRATION_TEMPLATES;
+exports.LogLevel = LogLevel;
+exports.TEXT_TEMPLATES = TEXT_TEMPLATES;
+exports.analyzeDeveloperConfiguration = analyzeDeveloperConfiguration;
+exports.analyzeIntegrationCategories = analyzeIntegrationCategories;
+exports.autoConfigureCategories = autoConfigureCategories;
+exports.categorizeDiscoveredCookies = categorizeDiscoveredCookies;
+exports.createClarityIntegration = createClarityIntegration;
+exports.createCorporateIntegrations = createCorporateIntegrations;
+exports.createECommerceIntegrations = createECommerceIntegrations;
+exports.createFacebookPixelIntegration = createFacebookPixelIntegration;
+exports.createGoogleAnalyticsIntegration = createGoogleAnalyticsIntegration;
+exports.createGoogleTagManagerIntegration = createGoogleTagManagerIntegration;
+exports.createHotjarIntegration = createHotjarIntegration;
+exports.createIntercomIntegration = createIntercomIntegration;
+exports.createMixpanelIntegration = createMixpanelIntegration;
+exports.createProjectPreferences = createProjectPreferences;
+exports.createSaaSIntegrations = createSaaSIntegrations;
+exports.createUserWayIntegration = createUserWayIntegration;
+exports.createZendeskChatIntegration = createZendeskChatIntegration;
+exports.defaultTexts = defaultTexts;
+exports.detectConsentCookieName = detectConsentCookieName;
+exports.discoverRuntimeCookies = discoverRuntimeCookies;
+exports.extractCategoriesFromIntegrations = extractCategoriesFromIntegrations;
+exports.getAllProjectCategories = getAllProjectCategories;
+exports.getCookiesInfoForCategory = getCookiesInfoForCategory;
+exports.loadScript = loadScript;
+exports.logDeveloperGuidance = logDeveloperGuidance;
+exports.logger = logger;
+exports.openPreferencesModal = openPreferencesModal;
+exports.pushConsentInitializedEvent = pushConsentInitializedEvent;
+exports.pushConsentUpdatedEvent = pushConsentUpdatedEvent;
+exports.resolveTexts = resolveTexts;
+exports.setCookieCatalogOverrides = setCookieCatalogOverrides;
+exports.setCookieCategoryOverrides = setCookieCategoryOverrides;
+exports.setDebugLogging = setDebugLogging;
+exports.suggestCategoryForScript = suggestCategoryForScript;
+exports.useCategories = useCategories;
+exports.useCategoryStatus = useCategoryStatus;
+exports.useConsent = useConsent;
+exports.useConsentHydration = useConsentHydration;
+exports.useConsentScriptLoader = useConsentScriptLoader;
+exports.useConsentTexts = useConsentTexts;
+exports.useDataLayerEvents = useDataLayerEvents;
+exports.useDesignTokens = useDesignTokens;
+exports.useDeveloperGuidance = useDeveloperGuidance;
+exports.useOpenPreferencesModal = useOpenPreferencesModal;
+exports.validateIntegrationCategories = validateIntegrationCategories;
+exports.validateNecessaryClassification = validateNecessaryClassification;
+exports.validateProjectPreferences = validateProjectPreferences;