@jjlmoya/utils-streaming 1.1.0

package/src/tool/sorteo/engine.ts

@@ -0,0 +1,143 @@
+export class GiveawayEngine {
+  private rawParticipants: string[] = [];
+  private excludeList: string[] = [];
+  private allowDuplicates: boolean = false;
+  private weightRegex = /^(.+?)(?:\s+[\*x]\s*(\d+)|\s*\(\s*[x\*]?\s*(\d+)\s*\))$/i;
+
+  private processedParticipants: string[] = [];
+
+  constructor() {
+    this.process();
+  }
+
+  public setParticipantsFromText(text: string): void {
+    this.rawParticipants = text
+      .split(/\n/)
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+    this.process();
+  }
+
+  public setBlacklistFromText(text: string): void {
+    this.excludeList = text
+      .split(/[\n,]/)
+      .map((s) => s.trim().toLowerCase())
+      .filter((s) => s.length > 0);
+    this.process();
+  }
+
+  public setAllowDuplicates(allow: boolean): void {
+    this.allowDuplicates = allow;
+    this.process();
+  }
+
+  private parseLine(line: string): { name: string; weight: number } {
+    let name = line;
+    let weight = 1;
+    const match = line.match(this.weightRegex);
+    if (match && match[1]) {
+      name = match[1].trim();
+      const wStr = match[2] || match[3] || '1';
+      weight = parseInt(wStr, 10);
+      if (isNaN(weight) || weight < 1) {
+        weight = 1;
+      }
+    }
+    return { name, weight };
+  }
+
+  private process(): void {
+    this.processedParticipants = [];
+
+    if (this.allowDuplicates) {
+      this.processDuplicates();
+    } else {
+      this.processUnique();
+    }
+  }
+
+  private processDuplicates(): void {
+    for (const line of this.rawParticipants) {
+      const { name, weight } = this.parseLine(line);
+      if (this.excludeList.includes(name.toLowerCase())) {
+        continue;
+      }
+
+      for (let i = 0; i < weight; i++) {
+        this.processedParticipants.push(name);
+      }
+    }
+  }
+
+  private processUnique(): void {
+    const tempMap = new Map<string, number>();
+
+    for (const line of this.rawParticipants) {
+      const { name, weight } = this.parseLine(line);
+      if (this.excludeList.includes(name.toLowerCase())) {
+        continue;
+      }
+
+      const currentW = tempMap.get(name) || 0;
+      tempMap.set(name, currentW + weight);
+    }
+
+    tempMap.forEach((w, n) => {
+      for (let i = 0; i < w; i++) {
+        this.processedParticipants.push(n);
+      }
+    });
+  }
+
+  public getParticipants(): string[] {
+    return this.processedParticipants;
+  }
+
+  public getCount(): number {
+    return this.processedParticipants.length;
+  }
+
+  public pickWinners(count: number = 1): string[] {
+    if (this.processedParticipants.length === 0) {
+      return [];
+    }
+
+    const availableIndices = Array.from(
+      { length: this.processedParticipants.length },
+      (_, i) => i
+    );
+    const winners: string[] = [];
+    const numToPick = Math.min(count, availableIndices.length);
+
+    for (let i = 0; i < numToPick; i++) {
+      const randomIndex = this.getSecureRandomIndex(availableIndices.length);
+      const winningIndex = availableIndices[randomIndex];
+      if (winningIndex !== undefined) {
+        const winner = this.processedParticipants[winningIndex];
+        if (winner) winners.push(winner);
+        availableIndices.splice(randomIndex, 1);
+      }
+    }
+
+    return winners;
+  }
+
+  private getSecureRandomIndex(limit: number): number {
+    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
+      const array = new Uint32Array(1);
+      crypto.getRandomValues(array);
+      const val = array[0];
+      if (val !== undefined) return val % limit;
+    }
+    return Math.floor(Math.random() * limit);
+  }
+
+  public removeParticipant(name: string): void {
+    this.rawParticipants = this.rawParticipants.filter((line) => {
+      const { name: extractedName } = this.parseLine(line);
+      return extractedName.toLowerCase() !== name.toLowerCase();
+    });
+
+    this.process();
+  }
+}

package/src/tool/sorteo/i18n/en.ts

@@ -0,0 +1,253 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { SorteoUI } from '../ui';
+
+const slug = 'giveaway';
+const title = 'Random Name Picker for Streaming';
+const description =
+  'Choose a winner at random from a list of names. Free, fast, and visual giveaway tool for Twitch, YouTube, and events.';
+
+const faqData = [
+  {
+    question: 'Is this giveaway truly random?',
+    answer:
+      'Yes, we use the browser\'s cryptographic randomness algorithm (Web Crypto API) to ensure that each participant has exactly the same probability of winning, without bias or manipulation.',
+  },
+  {
+    question: 'Can I use this giveaway on Twitch or YouTube?',
+    answer:
+      'Absolutely. As a web tool, you can capture the window with OBS or share your screen directly. The clean design and animations are designed so that the audience sees the process with total transparency.',
+  },
+  {
+    question: 'How do I prevent someone from participating twice?',
+    answer:
+      'The tool has an automatic "duplicate cleaning" function that detects identical names or those with small spacing variations to ensure each real person counts only once.',
+  },
+  {
+    question: 'Can I draw several winners at once?',
+    answer:
+      'Yes, you can configure the number of winners desired before clicking the button. The tool will list the lucky ones clearly so you can mention them in your live stream.',
+  },
+  {
+    question: 'How many names can I add to the list?',
+    answer:
+      'There is no strict limit imposed by the tool. We have optimized the engine to handle lists of thousands of participants without performance issues, making it ideal even for massive giveaways.',
+  },
+  {
+    question: 'Are my data or the list of participants saved?',
+    answer:
+      'No, never. Your privacy comes first. The entire giveaway process runs locally in your web browser. The names you enter are never sent to our servers or stored in any database.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Prepare the list of participants',
+    text: 'Copy the list of names from your chat, Excel, or social network and paste it into the text box.',
+  },
+  {
+    name: 'Configure giveaway options',
+    text: 'Choose how many winners you need and if you want to filter duplicates or empty names.',
+  },
+  {
+    name: 'Launch the innocent hand',
+    text: 'Click the giveaway button. A visual animation will maintain the tension before revealing the winner.',
+  },
+  {
+    name: 'Announce results',
+    text: 'Copy the names of the winners to share them on your social networks or streaming chat.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'en',
+};
+
+export const content: ToolLocaleContent<SorteoUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Frequently Asked Questions',
+  faq: faqData,
+  bibliographyTitle: 'Technical References',
+  bibliography: [
+    {
+      name: 'Web Crypto API: getRandomValues()',
+      url: 'https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues',
+    },
+    {
+      name: 'Fisher-Yates Shuffle Algorithm',
+      url: 'https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema as any, howToSchema as any, appSchema as any],
+  seo: [
+    {
+      type: 'title',
+      text: 'Random Name Picker and Participants List Online',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Wondering how to do a random giveaway online quickly, safely, and totally transparently? Our free <strong>Name Picker</strong> tool is the ultimate solution to choose a winner at random in seconds. Designed to be simple, visual, and effective, it is perfect for any scenario where you need a digital "innocent hand".',
+    },
+    {
+      type: 'paragraph',
+      html: 'Whether you are managing a contest on social networks, a massive giveaway on your streaming channel, or simply deciding who takes out the trash today, our random selector guarantees total impartiality thanks to modern cryptographic algorithms. <strong>No manipulation, no bias, just pure randomness.</strong>'
+    },
+    {
+      type: 'title',
+      text: 'Use Cases',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Social Media Giveaways',
+          description: 'Ideal for Instagram, Twitter (X), or Facebook contests. Simply copy names from comments and paste them to choose a fair winner. The tool automatically removes duplicates.',
+        },
+        {
+          title: 'Twitch / YouTube Streaming',
+          description: 'Thanks to our Studio Mode with smooth animations and integrated sounds, you can share your screen directly in OBS and offer an exciting visual show to your audience while choosing winners live.',
+        },
+        {
+          title: 'Class and Team Dynamics',
+          description: 'Teachers and team leaders can use it to form random groups, choose who presents first, or assign tasks at random with total transparency and no favoritism.',
+        },
+        {
+          title: 'Secret Santa and Events',
+          description: 'Simplify the organization of family events, office giveaways, or Secret Santa by choosing names at random instantly without the need for papers or complicated logistics.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Why is our tool different?',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Real Cryptography:</strong> We use the browser\'s Web Crypto API (W3C standard) instead of weak pseudo-random generators. Every giveaway is mathematically impartial.',
+        '<strong>No Storage:</strong> Your data never leaves your browser. We don\'t sell lists, we don\'t profile you, we don\'t store anything. Pure local processing.',
+        '<strong>Visual Design:</strong> Cinema mode and animations make every giveaway a memorable event. Perfect for OBS capture or live streaming.',
+        '<strong>Duplicate Handling:</strong> Automatically detects repeated names or variants (extra spaces, capitalization, etc.) to ensure each real person counts only once.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'How to use the giveaway step by step',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Step 1 - Enter participants:</strong> Paste your list of names into the main text box. The tool automatically detects each line break as a different participant. Do you have duplicates? No problem, the tool removes them.',
+        '<strong>Step 2 - Customize:</strong> In the settings tab you can enable the countdown to generate tension, the confetti effect to celebrate, or enable the "blacklist" to exclude certain names.',
+        '<strong>Step 3 - Draw!</strong> Click the main button and our engine will generate a cryptographically secure random selection. The winners will be displayed clearly and memorably.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Weighted Entries: Give Advantage to Some Participants',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Want to reward your most loyal subscribers or give more opportunities to certain participants? Our <strong>Weighted Entries</strong> system is unique and allows you to assign a "weight" or multiplier to any name without having to write it multiple times.',
+    },
+    {
+      type: 'tip',
+      title: 'How to assign weights to names',
+      html: '<p>Use an asterisk (*) or an "x" followed by the number of participations. Examples:</p><ul><li><strong>"John * 5"</strong> - John competes as if he were 5 people</li><li><strong>"Maria x 10"</strong> - Maria has 10 times more chances</li><li><strong>"Peter"</strong> - No symbol = 1 regular entry</li></ul><p>This is perfect for giveaways where you want to give VIP subscribers or special users an advantage.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Total Privacy and Security',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Unlike other online tools, <strong>we do not store your data</strong>. All processing of names and execution of the giveaway occurs locally in your own browser. Your participant lists never travel over the network or are saved on any external server.',
+    },
+    {
+      type: 'paragraph',
+      html: '<strong>What does this mean?</strong> Your participant list is yours and yours alone. Closing the tab, it disappears. No tracking cookies, no user profiles, no central database. Maximum privacy guaranteed for you and those who participate in your giveaways.',
+    },
+    {
+      type: 'title',
+      text: 'Mathematical Transparency',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Some might wonder: "What if you manipulate the results?" The answer is simple: <strong>we can\'t</strong>. The giveaway code is deterministic and cryptographic. No hidden variables, no "fingers on the stage".',
+    },
+    {
+      type: 'paragraph',
+      html: 'Each winner is the direct result of the Fisher-Yates Shuffle algorithm applied to your exact list, using real cryptographic entropy. If you want to audit the process, the code is available on GitHub for public inspection.',
+    },
+  ],
+  ui: {
+    title: 'Random Giveaway',
+    totalParticipants: 'Total Unique Participants',
+    ready: 'READY',
+    participants: 'Participants',
+    settings: 'Settings',
+    importFile: 'Import File',
+    clearAll: 'Clear all',
+    placeholder: 'Type or paste names here...\nJohn Doe\nMaria Garcia\n@twitch_user',
+    onePerLine: '1 participant per line',
+    lines: 'lines',
+    filters: 'Filters',
+    allowDuplicates: 'Allow Duplicates',
+    winnerCount: 'Number of Winners',
+    autoRemove: 'Auto-Remove Winner',
+    blacklist: 'Blacklist (Exclude)',
+    blacklistPlaceholder: 'Prohibited names (one per line)...',
+    blacklistInfo: 'These users will not enter the giveaway.',
+    sceneEffects: 'Scene Effects',
+    countdown: 'Countdown (3s)',
+    confetti: 'Victory Confetti',
+    zenMode: 'Zen Mode (Hide Panel)',
+    waitingParticipants: 'Waiting for participants...',
+    winner: 'WINNER',
+    reroll: 'Reroll Giveaway',
+    history: 'History for this session',
+    noWinnersYet: 'No winners yet...',
+    startGiveaway: 'Start Giveaway',
+  },
+};

package/src/tool/sorteo/i18n/es.ts

@@ -0,0 +1,253 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { SorteoUI } from '../ui';
+
+const slug = 'sorteo';
+const title = 'Sorteo Aleatorio de Nombres para Streaming';
+const description =
+  'Elije un ganador al azar de una lista de nombres. Herramienta de sorteos gratuita, rápida y visual para Twitch, YouTube y eventos.';
+
+const faqData = [
+  {
+    question: '¿Es realmente aleatorio este sorteo?',
+    answer:
+      'Sí, utilizamos el algoritmo de aleatoriedad criptográfica del navegador (Web Crypto API) para asegurar que cada participante tenga exactamente las mismas probabilidades de ganar, sin sesgos ni manipulaciones.',
+  },
+  {
+    question: '¿Puedo usar este sorteo en Twitch o YouTube?',
+    answer:
+      'Totalmente. Al ser una herramienta web, puedes capturar la ventana con OBS o compartir pantalla directamente. El diseño limpio y las animaciones están pensados para que el público vea el proceso con total transparencia.',
+  },
+  {
+    question: '¿Cómo evito que alguien participe dos veces?',
+    answer:
+      'La herramienta tiene una función de "limpieza de duplicados" automática que detecta nombres idénticos o con pequeñas variaciones de espacios para asegurar que cada persona real cuente solo una vez.',
+  },
+  {
+    question: '¿Puedo sacar varios ganadores a la vez?',
+    answer:
+      'Sí, puedes configurar el número de ganadores deseados antes de pulsar el botón. La herramienta listará a los afortunados de forma clara para que puedas mencionarlos en tu directo.',
+  },
+  {
+    question: '¿Cuántos nombres puedo añadir a la lista?',
+    answer:
+      'No hay un límite estricto impuesto por la herramienta. Hemos optimizado el motor para manejar listas de miles de participantes sin problemas de rendimiento, lo que lo hace ideal incluso para sorteos masivos.',
+  },
+  {
+    question: '¿Se guardan mis datos o la lista de participantes?',
+    answer:
+      'No, nunca. Tu privacidad es lo primero. Todo el proceso del sorteo se ejecuta localmente en tu navegador web. Los nombres que introduces nunca se envían a nuestros servidores ni se almacenan en ninguna base de datos.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Preparar la lista de participantes',
+    text: 'Copia la lista de nombres desde tu chat, Excel o red social y pégala en el cuadro de texto.',
+  },
+  {
+    name: 'Configurar opciones de sorteo',
+    text: 'Elige cuántos ganadores necesitas y si quieres filtrar duplicados o nombres vacíos.',
+  },
+  {
+    name: 'Lanzar la mano inocente',
+    text: 'Haz clic en el botón de sorteo. Una animación visual mantendrá la tensión antes de revelar al ganador.',
+  },
+  {
+    name: 'Anunciar resultados',
+    text: 'Copia los nombres de los ganadores para compartirlos en tus redes o chat de streaming.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'UtilityApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+  inLanguage: 'es',
+};
+
+export const content: ToolLocaleContent<SorteoUI> = {
+  slug,
+  title,
+  description,
+  faqTitle: 'Preguntas Frecuentes',
+  faq: faqData,
+  bibliographyTitle: 'Referencias Técnicas',
+  bibliography: [
+    {
+      name: 'Web Crypto API: getRandomValues()',
+      url: 'https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues',
+    },
+    {
+      name: 'Fisher-Yates Shuffle Algorithm',
+      url: 'https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle',
+    },
+  ],
+  howTo: howToData,
+  schemas: [faqSchema as any, howToSchema as any, appSchema as any],
+  seo: [
+    {
+      type: 'title',
+      text: 'Sorteo Aleatorio de Nombres y Lista de Participantes Online',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: '¿Te preguntas cómo hacer un sorteo aleatorio online de forma rápida, segura y totalmente transparente? Nuestra herramienta gratuita de <strong>Sorteo de Nombres</strong> es la solución definitiva para elegir un ganador al azar en cuestión de segundos. Diseñada para ser simple, visual y efectiva, es perfecta para cualquier escenario donde necesites una "mano inocente" digital.',
+    },
+    {
+      type: 'paragraph',
+      html: 'Ya sea que estés gestionando un concurso en redes sociales, un sorteo masivo en tu canal de streaming o simplemente decidiendo quién saca la basura hoy, nuestro selector aleatorio garantiza una imparcialidad total gracias a algoritmos criptográficos modernos. <strong>Sin manipulaciones, sin sesgo, solo pura aleatoriedad.</strong>'
+    },
+    {
+      type: 'title',
+      text: 'Casos de Uso',
+      level: 3,
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Sorteos en Redes Sociales',
+          description: 'Ideal para concursos de Instagram, Twitter (X) o Facebook. Simplemente copia los nombres de los comentarios y pégalos para elegir un ganador justo. La herramienta limpia duplicados automáticamente.',
+        },
+        {
+          title: 'Streaming en Twitch / YouTube',
+          description: 'Gracias a nuestro Modo Estudio con animaciones fluidas y sonidos integrados, puedes compartir tu pantalla directamente en OBS y ofrecer un espectáculo visual emocionante a tu audiencia mientras eliges ganadores en directo.',
+        },
+        {
+          title: 'Dinámicas de Clase y Equipos',
+          description: 'Profesores y líderes de equipo pueden usarla para formar grupos aleatorios, elegir quién expone primero o asignar tareas al azar con total transparencia y sin favoritismos.',
+        },
+        {
+          title: 'Amigo Invisible y Eventos',
+          description: 'Simplifica la organización de eventos familiares, sorteos de oficina o el Amigo Invisible eligiendo nombres al azar de forma instantánea sin necesidad de papeles ni logística complicada.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: '¿Por qué nuestra herramienta es diferente?',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Criptografía Real:</strong> Usamos la Web Crypto API del navegador (estándar W3C) en lugar de generadores pseudoaleatorios débiles. Cada sorteo es matemáticamente imparcial.',
+        '<strong>Sin Almacenamiento:</strong> Tus datos nunca abandonan tu navegador. No vendemos listas, no hacemos perfilado, no almacenamos nada. Puro procesamiento local.',
+        '<strong>Diseño Visual:</strong> El modo cine y las animaciones hacen que cada sorteo sea un evento memorable. Perfecto para captura en OBS o transmisión directa.',
+        '<strong>Manejo de Duplicados:</strong> Detecta automáticamente nombres repetidos o variantes (espacios extras, mayúsculas, etc.) para asegurar que cada persona real cuente una sola vez.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Cómo usar el sorteo paso a paso',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        '<strong>Paso 1 - Introduce los participantes:</strong> Pega tu lista de nombres en el cuadro de texto principal. La herramienta detecta automáticamente cada salto de línea como un participante diferente. ¿Tienes duplicados? No hay problema, la herramienta los limpia.',
+        '<strong>Paso 2 - Personaliza:</strong> En la pestaña de configuración puedes activar la cuenta atrás para generar tensión, el efecto de confeti para celebrar, o activar la "lista negra" para excluir ciertos nombres.',
+        '<strong>Paso 3 - ¡Sortear!</strong> Haz clic en el botón principal y nuestro motor generará una selección aleatoria criptográficamente segura. Los ganadores se mostrarán de forma clara y memorable.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Entradas Ponderadas: Dar Ventaja a Algunos Participantes',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: '¿Quieres premiar a tus suscriptores más fieles o dar más oportunidades a ciertos participantes? Nuestro sistema de <strong>Entradas Ponderadas</strong> es único y te permite asignar un "peso" o multiplicador a cualquier nombre sin tener que escribirlo varias veces.',
+    },
+    {
+      type: 'tip',
+      title: 'Cómo asignar pesos a los nombres',
+      html: '<p>Utiliza un asterisco (*) o una "x" seguida del número de participaciones. Ejemplos:</p><ul><li><strong>"Juan * 5"</strong> - Juan compite como si fuera 5 personas</li><li><strong>"María x 10"</strong> - María tiene 10 veces más probabilidades</li><li><strong>"Pedro"</strong> - Sin símbolo = 1 entrada normal</li></ul><p>Esto es perfecto para sorteos donde quieres dar ventaja a suscriptores VIP o usuarios especiales.</p>',
+    },
+    {
+      type: 'title',
+      text: 'Privacidad y Seguridad Total',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'A diferencia de otras herramientas online, <strong>no almacenamos tus datos</strong>. Todo el procesamiento de los nombres y la ejecución del sorteo ocurre localmente en tu propio navegador. Tus listas de participantes nunca viajan por la red ni se guardan en ningún servidor externo.',
+    },
+    {
+      type: 'paragraph',
+      html: '<strong>¿Qué significa esto?</strong> Tu lista de participantes es tuya y solo tuya. Cerrando la pestaña, desaparece. No hay cookies de rastreo, no hay perfiles de usuario, no hay base de datos central. Máxima privacidad garantizada para ti y para quienes participan en tus sorteos.',
+    },
+    {
+      type: 'title',
+      text: 'Transparencia Matemática',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Algunos se preguntarán: "¿Y si tú manipulas los resultados?" La respuesta es simple: <strong>no podemos</strong>. El código del sorteo es determinista y criptográfico. No hay variables ocultas, no hay "dedos en la escena".',
+    },
+    {
+      type: 'paragraph',
+      html: 'Cada ganador es el resultado directo del algoritmo Fisher-Yates Shuffle aplicado a tu lista exacta, usando entropía criptográfica real. Si quieres auditar el proceso, el código está disponible en GitHub para inspección pública.',
+    },
+  ],
+  ui: {
+    title: 'Sorteo Aleatorio',
+    totalParticipants: 'Total Participantes Únicos',
+    ready: 'LISTO',
+    participants: 'Participantes',
+    settings: 'Configuración',
+    importFile: 'Importar Archivo',
+    clearAll: 'Borrar todo',
+    placeholder: 'Escribe o pega los nombres aquí...\nJuan Pérez\nMaria García\n@usuario_twitch',
+    onePerLine: '1 participante por línea',
+    lines: 'líneas',
+    filters: 'Filtros',
+    allowDuplicates: 'Permitir Duplicados',
+    winnerCount: 'Número de Ganadores',
+    autoRemove: 'Auto-Eliminar Ganador',
+    blacklist: 'Lista Negra (Excluir)',
+    blacklistPlaceholder: 'Nombres prohibidos (uno por línea)...',
+    blacklistInfo: 'Estos usuarios no entrarán en el sorteo.',
+    sceneEffects: 'Efectos de Escena',
+    countdown: 'Cuenta Atrás (3s)',
+    confetti: 'Confeti de Victoria',
+    zenMode: 'Modo Cine (Ocultar Panel)',
+    waitingParticipants: 'Esperando participantes...',
+    winner: 'GANADOR',
+    reroll: 'Repetir Sorteo',
+    history: 'Historial de esta sesión',
+    noWinnersYet: 'Aún no hay ganadores...',
+    startGiveaway: 'Iniciar Sorteo',
+  },
+};