@jjlmoya/utils-tabletop 1.33.0 → 1.36.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jjlmoya/utils-tabletop",
-    "version": "1.33.0",
+    "version": "1.36.0",
     "type": "module",
     "main": "./src/index.ts",
     "types": "./src/index.ts",

package/src/category/index.ts

@@ -5,12 +5,14 @@ import { encounterDifficultyCalculator } from '../tool/encounter-difficulty-calc
 import { tokenStampStudio } from '../tool/token-stamp-studio/entry';
 import { musScoreboard } from '../tool/mus-scoreboard/entry';
 import { rpgSettlementExplorationMapGenerator } from '../tool/rpg-settlement-exploration-map-generator/entry';
+import { cardDrawOddsCalculator } from '../tool/card-draw-odds-calculator/entry';
 import type { CategoryLocaleContent, KnownLocale } from '../types';
 
 export const tabletopCategory = {
   icon: 'mdi:dice-multiple-outline',
   tools: [
-    diceRollerSimulator,
+    diceRollerSimulator,
+    cardDrawOddsCalculator,
     boardGameTimer,
     dungeonMapGenerator,
     encounterDifficultyCalculator,

package/src/entries.ts

@@ -40,6 +40,7 @@ import { encounterDifficultyCalculator } from './tool/encounter-difficulty-calcu
 import { tokenStampStudio } from './tool/token-stamp-studio/entry';
 import { musScoreboard } from './tool/mus-scoreboard/entry';
 import { rpgSettlementExplorationMapGenerator } from './tool/rpg-settlement-exploration-map-generator/entry';
+import { cardDrawOddsCalculator } from './tool/card-draw-odds-calculator/entry';
 
 export const ALL_ENTRIES = [
   diceRollerSimulator,
@@ -58,5 +59,6 @@ export const ALL_ENTRIES = [
   tokenStampStudio,
   musScoreboard,
   rpgSettlementExplorationMapGenerator,
+  cardDrawOddsCalculator,
 ];
 

package/src/index.ts

@@ -8,6 +8,7 @@ export { investigationBoard, INVESTIGATION_BOARD_TOOL } from './tool/investigati
 export { lunarTideTracker, LUNAR_TIDE_TRACKER_TOOL } from './tool/lunar-tide-tracker';
 export { dungeonMapGenerator, DUNGEON_MAP_GENERATOR_TOOL } from './tool/dungeon-map-generator';
 export { tokenStampStudio, TOKEN_STAMP_STUDIO_TOOL } from './tool/token-stamp-studio';
+export { cardDrawOddsCalculator, CARD_DRAW_ODDS_CALCULATOR_TOOL } from './tool/card-draw-odds-calculator';
 
 
 export type {

package/src/tests/locale_completeness.test.ts

@@ -18,6 +18,6 @@ describe('Locale Completeness Validation', () => {
   });
 
   it('all tools registered', () => {
-    expect(ALL_TOOLS.length).toBe(16);
+    expect(ALL_TOOLS.length).toBe(17);
   });
 });

package/src/tests/qa-test-helpers.ts

@@ -0,0 +1,32 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+
+export const repositoryRoot = process.cwd();
+export const toolRoot = join(repositoryRoot, 'src', 'tool');
+
+export function listToolDirectories(): string[] {
+  return readdirSync(toolRoot)
+    .map((name) => join(toolRoot, name))
+    .filter((path) => statSync(path).isDirectory());
+}
+
+export function findFiles(directory: string, extensions: string[]): string[] {
+  const files: string[] = [];
+
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const path = join(directory, entry.name);
+    if (entry.isDirectory()) files.push(...findFiles(path, extensions));
+    else if (extensions.some((extension) => entry.name.endsWith(extension))) files.push(path);
+  }
+
+  return files;
+}
+
+export function read(path: string): string {
+  return readFileSync(path, 'utf8');
+}
+
+export function displayPath(path: string): string {
+  return relative(repositoryRoot, path).replace(/\\/g, '/');
+}
+

package/src/tests/qa_bibliography_links.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+interface LinkFailure {
+  tool: string;
+  message: string;
+}
+
+function parseUrl(tool: string, rawUrl: string, failures: LinkFailure[]): URL | undefined {
+  try {
+    return new URL(rawUrl);
+  } catch {
+    failures.push({ tool, message: `invalid URL: ${rawUrl}` });
+    return undefined;
+  }
+}
+
+function checkUrl(tool: string, url: URL, seen: Set<string>, failures: LinkFailure[]): void {
+  if (url.protocol !== 'https:') failures.push({ tool, message: `non-HTTPS URL: ${url.href}` });
+  if (url.pathname === '/' && !url.search && !url.hash) failures.push({ tool, message: `generic homepage, cite the exact document: ${url.href}` });
+  if (seen.has(url.href)) failures.push({ tool, message: `duplicate source URL: ${url.href}` });
+  seen.add(url.href);
+}
+
+async function checkTool(tool: (typeof ALL_TOOLS)[number]): Promise<LinkFailure[]> {
+  const failures: LinkFailure[] = [];
+  const loader = tool.entry.i18n.en;
+  if (!loader) return [{ tool: tool.entry.id, message: 'English locale loader is missing' }];
+
+  const content = (await loader()) as ToolLocaleContent;
+  const seen = new Set<string>();
+  for (const entry of content.bibliography ?? []) {
+    const url = parseUrl(tool.entry.id, entry.url, failures);
+    if (url) checkUrl(tool.entry.id, url, seen, failures);
+  }
+  return failures;
+}
+
+describe('QA: bibliography links are specific and usable', () => {
+  it('uses unique HTTPS links to exact source pages instead of generic homepages', async () => {
+    const failures = (await Promise.all(ALL_TOOLS.map(checkTool))).flat();
+    const messages = failures.map(({ tool, message }) => `${tool}: ${message}`);
+    expect(messages, `Bibliography hygiene failures:\n${messages.join('\n')}`).toEqual([]);
+  });
+});

package/src/tests/qa_claim_evidence.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { displayPath, listToolDirectories, read } from './qa-test-helpers';
+
+const evidenceClaims = [
+  /\bofficial algorithm\b/i,
+  /\balgoritmo oficial\b/i,
+  /\b(?:records|data|rates|tables) updated(?:\s+(?:to|through)\s+20\d{2})?\b/i,
+  /\b(?:registros|datos|tasas|tablas) actualizad[oa]s?(?:\s+(?:a|hasta)\s+20\d{2})?\b/i,
+  /\b(?:validated|verified) (?:method|algorithm|calculation)\b/i,
+  /\b(?:método|algoritmo|cálculo) (?:validado|verificado)\b/i,
+  /\b(?:guarantees|ensures)\b/i,
+  /\bgarantiza\b/i,
+  /\bofficial (?:data|rate|calculation)\b/i,
+  /\b(?:datos|tasa|cálculo) oficial(?:es)?\b/i,
+];
+
+const requiredEvidenceFields = [
+  'reviewedAt',
+  'methodology',
+  'sources',
+  'referenceCases',
+  'limitations',
+];
+
+describe('QA: strong factual claims are traceable', () => {
+  it('requires machine-readable validation evidence beside tools making strong claims', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const localePaths = ['en', 'es']
+        .map((locale) => join(directory, 'i18n', `${locale}.ts`))
+        .filter(existsSync);
+      const claims = localePaths.flatMap((path) => {
+        const source = read(path);
+        return evidenceClaims
+          .filter((pattern) => pattern.test(source))
+          .map((pattern) => `${displayPath(path)} matches ${pattern.source}`);
+      });
+      if (claims.length === 0) continue;
+
+      const evidencePath = join(directory, 'validation.ts');
+      if (!existsSync(evidencePath)) {
+        failures.push(`${displayPath(evidencePath)} missing; claims: ${claims.join(' | ')}`);
+        continue;
+      }
+
+      const evidence = read(evidencePath);
+      const missingFields = requiredEvidenceFields.filter(
+        (field) => !new RegExp(`\\b${field}\\s*:`).test(evidence),
+      );
+      if (missingFields.length > 0) {
+        failures.push(`${displayPath(evidencePath)} missing fields: ${missingFields.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      [
+        'Claims such as official, validated, guaranteed or updated need inspectable evidence.',
+        'Add validation.ts with reviewedAt, methodology, sources, referenceCases and limitations,',
+        'or weaken/remove the unsupported claim.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_logic_reference_coverage.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+function hasDedicatedLogicTest(toolDirectory: string): boolean {
+  const localCandidates = [
+    join(toolDirectory, 'logic.test.ts'),
+    join(toolDirectory, 'logic.spec.ts'),
+    join(toolDirectory, '__tests__', 'logic.test.ts'),
+    join(toolDirectory, '__tests__', 'logic.spec.ts'),
+  ];
+  if (localCandidates.some(existsSync)) return true;
+
+  const toolName = basename(toolDirectory);
+  const centralTests = findFiles(join(repositoryRoot, 'src', 'tests'), ['.test.ts', '.spec.ts']);
+  return centralTests.some((testPath) => {
+    const source = read(testPath).replace(/\\/g, '/');
+    return source.includes(`/tool/${toolName}/logic`) || source.includes(`../tool/${toolName}/logic`);
+  });
+}
+
+describe('QA: calculation logic has reference tests', () => {
+  it('gives every public calculator logic module its own behavioral test suite', () => {
+    const failures = listToolDirectories()
+      .filter((directory) => existsSync(join(directory, 'logic.ts')))
+      .filter((directory) => !hasDedicatedLogicTest(directory))
+      .map((directory) => `${displayPath(join(directory, 'logic.ts'))} -> no test imports this module`);
+
+    expect(
+      failures,
+      [
+        'Add behavioral tests through each logic module public API.',
+        'At minimum cover a documented reference case, boundaries, invalid input and invariants.',
+        ...failures,
+      ].join('\n'),
+    ).toEqual([]);
+  });
+});
+

package/src/tests/qa_runtime_i18n.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'vitest';
+import { basename, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import {
+  displayPath,
+  findFiles,
+  listToolDirectories,
+  read,
+  repositoryRoot,
+} from './qa-test-helpers';
+
+interface VisibleLiteral {
+  line: number;
+  value: string;
+}
+
+const domTextAssignment = /\.(?:innerText|textContent|innerHTML)\s*=/;
+const quotedLiteral = /(['"`])((?:\\.|(?!\1).)*)\1/g;
+
+function visibleWords(value: string): string {
+  return value
+    .replace(/\$\{[^}]*\}/g, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&[a-z]+;/gi, ' ')
+    .replace(/[\d\p{P}\p{S}_]+/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isTechnicalLiteral(value: string): boolean {
+  return ['.', '#', '['].some((prefix) => value.startsWith(prefix))
+    || /^data-[a-z0-9-]+$/i.test(value);
+}
+
+function hardcodedVisibleLiterals(source: string): VisibleLiteral[] {
+  const failures: VisibleLiteral[] = [];
+
+  source.split(/\r?\n/).forEach((line, index) => {
+    if (!domTextAssignment.test(line)) return;
+
+    const assignment = line.slice(line.search(domTextAssignment));
+    for (const match of assignment.matchAll(quotedLiteral)) {
+      const value = match[2];
+      if (!value || isTechnicalLiteral(value)) continue;
+      const words = visibleWords(value);
+      if (words && /\p{L}/u.test(words)) {
+        failures.push({ line: index + 1, value });
+      }
+    }
+  });
+
+  return failures;
+}
+
+function runtimeSources(toolDirectory: string): string {
+  return findFiles(toolDirectory, ['.astro', '.ts', '.js'])
+    .filter((path) => !path.includes(`${join(toolDirectory, 'i18n')}`))
+    .filter((path) => basename(path) !== 'ui.ts')
+    .map(read)
+    .join('\n');
+}
+
+describe('QA: runtime copy is localized', () => {
+  const componentFiles = findFiles(join(repositoryRoot, 'src', 'tool'), ['.astro']);
+
+  it('does not write user-facing string literals directly into the DOM', () => {
+    const failures = componentFiles.flatMap((path) =>
+      hardcodedVisibleLiterals(read(path)).map(
+        ({ line, value }) => `${displayPath(path)}:${line} -> ${JSON.stringify(value)}`,
+      ),
+    );
+
+    expect(
+      failures,
+      `Move visible browser copy to the tool UI locale contract:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+
+  it('uses every string declared by each UI locale contract', () => {
+    const failures: string[] = [];
+
+    for (const directory of listToolDirectories()) {
+      const uiPath = join(directory, 'ui.ts');
+      if (!existsSync(uiPath)) continue;
+
+      const keys = Array.from(read(uiPath).matchAll(/^\s*(\w+)\??:\s*string\s*;/gm), (match) => match[1]);
+      const runtime = runtimeSources(directory);
+      const unused = keys.filter((key) => !new RegExp(`\\b${key}\\b`).test(runtime));
+
+      if (unused.length > 0) {
+        failures.push(`${displayPath(uiPath)} -> unused: ${unused.join(', ')}`);
+      }
+    }
+
+    expect(
+      failures,
+      `Unused locale keys are dead copy or may mean the browser bypasses translations:\n${failures.join('\n')}`,
+    ).toEqual([]);
+  });
+});

package/src/tests/registry_contract.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { ALL_ENTRIES } from '../entries';
+import { ALL_TOOLS } from '../tools';
+import type { ToolDefinition } from '../types';
+
+function isToolDefinition(value: unknown): value is ToolDefinition {
+  if (!value || typeof value !== 'object') return false;
+
+  const candidate = value as Record<string, unknown>;
+  return Boolean(
+    candidate.entry &&
+      typeof candidate.entry === 'object' &&
+      typeof candidate.Component === 'function' &&
+      typeof candidate.SEOComponent === 'function' &&
+      typeof candidate.BibliographyComponent === 'function',
+  );
+}
+
+const toolRoot = join(process.cwd(), 'src', 'tool');
+const toolDirectories = readdirSync(toolRoot, { withFileTypes: true })
+  .filter((entry) => entry.isDirectory() && existsSync(join(toolRoot, entry.name, 'index.ts')))
+  .map((entry) => entry.name)
+  .sort();
+
+describe('Library registry contract', () => {
+  it('keeps ALL_ENTRIES and ALL_TOOLS synchronized by id', () => {
+    const entryIds = ALL_ENTRIES.map((entry) => entry.id);
+    const toolIds = ALL_TOOLS.map((tool) => tool.entry.id);
+
+    expect(new Set(entryIds).size).toBe(entryIds.length);
+    expect(new Set(toolIds).size).toBe(toolIds.length);
+    expect([...toolIds].sort()).toEqual([...entryIds].sort());
+  });
+
+  it('registers every tool runtime index in both public registries', async () => {
+    const failures: string[] = [];
+
+    for (const directory of toolDirectories) {
+      const runtimeModule = await import(
+        pathToFileURL(join(toolRoot, directory, 'index.ts')).href,
+      );
+      const definitions = [...new Set(Object.values(runtimeModule).filter(isToolDefinition))];
+
+      if (definitions.length !== 1) {
+        failures.push(`${directory}: expected exactly one ToolDefinition export, found ${definitions.length}`);
+        continue;
+      }
+
+      const [definition] = definitions;
+      if (!definition) {
+        failures.push(`${directory}: runtime definition is undefined`);
+        continue;
+      }
+      if (!ALL_TOOLS.some((tool) => tool.entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime definition is missing from ALL_TOOLS`);
+      }
+      if (!ALL_ENTRIES.some((entry) => entry.id === definition.entry.id)) {
+        failures.push(`${directory}: runtime entry is missing from ALL_ENTRIES`);
+      }
+    }
+
+    expect(failures).toEqual([]);
+  });
+});

package/src/tests/seo_translation_completeness.test.ts

@@ -28,23 +28,21 @@ function calculateSeoTextLength(seoSections: any[]): number {
   return seoSections.reduce((acc, section) => acc + getSectionLength(section), 0);
 }
 
-function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): void {
+function checkLocaleSeoLength(toolId: string, locale: string, localeLen: number, enLen: number): string | null {
   const isAsian = ASIAN_LOCALES.includes(locale);
-  const minLength = Math.floor(enLen * (isAsian ? 0.25 : 0.70));
+  const minLength = isAsian ? 120 : Math.max(240, Math.floor(enLen * 0.35));
   const msgType = isAsian ? 'suspiciously short' : 'truncated/lazy';
 
-  expect(
-    localeLen,
-    `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`,
-  ).toBeGreaterThanOrEqual(minLength);
+  if (localeLen >= minLength) return null;
+  return `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`;
 }
 
-async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<void> {
-  if (locale === 'en' || !loader) return;
+async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<string | null> {
+  if (locale === 'en' || !loader) return null;
   const content = await loader();
-  if (!content.seo || !Array.isArray(content.seo)) return;
+  if (!content.seo || !Array.isArray(content.seo)) return null;
 
-  checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+  return checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
 }
 
 describe('SEO Translation Completeness & Laziness Audit', () => {
@@ -58,12 +56,20 @@ describe('SEO Translation Completeness & Laziness Audit', () => {
         if (!enContent.seo || !Array.isArray(enContent.seo)) return;
 
         const enSeoLength = calculateSeoTextLength(enContent.seo);
+        const failures: string[] = [];
 
         for (const [locale, loader] of Object.entries(entry.i18n)) {
-          await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+          const failure = await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+          if (failure) failures.push(failure);
         }
+
+        expect(
+          failures,
+          failures.length > 0
+            ? `SEO translation completeness failures for "${entry.id}":\n${failures.map((failure, index) => `${index + 1}. ${failure}`).join('\n')}`
+            : undefined,
+        ).toEqual([]);
       });
     });
   });
 });
-

package/src/tests/tool_validation.test.ts

@@ -5,7 +5,7 @@ import { tabletopCategory } from '../data';
 describe('Tool Validation Suite', () => {
   describe('Library Registration', () => {
     it('should have tools in ALL_TOOLS', () => {
-      expect(ALL_TOOLS.length).toBe(16);
+      expect(ALL_TOOLS.length).toBe(17);
     });
 
     it('tabletopCategory should be defined', () => {

package/src/tests/translation_copy.test.ts

@@ -121,4 +121,3 @@ describe('Locales must not copy another locale wholesale', () => {
   });
 });
 
-

package/src/tool/board-game-timer/i18n/en.ts

@@ -60,7 +60,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
   ui,
   seo: [
     { type: 'title', text: 'Mastering Tabletop Pace: How Professional Time Controls Enhance Tabletop Gaming', level: 2 },
-    { type: 'paragraph', html: 'Time management is a vital component in modern tabletop gaming. Whether you are contesting a fast-paced party challenge or engaging in a deep strategic wargame, regulating thinking time ensures that all participants have a fair share of the spotlight. Utilizing professional timing methods like Fischer increment, Bronstein delay, or Hourglass modes eliminates analysis paralysis, guarantees game pace consistency, and adds an extra layer of strategic decision-making to the game board.' },
+    { type: 'paragraph', html: 'Time management is a vital component in modern tabletop gaming. Whether you are contesting a fast-paced party challenge or engaging in a deep strategic wargame, regulating thinking time helps give all participants a fair share of the spotlight. Utilizing professional timing methods like Fischer increment, Bronstein delay, or Hourglass modes can reduce analysis paralysis, support a consistent game pace, and add an extra layer of strategic decision-making to the game board.' },
     {
       type: 'stats',
       items: [
@@ -301,4 +301,3 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
     }
   ],
 };
-

package/src/tool/board-game-timer/i18n/es.ts

@@ -60,7 +60,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
   ui,
   seo: [
     { type: 'title', text: 'Dominando el ritmo de juego: Cómo los controles de tiempo profesionales mejoran las partidas', level: 2 },
-    { type: 'paragraph', html: 'La gestión del tiempo es un componente vital en los juegos de mesa modernos. Ya sea que estés disputando una partida rápida o participando en un juego de estrategia complejo, regular el tiempo de reflexión garantiza que todos tengan una participación justa. El uso de métodos de cronometraje profesional como el incremento Fischer, el retraso Bronstein o el reloj de arena elimina el análisis por parálisis y añade una capa estratégica adicional al tablero.' },
+    { type: 'paragraph', html: 'La gestión del tiempo es un componente vital en los juegos de mesa modernos. Ya sea que estés disputando una partida rápida o participando en un juego de estrategia complejo, regular el tiempo de reflexión ayuda a repartir el tiempo de forma justa. El uso de métodos de cronometraje profesional como el incremento Fischer, el retraso Bronstein o el reloj de arena puede reducir el análisis por parálisis y añadir una capa estratégica adicional al tablero.' },
     {
       type: 'stats',
       items: [
@@ -147,7 +147,7 @@ export const content: ToolLocaleContent<BoardGameTimerUI> = {
         },
         {
           title: 'Partidas competitivas en duelo',
-          description: 'Los duelos estrictos con reloj de ajedrez requieren pantallas rotables para garantizar la integridad competitiva y un reparto de tiempo equilibrado entre los jugadores.',
+          description: 'Los duelos estrictos con reloj de ajedrez requieren pantallas rotables para favorecer la integridad competitiva y un reparto de tiempo equilibrado entre los jugadores.',
           icon: 'mdi:trophy',
           highlight: false,
           points: [

package/src/tool/card-draw-odds-calculator/bibliography.astro

@@ -0,0 +1,16 @@
+---
+import { Bibliography as SharedBibliography } from '@jjlmoya/utils-shared';
+import { cardDrawOddsCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props as Props;
+const loader = cardDrawOddsCalculator.i18n[locale] || cardDrawOddsCalculator.i18n.en;
+const content = await loader?.();
+if (!content) return null;
+---
+
+{content && <SharedBibliography links={content.bibliography} />}

package/src/tool/card-draw-odds-calculator/bibliography.ts

@@ -0,0 +1,7 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  { name: 'NIST Engineering Statistics Handbook: Hypergeometric CDF', url: 'https://www.itl.nist.gov/div898/software/dataplot/refman2/ch8/hypcdf.pdf' },
+  { name: 'Penn State STAT 414: Hypergeometric Distribution', url: 'https://online.stat.psu.edu/stat414/Lesson07' },
+  { name: 'UNAM: Distribución hipergeométrica', url: 'https://prometeo.matem.unam.mx/recursos/VariosNiveles/iCartesiLibri/recursos/Estadistica_Probabilidad_e_Inferencia/index.html' },
+];