eyecite-ts 0.3.0 → 0.5.0

package/README.md

@@ -9,19 +9,22 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.9-blue.svg)](https://www.typescriptlang.org/)
 [![Zero Dependencies](https://img.shields.io/badge/dependencies-0-brightgreen.svg)](https://www.npmjs.com/package/eyecite-ts)
 
-TypeScript legal citation extraction library — port of Python [eyecite](https://github.com/freelawproject/eyecite).
+TypeScript legal citation extraction library — inspired by and extending Python [eyecite](https://github.com/freelawproject/eyecite).
 
 Extract, resolve, and annotate legal citations from court opinions and legal documents with zero runtime dependencies.
 
 ## Features
 
-- **Full citation extraction**: Case citations, statutes, journal articles, neutral citations, public laws, federal register
+- **Full citation extraction**: Case citations, statutes (20 jurisdictions), journal articles, neutral citations, public laws, federal register
+- **Case name & full span**: Backward search extracts case names ("Smith v. Jones", "In re Smith"), `fullSpan` covers case name through closing parenthetical
+- **Parallel citation linking**: Automatic detection and grouping of comma-separated citations sharing a parenthetical (e.g., "410 U.S. 113, 93 S. Ct. 705 (1973)")
+- **Complex parentheticals**: Unified parser handles court+year, full dates (Jan. 15, 2020 / January 15, 2020 / 1/15/2020), disposition (en banc, per curiam), and chained parentheticals
 - **Short-form resolution**: Id./Ibid., supra, and short-form case citations resolved to their full antecedents
 - **Reporter database**: 1,200+ reporters with variant matching and confidence scoring
 - **Citation annotation**: HTML markup with auto-escape XSS protection and position tracking
 - **Bundle optimization**: Tree-shakeable exports, lazy-loaded reporter data, separate entry points
 - **TypeScript native**: Discriminated unions, conditional types, type guards, full IntelliSense
-- **Zero dependencies**: No runtime dependencies, 4.4KB gzipped core bundle
+- **Zero dependencies**: No runtime dependencies, ~10KB gzipped core bundle
 
 ## Installation
 
@@ -34,7 +37,7 @@ npm install eyecite-ts
 ```typescript
 import { extractCitations } from 'eyecite-ts'
 
-const text = 'See Smith v. Jones, 500 F.2d 123 (9th Cir. 2020)'
+const text = 'See Smith v. Jones, 500 F.2d 123 (9th Cir. Jan. 15, 2020)'
 const citations = extractCitations(text)
 
 console.log(citations[0])
@@ -45,8 +48,11 @@ console.log(citations[0])
 //   page: 123,
 //   court: '9th Cir.',
 //   year: 2020,
+//   caseName: 'Smith v. Jones',
+//   date: { iso: '2020-01-15', parsed: { year: 2020, month: 1, day: 15 } },
 //   confidence: 0.85,
-//   span: { originalStart: 4, originalEnd: 48, cleanStart: 4, cleanEnd: 48 }
+//   span: { originalStart: 20, originalEnd: 33, ... },
+//   fullSpan: { originalStart: 4, originalEnd: 57, ... }
 // }
 ```
 
@@ -69,6 +75,46 @@ citations.forEach(citation => {
 })
 ```
 
+### Statute Citations
+
+Extract citations from 20 state and federal jurisdictions with subsection, et seq., and jurisdiction identification:
+
+```typescript
+import { extractCitations } from 'eyecite-ts'
+
+const text = `
+  See 42 U.S.C. § 1983(a)(1) et seq.
+  Also Cal. Penal Code § 187.
+  And N.Y. Penal Law § 125.25(1)(a).
+  Compare 735 ILCS 5/2-1001.
+`
+const citations = extractCitations(text)
+
+// Federal with subsections + et seq.
+// { type: 'statute', title: 42, code: 'U.S.C.', section: '1983',
+//   subsection: '(a)(1)', jurisdiction: 'US', hasEtSeq: true, confidence: 1.0 }
+
+// California named-code
+// { type: 'statute', code: 'Penal', section: '187', jurisdiction: 'CA', confidence: 0.95 }
+
+// New York named-code with subsections
+// { type: 'statute', code: 'Penal Law', section: '125.25',
+//   subsection: '(1)(a)', jurisdiction: 'NY', confidence: 1.0 }
+
+// Illinois chapter-act format
+// { type: 'statute', title: 735, code: '5', section: '2-1001',
+//   jurisdiction: 'IL', confidence: 0.95 }
+```
+
+**Supported jurisdictions:**
+
+| Family | Jurisdictions |
+|--------|--------------|
+| Federal | USC, CFR, prose ("section X of title Y") |
+| Named-code | NY (21 laws), CA (29 codes), TX (29 codes), MD (36 articles), VA, AL, MA |
+| Abbreviated-code | FL, OH, MI, UT, CO, WA, NC, GA, PA, IN, NJ, DE |
+| Chapter-act | IL (ILCS) |
+
 ### Async API
 
 ```typescript
@@ -100,6 +146,97 @@ const citations = extractCitations(html, {
 })
 ```
 
+## Case Names & Full Spans
+
+Case citations can include the case name and full citation boundaries:
+
+```typescript
+const text = 'In Smith v. Jones, 500 F.2d 123 (9th Cir. 2020) (en banc), the court held...'
+const citations = extractCitations(text)
+
+if (citations[0].type === 'case') {
+  console.log(citations[0].caseName)     // 'Smith v. Jones'
+  console.log(citations[0].disposition)  // 'en banc'
+  console.log(citations[0].fullSpan)     // covers "Smith v. Jones, 500 F.2d 123 (9th Cir. 2020) (en banc)"
+  console.log(citations[0].span)         // covers "500 F.2d 123" only (citation core)
+}
+```
+
+Procedural prefixes are recognized automatically:
+
+```typescript
+const text = 'In re Smith, 410 U.S. 113 (1973)'
+// caseName: 'In re Smith'
+
+const text2 = 'Ex parte Young, 209 U.S. 123 (1908)'
+// caseName: 'Ex parte Young'
+```
+
+### Structured Dates
+
+Parentheticals with full dates return structured date objects:
+
+```typescript
+const text = '500 F.3d 100 (2d Cir. Jan. 15, 2020)'
+// date: { iso: '2020-01-15', parsed: { year: 2020, month: 1, day: 15 } }
+
+const text2 = '410 U.S. 113 (1973)'
+// date: { iso: '1973', parsed: { year: 1973 } }
+```
+
+Three date formats are supported: `Jan. 15, 2020`, `January 15, 2020`, and `1/15/2020`.
+
+### Blank Page Citations
+
+Citations can reference blank pages using placeholder notation:
+
+```typescript
+const text = '500 F.2d ___ (2020)'
+const citations = extractCitations(text)
+
+if (citations[0].type === 'case') {
+  console.log(citations[0].hasBlankPage)  // true
+  console.log(citations[0].page)          // undefined
+}
+```
+
+Both `___` (triple underscore) and `---` (triple dash) are recognized as blank page placeholders. These appear in slip opinions or unpublished decisions where the final reporter page number is not yet available.
+
+## Parallel Citations
+
+When multiple case citations share the same parenthetical, they represent parallel citations for the same case in different reporters. The library automatically detects and groups them:
+
+```typescript
+const text = 'See 410 U.S. 113, 93 S. Ct. 705, 35 L. Ed. 2d 147 (1973).'
+const citations = extractCitations(text)
+
+// Returns 3 citations, all linked by groupId
+console.log(citations[0].groupId)  // "410-U.S.-113"
+console.log(citations[1].groupId)  // "410-U.S.-113" (same group)
+console.log(citations[2].groupId)  // "410-U.S.-113" (same group)
+
+// Primary citation (first in group) has parallelCitations array
+if (citations[0].type === 'case') {
+  console.log(citations[0].parallelCitations)
+  // [
+  //   { volume: 93, reporter: 'S. Ct.', page: 705 },
+  //   { volume: 35, reporter: 'L. Ed. 2d', page: 147 }
+  // ]
+}
+
+// Secondary citations don't duplicate the array
+console.log(citations[1].parallelCitations)  // undefined
+console.log(citations[2].parallelCitations)  // undefined
+```
+
+**Key points:**
+- All citations in a parallel group share the same `groupId`
+- Only the **first citation** (primary) has the `parallelCitations` array
+- Secondary citations remain in the results array for individual processing
+- Group ID format: `${volume}-${reporter}-${page}` (e.g., "410-U.S.-113")
+
+Use `groupId` to identify which citations refer to the same case, or access `parallelCitations` on the primary to get all reporters at once.
+
 ## Resolving Short-Form Citations
 
 Short-form citations (Id., supra, short-form case) refer to earlier citations in the document. The resolution engine links them to their full antecedents.
@@ -221,6 +358,38 @@ const result = annotate(text, citations, {
 })
 ```
 
+### Annotating Full Spans
+
+By default, annotation wraps only the citation core (volume-reporter-page). Use `useFullSpan` to annotate from the case name through the closing parenthetical:
+
+```typescript
+const text = 'In Smith v. Jones, 500 F.2d 123 (9th Cir. 2020) (en banc), the court held...'
+const citations = extractCitations(text)
+
+// Default: annotates only "500 F.2d 123"
+const coreOnly = annotate(text, citations, {
+  template: { before: '<cite>', after: '</cite>' }
+})
+// Result: "In Smith v. Jones, <cite>500 F.2d 123</cite> (9th Cir. 2020) (en banc), the court held..."
+
+// With useFullSpan: annotates "Smith v. Jones, 500 F.2d 123 (9th Cir. 2020) (en banc)"
+const fullSpan = annotate(text, citations, {
+  template: { before: '<cite>', after: '</cite>' },
+  useFullSpan: true
+})
+// Result: "In <cite>Smith v. Jones, 500 F.2d 123 (9th Cir. 2020) (en banc)</cite>, the court held..."
+```
+
+Full span annotation covers:
+- Case name (if present)
+- Volume-reporter-page
+- Court and date parenthetical
+- Disposition parenthetical (en banc, per curiam)
+- Chained parentheticals
+- Subsequent history
+
+Use `useFullSpan: true` when you want to highlight the entire citation as a unit, or `useFullSpan: false` (default) to annotate only the citation core for minimal markup.
+
 ## Reporter Validation
 
 Validate case citations against the reporters database:
@@ -305,9 +474,9 @@ Three entry points for optimal tree-shaking:
 
 | Entry Point | Import | Gzipped |
 |------------|--------|---------|
-| Core extraction | `eyecite-ts` | 4.4 KB |
-| Annotation | `eyecite-ts/annotate` | 0.5 KB |
-| Reporter data | `eyecite-ts/data` | 88.5 KB (lazy-loaded) |
+| Core extraction | `eyecite-ts` | ~10 KB |
+| Annotation | `eyecite-ts/annotate` | 0.7 KB |
+| Reporter data | `eyecite-ts/data` | 86.5 KB (lazy-loaded) |
 
 ```typescript
 import { extractCitations } from 'eyecite-ts'           // Core only
@@ -340,7 +509,7 @@ pnpm lint            # Lint with Biome
 pnpm format          # Format with Biome
 ```
 
-304 tests, 97% statement coverage, 91% branch coverage.
+985+ tests across 32 test files.
 
 ## License
 
@@ -348,4 +517,4 @@ MIT
 
 ## Credits
 
-Ported from [eyecite](https://github.com/freelawproject/eyecite) (Python) by Free Law Project.
+Inspired by [eyecite](https://github.com/freelawproject/eyecite) (Python) by Free Law Project. This TypeScript implementation adds parallel citation linking, party name extraction, full span tracking, and performance optimizations while maintaining compatibility with the original API design.

package/dist/annotate/index.cjs

@@ -1,2 +1,2 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,t,i={}){let{useCleanText:a=!1,autoEscape:o=!0,template:s,callback:c}=i,l=[...t].sort((e,t)=>{let n=a?e.span.cleanStart:e.span.originalStart;return(a?t.span.cleanStart:t.span.originalStart)-n}),u=e,d=new Map,f=[];for(let t of l){let i=a?t.span.cleanStart:t.span.originalStart,l=a?t.span.cleanEnd:t.span.originalEnd;if(!a){let e=n(u,i,l);if(e===null){f.push(t);continue}i=e.start,l=e.end}let p=``;if(c)p=c(t,e.substring(Math.max(0,i-30),Math.min(e.length,l+30)));else if(s){let e=u.substring(i,l),t=o?r(e):e;p=s.before+t+s.after}else continue;u=u.slice(0,i)+p+u.slice(l),d.set(i,i)}return{text:u,positionMap:d,skipped:f}}function t(e,t){let n=t-1;for(;n>=0;){if(e[n]===`>`)return null;if(e[n]===`<`){let r=t;for(;r<e.length;){if(e[r]===`>`)return{tagStart:n,tagEnd:r+1};r++}return{tagStart:n,tagEnd:e.length}}n--}return null}function n(e,n,r){let i=n,a=r,o=t(e,n);o&&(i=o.tagStart);let s=t(e,r);return s&&(a=s.tagEnd),i>=a?null:{start:i,end:a}}function r(e){let t={"&":`&amp;`,"<":`&lt;`,">":`&gt;`,'"':`&quot;`,"'":`&#39;`,"/":`&#x2F;`};return e.replace(/[&<>"'/]/g,e=>t[e])}exports.annotate=e;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e,t,i={}){let{useCleanText:a=!1,autoEscape:o=!0,useFullSpan:s=!1,template:c,callback:l}=i,u=[...t].sort((e,t)=>{let n=a?e.span.cleanStart:e.span.originalStart;return(a?t.span.cleanStart:t.span.originalStart)-n}),d=e,f=new Map,p=[];for(let t of u){let i,u;if(s&&`fullSpan`in t&&t.fullSpan?(i=a?t.fullSpan.cleanStart:t.fullSpan.originalStart,u=a?t.fullSpan.cleanEnd:t.fullSpan.originalEnd):(i=a?t.span.cleanStart:t.span.originalStart,u=a?t.span.cleanEnd:t.span.originalEnd),!a){let e=n(d,i,u);if(e===null){p.push(t);continue}i=e.start,u=e.end}let m=``;if(l)m=l(t,e.substring(Math.max(0,i-30),Math.min(e.length,u+30)));else if(c){let e=d.substring(i,u),t=o?r(e):e;m=c.before+t+c.after}else continue;d=d.slice(0,i)+m+d.slice(u),f.set(i,i)}return{text:d,positionMap:f,skipped:p}}function t(e,t){let n=t-1;for(;n>=0;){if(e[n]===`>`)return null;if(e[n]===`<`){let r=t;for(;r<e.length;){if(e[r]===`>`)return{tagStart:n,tagEnd:r+1};r++}return{tagStart:n,tagEnd:e.length}}n--}return null}function n(e,n,r){let i=n,a=r,o=t(e,n);o&&(i=o.tagStart);let s=t(e,r);return s&&(a=s.tagEnd),i>=a?null:{start:i,end:a}}function r(e){let t={"&":`&amp;`,"<":`&lt;`,">":`&gt;`,'"':`&quot;`,"'":`&#39;`,"/":`&#x2F;`};return e.replace(/[&<>"'/]/g,e=>t[e])}exports.annotate=e;
 //# sourceMappingURL=index.cjs.map

package/dist/annotate/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":[],"sources":["../../src/annotate/annotate.ts"],"sourcesContent":["import type { Citation } from '../types/citation'\nimport type { AnnotationOptions, AnnotationResult } from './types'\n\n/**\n * Annotate citations in text with custom markup.\n *\n * Supports two modes:\n * - **Template mode**: Simple before/after wrapping (set `options.template`)\n * - **Callback mode**: Custom logic with full citation context (set `options.callback`)\n *\n * Citations are processed in reverse order to avoid position shifts invalidating\n * subsequent annotations. Position tracking maps original positions to new positions\n * after markup insertion.\n *\n * @param text - Original or cleaned text to annotate\n * @param citations - Citations to mark up (from extraction pipeline)\n * @param options - Annotation configuration\n * @returns Annotated text with position mapping\n *\n * @example Template mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   template: { before: '<cite>', after: '</cite>' }\n * })\n * // Result: \"See <cite>500 F.2d 123</cite>\"\n * ```\n *\n * @example Callback mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   callback: (citation) => {\n *     if (citation.type === 'case') {\n *       return `<a href=\"/cases/${citation.volume}\">${citation.matchedText}</a>`\n *     }\n *     return citation.matchedText\n *   }\n * })\n * ```\n *\n * @example Position tracking\n * ```typescript\n * const result = annotate(text, citations, { template: { before: '<mark>', after: '</mark>' } })\n * // result.positionMap tracks how positions shifted\n * const originalPos = 10\n * const newPos = result.positionMap.get(originalPos)\n * ```\n */\nexport function annotate<C extends Citation = Citation>(\n  text: string,\n  citations: C[],\n  options: AnnotationOptions<C> = {}\n): AnnotationResult {\n  const {\n    useCleanText = false,\n    autoEscape = true,  // Secure by default\n    template,\n    callback,\n  } = options\n\n  // Sort reverse to avoid position shifts invalidating subsequent annotations\n  const sorted = [...citations].sort((a, b) => {\n    const aPos = useCleanText ? a.span.cleanStart : a.span.originalStart\n    const bPos = useCleanText ? b.span.cleanStart : b.span.originalStart\n    return bPos - aPos  // Reverse for backward iteration\n  })\n\n  let result = text\n  const positionMap = new Map<number, number>()\n  const skipped: Citation[] = []\n\n  for (const citation of sorted) {\n    let start = useCleanText ? citation.span.cleanStart : citation.span.originalStart\n    let end = useCleanText ? citation.span.cleanEnd : citation.span.originalEnd\n\n    // Snap positions out of HTML tags when annotating original text\n    if (!useCleanText) {\n      const snapped = snapOutOfHtmlTags(result, start, end)\n      if (snapped === null) {\n        // Could not safely snap — skip this citation\n        skipped.push(citation)\n        continue\n      }\n      start = snapped.start\n      end = snapped.end\n    }\n\n    let markup = ''\n\n    if (callback) {\n      // Callback mode: developer provides full logic\n      const surrounding = text.substring(\n        Math.max(0, start - 30),\n        Math.min(text.length, end + 30)\n      )\n      markup = callback(citation, surrounding)\n    } else if (template) {\n      // Template mode: simple before/after wrapping\n      const citationText = result.substring(start, end)\n      const escaped = autoEscape ? escapeHtmlEntities(citationText) : citationText\n      markup = template.before + escaped + template.after\n    } else {\n      // No annotation specified\n      continue\n    }\n\n    // Insert annotation (working backwards preserves positions for later citations)\n    result = result.slice(0, start) + markup + result.slice(end)\n\n    // Track original position to new position (before this annotation was added)\n    positionMap.set(start, start)\n  }\n\n  return { text: result, positionMap, skipped }\n}\n\n/**\n * Check if a position falls inside an HTML tag (between `<` and `>`).\n * Returns the index of the opening `<` if inside a tag, otherwise -1.\n */\nfunction findContainingTag(text: string, pos: number): { tagStart: number; tagEnd: number } | null {\n  // Search backwards from pos for '<' without encountering '>' first\n  let i = pos - 1\n  while (i >= 0) {\n    if (text[i] === '>') return null  // Hit a tag close — we're outside\n    if (text[i] === '<') {\n      // Found opening '<' — now find the closing '>'\n      let j = pos\n      while (j < text.length) {\n        if (text[j] === '>') return { tagStart: i, tagEnd: j + 1 }\n        j++\n      }\n      // Unclosed tag — treat as inside\n      return { tagStart: i, tagEnd: text.length }\n    }\n    i--\n  }\n  return null\n}\n\n/**\n * Snap annotation start/end positions to avoid landing inside HTML tags.\n *\n * If a position falls inside an HTML tag, it is moved:\n * - Start position: snapped to before the tag's `<`\n * - End position: snapped to after the tag's `>`\n *\n * Returns null if the positions can't be safely adjusted (e.g., entirely\n * within a single tag).\n */\nfunction snapOutOfHtmlTags(\n  text: string,\n  start: number,\n  end: number,\n): { start: number; end: number } | null {\n  let snappedStart = start\n  let snappedEnd = end\n\n  const startTag = findContainingTag(text, start)\n  if (startTag) {\n    snappedStart = startTag.tagStart\n  }\n\n  const endTag = findContainingTag(text, end)\n  if (endTag) {\n    snappedEnd = endTag.tagEnd\n  }\n\n  // Sanity check: start must come before end\n  if (snappedStart >= snappedEnd) return null\n\n  return { start: snappedStart, end: snappedEnd }\n}\n\n/**\n * Escape HTML entities to prevent XSS injection.\n *\n * Converts special HTML characters to their entity equivalents:\n * - `&` → `&amp;`\n * - `<` → `&lt;`\n * - `>` → `&gt;`\n * - `\"` → `&quot;`\n * - `'` → `&#39;`\n * - `/` → `&#x2F;`\n *\n * @param text - Text to escape\n * @returns Escaped text safe for HTML insertion\n */\nfunction escapeHtmlEntities(text: string): string {\n  const map: Record<string, string> = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    '/': '&#x2F;',\n  }\n  return text.replace(/[&<>\"'/]/g, (char) => map[char])\n}\n"],"mappings":"mEA+CA,SAAgB,EACd,EACA,EACA,EAAgC,EAAE,CAChB,CAClB,GAAM,CACJ,eAAe,GACf,aAAa,GACb,WACA,YACE,EAGE,EAAS,CAAC,GAAG,EAAU,CAAC,MAAM,EAAG,IAAM,CAC3C,IAAM,EAAO,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,cAEvD,OADa,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,eACzC,GACd,CAEE,EAAS,EACP,EAAc,IAAI,IAClB,EAAsB,EAAE,CAE9B,IAAK,IAAM,KAAY,EAAQ,CAC7B,IAAI,EAAQ,EAAe,EAAS,KAAK,WAAa,EAAS,KAAK,cAChE,EAAM,EAAe,EAAS,KAAK,SAAW,EAAS,KAAK,YAGhE,GAAI,CAAC,EAAc,CACjB,IAAM,EAAU,EAAkB,EAAQ,EAAO,EAAI,CACrD,GAAI,IAAY,KAAM,CAEpB,EAAQ,KAAK,EAAS,CACtB,SAEF,EAAQ,EAAQ,MAChB,EAAM,EAAQ,IAGhB,IAAI,EAAS,GAEb,GAAI,EAMF,EAAS,EAAS,EAJE,EAAK,UACvB,KAAK,IAAI,EAAG,EAAQ,GAAG,CACvB,KAAK,IAAI,EAAK,OAAQ,EAAM,GAAG,CAChC,CACuC,SAC/B,EAAU,CAEnB,IAAM,EAAe,EAAO,UAAU,EAAO,EAAI,CAC3C,EAAU,EAAa,EAAmB,EAAa,CAAG,EAChE,EAAS,EAAS,OAAS,EAAU,EAAS,WAG9C,SAIF,EAAS,EAAO,MAAM,EAAG,EAAM,CAAG,EAAS,EAAO,MAAM,EAAI,CAG5D,EAAY,IAAI,EAAO,EAAM,CAG/B,MAAO,CAAE,KAAM,EAAQ,cAAa,UAAS,CAO/C,SAAS,EAAkB,EAAc,EAA0D,CAEjG,IAAI,EAAI,EAAM,EACd,KAAO,GAAK,GAAG,CACb,GAAI,EAAK,KAAO,IAAK,OAAO,KAC5B,GAAI,EAAK,KAAO,IAAK,CAEnB,IAAI,EAAI,EACR,KAAO,EAAI,EAAK,QAAQ,CACtB,GAAI,EAAK,KAAO,IAAK,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAI,EAAG,CAC1D,IAGF,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAK,OAAQ,CAE7C,IAEF,OAAO,KAaT,SAAS,EACP,EACA,EACA,EACuC,CACvC,IAAI,EAAe,EACf,EAAa,EAEX,EAAW,EAAkB,EAAM,EAAM,CAC3C,IACF,EAAe,EAAS,UAG1B,IAAM,EAAS,EAAkB,EAAM,EAAI,CAQ3C,OAPI,IACF,EAAa,EAAO,QAIlB,GAAgB,EAAmB,KAEhC,CAAE,MAAO,EAAc,IAAK,EAAY,CAiBjD,SAAS,EAAmB,EAAsB,CAChD,IAAM,EAA8B,CAClC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,QACL,IAAK,SACN,CACD,OAAO,EAAK,QAAQ,YAAc,GAAS,EAAI,GAAM"}
+{"version":3,"file":"index.cjs","names":[],"sources":["../../src/annotate/annotate.ts"],"sourcesContent":["import type { Citation } from '../types/citation'\nimport type { AnnotationOptions, AnnotationResult } from './types'\n\n/**\n * Annotate citations in text with custom markup.\n *\n * Supports two modes:\n * - **Template mode**: Simple before/after wrapping (set `options.template`)\n * - **Callback mode**: Custom logic with full citation context (set `options.callback`)\n *\n * Citations are processed in reverse order to avoid position shifts invalidating\n * subsequent annotations. Position tracking maps original positions to new positions\n * after markup insertion.\n *\n * @param text - Original or cleaned text to annotate\n * @param citations - Citations to mark up (from extraction pipeline)\n * @param options - Annotation configuration\n * @returns Annotated text with position mapping\n *\n * @example Template mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   template: { before: '<cite>', after: '</cite>' }\n * })\n * // Result: \"See <cite>500 F.2d 123</cite>\"\n * ```\n *\n * @example Callback mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   callback: (citation) => {\n *     if (citation.type === 'case') {\n *       return `<a href=\"/cases/${citation.volume}\">${citation.matchedText}</a>`\n *     }\n *     return citation.matchedText\n *   }\n * })\n * ```\n *\n * @example Position tracking\n * ```typescript\n * const result = annotate(text, citations, { template: { before: '<mark>', after: '</mark>' } })\n * // result.positionMap tracks how positions shifted\n * const originalPos = 10\n * const newPos = result.positionMap.get(originalPos)\n * ```\n */\nexport function annotate<C extends Citation = Citation>(\n  text: string,\n  citations: C[],\n  options: AnnotationOptions<C> = {}\n): AnnotationResult {\n  const {\n    useCleanText = false,\n    autoEscape = true,  // Secure by default\n    useFullSpan = false,  // Backward compatible default\n    template,\n    callback,\n  } = options\n\n  // Sort reverse to avoid position shifts invalidating subsequent annotations\n  const sorted = [...citations].sort((a, b) => {\n    const aPos = useCleanText ? a.span.cleanStart : a.span.originalStart\n    const bPos = useCleanText ? b.span.cleanStart : b.span.originalStart\n    return bPos - aPos  // Reverse for backward iteration\n  })\n\n  let result = text\n  const positionMap = new Map<number, number>()\n  const skipped: Citation[] = []\n\n  for (const citation of sorted) {\n    // Determine which span to use\n    let start: number\n    let end: number\n\n    if (useFullSpan && 'fullSpan' in citation && citation.fullSpan) {\n      // Full span mode: case name through parenthetical\n      start = useCleanText ? citation.fullSpan.cleanStart : citation.fullSpan.originalStart\n      end = useCleanText ? citation.fullSpan.cleanEnd : citation.fullSpan.originalEnd\n    } else {\n      // Default mode: core citation only\n      start = useCleanText ? citation.span.cleanStart : citation.span.originalStart\n      end = useCleanText ? citation.span.cleanEnd : citation.span.originalEnd\n    }\n\n    // Snap positions out of HTML tags when annotating original text\n    if (!useCleanText) {\n      const snapped = snapOutOfHtmlTags(result, start, end)\n      if (snapped === null) {\n        // Could not safely snap — skip this citation\n        skipped.push(citation)\n        continue\n      }\n      start = snapped.start\n      end = snapped.end\n    }\n\n    let markup = ''\n\n    if (callback) {\n      // Callback mode: developer provides full logic\n      const surrounding = text.substring(\n        Math.max(0, start - 30),\n        Math.min(text.length, end + 30)\n      )\n      markup = callback(citation, surrounding)\n    } else if (template) {\n      // Template mode: simple before/after wrapping\n      const citationText = result.substring(start, end)\n      const escaped = autoEscape ? escapeHtmlEntities(citationText) : citationText\n      markup = template.before + escaped + template.after\n    } else {\n      // No annotation specified\n      continue\n    }\n\n    // Insert annotation (working backwards preserves positions for later citations)\n    result = result.slice(0, start) + markup + result.slice(end)\n\n    // Track original position to new position (before this annotation was added)\n    positionMap.set(start, start)\n  }\n\n  return { text: result, positionMap, skipped }\n}\n\n/**\n * Check if a position falls inside an HTML tag (between `<` and `>`).\n * Returns the index of the opening `<` if inside a tag, otherwise -1.\n */\nfunction findContainingTag(text: string, pos: number): { tagStart: number; tagEnd: number } | null {\n  // Search backwards from pos for '<' without encountering '>' first\n  let i = pos - 1\n  while (i >= 0) {\n    if (text[i] === '>') return null  // Hit a tag close — we're outside\n    if (text[i] === '<') {\n      // Found opening '<' — now find the closing '>'\n      let j = pos\n      while (j < text.length) {\n        if (text[j] === '>') return { tagStart: i, tagEnd: j + 1 }\n        j++\n      }\n      // Unclosed tag — treat as inside\n      return { tagStart: i, tagEnd: text.length }\n    }\n    i--\n  }\n  return null\n}\n\n/**\n * Snap annotation start/end positions to avoid landing inside HTML tags.\n *\n * If a position falls inside an HTML tag, it is moved:\n * - Start position: snapped to before the tag's `<`\n * - End position: snapped to after the tag's `>`\n *\n * Returns null if the positions can't be safely adjusted (e.g., entirely\n * within a single tag).\n */\nfunction snapOutOfHtmlTags(\n  text: string,\n  start: number,\n  end: number,\n): { start: number; end: number } | null {\n  let snappedStart = start\n  let snappedEnd = end\n\n  const startTag = findContainingTag(text, start)\n  if (startTag) {\n    snappedStart = startTag.tagStart\n  }\n\n  const endTag = findContainingTag(text, end)\n  if (endTag) {\n    snappedEnd = endTag.tagEnd\n  }\n\n  // Sanity check: start must come before end\n  if (snappedStart >= snappedEnd) return null\n\n  return { start: snappedStart, end: snappedEnd }\n}\n\n/**\n * Escape HTML entities to prevent XSS injection.\n *\n * Converts special HTML characters to their entity equivalents:\n * - `&` → `&amp;`\n * - `<` → `&lt;`\n * - `>` → `&gt;`\n * - `\"` → `&quot;`\n * - `'` → `&#39;`\n * - `/` → `&#x2F;`\n *\n * @param text - Text to escape\n * @returns Escaped text safe for HTML insertion\n */\nfunction escapeHtmlEntities(text: string): string {\n  const map: Record<string, string> = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    '/': '&#x2F;',\n  }\n  return text.replace(/[&<>\"'/]/g, (char) => map[char])\n}\n"],"mappings":"mEA+CA,SAAgB,EACd,EACA,EACA,EAAgC,EAAE,CAChB,CAClB,GAAM,CACJ,eAAe,GACf,aAAa,GACb,cAAc,GACd,WACA,YACE,EAGE,EAAS,CAAC,GAAG,EAAU,CAAC,MAAM,EAAG,IAAM,CAC3C,IAAM,EAAO,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,cAEvD,OADa,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,eACzC,GACd,CAEE,EAAS,EACP,EAAc,IAAI,IAClB,EAAsB,EAAE,CAE9B,IAAK,IAAM,KAAY,EAAQ,CAE7B,IAAI,EACA,EAaJ,GAXI,GAAe,aAAc,GAAY,EAAS,UAEpD,EAAQ,EAAe,EAAS,SAAS,WAAa,EAAS,SAAS,cACxE,EAAM,EAAe,EAAS,SAAS,SAAW,EAAS,SAAS,cAGpE,EAAQ,EAAe,EAAS,KAAK,WAAa,EAAS,KAAK,cAChE,EAAM,EAAe,EAAS,KAAK,SAAW,EAAS,KAAK,aAI1D,CAAC,EAAc,CACjB,IAAM,EAAU,EAAkB,EAAQ,EAAO,EAAI,CACrD,GAAI,IAAY,KAAM,CAEpB,EAAQ,KAAK,EAAS,CACtB,SAEF,EAAQ,EAAQ,MAChB,EAAM,EAAQ,IAGhB,IAAI,EAAS,GAEb,GAAI,EAMF,EAAS,EAAS,EAJE,EAAK,UACvB,KAAK,IAAI,EAAG,EAAQ,GAAG,CACvB,KAAK,IAAI,EAAK,OAAQ,EAAM,GAAG,CAChC,CACuC,SAC/B,EAAU,CAEnB,IAAM,EAAe,EAAO,UAAU,EAAO,EAAI,CAC3C,EAAU,EAAa,EAAmB,EAAa,CAAG,EAChE,EAAS,EAAS,OAAS,EAAU,EAAS,WAG9C,SAIF,EAAS,EAAO,MAAM,EAAG,EAAM,CAAG,EAAS,EAAO,MAAM,EAAI,CAG5D,EAAY,IAAI,EAAO,EAAM,CAG/B,MAAO,CAAE,KAAM,EAAQ,cAAa,UAAS,CAO/C,SAAS,EAAkB,EAAc,EAA0D,CAEjG,IAAI,EAAI,EAAM,EACd,KAAO,GAAK,GAAG,CACb,GAAI,EAAK,KAAO,IAAK,OAAO,KAC5B,GAAI,EAAK,KAAO,IAAK,CAEnB,IAAI,EAAI,EACR,KAAO,EAAI,EAAK,QAAQ,CACtB,GAAI,EAAK,KAAO,IAAK,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAI,EAAG,CAC1D,IAGF,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAK,OAAQ,CAE7C,IAEF,OAAO,KAaT,SAAS,EACP,EACA,EACA,EACuC,CACvC,IAAI,EAAe,EACf,EAAa,EAEX,EAAW,EAAkB,EAAM,EAAM,CAC3C,IACF,EAAe,EAAS,UAG1B,IAAM,EAAS,EAAkB,EAAM,EAAI,CAQ3C,OAPI,IACF,EAAa,EAAO,QAIlB,GAAgB,EAAmB,KAEhC,CAAE,MAAO,EAAc,IAAK,EAAY,CAiBjD,SAAS,EAAmB,EAAsB,CAChD,IAAM,EAA8B,CAClC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,QACL,IAAK,SACN,CACD,OAAO,EAAK,QAAQ,YAAc,GAAS,EAAI,GAAM"}

package/dist/annotate/index.d.cts

@@ -1,4 +1,4 @@
-import { t as Citation } from "../citation-qKSc_Myj.cjs";
+import { t as Citation } from "../citation-Cymq3pJ-.cjs";
 
 //#region src/annotate/types.d.ts
 /**
@@ -56,6 +56,19 @@ interface AnnotationOptions<C extends Citation = Citation> {
   */
   autoEscape?: boolean;
   /**
+  * Use full citation span from case name through parenthetical (true) or core citation only (false).
+  *
+  * When enabled and citation has a fullSpan field (from Phase 6+), annotation will span:
+  * - Case name: "Smith v. Jones"
+  * - Reporter: "500 F.2d 123"
+  * - Parenthetical: "(9th Cir. 1974)"
+  *
+  * When disabled or fullSpan unavailable, falls back to core citation span (volume-reporter-page).
+  *
+  * @default false (backward compatible)
+  */
+  useFullSpan?: boolean;
+  /**
   * Callback for custom annotation logic.
   *
   * Receives each citation and surrounding context (±30 characters),

package/dist/annotate/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/annotate/types.ts","../../src/annotate/annotate.ts"],"mappings":";;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;AAoEA;;UApEiB,iBAAA,WAA4B,QAAA,GAAW,QAAA;EA0F7C;;;;;;;;EAjFT,YAAA;;;ACUF;;;;;;;;;;;;;;;EDSE,UAAA;;;;;;;;;;;EAYA,QAAA,IAAY,QAAA,EAAU,CAAA,EAAG,WAAA;;;;;;;;;;;;;;;;EAiBzB,QAAA;+CAEE,MAAA;IAEA,KAAA;EAAA;AAAA;;;;UAOa,gBAAA;;;;EAIf,IAAA;;;;;;;;;EAUA,WAAA,EAAa,GAAA;;;;;;;EAQb,OAAA,EAAS,QAAA;AAAA;;;;AA1FX;;;;;;;;;;;;;;;;;;;;;;AAoEA;;;;;;;;;;;;;;ACjDA;;;;;;;iBAAgB,QAAA,WAAmB,QAAA,GAAW,QAAA,CAAA,CAC5C,IAAA,UACA,SAAA,EAAW,CAAA,IACX,OAAA,GAAS,iBAAA,CAAkB,CAAA,IAC1B,gBAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/annotate/types.ts","../../src/annotate/annotate.ts"],"mappings":";;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;AAkFA;UAlFiB,iBAAA,WAA4B,QAAA,GAAW,QAAA;;;;;;;;;EAStD,YAAA;;;;ACUF;;;;;;;;;;;;;;EDSE,UAAA;;;;;;;;;;;;;EAcA,WAAA;;;;;;;;;;;EAYA,QAAA,IAAY,QAAA,EAAU,CAAA,EAAG,WAAA;;;;;;;;;;;;;;;;EAiBzB,QAAA;+CAEE,MAAA;IAEA,KAAA;EAAA;AAAA;;;;UAOa,gBAAA;;;;EAIf,IAAA;;;;;;;;;EAUA,WAAA,EAAa,GAAA;;;;;;;EAQb,OAAA,EAAS,QAAA;AAAA;;;;AAxGX;;;;;;;;;;;;;;;;;;;;;;;AAkFA;;;;;;;;;;;;;;AC/DA;;;;;;iBAAgB,QAAA,WAAmB,QAAA,GAAW,QAAA,CAAA,CAC5C,IAAA,UACA,SAAA,EAAW,CAAA,IACX,OAAA,GAAS,iBAAA,CAAkB,CAAA,IAC1B,gBAAA"}

package/dist/annotate/index.d.mts

@@ -1,4 +1,4 @@
-import { t as Citation } from "../citation-DAyM8kNA.mjs";
+import { t as Citation } from "../citation-25ZydLsu.mjs";
 
 //#region src/annotate/types.d.ts
 /**
@@ -56,6 +56,19 @@ interface AnnotationOptions<C extends Citation = Citation> {
   */
   autoEscape?: boolean;
   /**
+  * Use full citation span from case name through parenthetical (true) or core citation only (false).
+  *
+  * When enabled and citation has a fullSpan field (from Phase 6+), annotation will span:
+  * - Case name: "Smith v. Jones"
+  * - Reporter: "500 F.2d 123"
+  * - Parenthetical: "(9th Cir. 1974)"
+  *
+  * When disabled or fullSpan unavailable, falls back to core citation span (volume-reporter-page).
+  *
+  * @default false (backward compatible)
+  */
+  useFullSpan?: boolean;
+  /**
   * Callback for custom annotation logic.
   *
   * Receives each citation and surrounding context (±30 characters),

package/dist/annotate/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/annotate/types.ts","../../src/annotate/annotate.ts"],"mappings":";;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;AAoEA;;UApEiB,iBAAA,WAA4B,QAAA,GAAW,QAAA;EA0F7C;;;;;;;;EAjFT,YAAA;;;ACUF;;;;;;;;;;;;;;;EDSE,UAAA;;;;;;;;;;;EAYA,QAAA,IAAY,QAAA,EAAU,CAAA,EAAG,WAAA;;;;;;;;;;;;;;;;EAiBzB,QAAA;+CAEE,MAAA;IAEA,KAAA;EAAA;AAAA;;;;UAOa,gBAAA;;;;EAIf,IAAA;;;;;;;;;EAUA,WAAA,EAAa,GAAA;;;;;;;EAQb,OAAA,EAAS,QAAA;AAAA;;;;AA1FX;;;;;;;;;;;;;;;;;;;;;;AAoEA;;;;;;;;;;;;;;ACjDA;;;;;;;iBAAgB,QAAA,WAAmB,QAAA,GAAW,QAAA,CAAA,CAC5C,IAAA,UACA,SAAA,EAAW,CAAA,IACX,OAAA,GAAS,iBAAA,CAAkB,CAAA,IAC1B,gBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/annotate/types.ts","../../src/annotate/annotate.ts"],"mappings":";;;;;AA4BA;;;;;;;;;;;;;;;;;;;;;;;AAkFA;UAlFiB,iBAAA,WAA4B,QAAA,GAAW,QAAA;;;;;;;;;EAStD,YAAA;;;;ACUF;;;;;;;;;;;;;;EDSE,UAAA;;;;;;;;;;;;;EAcA,WAAA;;;;;;;;;;;EAYA,QAAA,IAAY,QAAA,EAAU,CAAA,EAAG,WAAA;;;;;;;;;;;;;;;;EAiBzB,QAAA;+CAEE,MAAA;IAEA,KAAA;EAAA;AAAA;;;;UAOa,gBAAA;;;;EAIf,IAAA;;;;;;;;;EAUA,WAAA,EAAa,GAAA;;;;;;;EAQb,OAAA,EAAS,QAAA;AAAA;;;;AAxGX;;;;;;;;;;;;;;;;;;;;;;;AAkFA;;;;;;;;;;;;;;AC/DA;;;;;;iBAAgB,QAAA,WAAmB,QAAA,GAAW,QAAA,CAAA,CAC5C,IAAA,UACA,SAAA,EAAW,CAAA,IACX,OAAA,GAAS,iBAAA,CAAkB,CAAA,IAC1B,gBAAA"}

package/dist/annotate/index.mjs

@@ -1,2 +1,2 @@
-function e(e,t,i={}){let{useCleanText:a=!1,autoEscape:o=!0,template:s,callback:c}=i,l=[...t].sort((e,t)=>{let n=a?e.span.cleanStart:e.span.originalStart;return(a?t.span.cleanStart:t.span.originalStart)-n}),u=e,d=new Map,f=[];for(let t of l){let i=a?t.span.cleanStart:t.span.originalStart,l=a?t.span.cleanEnd:t.span.originalEnd;if(!a){let e=n(u,i,l);if(e===null){f.push(t);continue}i=e.start,l=e.end}let p=``;if(c)p=c(t,e.substring(Math.max(0,i-30),Math.min(e.length,l+30)));else if(s){let e=u.substring(i,l),t=o?r(e):e;p=s.before+t+s.after}else continue;u=u.slice(0,i)+p+u.slice(l),d.set(i,i)}return{text:u,positionMap:d,skipped:f}}function t(e,t){let n=t-1;for(;n>=0;){if(e[n]===`>`)return null;if(e[n]===`<`){let r=t;for(;r<e.length;){if(e[r]===`>`)return{tagStart:n,tagEnd:r+1};r++}return{tagStart:n,tagEnd:e.length}}n--}return null}function n(e,n,r){let i=n,a=r,o=t(e,n);o&&(i=o.tagStart);let s=t(e,r);return s&&(a=s.tagEnd),i>=a?null:{start:i,end:a}}function r(e){let t={"&":`&amp;`,"<":`&lt;`,">":`&gt;`,'"':`&quot;`,"'":`&#39;`,"/":`&#x2F;`};return e.replace(/[&<>"'/]/g,e=>t[e])}export{e as annotate};
+function e(e,t,i={}){let{useCleanText:a=!1,autoEscape:o=!0,useFullSpan:s=!1,template:c,callback:l}=i,u=[...t].sort((e,t)=>{let n=a?e.span.cleanStart:e.span.originalStart;return(a?t.span.cleanStart:t.span.originalStart)-n}),d=e,f=new Map,p=[];for(let t of u){let i,u;if(s&&`fullSpan`in t&&t.fullSpan?(i=a?t.fullSpan.cleanStart:t.fullSpan.originalStart,u=a?t.fullSpan.cleanEnd:t.fullSpan.originalEnd):(i=a?t.span.cleanStart:t.span.originalStart,u=a?t.span.cleanEnd:t.span.originalEnd),!a){let e=n(d,i,u);if(e===null){p.push(t);continue}i=e.start,u=e.end}let m=``;if(l)m=l(t,e.substring(Math.max(0,i-30),Math.min(e.length,u+30)));else if(c){let e=d.substring(i,u),t=o?r(e):e;m=c.before+t+c.after}else continue;d=d.slice(0,i)+m+d.slice(u),f.set(i,i)}return{text:d,positionMap:f,skipped:p}}function t(e,t){let n=t-1;for(;n>=0;){if(e[n]===`>`)return null;if(e[n]===`<`){let r=t;for(;r<e.length;){if(e[r]===`>`)return{tagStart:n,tagEnd:r+1};r++}return{tagStart:n,tagEnd:e.length}}n--}return null}function n(e,n,r){let i=n,a=r,o=t(e,n);o&&(i=o.tagStart);let s=t(e,r);return s&&(a=s.tagEnd),i>=a?null:{start:i,end:a}}function r(e){let t={"&":`&amp;`,"<":`&lt;`,">":`&gt;`,'"':`&quot;`,"'":`&#39;`,"/":`&#x2F;`};return e.replace(/[&<>"'/]/g,e=>t[e])}export{e as annotate};
 //# sourceMappingURL=index.mjs.map

package/dist/annotate/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../../src/annotate/annotate.ts"],"sourcesContent":["import type { Citation } from '../types/citation'\nimport type { AnnotationOptions, AnnotationResult } from './types'\n\n/**\n * Annotate citations in text with custom markup.\n *\n * Supports two modes:\n * - **Template mode**: Simple before/after wrapping (set `options.template`)\n * - **Callback mode**: Custom logic with full citation context (set `options.callback`)\n *\n * Citations are processed in reverse order to avoid position shifts invalidating\n * subsequent annotations. Position tracking maps original positions to new positions\n * after markup insertion.\n *\n * @param text - Original or cleaned text to annotate\n * @param citations - Citations to mark up (from extraction pipeline)\n * @param options - Annotation configuration\n * @returns Annotated text with position mapping\n *\n * @example Template mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   template: { before: '<cite>', after: '</cite>' }\n * })\n * // Result: \"See <cite>500 F.2d 123</cite>\"\n * ```\n *\n * @example Callback mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   callback: (citation) => {\n *     if (citation.type === 'case') {\n *       return `<a href=\"/cases/${citation.volume}\">${citation.matchedText}</a>`\n *     }\n *     return citation.matchedText\n *   }\n * })\n * ```\n *\n * @example Position tracking\n * ```typescript\n * const result = annotate(text, citations, { template: { before: '<mark>', after: '</mark>' } })\n * // result.positionMap tracks how positions shifted\n * const originalPos = 10\n * const newPos = result.positionMap.get(originalPos)\n * ```\n */\nexport function annotate<C extends Citation = Citation>(\n  text: string,\n  citations: C[],\n  options: AnnotationOptions<C> = {}\n): AnnotationResult {\n  const {\n    useCleanText = false,\n    autoEscape = true,  // Secure by default\n    template,\n    callback,\n  } = options\n\n  // Sort reverse to avoid position shifts invalidating subsequent annotations\n  const sorted = [...citations].sort((a, b) => {\n    const aPos = useCleanText ? a.span.cleanStart : a.span.originalStart\n    const bPos = useCleanText ? b.span.cleanStart : b.span.originalStart\n    return bPos - aPos  // Reverse for backward iteration\n  })\n\n  let result = text\n  const positionMap = new Map<number, number>()\n  const skipped: Citation[] = []\n\n  for (const citation of sorted) {\n    let start = useCleanText ? citation.span.cleanStart : citation.span.originalStart\n    let end = useCleanText ? citation.span.cleanEnd : citation.span.originalEnd\n\n    // Snap positions out of HTML tags when annotating original text\n    if (!useCleanText) {\n      const snapped = snapOutOfHtmlTags(result, start, end)\n      if (snapped === null) {\n        // Could not safely snap — skip this citation\n        skipped.push(citation)\n        continue\n      }\n      start = snapped.start\n      end = snapped.end\n    }\n\n    let markup = ''\n\n    if (callback) {\n      // Callback mode: developer provides full logic\n      const surrounding = text.substring(\n        Math.max(0, start - 30),\n        Math.min(text.length, end + 30)\n      )\n      markup = callback(citation, surrounding)\n    } else if (template) {\n      // Template mode: simple before/after wrapping\n      const citationText = result.substring(start, end)\n      const escaped = autoEscape ? escapeHtmlEntities(citationText) : citationText\n      markup = template.before + escaped + template.after\n    } else {\n      // No annotation specified\n      continue\n    }\n\n    // Insert annotation (working backwards preserves positions for later citations)\n    result = result.slice(0, start) + markup + result.slice(end)\n\n    // Track original position to new position (before this annotation was added)\n    positionMap.set(start, start)\n  }\n\n  return { text: result, positionMap, skipped }\n}\n\n/**\n * Check if a position falls inside an HTML tag (between `<` and `>`).\n * Returns the index of the opening `<` if inside a tag, otherwise -1.\n */\nfunction findContainingTag(text: string, pos: number): { tagStart: number; tagEnd: number } | null {\n  // Search backwards from pos for '<' without encountering '>' first\n  let i = pos - 1\n  while (i >= 0) {\n    if (text[i] === '>') return null  // Hit a tag close — we're outside\n    if (text[i] === '<') {\n      // Found opening '<' — now find the closing '>'\n      let j = pos\n      while (j < text.length) {\n        if (text[j] === '>') return { tagStart: i, tagEnd: j + 1 }\n        j++\n      }\n      // Unclosed tag — treat as inside\n      return { tagStart: i, tagEnd: text.length }\n    }\n    i--\n  }\n  return null\n}\n\n/**\n * Snap annotation start/end positions to avoid landing inside HTML tags.\n *\n * If a position falls inside an HTML tag, it is moved:\n * - Start position: snapped to before the tag's `<`\n * - End position: snapped to after the tag's `>`\n *\n * Returns null if the positions can't be safely adjusted (e.g., entirely\n * within a single tag).\n */\nfunction snapOutOfHtmlTags(\n  text: string,\n  start: number,\n  end: number,\n): { start: number; end: number } | null {\n  let snappedStart = start\n  let snappedEnd = end\n\n  const startTag = findContainingTag(text, start)\n  if (startTag) {\n    snappedStart = startTag.tagStart\n  }\n\n  const endTag = findContainingTag(text, end)\n  if (endTag) {\n    snappedEnd = endTag.tagEnd\n  }\n\n  // Sanity check: start must come before end\n  if (snappedStart >= snappedEnd) return null\n\n  return { start: snappedStart, end: snappedEnd }\n}\n\n/**\n * Escape HTML entities to prevent XSS injection.\n *\n * Converts special HTML characters to their entity equivalents:\n * - `&` → `&amp;`\n * - `<` → `&lt;`\n * - `>` → `&gt;`\n * - `\"` → `&quot;`\n * - `'` → `&#39;`\n * - `/` → `&#x2F;`\n *\n * @param text - Text to escape\n * @returns Escaped text safe for HTML insertion\n */\nfunction escapeHtmlEntities(text: string): string {\n  const map: Record<string, string> = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    '/': '&#x2F;',\n  }\n  return text.replace(/[&<>\"'/]/g, (char) => map[char])\n}\n"],"mappings":"AA+CA,SAAgB,EACd,EACA,EACA,EAAgC,EAAE,CAChB,CAClB,GAAM,CACJ,eAAe,GACf,aAAa,GACb,WACA,YACE,EAGE,EAAS,CAAC,GAAG,EAAU,CAAC,MAAM,EAAG,IAAM,CAC3C,IAAM,EAAO,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,cAEvD,OADa,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,eACzC,GACd,CAEE,EAAS,EACP,EAAc,IAAI,IAClB,EAAsB,EAAE,CAE9B,IAAK,IAAM,KAAY,EAAQ,CAC7B,IAAI,EAAQ,EAAe,EAAS,KAAK,WAAa,EAAS,KAAK,cAChE,EAAM,EAAe,EAAS,KAAK,SAAW,EAAS,KAAK,YAGhE,GAAI,CAAC,EAAc,CACjB,IAAM,EAAU,EAAkB,EAAQ,EAAO,EAAI,CACrD,GAAI,IAAY,KAAM,CAEpB,EAAQ,KAAK,EAAS,CACtB,SAEF,EAAQ,EAAQ,MAChB,EAAM,EAAQ,IAGhB,IAAI,EAAS,GAEb,GAAI,EAMF,EAAS,EAAS,EAJE,EAAK,UACvB,KAAK,IAAI,EAAG,EAAQ,GAAG,CACvB,KAAK,IAAI,EAAK,OAAQ,EAAM,GAAG,CAChC,CACuC,SAC/B,EAAU,CAEnB,IAAM,EAAe,EAAO,UAAU,EAAO,EAAI,CAC3C,EAAU,EAAa,EAAmB,EAAa,CAAG,EAChE,EAAS,EAAS,OAAS,EAAU,EAAS,WAG9C,SAIF,EAAS,EAAO,MAAM,EAAG,EAAM,CAAG,EAAS,EAAO,MAAM,EAAI,CAG5D,EAAY,IAAI,EAAO,EAAM,CAG/B,MAAO,CAAE,KAAM,EAAQ,cAAa,UAAS,CAO/C,SAAS,EAAkB,EAAc,EAA0D,CAEjG,IAAI,EAAI,EAAM,EACd,KAAO,GAAK,GAAG,CACb,GAAI,EAAK,KAAO,IAAK,OAAO,KAC5B,GAAI,EAAK,KAAO,IAAK,CAEnB,IAAI,EAAI,EACR,KAAO,EAAI,EAAK,QAAQ,CACtB,GAAI,EAAK,KAAO,IAAK,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAI,EAAG,CAC1D,IAGF,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAK,OAAQ,CAE7C,IAEF,OAAO,KAaT,SAAS,EACP,EACA,EACA,EACuC,CACvC,IAAI,EAAe,EACf,EAAa,EAEX,EAAW,EAAkB,EAAM,EAAM,CAC3C,IACF,EAAe,EAAS,UAG1B,IAAM,EAAS,EAAkB,EAAM,EAAI,CAQ3C,OAPI,IACF,EAAa,EAAO,QAIlB,GAAgB,EAAmB,KAEhC,CAAE,MAAO,EAAc,IAAK,EAAY,CAiBjD,SAAS,EAAmB,EAAsB,CAChD,IAAM,EAA8B,CAClC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,QACL,IAAK,SACN,CACD,OAAO,EAAK,QAAQ,YAAc,GAAS,EAAI,GAAM"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/annotate/annotate.ts"],"sourcesContent":["import type { Citation } from '../types/citation'\nimport type { AnnotationOptions, AnnotationResult } from './types'\n\n/**\n * Annotate citations in text with custom markup.\n *\n * Supports two modes:\n * - **Template mode**: Simple before/after wrapping (set `options.template`)\n * - **Callback mode**: Custom logic with full citation context (set `options.callback`)\n *\n * Citations are processed in reverse order to avoid position shifts invalidating\n * subsequent annotations. Position tracking maps original positions to new positions\n * after markup insertion.\n *\n * @param text - Original or cleaned text to annotate\n * @param citations - Citations to mark up (from extraction pipeline)\n * @param options - Annotation configuration\n * @returns Annotated text with position mapping\n *\n * @example Template mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   template: { before: '<cite>', after: '</cite>' }\n * })\n * // Result: \"See <cite>500 F.2d 123</cite>\"\n * ```\n *\n * @example Callback mode\n * ```typescript\n * const result = annotate(text, citations, {\n *   callback: (citation) => {\n *     if (citation.type === 'case') {\n *       return `<a href=\"/cases/${citation.volume}\">${citation.matchedText}</a>`\n *     }\n *     return citation.matchedText\n *   }\n * })\n * ```\n *\n * @example Position tracking\n * ```typescript\n * const result = annotate(text, citations, { template: { before: '<mark>', after: '</mark>' } })\n * // result.positionMap tracks how positions shifted\n * const originalPos = 10\n * const newPos = result.positionMap.get(originalPos)\n * ```\n */\nexport function annotate<C extends Citation = Citation>(\n  text: string,\n  citations: C[],\n  options: AnnotationOptions<C> = {}\n): AnnotationResult {\n  const {\n    useCleanText = false,\n    autoEscape = true,  // Secure by default\n    useFullSpan = false,  // Backward compatible default\n    template,\n    callback,\n  } = options\n\n  // Sort reverse to avoid position shifts invalidating subsequent annotations\n  const sorted = [...citations].sort((a, b) => {\n    const aPos = useCleanText ? a.span.cleanStart : a.span.originalStart\n    const bPos = useCleanText ? b.span.cleanStart : b.span.originalStart\n    return bPos - aPos  // Reverse for backward iteration\n  })\n\n  let result = text\n  const positionMap = new Map<number, number>()\n  const skipped: Citation[] = []\n\n  for (const citation of sorted) {\n    // Determine which span to use\n    let start: number\n    let end: number\n\n    if (useFullSpan && 'fullSpan' in citation && citation.fullSpan) {\n      // Full span mode: case name through parenthetical\n      start = useCleanText ? citation.fullSpan.cleanStart : citation.fullSpan.originalStart\n      end = useCleanText ? citation.fullSpan.cleanEnd : citation.fullSpan.originalEnd\n    } else {\n      // Default mode: core citation only\n      start = useCleanText ? citation.span.cleanStart : citation.span.originalStart\n      end = useCleanText ? citation.span.cleanEnd : citation.span.originalEnd\n    }\n\n    // Snap positions out of HTML tags when annotating original text\n    if (!useCleanText) {\n      const snapped = snapOutOfHtmlTags(result, start, end)\n      if (snapped === null) {\n        // Could not safely snap — skip this citation\n        skipped.push(citation)\n        continue\n      }\n      start = snapped.start\n      end = snapped.end\n    }\n\n    let markup = ''\n\n    if (callback) {\n      // Callback mode: developer provides full logic\n      const surrounding = text.substring(\n        Math.max(0, start - 30),\n        Math.min(text.length, end + 30)\n      )\n      markup = callback(citation, surrounding)\n    } else if (template) {\n      // Template mode: simple before/after wrapping\n      const citationText = result.substring(start, end)\n      const escaped = autoEscape ? escapeHtmlEntities(citationText) : citationText\n      markup = template.before + escaped + template.after\n    } else {\n      // No annotation specified\n      continue\n    }\n\n    // Insert annotation (working backwards preserves positions for later citations)\n    result = result.slice(0, start) + markup + result.slice(end)\n\n    // Track original position to new position (before this annotation was added)\n    positionMap.set(start, start)\n  }\n\n  return { text: result, positionMap, skipped }\n}\n\n/**\n * Check if a position falls inside an HTML tag (between `<` and `>`).\n * Returns the index of the opening `<` if inside a tag, otherwise -1.\n */\nfunction findContainingTag(text: string, pos: number): { tagStart: number; tagEnd: number } | null {\n  // Search backwards from pos for '<' without encountering '>' first\n  let i = pos - 1\n  while (i >= 0) {\n    if (text[i] === '>') return null  // Hit a tag close — we're outside\n    if (text[i] === '<') {\n      // Found opening '<' — now find the closing '>'\n      let j = pos\n      while (j < text.length) {\n        if (text[j] === '>') return { tagStart: i, tagEnd: j + 1 }\n        j++\n      }\n      // Unclosed tag — treat as inside\n      return { tagStart: i, tagEnd: text.length }\n    }\n    i--\n  }\n  return null\n}\n\n/**\n * Snap annotation start/end positions to avoid landing inside HTML tags.\n *\n * If a position falls inside an HTML tag, it is moved:\n * - Start position: snapped to before the tag's `<`\n * - End position: snapped to after the tag's `>`\n *\n * Returns null if the positions can't be safely adjusted (e.g., entirely\n * within a single tag).\n */\nfunction snapOutOfHtmlTags(\n  text: string,\n  start: number,\n  end: number,\n): { start: number; end: number } | null {\n  let snappedStart = start\n  let snappedEnd = end\n\n  const startTag = findContainingTag(text, start)\n  if (startTag) {\n    snappedStart = startTag.tagStart\n  }\n\n  const endTag = findContainingTag(text, end)\n  if (endTag) {\n    snappedEnd = endTag.tagEnd\n  }\n\n  // Sanity check: start must come before end\n  if (snappedStart >= snappedEnd) return null\n\n  return { start: snappedStart, end: snappedEnd }\n}\n\n/**\n * Escape HTML entities to prevent XSS injection.\n *\n * Converts special HTML characters to their entity equivalents:\n * - `&` → `&amp;`\n * - `<` → `&lt;`\n * - `>` → `&gt;`\n * - `\"` → `&quot;`\n * - `'` → `&#39;`\n * - `/` → `&#x2F;`\n *\n * @param text - Text to escape\n * @returns Escaped text safe for HTML insertion\n */\nfunction escapeHtmlEntities(text: string): string {\n  const map: Record<string, string> = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#39;',\n    '/': '&#x2F;',\n  }\n  return text.replace(/[&<>\"'/]/g, (char) => map[char])\n}\n"],"mappings":"AA+CA,SAAgB,EACd,EACA,EACA,EAAgC,EAAE,CAChB,CAClB,GAAM,CACJ,eAAe,GACf,aAAa,GACb,cAAc,GACd,WACA,YACE,EAGE,EAAS,CAAC,GAAG,EAAU,CAAC,MAAM,EAAG,IAAM,CAC3C,IAAM,EAAO,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,cAEvD,OADa,EAAe,EAAE,KAAK,WAAa,EAAE,KAAK,eACzC,GACd,CAEE,EAAS,EACP,EAAc,IAAI,IAClB,EAAsB,EAAE,CAE9B,IAAK,IAAM,KAAY,EAAQ,CAE7B,IAAI,EACA,EAaJ,GAXI,GAAe,aAAc,GAAY,EAAS,UAEpD,EAAQ,EAAe,EAAS,SAAS,WAAa,EAAS,SAAS,cACxE,EAAM,EAAe,EAAS,SAAS,SAAW,EAAS,SAAS,cAGpE,EAAQ,EAAe,EAAS,KAAK,WAAa,EAAS,KAAK,cAChE,EAAM,EAAe,EAAS,KAAK,SAAW,EAAS,KAAK,aAI1D,CAAC,EAAc,CACjB,IAAM,EAAU,EAAkB,EAAQ,EAAO,EAAI,CACrD,GAAI,IAAY,KAAM,CAEpB,EAAQ,KAAK,EAAS,CACtB,SAEF,EAAQ,EAAQ,MAChB,EAAM,EAAQ,IAGhB,IAAI,EAAS,GAEb,GAAI,EAMF,EAAS,EAAS,EAJE,EAAK,UACvB,KAAK,IAAI,EAAG,EAAQ,GAAG,CACvB,KAAK,IAAI,EAAK,OAAQ,EAAM,GAAG,CAChC,CACuC,SAC/B,EAAU,CAEnB,IAAM,EAAe,EAAO,UAAU,EAAO,EAAI,CAC3C,EAAU,EAAa,EAAmB,EAAa,CAAG,EAChE,EAAS,EAAS,OAAS,EAAU,EAAS,WAG9C,SAIF,EAAS,EAAO,MAAM,EAAG,EAAM,CAAG,EAAS,EAAO,MAAM,EAAI,CAG5D,EAAY,IAAI,EAAO,EAAM,CAG/B,MAAO,CAAE,KAAM,EAAQ,cAAa,UAAS,CAO/C,SAAS,EAAkB,EAAc,EAA0D,CAEjG,IAAI,EAAI,EAAM,EACd,KAAO,GAAK,GAAG,CACb,GAAI,EAAK,KAAO,IAAK,OAAO,KAC5B,GAAI,EAAK,KAAO,IAAK,CAEnB,IAAI,EAAI,EACR,KAAO,EAAI,EAAK,QAAQ,CACtB,GAAI,EAAK,KAAO,IAAK,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAI,EAAG,CAC1D,IAGF,MAAO,CAAE,SAAU,EAAG,OAAQ,EAAK,OAAQ,CAE7C,IAEF,OAAO,KAaT,SAAS,EACP,EACA,EACA,EACuC,CACvC,IAAI,EAAe,EACf,EAAa,EAEX,EAAW,EAAkB,EAAM,EAAM,CAC3C,IACF,EAAe,EAAS,UAG1B,IAAM,EAAS,EAAkB,EAAM,EAAI,CAQ3C,OAPI,IACF,EAAa,EAAO,QAIlB,GAAgB,EAAmB,KAEhC,CAAE,MAAO,EAAc,IAAK,EAAY,CAiBjD,SAAS,EAAmB,EAAsB,CAChD,IAAM,EAA8B,CAClC,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,SACL,IAAK,QACL,IAAK,SACN,CACD,OAAO,EAAK,QAAQ,YAAc,GAAS,EAAI,GAAM"}

package/dist/{citation-DAyM8kNA.d.mts → citation-25ZydLsu.d.mts}

@@ -95,12 +95,21 @@ interface FullCaseCitation extends CitationBase {
   type: "case";
   volume: number | string;
   reporter: string;
-  page: number;
+  /** Page number — optional for blank page placeholder citations (e.g., "___" or "---") */
+  page?: number;
   pincite?: number;
   court?: string;
   year?: number;
   /** Normalized reporter abbreviation from reporters-db (e.g., "F.2d" vs "F. 2d") */
   normalizedReporter?: string;
+  /**
+  * Group identifier for parallel citations (same case in multiple reporters).
+  * Populated by Phase 8 (Parallel Linking).
+  * Format: ${volume}-${reporter}-${page} (e.g., "410-U.S.-113")
+  * All citations in the same parallel group share the same groupId.
+  * @example "410-U.S.-113" for parallel group [410 U.S. 113, 93 S. Ct. 705]
+  */
+  groupId?: string;
   /** Parallel citations for same case in different reporters */
   parallelCitations?: Array<{
     volume: number | string;
@@ -137,17 +146,84 @@ interface FullCaseCitation extends CitationBase {
     confidence: number;
     reason: string;
   }>;
+  /**
+  * Full span covering citation from case name through closing parenthetical.
+  * Populated by Phase 6 (Full Span extraction).
+  * @example For "Smith v. Doe, 500 F.2d 123 (2020)", fullSpan covers entire text.
+  */
+  fullSpan?: Span;
+  /**
+  * Extracted case name (party names around "v.").
+  * Populated by Phase 6 (Full Span extraction).
+  * @example "Smith v. Doe" or "United States v. Jones"
+  */
+  caseName?: string;
+  /**
+  * Plaintiff party name (text before "v." or procedural prefix).
+  * Populated by Phase 7 (Party Name extraction).
+  * @example "Smith" from "Smith v. Doe" or "Jones" from "In re Jones"
+  */
+  plaintiff?: string;
+  /**
+  * Defendant party name (text after "v.").
+  * Populated by Phase 7 (Party Name extraction).
+  * @example "Doe" from "Smith v. Doe"
+  */
+  defendant?: string;
+  /**
+  * Normalized plaintiff name for matching (lowercase, stripped of noise).
+  * Populated by Phase 7 (Party Name extraction).
+  * @example "smith" from "The Smith Corp., Inc."
+  */
+  plaintiffNormalized?: string;
+  /**
+  * Normalized defendant name for matching (lowercase, stripped of noise).
+  * Populated by Phase 7 (Party Name extraction).
+  * @example "doe" from "Doe et al."
+  */
+  defendantNormalized?: string;
+  /**
+  * Procedural prefix for non-adversarial cases.
+  * Populated by Phase 7 (Party Name extraction).
+  * @example "In re" from "In re Smith"
+  */
+  proceduralPrefix?: string;
+  /**
+  * True when page position contains a blank placeholder ("___" or "---").
+  * Populated by Phase 5 (Blank Page support).
+  * When true, page field will be undefined and confidence reduced to 0.8.
+  */
+  hasBlankPage?: boolean;
+  /**
+  * Disposition or procedural status from parenthetical.
+  * Populated by Phase 6 (Complex Parentheticals).
+  * @example "en banc", "per curiam"
+  */
+  disposition?: string;
 }
 /**
 * Statute citation (U.S. Code, state codes, etc.).
 *
 * @example "42 U.S.C. § 1983"
+* @example "42 U.S.C. § 1983(a)(1) et seq."
 */
 interface StatuteCitation extends CitationBase {
   type: "statute";
   title?: number;
   code: string;
   section: string;
+  /** Subsection/pincite chain, e.g. "(a)(1)(A)" */
+  subsection?: string;
+  /** 2-letter state code or "US" when unambiguously identified */
+  jurisdiction?: string;
+  /**
+  * Alias for subsection (eyecite-ts convention).
+  * Note: this is string (subsection chain), unlike FullCaseCitation.pincite which is number (page offset).
+  * The discriminated union on `type` ensures type safety at call sites.
+  */
+  pincite?: string;
+  /** True when "et seq." follows the citation */
+  hasEtSeq?: boolean;
 }
 /**
 * Journal citation (law review, legal periodical).
@@ -323,4 +399,4 @@ type CitationOfType<T extends CitationType> = Extract<Citation, {
 type ExtractorMap = { [K in FullCitationType]: CitationOfType<K> };
 //#endregion
 export { TransformationMap as S, StatuteCitation as _, ExtractorMap as a, Warning as b, FullCitation as c, JournalCitation as d, NeutralCitation as f, ShortFormCitationType as g, ShortFormCitation as h, CitationType as i, FullCitationType as l, ShortFormCaseCitation as m, CitationBase as n, FederalRegisterCitation as o, PublicLawCitation as p, CitationOfType as r, FullCaseCitation as s, Citation as t, IdCitation as u, StatutesAtLargeCitation as v, Span as x, SupraCitation as y };
-//# sourceMappingURL=citation-DAyM8kNA.d.mts.map
+//# sourceMappingURL=citation-25ZydLsu.d.mts.map

package/dist/citation-25ZydLsu.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"citation-25ZydLsu.d.mts","names":[],"sources":["../src/types/span.ts","../src/types/citation.ts"],"mappings":";;AAiBA;;;;;;;;;;AAoBA;;;;;;UApBiB,IAAA;;EAEf,UAAA;EAuBiB;EApBjB,QAAA;;EAGA,aAAA;ECpBF;EDuBE,WAAA;AAAA;;;AClBF;;;;UD2BiB,iBAAA;;EAEf,eAAA,EAAiB,GAAA;;EAGjB,eAAA,EAAiB,GAAA;AAAA;;;AAzBnB;;;AAAA,KCZY,YAAA;;;;UAKK,OAAA;;EAEf,KAAA;EDyBF;ECvBE,OAAA;;EAEA,QAAA;IAAY,KAAA;IAAe,GAAA;EAAA;;EAE3B,OAAA;AAAA;;;;UAMe,YAAA;EAnBL;EAqBV,IAAA;EArBU;EAwBV,IAAA,EAAM,IAAA;EAnBR;;;;;;;EA4BE,UAAA;;EAGA,WAAA;;EAGA,aAAA;EApBF;EAuBE,eAAA;;EAGA,QAAA,GAAW,OAAA;AAAA;;;;;;;UASI,gBAAA,SAAyB,YAAA;EACxC,IAAA;EACA,MAAA;EACA,QAAA;EAHF;EAKE,IAAA;EACA,OAAA;EACA,KAAA;EACA,IAAA;;EAGA,kBAAA;;;;;;;;EASA,OAAA;;EAGA,iBAAA,GAAoB,KAAA;IAClB,MAAA;IACA,QAAA;IACA,IAAA;EAAA;;EAIF,MAAA;;EAGA,aAAA;;EAGA,iBAAA;;;;;;EAOA,IAAA;IACE,GAAA;IACA,MAAA;MAAW,IAAA;MAAc,KAAA;MAAgB,GAAA;IAAA;EAAA;;;;;EAO3C,uBAAA,GAA0B,KAAA;IACxB,MAAA;IACA,QAAA;IACA,IAAA;IACA,UAAA;IACA,MAAA;EAAA;EAgEF;AASF;;;;EAjEE,QAAA,GAAW,IAAA;;;;;;EAOX,QAAA;;;;;AAqFF;EA9EE,SAAA;;;;;;EAOA,SAAA;;;;;;EAOA,mBAAA;;;AA4FF;;;EArFE,mBAAA;;;;;;EAOA,gBAAA;EAqFA;AAWF;;;;EAzFE,YAAA;;;;;;EAOA,WAAA;AAAA;;;;;;;UASe,eAAA,SAAwB,YAAA;EACvC,IAAA;EACA,KAAA;EACA,IAAA;EACA,OAAA;EAkGe;EAhGf,UAAA;EAgG+C;EA9F/C,YAAA;;;;;;EAMA,OAAA;EAwGF;EAtGE,QAAA;AAAA;;;;;;;AAiHF;;UAtGiB,eAAA,SAAwB,YAAA;EACvC,IAAA;;EAEA,MAAA;;EAEA,KAAA;;EAEA,MAAA;EA6GF;EA3GE,OAAA;;EAEA,YAAA;;EAEA,IAAA;;EAEA,OAAA;;EAEA,IAAA;AAAA;;AA4HF;;;;;;;UAjHiB,eAAA,SAAwB,YAAA;EACvC,IAAA;;EAEA,IAAA;;EAEA,KAAA;;EAEA,cAAA;AAAA;;;;;;;;;UAWe,iBAAA,SAA0B,YAAA;EACzC,IAAA;EAwGE;EAtGF,QAAA;EA2GU;EAzGV,SAAA;EAyGU;EAvGV,KAAA;AAAA;;;;;AA6GF;;;;UAlGiB,uBAAA,SAAgC,YAAA;EAC/C,IAAA;;EAEA,MAAA;;EAEA,IAAA;;EAEA,IAAA;AAAA;;UAIe,uBAAA,SAAgC,YAAA;EAC/C,IAAA;;EAEA,MAAA;;EAEA,IAAA;EAkFgJ;EAhFhJ,IAAA;AAAA;;;;;;;UASe,UAAA,SAAmB,YAAA;EAClC,IAAA;EACA,OAAA;AAAA;;AAqFF;;;;;UA5EiB,aAAA,SAAsB,YAAA;EACrC,IAAA;;EAEA,SAAA;;EAEA,OAAA;AAAA;;;;;;AA6EF;UApEiB,qBAAA,SAA8B,YAAA;EAC7C,IAAA;EACA,MAAA;EACA,QAAA;EACA,IAAA;EACA,OAAA;AAAA;;;;;;;;;;;;;;;;;;KAoBU,QAAA,GACR,gBAAA,GACA,eAAA,GACA,eAAA,GACA,eAAA,GACA,iBAAA,GACA,uBAAA,GACA,uBAAA,GACA,UAAA,GACA,aAAA,GACA,qBAAA;;;;KAKQ,gBAAA;AAAA,KACA,qBAAA;;;;KAKA,YAAA,GAAe,gBAAA,GAAmB,eAAA,GAAkB,eAAA,GAAkB,eAAA,GAAkB,iBAAA,GAAoB,uBAAA,GAA0B,uBAAA;;;;KAKtI,iBAAA,GAAoB,UAAA,GAAa,aAAA,GAAgB,qBAAA;;;;;;;;;;KAWjD,cAAA,WAAyB,YAAA,IAAgB,OAAA,CAAQ,QAAA;EAAY,IAAA,EAAM,CAAA;AAAA;;;;;KAMnE,YAAA,WACJ,gBAAA,GAAmB,cAAA,CAAe,CAAA"}