eyecite-ts 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,682 @@
+import { a as FullCaseCitation, c as NeutralCitation, d as StatuteCitation, f as SupraCitation, i as FederalRegisterCitation, l as PublicLawCitation, m as TransformationMap, n as CitationBase, o as IdCitation, p as Span, r as CitationType, s as JournalCitation, t as Citation, u as ShortFormCaseCitation } from "./citation-BcY5zzWb.cjs";
+
+//#region src/patterns/casePatterns.d.ts
+/**
+* Case Citation Regex Patterns
+*
+* These patterns are designed for tokenization (broad matching) not extraction.
+* They identify potential case citations in text for the tokenizer (Plan 3).
+* Metadata parsing and validation against reporters-db happens in Phase 2 Plan 5 (extraction layer).
+*
+* Pattern Design Principles (from RESEARCH.md):
+* - Use \b word boundaries to avoid matching "F." in "F.B.I."
+* - Avoid nested quantifiers: (a+)+ causes ReDoS
+* - Keep patterns simple: tokenization only needs to find candidates
+* - Use global flag /g for matchAll()
+*/
+interface Pattern {
+  id: string;
+  regex: RegExp;
+  description: string;
+  type: "case" | "statute" | "journal" | "neutral" | "publicLaw" | "federalRegister";
+}
+//#endregion
+//#region src/resolve/types.d.ts
+/**
+* Scope boundary strategy for resolution.
+* Determines how far back to search for antecedent citations.
+*/
+type ScopeStrategy = "paragraph" | "section" | "footnote" | "none";
+/**
+* Options for citation resolution.
+*/
+interface ResolutionOptions {
+  /**
+  * Scope boundary strategy (default: 'paragraph')
+  * - paragraph: Only resolve within same paragraph
+  * - section: Only resolve within same section
+  * - footnote: Only resolve within same footnote
+  * - none: Resolve across entire document
+  */
+  scopeStrategy?: ScopeStrategy;
+  /**
+  * Auto-detect paragraph boundaries from text (default: true)
+  * Uses paragraphBoundaryPattern to split text
+  */
+  autoDetectParagraphs?: boolean;
+  /**
+  * Regex pattern to detect paragraph boundaries (default: /\n\n+/)
+  * Only used if autoDetectParagraphs is true
+  */
+  paragraphBoundaryPattern?: RegExp;
+  /**
+  * Enable fuzzy party name matching for supra resolution (default: true)
+  * Uses Levenshtein distance to handle typos and variations
+  */
+  fuzzyPartyMatching?: boolean;
+  /**
+  * Similarity threshold for fuzzy party matching (default: 0.8)
+  * Range: 0-1 where 1.0 is exact match
+  * Only used if fuzzyPartyMatching is true
+  */
+  partyMatchThreshold?: number;
+  /**
+  * Allow Id. citations to resolve to other short-form citations (default: false)
+  * If true: "Smith v. Jones, 500 F.2d 100" -> "Id." -> "Id. at 105"
+  * If false: Second Id. fails to resolve (no full citation between them)
+  */
+  allowNestedResolution?: boolean;
+  /**
+  * Report unresolved citations with failure reasons (default: true)
+  * If false: resolution field will be undefined for unresolved citations
+  */
+  reportUnresolved?: boolean;
+}
+/**
+* Result of resolving a short-form citation.
+*/
+interface ResolutionResult {
+  /**
+  * Index of the citation this resolves to.
+  * undefined if resolution failed
+  */
+  resolvedTo?: number;
+  /**
+  * Reason for resolution failure (if any)
+  */
+  failureReason?: string;
+  /**
+  * Warnings about ambiguous or uncertain resolutions
+  */
+  warnings?: string[];
+  /**
+  * Confidence in the resolution (0-1)
+  * Factors: party name similarity, scope boundary, citation type match
+  */
+  confidence: number;
+}
+/**
+* Citation with optional resolution metadata.
+* Uses intersection type to add resolution field to any Citation type.
+*/
+type ResolvedCitation = Citation & {
+  /**
+  * Resolution result for short-form citations.
+  * Only present for Id/supra/shortFormCase types
+  */
+  resolution?: ResolutionResult;
+};
+//#endregion
+//#region src/extract/extractCitations.d.ts
+/**
+* Options for customizing citation extraction behavior.
+*/
+interface ExtractOptions {
+  /**
+  * Custom text cleaners (overrides defaults).
+  *
+  * If provided, these cleaners replace the default pipeline:
+  * [stripHtmlTags, normalizeWhitespace, normalizeUnicode, fixSmartQuotes]
+  *
+  * @example
+  * ```typescript
+  * // Use only HTML stripping, skip Unicode normalization
+  * const citations = extractCitations(text, {
+  *   cleaners: [stripHtmlTags]
+  * })
+  * ```
+  */
+  cleaners?: Array<(text: string) => string>;
+  /**
+  * Custom regex patterns (overrides defaults).
+  *
+  * If provided, these patterns replace the default pattern set:
+  * [casePatterns, statutePatterns, journalPatterns, neutralPatterns, shortFormPatterns]
+  *
+  * @example
+  * ```typescript
+  * // Extract only case citations
+  * const citations = extractCitations(text, {
+  *   patterns: casePatterns
+  * })
+  * ```
+  */
+  patterns?: Pattern[];
+  /**
+  * Resolve short-form citations to their full antecedents (default: false).
+  *
+  * If true, returns ResolvedCitation[] with resolution metadata for short-form citations
+  * (Id., supra, short-form case). Full citations are unchanged.
+  *
+  * @example
+  * ```typescript
+  * const text = "Smith v. Jones, 500 F.2d 100 (1974). Id. at 105."
+  * const citations = extractCitations(text, { resolve: true })
+  * // citations[1].resolution.resolvedTo === 0 (points to Smith v. Jones)
+  * ```
+  */
+  resolve?: boolean;
+  /**
+  * Options for citation resolution (only used if resolve: true).
+  *
+  * @example
+  * ```typescript
+  * const citations = extractCitations(text, {
+  *   resolve: true,
+  *   resolutionOptions: {
+  *     scopeStrategy: 'paragraph',
+  *     fuzzyPartyMatching: true
+  *   }
+  * })
+  * ```
+  */
+  resolutionOptions?: ResolutionOptions;
+}
+/**
+* Extracts legal citations from text using the full parsing pipeline.
+*
+* Pipeline flow:
+* 1. **Clean:** Remove HTML tags, normalize Unicode, fix smart quotes
+* 2. **Tokenize:** Apply regex patterns to find citation candidates
+* 3. **Extract:** Parse metadata (volume, reporter, page, etc.)
+* 4. **Translate:** Map positions from cleaned text back to original text
+*
+* This function is synchronous because all stages (cleaning, tokenization,
+* extraction) are synchronous. For async operations (e.g., future reporters-db
+* lookups), use extractCitationsAsync().
+*
+* Position tracking:
+* - TransformationMap is built during cleaning
+* - Tokens contain positions in cleaned text (cleanStart/cleanEnd)
+* - Extraction translates cleaned positions → original positions
+* - Final citations have originalStart/originalEnd pointing to input text
+*
+* Warnings from cleaning layer are attached to all extracted citations.
+*
+* @param text - Raw text to extract citations from (may contain HTML, Unicode)
+* @param options - Optional customization (cleaners, patterns)
+* @returns Array of citations with parsed metadata and accurate positions
+*
+* @example
+* ```typescript
+* const text = "See Smith v. Doe, 500 F.2d 123 (9th Cir. 2020)"
+* const citations = extractCitations(text)
+* // citations[0] = {
+* //   type: "case",
+* //   volume: 500,
+* //   reporter: "F.2d",
+* //   page: 123,
+* //   court: "9th Cir.",
+* //   year: 2020,
+* //   span: { originalStart: 18, originalEnd: 30, ... }
+* // }
+* ```
+*
+* @example
+* ```typescript
+* // Extract from HTML
+* const html = "<p>In <b>Smith</b>, 500 F.2d 123, the court held...</p>"
+* const citations = extractCitations(html)
+* // HTML is stripped, positions point to original HTML
+* ```
+*
+* @example
+* ```typescript
+* // Extract multiple citation types
+* const text = "See 42 U.S.C. § 1983; Smith, 500 F.2d 123; 123 Harv. L. Rev. 456"
+* const citations = extractCitations(text)
+* // citations[0].type === "statute"
+* // citations[1].type === "case"
+* // citations[2].type === "journal"
+* ```
+*/
+declare function extractCitations(text: string, options?: ExtractOptions): Citation[] | ResolvedCitation[];
+/**
+* Asynchronous version of extractCitations().
+*
+* Currently wraps the synchronous extractCitations() function. This API
+* exists for future extensibility when async operations are added:
+* - Async reporters-db lookups (Phase 3)
+* - Async resolution/annotation services
+* - Web Workers for parallel processing
+*
+* For now, this function immediately resolves with the same results as
+* the synchronous version.
+*
+* @param text - Raw text to extract citations from
+* @param options - Optional customization (cleaners, patterns, resolve)
+* @returns Promise resolving to array of citations (or ResolvedCitation[] if resolve: true)
+*
+* @example
+* ```typescript
+* const citations = await extractCitationsAsync(text, { resolve: true })
+* // Returns ResolvedCitation[] with resolution metadata
+* ```
+*/
+declare function extractCitationsAsync(text: string, options?: ExtractOptions): Promise<Citation[] | ResolvedCitation[]>;
+//#endregion
+//#region src/clean/cleanText.d.ts
+/**
+* Result of text cleaning operation.
+*/
+interface CleanTextResult {
+  /** Cleaned text after all transformations */
+  cleaned: string;
+  /** Position mappings between cleaned and original text */
+  transformationMap: TransformationMap;
+  /** Warnings generated during cleaning (currently unused) */
+  warnings: Warning[];
+}
+/**
+* Warning generated during text cleaning.
+*/
+interface Warning {
+  level: "error" | "warning" | "info";
+  message: string;
+  position: {
+    start: number;
+    end: number;
+  };
+}
+/**
+* Clean text using a pipeline of transformation functions.
+*
+* Applies cleaners sequentially while maintaining accurate position mappings
+* between the original and cleaned text. This enables citation extraction from
+* cleaned text while reporting positions in the original text.
+*
+* @param original - Original input text
+* @param cleaners - Array of cleaner functions to apply (default: stripHtmlTags, normalizeWhitespace, normalizeUnicode, fixSmartQuotes)
+* @returns Cleaned text with position mappings and warnings
+*
+* @example
+* const result = cleanText("Smith v. <b>Doe</b>, 500 F.2d 123")
+* // result.cleaned: "Smith v. Doe, 500 F.2d 123"
+* // result.transformationMap tracks position shifts from HTML removal
+*/
+declare function cleanText(original: string, cleaners?: Array<(text: string) => string>): CleanTextResult;
+//#endregion
+//#region src/tokenize/tokenizer.d.ts
+/**
+* A token representing a potential citation found in cleaned text.
+*
+* Tokens are produced by applying regex patterns to cleaned text.
+* They include matched text, position in cleaned text, and pattern metadata
+* for use in the extraction layer.
+*/
+interface Token {
+  /** Matched text from input */
+  text: string;
+  /** Position in cleaned text (cleanStart/cleanEnd only, no original positions yet) */
+  span: Pick<Span, "cleanStart" | "cleanEnd">;
+  /** Pattern type that matched this token */
+  type: Pattern["type"];
+  /** Pattern ID that matched this token */
+  patternId: string;
+}
+/**
+* Tokenizes cleaned text by applying regex patterns to find citation candidates.
+*
+* For each pattern in the patterns array:
+*   1. Apply pattern.regex.matchAll(cleanedText)
+*   2. Create Token for each match with position, text, and pattern metadata
+*   3. Collect all tokens from all patterns
+*   4. Sort by cleanStart position (ascending)
+*
+* Timeout protection: If a pattern throws (e.g., ReDoS), skip it and continue
+* with remaining patterns. Logs warning to console.
+*
+* Note: This function is synchronous because regex matching is inherently
+* synchronous. This enables both sync (extractCitations) and async
+* (extractCitationsAsync) APIs in Plan 6.
+*
+* @param cleanedText - Text that has been cleaned by cleanText() from Plan 1
+* @param patterns - Regex patterns to apply (defaults to all patterns from Plan 2)
+* @returns Array of tokens sorted by position (cleanStart ascending)
+*
+* @example
+* ```typescript
+* import { tokenize } from '@/tokenize'
+* import { cleanText } from '@/clean'
+*
+* const original = "See Smith v. Doe, 500 F.2d 123 (9th Cir. 2020)"
+* const { cleanedText } = cleanText(original)
+* const tokens = tokenize(cleanedText)
+* // tokens[0] = {
+* //   text: "500 F.2d 123",
+* //   span: { cleanStart: 18, cleanEnd: 30 },
+* //   type: "case",
+* //   patternId: "federal-reporter"
+* // }
+* ```
+*/
+declare function tokenize(cleanedText: string, patterns?: Pattern[]): Token[];
+//#endregion
+//#region src/extract/extractCase.d.ts
+/**
+* Extracts case citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Volume: Leading digits (e.g., "500" from "500 F.2d 123")
+* - Reporter: Alphabetic abbreviation (e.g., "F.2d")
+* - Page: Trailing digits after reporter (e.g., "123")
+* - Pincite: Optional page reference after comma (e.g., ", 125")
+* - Court: Optional court abbreviation in parentheses (e.g., "(9th Cir.)")
+* - Year: Optional year in parentheses (e.g., "(2020)")
+*
+* Confidence scoring:
+* - Base: 0.5
+* - Common reporter pattern (F., U.S., etc.): +0.3
+* - Valid year (not future): +0.2
+* - Capped at 1.0
+*
+* Position translation:
+* - Uses TransformationMap to convert clean positions → original positions
+* - cleanStart/cleanEnd from token span
+* - originalStart/originalEnd via transformationMap.cleanToOriginal
+*
+* Note: This function does NOT validate against reporters-db. That happens
+* in Phase 3 (resolution layer). Phase 2 extraction only parses structure.
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns FullCaseCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "500 F.2d 123, 125",
+*   span: { cleanStart: 10, cleanEnd: 27 },
+*   type: "case",
+*   patternId: "federal-reporter"
+* }
+* const citation = extractCase(token, transformationMap)
+* // citation = {
+* //   type: "case",
+* //   text: "500 F.2d 123, 125",
+* //   volume: 500,
+* //   reporter: "F.2d",
+* //   page: 123,
+* //   pincite: 125,
+* //   span: { cleanStart: 10, cleanEnd: 27, originalStart: 10, originalEnd: 27 },
+* //   confidence: 0.8,
+* //   ...
+* // }
+* ```
+*/
+declare function extractCase(token: Token, transformationMap: TransformationMap): FullCaseCitation;
+//#endregion
+//#region src/extract/extractStatute.d.ts
+/**
+* Extracts statute citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Title: Optional leading digits (e.g., "42" from "42 U.S.C. § 1983")
+* - Code: Statutory code abbreviation (e.g., "U.S.C.", "Cal. Civ. Code")
+* - Section: Section number after § symbol (e.g., "1983")
+* - Subsections: Optional parenthetical subdivisions (e.g., "(a)(1)")
+*
+* Confidence scoring:
+* - Base: 0.5
+* - Known code pattern (U.S.C., C.F.R., state codes): +0.3
+* - Capped at 1.0
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns StatuteCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "42 U.S.C. § 1983",
+*   span: { cleanStart: 10, cleanEnd: 26 },
+*   type: "statute",
+*   patternId: "usc"
+* }
+* const citation = extractStatute(token, transformationMap)
+* // citation = {
+* //   type: "statute",
+* //   title: 42,
+* //   code: "U.S.C.",
+* //   section: "1983",
+* //   ...
+* // }
+* ```
+*/
+declare function extractStatute(token: Token, transformationMap: TransformationMap): StatuteCitation;
+//#endregion
+//#region src/extract/extractJournal.d.ts
+/**
+* Extracts journal citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Volume: Leading digits (e.g., "123" from "123 Harv. L. Rev. 456")
+* - Journal: Journal abbreviation (e.g., "Harv. L. Rev.")
+* - Page: Starting page number (e.g., "456")
+* - Pincite: Optional specific page reference after comma (e.g., ", 458")
+*
+* Confidence scoring:
+* - Base: 0.6 (journal validation happens in Phase 3)
+*
+* Note: Author and title extraction from preceding text is not implemented
+* in Phase 2. That requires context analysis in Phase 3.
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns JournalCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "123 Harv. L. Rev. 456",
+*   span: { cleanStart: 10, cleanEnd: 31 },
+*   type: "journal",
+*   patternId: "journal-standard"
+* }
+* const citation = extractJournal(token, transformationMap)
+* // citation = {
+* //   type: "journal",
+* //   volume: 123,
+* //   journal: "Harv. L. Rev.",
+* //   abbreviation: "Harv. L. Rev.",
+* //   page: 456,
+* //   ...
+* // }
+* ```
+*/
+declare function extractJournal(token: Token, transformationMap: TransformationMap): JournalCitation;
+//#endregion
+//#region src/extract/extractNeutral.d.ts
+/**
+* Extracts neutral citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Year: 4-digit year (e.g., "2020")
+* - Court: Vendor identifier (e.g., "WL", "U.S. LEXIS")
+* - Document number: Unique document identifier (e.g., "123456")
+*
+* Confidence scoring:
+* - 1.0 (neutral format is unambiguous and standardized)
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns NeutralCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "2020 WL 123456",
+*   span: { cleanStart: 10, cleanEnd: 24 },
+*   type: "neutral",
+*   patternId: "westlaw-neutral"
+* }
+* const citation = extractNeutral(token, transformationMap)
+* // citation = {
+* //   type: "neutral",
+* //   year: 2020,
+* //   court: "WL",
+* //   documentNumber: "123456",
+* //   confidence: 1.0,
+* //   ...
+* // }
+* ```
+*/
+declare function extractNeutral(token: Token, transformationMap: TransformationMap): NeutralCitation;
+//#endregion
+//#region src/extract/extractPublicLaw.d.ts
+/**
+* Extracts public law citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Congress: Congress number (e.g., "116" from "Pub. L. No. 116-283")
+* - Law number: Law number within that Congress (e.g., "283")
+*
+* Confidence scoring:
+* - 0.9 (public law format is fairly standard)
+*
+* Note: Bill title extraction from nearby text is not implemented in Phase 2.
+* That requires context analysis in Phase 3.
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns PublicLawCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "Pub. L. No. 116-283",
+*   span: { cleanStart: 10, cleanEnd: 29 },
+*   type: "publicLaw",
+*   patternId: "public-law"
+* }
+* const citation = extractPublicLaw(token, transformationMap)
+* // citation = {
+* //   type: "publicLaw",
+* //   congress: 116,
+* //   lawNumber: 283,
+* //   confidence: 0.9,
+* //   ...
+* // }
+* ```
+*/
+declare function extractPublicLaw(token: Token, transformationMap: TransformationMap): PublicLawCitation;
+//#endregion
+//#region src/extract/extractFederalRegister.d.ts
+/**
+* Extracts Federal Register citation metadata from a tokenized citation.
+*
+* Parses token text to extract:
+* - Volume: Federal Register volume number (e.g., "85")
+* - Page: Page number (e.g., "12345")
+* - Year: Optional publication year in parentheses (e.g., "(2021)")
+*
+* Confidence scoring:
+* - 0.9 (Federal Register format is standardized)
+*
+* @param token - Token from tokenizer containing matched text and clean positions
+* @param transformationMap - Position mapping from clean → original text
+* @returns FederalRegisterCitation with parsed metadata and translated positions
+*
+* @example
+* ```typescript
+* const token = {
+*   text: "85 Fed. Reg. 12345",
+*   span: { cleanStart: 10, cleanEnd: 28 },
+*   type: "federalRegister",
+*   patternId: "federal-register"
+* }
+* const citation = extractFederalRegister(token, transformationMap)
+* // citation = {
+* //   type: "federalRegister",
+* //   volume: 85,
+* //   page: 12345,
+* //   confidence: 0.9,
+* //   ...
+* // }
+* ```
+*/
+declare function extractFederalRegister(token: Token, transformationMap: TransformationMap): FederalRegisterCitation;
+//#endregion
+//#region src/resolve/DocumentResolver.d.ts
+/**
+* Document-scoped resolver that processes citations sequentially
+* and resolves short-form citations to their antecedents.
+*/
+declare class DocumentResolver {
+  private readonly citations;
+  private readonly text;
+  private readonly options;
+  private readonly context;
+  /**
+  * Creates a new DocumentResolver.
+  *
+  * @param citations - All citations in document (in order of appearance)
+  * @param text - Original document text
+  * @param options - Resolution options
+  */
+  constructor(citations: Citation[], text: string, options?: ResolutionOptions);
+  /**
+  * Resolves all citations in the document.
+  *
+  * @returns Array of citations with resolution metadata
+  */
+  resolve(): ResolvedCitation[];
+  /**
+  * Resolves Id. citation to immediately preceding full case citation.
+  */
+  private resolveId;
+  /**
+  * Resolves supra citation by matching party name.
+  */
+  private resolveSupra;
+  /**
+  * Resolves short-form case citation by matching volume/reporter.
+  */
+  private resolveShortFormCase;
+  /**
+  * Checks if a citation is a full citation (not short-form).
+  */
+  private isFullCitation;
+  /**
+  * Tracks a full citation in the resolution history.
+  * Extracts party name for supra resolution.
+  */
+  private trackFullCitation;
+  /**
+  * Extracts party name from full case citation text.
+  * Handles "Party v. Party" format by looking at text before citation span.
+  */
+  private extractPartyName;
+  /**
+  * Normalizes party name for matching.
+  */
+  private normalizePartyName;
+  /**
+  * Normalizes reporter abbreviation for matching.
+  */
+  private normalizeReporter;
+  /**
+  * Checks if antecedent citation is within scope boundary.
+  */
+  private isWithinScope;
+  /**
+  * Creates a failure result for unresolved citations.
+  */
+  private createFailureResult;
+}
+//#endregion
+//#region src/resolve/index.d.ts
+/**
+* Resolves short-form citations to their full antecedents.
+*
+* Convenience wrapper around DocumentResolver that handles common use cases.
+*
+* @param citations - Extracted citations in order of appearance
+* @param text - Original document text
+* @param options - Resolution options
+* @returns Citations with resolution metadata
+*/
+declare function resolveCitations(citations: Citation[], text: string, options?: ResolutionOptions): ResolvedCitation[];
+//#endregion
+export { type Citation, type CitationBase, type CitationType, type CleanTextResult, DocumentResolver, type ExtractOptions, type FederalRegisterCitation, type FullCaseCitation, type IdCitation, type JournalCitation, type NeutralCitation, type PublicLawCitation, type ResolutionOptions, type ResolutionResult, type ResolvedCitation, type ScopeStrategy, type ShortFormCaseCitation, type Span, type StatuteCitation, type SupraCitation, type Token, type TransformationMap, type Warning, cleanText, extractCase, extractCitations, extractCitationsAsync, extractFederalRegister, extractJournal, extractNeutral, extractPublicLaw, extractStatute, resolveCitations, tokenize };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/patterns/casePatterns.ts","../src/resolve/types.ts","../src/extract/extractCitations.ts","../src/clean/cleanText.ts","../src/tokenize/tokenizer.ts","../src/extract/extractCase.ts","../src/extract/extractStatute.ts","../src/extract/extractJournal.ts","../src/extract/extractNeutral.ts","../src/extract/extractPublicLaw.ts","../src/extract/extractFederalRegister.ts","../src/resolve/DocumentResolver.ts","../src/resolve/index.ts"],"mappings":"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"}