@jjlmoya/utils-sports 1.35.0 → 1.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-sports",
-    "version": "1.35.0",
+    "version": "1.40.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -9,6 +9,8 @@ import { eloRatingCalculator } from '../tool/eloRatingCalculator/entry';
 import { pingPongScoreKeeper } from '../tool/pingPongScoreKeeper/entry';
 import { rugbyScoreKeeper } from '../tool/rugbyScoreKeeper/entry';
 import { baseballScoreKeeper } from '../tool/baseballScoreKeeper/entry';
+import { penaltyShootout } from '../tool/penaltyShootout/entry';
+import { swimCssCalculator } from '../tool/swimCssCalculator/entry';
 
 export const sportsCategory: SportsCategoryEntry = {
   icon: 'mdi:soccer',
@@ -23,6 +25,8 @@ export const sportsCategory: SportsCategoryEntry = {
     pingPongScoreKeeper,
     rugbyScoreKeeper,
     baseballScoreKeeper,
+    penaltyShootout,
+    swimCssCalculator,
   ] as unknown as SportsToolEntry<Record<string, string>>[],
   i18n: {
     es: () => import('./i18n/es').then((m) => m.content),
@@ -42,4 +46,3 @@ export const sportsCategory: SportsCategoryEntry = {
     zh: () => import('./i18n/zh').then((m) => m.content),
   },
 };
-

package/src/entries.ts

@@ -30,7 +30,15 @@ export { rugbyScoreKeeper } from './tool/rugbyScoreKeeper/entry';
 export type { RugbyScoreKeeperLocaleContent } from './tool/rugbyScoreKeeper/entry';
 export { baseballScoreKeeper } from './tool/baseballScoreKeeper/entry';
 export type { BaseballScoreKeeperLocaleContent } from './tool/baseballScoreKeeper/entry';
+export { penaltyShootout } from './tool/penaltyShootout/entry';
+export type { PenaltyShootoutLocaleContent } from './tool/penaltyShootout/entry';
+export { runningPacePredictor } from './tool/runningPacePredictor/entry';
+export type { RunningPacePredictorLocaleContent } from './tool/runningPacePredictor/entry';
+export { swimCssCalculator } from './tool/swimCssCalculator/entry';
+export type { SwimCssCalculatorLocaleContent } from './tool/swimCssCalculator/entry';
+
 export { sportsCategory } from './category';
+
 import { basketScoreKeeper } from './tool/basketScoreKeeper/entry';
 import { footballScoreKeeper } from './tool/footballScoreKeeper/entry';
 import { gymTracker } from './tool/gymTracker/entry';
@@ -47,5 +55,28 @@ import { beachVolleyballScoreKeeper } from './tool/beachVolleyballScoreKeeper/en
 import { snookerScoreKeeper } from './tool/snookerScoreKeeper/entry';
 import { rugbyScoreKeeper } from './tool/rugbyScoreKeeper/entry';
 import { baseballScoreKeeper } from './tool/baseballScoreKeeper/entry';
-export const ALL_ENTRIES = [basketScoreKeeper, footballScoreKeeper, gymTracker, pingPongScoreKeeper, reactionTester, eloRatingCalculator, scoreKeeper, tournamentBracket, tennisScoreKeeper, dartsScoreKeeper, padelScoreKeeper, streetballScoreKeeper, beachVolleyballScoreKeeper, snookerScoreKeeper, rugbyScoreKeeper, baseballScoreKeeper];
+import { penaltyShootout } from './tool/penaltyShootout/entry';
+import { runningPacePredictor } from './tool/runningPacePredictor/entry';
+import { swimCssCalculator } from './tool/swimCssCalculator/entry';
 
+export const ALL_ENTRIES = [
+  basketScoreKeeper,
+  footballScoreKeeper,
+  gymTracker,
+  pingPongScoreKeeper,
+  reactionTester,
+  eloRatingCalculator,
+  scoreKeeper,
+  tournamentBracket,
+  tennisScoreKeeper,
+  dartsScoreKeeper,
+  padelScoreKeeper,
+  streetballScoreKeeper,
+  beachVolleyballScoreKeeper,
+  snookerScoreKeeper,
+  rugbyScoreKeeper,
+  baseballScoreKeeper,
+  penaltyShootout,
+  runningPacePredictor,
+  swimCssCalculator,
+];

package/src/index.ts

@@ -31,3 +31,6 @@ export type { ReactionTesterUI, ReactionTesterLocaleContent } from './tool/react
 
 export { ELO_RATING_CALCULATOR_TOOL, eloRatingCalculator } from './tool/eloRatingCalculator/index';
 export type { EloRatingCalculatorUI, EloRatingCalculatorLocaleContent } from './tool/eloRatingCalculator/index';
+
+export { PENALTY_SHOOTOUT_TOOL, penaltyShootout } from './tool/penaltyShootout/index';
+export type { PenaltyShootoutUI, PenaltyShootoutLocaleContent } from './tool/penaltyShootout/index';

package/src/tests/locale_completeness.test.ts

@@ -1,8 +1,29 @@
 import { describe, it, expect } from 'vitest';
 import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
 
-describe('Locale Completeness Validation', () => {
-  it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(16);
+describe('Locale Completeness and Slug Validation', () => {
+  it('all tools registered in ALL_TOOLS', () => {
+    expect(ALL_TOOLS.length).toBeGreaterThan(0);
+  });
+
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool entry: ${tool.entry.id}`, () => {
+      it('every registered locale content must have a valid non-empty slug', async () => {
+        const locales = Object.keys(tool.entry.i18n);
+        expect(locales.length).toBeGreaterThan(0);
+
+        for (const locale of locales) {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          expect(loader).toBeDefined();
+          const content = (await loader?.()) as ToolLocaleContent;
+          expect(content, `Locale "${locale}" for tool "${tool.entry.id}" failed to load content object`).toBeDefined();
+          expect(content.slug, `Locale "${locale}" for tool "${tool.entry.id}" has undefined or empty slug`).toBeDefined();
+          expect(typeof content.slug).toBe('string');
+          expect(content.slug.length).toBeGreaterThan(0);
+          expect(content.title, `Locale "${locale}" for tool "${tool.entry.id}" has undefined title`).toBeDefined();
+        }
+      });
+    });
   });
 });

package/src/tests/tool_validation.test.ts

@@ -4,8 +4,8 @@ import { sportsCategory } from '../data';
 
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
-    it('should have 15 tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(16);
+    it('should have tools registered in ALL_TOOLS', () => {
+      expect(ALL_TOOLS.length).toBeGreaterThan(0);
     });
 
     it('sportsCategory should be defined', () => {

package/src/tool/penaltyShootout/bibliography.astro

@@ -0,0 +1,15 @@
+---
+import { bibliographyEntries } from './bibliography';
+---
+
+<div class="ps-bibliography">
+  <ul>
+    {bibliographyEntries.map((item) => (
+      <li>
+        <a href={item.url} target="_blank" rel="noopener noreferrer">
+          {item.name}
+        </a>
+      </li>
+    ))}
+  </ul>
+</div>

package/src/tool/penaltyShootout/bibliography.ts

@@ -0,0 +1,8 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliographyEntries: BibliographyEntry[] = [
+  {
+    name: 'FIFA Laws of the Game',
+    url: 'https://digitalhub.fifa.com/m/5371a6dcc42fbb44/original/d6g1medsi8jrrd3e4imp-pdf.pdf',
+  },
+];

package/src/tool/penaltyShootout/component.astro

@@ -0,0 +1,228 @@
+---
+import type { PenaltyShootoutUI } from './ui';
+import './penalty-shootout.css';
+
+interface Props {
+  ui: PenaltyShootoutUI;
+}
+
+const { ui: t } = Astro.props;
+---
+
+<div class="penalty-shootout-card" id="penalty-shootout-app">
+  <div class="ps-bar">
+    <span class="ps-bar-title">{t.roundLabel} <span id="ps-round-num">1</span></span>
+    <span class="ps-bar-title" id="ps-phase-label">{t.regularRounds}</span>
+  </div>
+
+  <div class="ps-team ps-team-a ps-active-turn" id="ps-team-a-box">
+    <input type="text" class="ps-name" id="ps-team-a-name" value={t.teamALabel} aria-label={t.teamALabel} />
+    <div class="ps-score ps-score-a" id="ps-team-a-score">0</div>
+    <div class="ps-indicator-row" id="ps-team-a-indicators"></div>
+  </div>
+
+  <div class="ps-team ps-team-b" id="ps-team-b-box">
+    <input type="text" class="ps-name" id="ps-team-b-name" value={t.teamBLabel} aria-label={t.teamBLabel} />
+    <div class="ps-score ps-score-b" id="ps-team-b-score">0</div>
+    <div class="ps-indicator-row" id="ps-team-b-indicators"></div>
+  </div>
+
+  <div class="ps-status-banner" id="ps-status-banner">
+    <span id="ps-status-text">{t.turnLabel}: {t.teamALabel}</span>
+  </div>
+
+  <div class="ps-controls" id="ps-action-controls">
+    <button class="ps-btn-shoot ps-btn-goal" id="ps-btn-goal">{t.scoreGoal}</button>
+    <button class="ps-btn-shoot ps-btn-miss" id="ps-btn-miss">{t.scoreMiss}</button>
+  </div>
+
+  <div class="ps-secondary-row">
+    <button class="ps-btn-sub" id="ps-btn-undo">{t.undo}</button>
+    <button class="ps-btn-sub" id="ps-btn-reset">{t.reset}</button>
+  </div>
+
+  <div class="ps-particles" id="ps-particles"></div>
+
+  <div class="ps-winner-overlay" id="ps-winner-overlay">
+    <div class="ps-winner-backdrop"></div>
+    <div class="ps-winner-card">
+      <div class="ps-trophy">CHAMPION</div>
+      <div class="ps-winner-title">{t.winnerTitle}</div>
+      <div class="ps-winner-name" id="ps-winner-name">Team Name</div>
+      <div class="ps-winner-details" id="ps-winner-details">Score: 5 - 3</div>
+      <button class="ps-winner-close-btn" id="ps-winner-close-btn">{t.reset}</button>
+    </div>
+  </div>
+</div>
+
+<script>
+  import { createInitialState, recordShot, undoShot } from './logic';
+
+  let state = createInitialState();
+
+  const teamABox = document.getElementById('ps-team-a-box');
+  const teamBBox = document.getElementById('ps-team-b-box');
+  const teamANameInput = document.getElementById('ps-team-a-name') as HTMLInputElement | null;
+  const teamBNameInput = document.getElementById('ps-team-b-name') as HTMLInputElement | null;
+  const teamAScore = document.getElementById('ps-team-a-score');
+  const teamBScore = document.getElementById('ps-team-b-score');
+  const teamAIndicators = document.getElementById('ps-team-a-indicators');
+  const teamBIndicators = document.getElementById('ps-team-b-indicators');
+  const statusBanner = document.getElementById('ps-status-banner');
+  const statusText = document.getElementById('ps-status-text');
+  const roundNum = document.getElementById('ps-round-num');
+  const phaseLabel = document.getElementById('ps-phase-label');
+  const particlesContainer = document.getElementById('ps-particles');
+
+  const winnerOverlay = document.getElementById('ps-winner-overlay');
+  const winnerName = document.getElementById('ps-winner-name');
+  const winnerDetails = document.getElementById('ps-winner-details');
+  const winnerCloseBtn = document.getElementById('ps-winner-close-btn');
+
+  const btnGoal = document.getElementById('ps-btn-goal') as HTMLButtonElement | null;
+  const btnMiss = document.getElementById('ps-btn-miss') as HTMLButtonElement | null;
+  const btnUndo = document.getElementById('ps-btn-undo');
+  const btnReset = document.getElementById('ps-btn-reset');
+
+  teamANameInput?.addEventListener('input', (e) => {
+    state.teamAName = (e.target as HTMLInputElement).value || 'Home Team';
+    render();
+  });
+
+  teamBNameInput?.addEventListener('input', (e) => {
+    state.teamBName = (e.target as HTMLInputElement).value || 'Away Team';
+    render();
+  });
+
+  function spawnParticle(text: string, type: 'goal' | 'miss') {
+    if (!particlesContainer) return;
+    const p = document.createElement('div');
+    p.className = `ps-p ps-p-${type}`;
+    p.textContent = text;
+    p.style.left = `${30 + Math.random() * 40}%`;
+    p.style.top = `${40 + Math.random() * 20}%`;
+    particlesContainer.appendChild(p);
+    setTimeout(() => p.remove(), 800);
+  }
+
+  function updateScoreDisplay() {
+    if (!teamAScore || !teamBScore || !roundNum || !phaseLabel) return;
+    teamAScore.textContent = String(state.teamAScore);
+    teamBScore.textContent = String(state.teamBScore);
+    roundNum.textContent = String(state.currentRound);
+    phaseLabel.textContent = state.currentRound > 5 ? 'Sudden Death' : 'Regular Round';
+  }
+
+  function getShotSymbol(shot: string, index: number) {
+    if (shot === 'scored') return 'O';
+    if (shot === 'missed') return 'X';
+    return String(index + 1);
+  }
+
+  function renderIndicators() {
+    if (!teamAIndicators || !teamBIndicators) return;
+    teamAIndicators.innerHTML = '';
+    state.teamAShoots.forEach((shot, i) => {
+      const circle = document.createElement('div');
+      circle.className = `ps-circle ps-${shot}`;
+      circle.textContent = getShotSymbol(shot, i);
+      teamAIndicators.appendChild(circle);
+    });
+
+    teamBIndicators.innerHTML = '';
+    state.teamBShoots.forEach((shot, i) => {
+      const circle = document.createElement('div');
+      circle.className = `ps-circle ps-${shot}`;
+      circle.textContent = getShotSymbol(shot, i);
+      teamBIndicators.appendChild(circle);
+    });
+  }
+
+  function updateFinishedElements(winner: string) {
+    if (statusText) statusText.textContent = `${winner} Wins! (${state.winReason})`;
+    if (winnerName) winnerName.textContent = winner;
+    if (winnerDetails) winnerDetails.textContent = `Score: ${state.teamAScore} - ${state.teamBScore} (${state.winReason})`;
+    if (winnerOverlay) winnerOverlay.classList.add('ps-winner-show');
+  }
+
+  function renderFinishedState() {
+    teamABox?.classList.remove('ps-active-turn');
+    teamBBox?.classList.remove('ps-active-turn');
+    if (statusBanner) statusBanner.className = 'ps-status-banner ps-winner';
+    const winner = state.winner === 'A' ? state.teamAName : state.teamBName;
+    if (btnGoal) btnGoal.disabled = true;
+    if (btnMiss) btnMiss.disabled = true;
+
+    updateFinishedElements(winner);
+  }
+
+  function setActiveTurnBox(isTurnA: boolean) {
+    if (isTurnA) {
+      teamABox?.classList.add('ps-active-turn');
+      teamBBox?.classList.remove('ps-active-turn');
+    } else {
+      teamBBox?.classList.add('ps-active-turn');
+      teamABox?.classList.remove('ps-active-turn');
+    }
+  }
+
+  function renderActiveState() {
+    if (statusBanner) statusBanner.className = 'ps-status-banner';
+    if (btnGoal) btnGoal.disabled = false;
+    if (btnMiss) btnMiss.disabled = false;
+    winnerOverlay?.classList.remove('ps-winner-show');
+
+    const isTurnA = state.currentTurn === 'A';
+    setActiveTurnBox(isTurnA);
+    const activeName = isTurnA ? state.teamAName : state.teamBName;
+    if (statusText) statusText.textContent = `Turn: ${activeName}`;
+  }
+
+  function render() {
+    updateScoreDisplay();
+    renderIndicators();
+
+    if (state.isFinished) {
+      renderFinishedState();
+    } else {
+      renderActiveState();
+    }
+  }
+
+  btnGoal?.addEventListener('click', () => {
+    const turn = state.currentTurn;
+    state = recordShot(state, 'scored');
+    spawnParticle('GOAL!', 'goal');
+    const targetScore = turn === 'A' ? teamAScore : teamBScore;
+    targetScore?.classList.add('ps-score-boom');
+    setTimeout(() => targetScore?.classList.remove('ps-score-boom'), 500);
+    render();
+  });
+
+  btnMiss?.addEventListener('click', () => {
+    state = recordShot(state, 'missed');
+    spawnParticle('MISS!', 'miss');
+    render();
+  });
+
+  btnUndo?.addEventListener('click', () => {
+    state = undoShot(state);
+    render();
+  });
+
+  btnReset?.addEventListener('click', () => {
+    const nameA = teamANameInput?.value || 'Home Team';
+    const nameB = teamBNameInput?.value || 'Away Team';
+    state = createInitialState(nameA, nameB);
+    render();
+  });
+
+  winnerCloseBtn?.addEventListener('click', () => {
+    const nameA = teamANameInput?.value || 'Home Team';
+    const nameB = teamBNameInput?.value || 'Away Team';
+    state = createInitialState(nameA, nameB);
+    render();
+  });
+
+  render();
+</script>

package/src/tool/penaltyShootout/entry.ts

@@ -0,0 +1,30 @@
+import type { SportsToolEntry, ToolLocaleContent } from '../../types';
+import type { PenaltyShootoutUI } from './ui';
+
+export type { PenaltyShootoutUI };
+export type PenaltyShootoutLocaleContent = ToolLocaleContent<PenaltyShootoutUI>;
+
+export const penaltyShootout: SportsToolEntry<PenaltyShootoutUI> = {
+  id: 'penalty-shootout-calculator',
+  icons: {
+    bg: 'mdi:soccer',
+    fg: 'mdi:scoreboard-outline',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/penaltyShootout/i18n/de.ts

@@ -0,0 +1,193 @@
+import { bibliographyEntries } from '../bibliography';
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { PenaltyShootoutUI } from '../ui';
+
+const slug = 'elfmeterschiessen-rechner';
+const title = 'Elfmeterschießen Rechner: Live Fußball Ergebnisstander';
+const description =
+  'Verfolgen Sie Fußball-Elfmeterschießen in Echtzeit. Mit 5-Schuss-Anzeige, mathematischem Ausscheidungsmodus, Sudden Death und Sieger-Animation.';
+
+const faqData = [
+  {
+    question: 'Wann endet ein Elfmeterschießen vorzeitig?',
+    answer:
+      'Ein Elfmeterschießen endet, sobald eine Mannschaft einen Vorsprung erzielt, den die andere Mannschaft mit den verbleibenden Schüssen mathematisch nicht mehr einholen kann.',
+  },
+  {
+    question: 'Wie funktioniert Sudden Death beim Elfmeterschießen?',
+    answer:
+      'Steht es nach jeweils 5 Schüssen unentschieden, wird das Schießen einzeln fortgesetzt, bis ein Team trifft und das andere im selben Durchgang verschießt.',
+  },
+  {
+    question: 'Wer schießt beim Elfmeterschießen zuerst?',
+    answer:
+      'Der Schiedsrichter wirft eine Münze zur Wahl des Tors und eine zweite Münze zur Entscheidung, welches Team zuerst antritt.',
+  },
+  {
+    question: 'Kann der Torwart während des Elfmeterschießens ausgewechselt werden?',
+    answer:
+      'Ein verletzter Torwart kann durch einen benannten Auswechselspieler ersetzt werden, sofern das Team sein Auswechselkontingent noch nicht ausgeschöpft hat.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Teamnamen eingeben',
+    text: 'Geben Sie die Wunschnamen der beiden Mannschaften in die Eingabefelder ein.',
+  },
+  {
+    name: 'Schüsse protokollieren',
+    text: 'Klicken Sie nach jedem Schuss auf TOR oder FEHL. Die App aktualisiert Spielstand, Rundenanzeige und Schussrecht automatisch.',
+  },
+  {
+    name: 'Sudden-Death-Modus',
+    text: 'Bei Gleichstand nach 5 Schüssen wechselt der Rechner automatisch in den Sudden-Death-Modus.',
+  },
+  {
+    name: 'Sieger verkünden',
+    text: 'Bei rechnerischem Sieg oder Entscheidung im Sudden Death verkündet ein Pokal-Overlay das Siegerteam.',
+  },
+];
+
+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: 'SportsApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<PenaltyShootoutUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography: bibliographyEntries,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'Offizielle IFAB-Regeln für das Elfmeterschießen',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Das Elfmeterschießen (offiziell <em>Schüsse von der Strafstoßmarke</em>) entscheidet nach Regel 10 der IFAB-Spielregeln über den Sieger eines unentschiedenen K.-o.-Spiels.',
+    },
+    {
+      type: 'stats',
+      columns: 4,
+      items: [
+        { value: '5', label: 'Schüsse zu Beginn' },
+        { value: '11m', label: 'Entfernung zum Tor' },
+        { value: '1v1', label: 'Schütze vs Torwart' },
+        { value: 'ABBA / AB', label: 'Schussreihenfolge' },
+      ],
+    },
+    {
+      type: 'tip',
+      title: 'Mathematische Ausscheidungsregel',
+      html: 'Hat ein Team mehr Tore erzielt als dem gegnerischen Team Schüsse verbleiben, beendet der Schiedsrichter das Schießen sofort.',
+    },
+    {
+      type: 'title',
+      text: 'Reguläre Phase vs Sudden Death im Vergleich',
+      level: 2,
+    },
+    {
+      type: 'comparative',
+      columns: 2,
+      items: [
+        {
+          title: 'Reguläre Phase (5 Schüsse)',
+          description: 'Jedes Team führt 5 Schüsse abwechselnd aus. Vorzeitiges Ende nur bei mathematischer Unmöglichkeit.',
+        },
+        {
+          title: 'Sudden Death Phase',
+          description: 'Einzelne Schussdurchgänge ab Runden 6. Jede Tordifferenz nach gleicher Schusszahl bringt die Entscheidung.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Wichtige IFAB-Bestimmungen',
+      level: 2,
+    },
+    {
+      type: 'table',
+      headers: ['Regel / Bestimmung', 'Offizieller IFAB-Standard'],
+      rows: [
+        ['Teilnahmeberechtigt', 'Nur Spieler, die bei Spielende auf dem Feld stehen, dürfen Schüsse ausführen.'],
+        ['Position des Torwarts', 'Muss im Moment des Schusses mit mindestens einem Teil eines Fußes die Torlinie berühren.'],
+        ['Täuschen beim Anlauf', 'Täuschen im Anlauf erlaubt; Täuschen nach Abschluss des Anlaufs wird geahndet.'],
+        ['Gleichzahl der Spieler', 'Wurde ein Spieler des Gegners feldverwiesen, muss das andere Team seine Spielerzahl anpassen.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Vor und Nachteile des Elfmeterschießens',
+      level: 2,
+    },
+    {
+      type: 'proscons',
+      title: 'Bewertung des Formats',
+      items: [
+        {
+          pro: 'Garantiert einen eindeutigen Sieger in einem planbaren Zeitrahmen.',
+          con: 'Hoher psychologischer Druck kann die Leistung der 120 Spielminuten in den Schatten stellen.',
+        },
+        {
+          pro: 'Bietet höchste Spannung für Fans und Zuschauer.',
+          con: 'Fehlschüsse einzelner Akteure werden oft übermäßig belastet.',
+        },
+      ],
+    },
+  ],
+  ui: {
+    teamALabel: 'Heimmannschaft',
+    teamBLabel: 'Auswärtsmannschaft',
+    scoreGoal: 'TOR',
+    scoreMiss: 'FEHL',
+    undo: 'Rückgängig',
+    reset: 'Zurücksetzen',
+    suddenDeath: 'Sudden Death',
+    regularRounds: 'Reguläre Runde',
+    roundLabel: 'Runde',
+    turnLabel: 'Am Schuss',
+    winnerTitle: 'Sieger steht fest',
+    unreachableLead: 'Unerreichbarer Vorsprung',
+    regularRoundsWin: 'Sieg nach 5 regulären Runden',
+    suddenDeathWin: 'Sieg im Sudden Death',
+    statusPending: 'Offen',
+    statusScored: 'Treffer',
+    statusMissed: 'Verschossen',
+  },
+};