@jjlmoya/utils-forensic-science 1.13.0 → 1.15.0

package/src/tests/script_density.test.ts

@@ -1,94 +1,94 @@
-import { describe, expect, it } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-
-type ScriptLocale = keyof typeof SCRIPT_RULES;
-
-const SCRIPT_RULES = {
-  ja: {
-    language: 'Japanese',
-    scriptName: 'kana/kanji',
-    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
-    minScriptRatio: 0.45,
-  },
-  ko: {
-    language: 'Korean',
-    scriptName: 'hangul',
-    scriptCharacters: /\p{Script=Hangul}/gu,
-    minScriptRatio: 0.55,
-  },
-  ru: {
-    language: 'Russian',
-    scriptName: 'cyrillic',
-    scriptCharacters: /\p{Script=Cyrillic}/gu,
-    minScriptRatio: 0.65,
-  },
-  zh: {
-    language: 'Chinese',
-    scriptName: 'han',
-    scriptCharacters: /\p{Script=Han}/gu,
-    minScriptRatio: 0.45,
-  },
-} as const;
-
-const LETTERS = /\p{L}/gu;
-const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
-
-function collectStrings(value: unknown): string[] {
-  if (typeof value === 'string') return [value];
-  if (!value || typeof value !== 'object') return [];
-  if (Array.isArray(value)) return value.flatMap(collectStrings);
-  return Object.values(value).flatMap(collectStrings);
-}
-
-function normalizeText(value: unknown): string {
-  return collectStrings(value).join(' ').normalize('NFC');
-}
-
-function translatableContent(content: Record<string, unknown>) {
-  return TRANSLATABLE_KEYS.map((key) => content[key]);
-}
-
-function letterCount(text: string): number {
-  return text.match(LETTERS)?.length ?? 0;
-}
-
-function scriptCount(text: string, locale: ScriptLocale): number {
-  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
-}
-
-function scriptRatio(text: string, locale: ScriptLocale): number {
-  const letters = letterCount(text);
-  if (letters === 0) return 0;
-  return scriptCount(text, locale) / letters;
-}
-
-describe('Native script density validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      Object.keys(SCRIPT_RULES).forEach((locale) => {
-        it(`${locale} keeps most translated text in its native script`, async () => {
-          const typedLocale = locale as ScriptLocale;
-          const loader = tool.entry.i18n[typedLocale];
-          if (!loader) return;
-
-          const content = await loader();
-          const rule = SCRIPT_RULES[typedLocale];
-          const text = normalizeText(translatableContent(content as Record<string, unknown>));
-          const letters = letterCount(text);
-          const matches = scriptCount(text, typedLocale);
-          const ratio = scriptRatio(text, typedLocale);
-
-          expect(
-            ratio,
-            [
-              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
-              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
-              `Most translatable content should be written in ${rule.scriptName} script.`,
-              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
-            ].join(' '),
-          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
-        });
-      });
-    });
-  });
-});
+import { describe, expect, it } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+type ScriptLocale = keyof typeof SCRIPT_RULES;
+
+const SCRIPT_RULES = {
+  ja: {
+    language: 'Japanese',
+    scriptName: 'kana/kanji',
+    scriptCharacters: /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/gu,
+    minScriptRatio: 0.45,
+  },
+  ko: {
+    language: 'Korean',
+    scriptName: 'hangul',
+    scriptCharacters: /\p{Script=Hangul}/gu,
+    minScriptRatio: 0.55,
+  },
+  ru: {
+    language: 'Russian',
+    scriptName: 'cyrillic',
+    scriptCharacters: /\p{Script=Cyrillic}/gu,
+    minScriptRatio: 0.65,
+  },
+  zh: {
+    language: 'Chinese',
+    scriptName: 'han',
+    scriptCharacters: /\p{Script=Han}/gu,
+    minScriptRatio: 0.45,
+  },
+} as const;
+
+const LETTERS = /\p{L}/gu;
+const TRANSLATABLE_KEYS = ['title', 'description', 'ui', 'seo', 'faq', 'howTo'] as const;
+
+function collectStrings(value: unknown): string[] {
+  if (typeof value === 'string') return [value];
+  if (!value || typeof value !== 'object') return [];
+  if (Array.isArray(value)) return value.flatMap(collectStrings);
+  return Object.values(value).flatMap(collectStrings);
+}
+
+function normalizeText(value: unknown): string {
+  return collectStrings(value).join(' ').normalize('NFC');
+}
+
+function translatableContent(content: Record<string, unknown>) {
+  return TRANSLATABLE_KEYS.map((key) => content[key]);
+}
+
+function letterCount(text: string): number {
+  return text.match(LETTERS)?.length ?? 0;
+}
+
+function scriptCount(text: string, locale: ScriptLocale): number {
+  return text.match(SCRIPT_RULES[locale].scriptCharacters)?.length ?? 0;
+}
+
+function scriptRatio(text: string, locale: ScriptLocale): number {
+  const letters = letterCount(text);
+  if (letters === 0) return 0;
+  return scriptCount(text, locale) / letters;
+}
+
+describe('Native script density validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(SCRIPT_RULES).forEach((locale) => {
+        it(`${locale} keeps most translated text in its native script`, async () => {
+          const typedLocale = locale as ScriptLocale;
+          const loader = tool.entry.i18n[typedLocale];
+          if (!loader) return;
+
+          const content = await loader();
+          const rule = SCRIPT_RULES[typedLocale];
+          const text = normalizeText(translatableContent(content as unknown as Record<string, unknown>));
+          const letters = letterCount(text);
+          const matches = scriptCount(text, typedLocale);
+          const ratio = scriptRatio(text, typedLocale);
+
+          expect(
+            ratio,
+            [
+              `Possible broken translation detected in ${tool.entry.id}/${typedLocale} (${rule.language}).`,
+              `The text has ${matches} ${rule.scriptName} characters out of ${letters} analyzed letters (${(ratio * 100).toFixed(1)}%).`,
+              `Most translatable content should be written in ${rule.scriptName} script.`,
+              'Non-translatable fields such as slug, bibliography, and schemas are ignored to avoid false positives.',
+            ].join(' '),
+          ).toBeGreaterThanOrEqual(rule.minScriptRatio);
+        });
+      });
+    });
+  });
+});

package/src/tests/seo_length.test.ts

@@ -1,46 +1,46 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from '../tools';
-import type { ToolLocaleContent } from '../types';
-
-describe('SEO Content Length Validation', () => {
-  ALL_TOOLS.forEach((tool) => {
-    describe(`Tool: ${tool.entry.id}`, () => {
-      Object.keys(tool.entry.i18n).forEach((locale) => {
-        it(`${locale}: SEO section should contain at least 300 words`, async () => {
-          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
-          if (loader) {
-            const content = (await loader()) as ToolLocaleContent;
-            expect(Array.isArray(content.seo)).toBe(true);
-
-            let textContent = '';
-            content.seo.forEach((item) => {
-              if (item.type === 'title' && item.text) {
-                textContent += ' ' + item.text;
-              } else if (item.type === 'paragraph' && item.html) {
-                textContent += ' ' + item.html;
-              } else if (item.type === 'table') {
-                if (item.headers) {
-                  textContent += ' ' + item.headers.join(' ');
-                }
-                if (item.rows) {
-                  item.rows.forEach((row) => {
-                    textContent += ' ' + row.join(' ');
-                  });
-                }
-              }
-            });
-
-            const cleanText = textContent.replace(/<[^>]*>/g, ' ').trim();
-            const words = cleanText.split(/\s+/).filter((w) => w.length > 0);
-
-            const isCjk = ['zh', 'ja', 'ko'].includes(locale);
-            const count = isCjk ? cleanText.replace(/\s+/g, '').length : words.length;
-
-            expect(count).toBeGreaterThanOrEqual(300);
-          }
-        });
-      });
-    });
-  });
-});
-
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+import type { ToolLocaleContent } from '../types';
+
+describe('SEO Content Length Validation', () => {
+  ALL_TOOLS.forEach((tool) => {
+    describe(`Tool: ${tool.entry.id}`, () => {
+      Object.keys(tool.entry.i18n).forEach((locale) => {
+        it(`${locale}: SEO section should contain at least 300 words`, async () => {
+          const loader = tool.entry.i18n[locale as keyof typeof tool.entry.i18n];
+          if (loader) {
+            const content = (await loader()) as ToolLocaleContent;
+            expect(Array.isArray(content.seo)).toBe(true);
+
+            let textContent = '';
+            content.seo.forEach((item) => {
+              if (item.type === 'title' && item.text) {
+                textContent += ' ' + item.text;
+              } else if (item.type === 'paragraph' && item.html) {
+                textContent += ' ' + item.html;
+              } else if (item.type === 'table') {
+                if (item.headers) {
+                  textContent += ' ' + item.headers.join(' ');
+                }
+                if (item.rows) {
+                  item.rows.forEach((row) => {
+                    textContent += ' ' + row.join(' ');
+                  });
+                }
+              }
+            });
+
+            const cleanText = textContent.replace(/<[^>]*>/g, ' ').trim();
+            const words = cleanText.split(/\s+/).filter((w) => w.length > 0);
+
+            const isCjk = ['zh', 'ja', 'ko'].includes(locale);
+            const count = isCjk ? cleanText.replace(/\s+/g, '').length : words.length;
+
+            expect(count).toBeGreaterThanOrEqual(300);
+          }
+        });
+      });
+    });
+  });
+});
+

package/src/tests/seo_parity.test.ts

@@ -3,7 +3,6 @@ import { ALL_ENTRIES } from '../entries';
 import type { KnownLocale } from '../types';
 
 interface ExpectedCounts {
-  seo: number;
   faq: number;
   howTo: number;
 }
@@ -24,10 +23,7 @@ async function verifyLocaleParity(
   const locFaqCount = countItems(locContent?.faq);
   const locHowToCount = countItems(locContent?.howTo);
 
-  expect(
-    locSeoCount,
-    `Locale ${loc} SEO sections count (${locSeoCount}) must match EN (${expected.seo})`,
-  ).toBe(expected.seo);
+  expect(locSeoCount, `Locale ${loc} must provide SEO content`).toBeGreaterThan(0);
   expect(
     locFaqCount,
     `Locale ${loc} FAQ items count (${locFaqCount}) must match EN (${expected.faq})`,
@@ -41,11 +37,10 @@ async function verifyLocaleParity(
 describe('SEO & i18n Structural Parity Suite', () => {
   ALL_ENTRIES.forEach((entry) => {
     describe(`Tool: ${entry.id}`, () => {
-      it('all 15 locales should have identical SEO section counts and types as English', async () => {
+      it('all 15 locales should provide SEO content and preserve FAQ and HowTo structure', async () => {
         const enContent = await entry.i18n.en?.();
         expect(enContent).toBeDefined();
         const expected: ExpectedCounts = {
-          seo: countItems(enContent?.seo),
           faq: countItems(enContent?.faq),
           howTo: countItems(enContent?.howTo),
         };

package/src/tests/seo_translation_completeness.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect } from 'vitest';
+import { ALL_TOOLS } from '../tools';
+
+const ASIAN_LOCALES = ['ja', 'ko', 'zh'];
+
+function getSimpleSectionLength(section: any): number {
+  if (section.type === 'title') return section.text ? section.text.length : 0;
+  if (section.type === 'paragraph') return section.html ? section.html.replace(/<[^>]*>/g, '').length : 0;
+  if (section.type === 'list') return section.items ? section.items.join('').length : 0;
+  return 0;
+}
+
+function getComplexSectionLength(section: any): number {
+  if (section.type === 'diagnostic' || section.type === 'tip') {
+    return (section.title ? section.title.length : 0) + (section.html ? section.html.replace(/<[^>]*>/g, '').length : 0);
+  }
+  if (section.type === 'table') {
+    return ((section.headers || []).join('').length) + ((section.rows || []).flat().join('').length);
+  }
+  return 0;
+}
+
+function getSectionLength(section: any): number {
+  return getSimpleSectionLength(section) || getComplexSectionLength(section);
+}
+
+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 {
+  const isAsian = ASIAN_LOCALES.includes(locale);
+  const minLength = Math.floor(enLen * (isAsian ? 0.25 : 0.70));
+  const msgType = isAsian ? 'suspiciously short' : 'truncated/lazy';
+
+  expect.soft(
+    localeLen,
+    `[LAZY SEO TRANSLATION] Tool "${toolId}" locale "${locale}" SEO text is ${msgType} (${localeLen} chars vs EN ${enLen} chars, expected min ${minLength})`,
+  ).toBeGreaterThanOrEqual(minLength);
+}
+
+async function auditSingleLocale(toolId: string, locale: string, loader: any, enSeoLength: number): Promise<void> {
+  if (locale === 'en' || !loader) return;
+  const content = await loader();
+  if (!content.seo || !Array.isArray(content.seo)) return;
+
+  checkLocaleSeoLength(toolId, locale, calculateSeoTextLength(content.seo), enSeoLength);
+}
+
+describe('SEO Translation Completeness & Laziness Audit', () => {
+  ALL_TOOLS.forEach(({ entry }) => {
+    describe(`Tool: ${entry.id}`, () => {
+      it('should not have lazy or truncated SEO content compared to English reference', async () => {
+        const enLoader = entry.i18n['en' as keyof typeof entry.i18n];
+        if (!enLoader) return;
+
+        const enContent = await enLoader();
+        if (!enContent.seo || !Array.isArray(enContent.seo)) return;
+
+        const enSeoLength = calculateSeoTextLength(enContent.seo);
+
+        for (const [locale, loader] of Object.entries(entry.i18n)) {
+          await auditSingleLocale(entry.id, locale, loader, enSeoLength);
+        }
+      });
+    });
+  });
+});

package/src/tests/seo_wellformed_export.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync, existsSync } from 'fs';
+import { join, relative } from 'path';
+
+function findSeoAstroFiles(dir: string): string[] {
+  const files: string[] = [];
+  if (!existsSync(dir)) return files;
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...findSeoAstroFiles(fullPath));
+    } else if (entry.isFile() && entry.name === 'seo.astro') {
+      files.push(fullPath);
+    }
+  }
+
+  return files;
+}
+
+const toolDir = join(process.cwd(), 'src', 'tool');
+const seoFiles = findSeoAstroFiles(toolDir);
+
+describe('SEO Component Wellformed Export', () => {
+  it('found tool seo.astro components', () => {
+    expect(seoFiles.length).toBeGreaterThan(0);
+  });
+
+  seoFiles.forEach((file) => {
+    const relativePath = relative(process.cwd(), file);
+
+    it(`${relativePath} should dynamically load SEO sections and use SEORenderer`, () => {
+      const content = readFileSync(file, 'utf-8');
+
+      const usesSeoRenderer =
+        content.includes('@jjlmoya/utils-shared') &&
+        (content.includes('SEORenderer') || content.includes('SEOArticle'));
+
+      const acquiresDynamicContent =
+        content.includes('.i18n') ||
+        content.includes('loader') ||
+        content.includes('await loader') ||
+        content.includes('.seo');
+
+      const isBrokenPattern =
+        /sections\s*=\s*\[\s*\]/.test(content) && !acquiresDynamicContent;
+
+      expect(
+        usesSeoRenderer,
+        `File "${relativePath}" does not import or use SEORenderer from @jjlmoya/utils-shared.`,
+      ).toBe(true);
+
+      expect(
+        isBrokenPattern,
+        `File "${relativePath}" relies on a static sections=[] prop default without fetching content from entry.i18n, resulting in empty SEO text on consumers.`,
+      ).toBe(false);
+
+      expect(
+        acquiresDynamicContent,
+        `File "${relativePath}" does not fetch dynamic i18n content for SEO rendering.`,
+      ).toBe(true);
+    });
+  });
+});

package/src/tests/tool_validation.test.ts

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

package/src/tests/translation_copy.test.ts

@@ -91,34 +91,33 @@ function copySimilarity(left: string, right: string): number {
   return (2 * shared) / (leftTotal + rightTotal);
 }
 
+async function loadLocaleCorpora(entry: typeof ALL_ENTRIES[number]): Promise<Map<string, string>> {
+  const corpora = new Map<string, string>();
+  for (const [locale, loader] of Object.entries(entry.i18n)) {
+    if (loader) corpora.set(locale, localeCorpus(await loader()));
+  }
+  return corpora;
+}
+
+function findCopyViolations(corpora: Map<string, string>): string[] {
+  const locales = [...corpora.keys()];
+  const violations: string[] = [];
+  for (let leftIndex = 0; leftIndex < locales.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < locales.length; rightIndex += 1) {
+      const left = locales[leftIndex] ?? '';
+      const right = locales[rightIndex] ?? '';
+      const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
+      if (similarity >= COPY_THRESHOLD) violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
+    }
+  }
+  return violations;
+}
+
 describe('Locales must not copy another locale wholesale', () => {
   ALL_ENTRIES.forEach((entry) => {
     it(`${entry.id} is not at least ${COPY_THRESHOLD * 100}% identical to another locale`, async () => {
-      const corpora = new Map<string, string>();
-
-      for (const [locale, loader] of Object.entries(entry.i18n)) {
-        if (!loader) continue;
-        corpora.set(locale, localeCorpus(await loader()));
-      }
-
-      const locales = [...corpora.keys()];
-      const violations: string[] = [];
-
-      for (let leftIndex = 0; leftIndex < locales.length; leftIndex += 1) {
-        for (let rightIndex = leftIndex + 1; rightIndex < locales.length; rightIndex += 1) {
-          const left = locales[leftIndex];
-          const right = locales[rightIndex];
-          const similarity = copySimilarity(corpora.get(left) ?? '', corpora.get(right) ?? '');
-
-          if (similarity >= COPY_THRESHOLD) {
-            violations.push(`${left} ↔ ${right}: ${(similarity * 100).toFixed(1)}%`);
-          }
-        }
-      }
-
+      const violations = findCopyViolations(await loadLocaleCorpora(entry));
       expect(violations, `Locale copy threshold exceeded in ${entry.id}`).toEqual([]);
     });
   });
 });
-
-

package/src/tool/bloodstain-pattern-origin-analyzer/component.astro

@@ -104,7 +104,7 @@ const { ui } = Astro.props;
 <template id="bpa-delete-icon">
   <Icon name="mdi:trash-can-outline" aria-hidden="true" />
 </template>
-<script id="bpa-ui" type="application/json" set:html={JSON.stringify(ui)}></script>
+<script is:inline id="bpa-ui" type="application/json" set:html={JSON.stringify(ui)}></script>
 
 <script>
   import * as THREE from 'three';
@@ -235,7 +235,7 @@ const { ui } = Astro.props;
   function syncFocusPanel() {
     const stain = selectedStain();
     if (!stain) return;
-    const color = palette[selectedIndex() % palette.length];
+    const color = palette[selectedIndex() % palette.length] ?? '#b3203f';
     if (focusNameEl) focusNameEl.textContent = `${ui.stainLabel} ${stain.id}`;
     if (focusSwatchEl) focusSwatchEl.style.background = color;
     configureFocusRanges();
@@ -251,13 +251,13 @@ const { ui } = Astro.props;
     const pointer = eventToSurface(event);
     if (!pointer) return null;
     let best: { stain: BloodstainInput; distance: number } | null = null;
-    stains.forEach((stain) => {
+    for (const stain of stains) {
       const point = stainScreenPoint(stain);
       const distance = Math.hypot(pointer.x - point.x, pointer.y - point.y);
       if (distance < 30 && (!best || distance < best.distance)) {
         best = { stain, distance };
       }
-    });
+    }
     return best?.stain ?? null;
   }
 
@@ -285,7 +285,7 @@ const { ui } = Astro.props;
   function clearDynamic3d() {
     for (let index = group.children.length - 1; index >= 0; index--) {
       const child = group.children[index];
-      if (child.userData.dynamic) group.remove(child);
+      if (child && child.userData.dynamic) group.remove(child);
     }
   }
 
@@ -356,7 +356,7 @@ const { ui } = Astro.props;
       const sx = cx + line.stain.xCm * scale;
       const sy = cy - line.stain.yCm * scale;
       const selected = line.stain.id === selectedStainId;
-      const color = palette[index % palette.length];
+      const color = palette[index % palette.length] ?? '#b3203f';
       ctx.globalAlpha = selected ? 0.22 : 0.1;
       ctx.strokeStyle = color;
       ctx.lineWidth = selected ? 3 : 2;
@@ -418,7 +418,7 @@ const { ui } = Astro.props;
     if (confidenceEl) confidenceEl.dataset.confidence = estimate.confidence;
     if (impactEl) impactEl.textContent = `${averageImpact.toFixed(1)} ${ui.degree}`;
     if (activeEl) activeEl.textContent = `${ui.stainLabel} ${selectedStainId}`;
-    if (activeDotEl) activeDotEl.style.background = palette[selectedIndex() % palette.length];
+    if (activeDotEl) activeDotEl.style.background = palette[selectedIndex() % palette.length] ?? '#b3203f';
     syncFocusPanel();
     drawSurface(estimate);
     render3d(estimate);
@@ -532,12 +532,12 @@ const { ui } = Astro.props;
     });
   });
 
-  renderer.domElement.addEventListener('pointerdown', (event) => {
+  renderer.domElement.addEventListener('pointerdown', (event: PointerEvent) => {
     dragging3d = true;
     lastX = event.clientX;
     renderer.domElement.setPointerCapture(event.pointerId);
   });
-  renderer.domElement.addEventListener('pointermove', (event) => {
+  renderer.domElement.addEventListener('pointermove', (event: PointerEvent) => {
     if (!dragging3d) return;
     group.rotation.z += (event.clientX - lastX) * 0.008;
     lastX = event.clientX;

package/src/tool/bloodstain-pattern-origin-analyzer/i18n/zh.ts

@@ -99,7 +99,7 @@ export const content: ToolLocaleContent = {
     { type: 'glossary', items: [
       { term: '撞击角度', definition: '血滴路径与承受体表面之间的估算角度，通常根据椭圆形血迹的宽长比计算。' },
       { term: '轨迹线', definition: '一条投影线，显示从血迹向三维空间反向延伸的可能飞行路径。' },
-      { term: '收敛区域', description: '在承受体平面上观察时，血迹方向交叉的大致区域。' },
+      { term: '收敛区域', definition: '在承受体平面上观察时，血迹方向交叉的大致区域。' },
       { term: '起点区域', definition: '根据多条投影轨迹确定的血液可能来源于的大致三维空间区域。' },
     ] },
     { type: 'summary', title: '最佳应用', items: [

package/src/tool/dna-profile-match-probability-lab/bibliography.astro

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

package/src/tool/dna-profile-match-probability-lab/bibliography.ts

@@ -0,0 +1,16 @@
+import type { BibliographyEntry } from '../../types';
+
+export const bibliography: BibliographyEntry[] = [
+  {
+    name: 'NIST STRBase: Hardy-Weinberg Equilibrium',
+    url: 'https://strbase.nist.gov/Educational_Resources/Mixtures/6-Forensic_DNA_Evidence_Interpretation/3-Hardy_Weinberg_Equilibrium.pdf',
+  },
+  {
+    name: 'ISFG DNA Commission: Recommendations on the interpretation of STR typing results',
+    url: 'https://pmc.ncbi.nlm.nih.gov/articles/PMC4689582/',
+  },
+  {
+    name: 'Ministerio del Interior: Supuesto de Biología',
+    url: 'https://www.interior.gob.es/opencms/pdf/servicios-al-ciudadano/empleo-publico/procesos-selectivos/personal-laboral/acceso-libre/grupos-profesionales-M3-M2-M1-E2-y-E1-de-la-subsecretaria-ministerio-del-interior/Supuesto_Biologia.pdf',
+  },
+];