@semiont/api-client 0.2.33 → 0.2.34-build.89

package/dist/utils/index.d.ts

@@ -1 +1,603 @@
-export { al as BoundingBox, F as FragmentSelector, aA as JWTTokenSchema, a1 as LOCALES, a0 as LocaleInfo, W as MatchQuality, ak as Point, i as Selector, h as SvgSelector, V as TextPosition, T as TextPositionSelector, g as TextQuoteSelector, at as ValidatedAnnotation, ay as ValidationFailure, az as ValidationResult, ax as ValidationSuccess, ao as createCircleSvg, an as createPolygonSvg, am as createRectangleSvg, aj as decodeRepresentation, aw as decodeWithCharset, Q as extractBoundingBox, av as extractCharset, as as extractContext, Y as findBestTextMatch, Z as findTextWithContext, a5 as formatLocaleDisplay, a6 as getAllLocaleCodes, H as getAnnotationExactText, j as getBodySource, k as getBodyType, aa as getChecksum, x as getCommentText, ad as getCreator, ae as getDerivedFrom, D as getExactText, O as getFragmentSelector, ab as getLanguage, a4 as getLocaleEnglishName, a2 as getLocaleInfo, a3 as getLocaleNativeName, ai as getNodeEncoding, a9 as getPrimaryMediaType, a8 as getPrimaryRepresentation, I as getPrimarySelector, ag as getResourceEntityTypes, a7 as getResourceId, ac as getStorageUri, N as getSvgSelector, n as getTargetSelector, m as getTargetSource, K as getTextPositionSelector, L as getTextQuoteSelector, q as hasTargetSelector, af as isArchived, t as isAssessment, l as isBodyResolved, u as isComment, ah as isDraft, r as isHighlight, s as isReference, z as isResolvedReference, y as isStubReference, v as isTag, aC as isValidEmail, aq as normalizeCoordinates, X as normalizeText, ap as parseSvgSelector, ar as scaleSvgToNative, au as validateAndCorrectOffsets, aB as validateData, P as validateSvgMarkup, _ as verifyPosition } from '../index-CJqmerJr.js';
+import { components, ResourceUri } from '@semiont/core';
+
+/**
+ * Annotation and Selector Utilities
+ *
+ * Pure TypeScript utilities for working with W3C Web Annotations.
+ * No React dependencies - safe to use in any JavaScript environment.
+ *
+ * Body is either empty array (stub) or single SpecificResource (resolved)
+ * Body can be array of TextualBody (tagging) + SpecificResource (linking)
+ * Target can be simple string IRI or object with source and optional selector
+ */
+
+type Annotation = components['schemas']['Annotation'];
+type HighlightAnnotation = Annotation;
+type ReferenceAnnotation = Annotation;
+type TextPositionSelector = components['schemas']['TextPositionSelector'];
+type TextQuoteSelector = components['schemas']['TextQuoteSelector'];
+type SvgSelector = components['schemas']['SvgSelector'];
+type FragmentSelector = components['schemas']['FragmentSelector'];
+type Selector = TextPositionSelector | TextQuoteSelector | SvgSelector | FragmentSelector;
+
+/**
+ * Get the source from an annotation body (null if stub)
+ * Search for SpecificResource in body array
+ */
+declare function getBodySource(body: Annotation['body']): ResourceUri | null;
+/**
+ * Get the type from an annotation body (returns first body type in array)
+ */
+declare function getBodyType(body: Annotation['body']): 'TextualBody' | 'SpecificResource' | null;
+/**
+ * Check if body is resolved (has a source)
+ * Check for SpecificResource in body array
+ */
+declare function isBodyResolved(body: Annotation['body']): boolean;
+/**
+ * Get the source IRI from target (handles both string and object forms)
+ */
+declare function getTargetSource(target: Annotation['target']): ResourceUri;
+/**
+ * Get the selector from target (undefined if string or no selector)
+ */
+declare function getTargetSelector(target: Annotation['target']): {
+    type: "TextPositionSelector";
+    start: number;
+    end: number;
+} | {
+    type: "TextQuoteSelector";
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+} | {
+    type: "SvgSelector";
+    value: string;
+} | {
+    type: "FragmentSelector";
+    value: string;
+    conformsTo?: string;
+} | ({
+    type: "TextPositionSelector";
+    start: number;
+    end: number;
+} | {
+    type: "TextQuoteSelector";
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+} | {
+    type: "SvgSelector";
+    value: string;
+} | {
+    type: "FragmentSelector";
+    value: string;
+    conformsTo?: string;
+})[] | undefined;
+/**
+ * Check if target has a selector
+ */
+declare function hasTargetSelector(target: Annotation['target']): boolean;
+/**
+ * Type guard to check if an annotation is a highlight
+ */
+declare function isHighlight(annotation: Annotation): annotation is HighlightAnnotation;
+/**
+ * Type guard to check if an annotation is a reference (linking)
+ */
+declare function isReference(annotation: Annotation): annotation is ReferenceAnnotation;
+/**
+ * Type guard to check if an annotation is an assessment
+ */
+declare function isAssessment(annotation: Annotation): annotation is Annotation;
+/**
+ * Type guard to check if an annotation is a comment
+ */
+declare function isComment(annotation: Annotation): annotation is Annotation;
+/**
+ * Type guard to check if an annotation is a tag
+ */
+declare function isTag(annotation: Annotation): annotation is Annotation;
+/**
+ * Extract comment text from a comment annotation's body
+ * @param annotation - The annotation to extract comment text from
+ * @returns The comment text, or undefined if not a comment or no text found
+ */
+declare function getCommentText(annotation: Annotation): string | undefined;
+/**
+ * Type guard to check if a reference annotation is a stub (unresolved)
+ * Stub if no SpecificResource in body array
+ */
+declare function isStubReference(annotation: Annotation): boolean;
+/**
+ * Type guard to check if a reference annotation is resolved
+ * Resolved if SpecificResource exists in body array
+ */
+declare function isResolvedReference(annotation: Annotation): annotation is ReferenceAnnotation;
+/**
+ * Get the exact text from a selector (single or array)
+ *
+ * When selector is an array, tries to find a TextQuoteSelector (which has exact text).
+ * TextPositionSelector does not have exact text, only character offsets.
+ * Handles undefined selector (when target is a string IRI with no selector)
+ */
+declare function getExactText(selector: Selector | Selector[] | undefined): string;
+/**
+ * Get the exact text from an annotation's target selector
+ * Uses getTargetSelector helper to safely get selector
+ */
+declare function getAnnotationExactText(annotation: Annotation): string;
+/**
+ * Get the primary selector from a selector (single or array)
+ *
+ * When selector is an array, returns the first selector.
+ * When selector is a single object, returns it as-is.
+ */
+declare function getPrimarySelector(selector: Selector | Selector[]): Selector;
+/**
+ * Get TextPositionSelector from a selector (single or array)
+ *
+ * Returns the first TextPositionSelector found, or null if none exists.
+ * Handles undefined selector (when target is a string IRI with no selector)
+ */
+declare function getTextPositionSelector(selector: Selector | Selector[] | undefined): TextPositionSelector | null;
+/**
+ * Get TextQuoteSelector from a selector (single or array)
+ *
+ * Returns the first TextQuoteSelector found, or null if none exists.
+ */
+declare function getTextQuoteSelector(selector: Selector | Selector[]): TextQuoteSelector | null;
+/**
+ * Get SvgSelector from a selector (single or array)
+ *
+ * Returns the first SvgSelector found, or null if none exists.
+ */
+declare function getSvgSelector(selector: Selector | Selector[] | undefined): SvgSelector | null;
+/**
+ * Get FragmentSelector from a selector (single or array)
+ *
+ * Returns the first FragmentSelector found, or null if none exists.
+ */
+declare function getFragmentSelector(selector: Selector | Selector[] | undefined): FragmentSelector | null;
+/**
+ * Validate SVG markup for W3C compliance
+ *
+ * Checks that:
+ * - SVG contains xmlns attribute
+ * - SVG is well-formed XML
+ * - SVG contains at least one shape element
+ *
+ * @returns null if valid, error message if invalid
+ */
+declare function validateSvgMarkup(svg: string): string | null;
+/**
+ * Extract bounding box from SVG markup
+ *
+ * Attempts to extract x, y, width, height from the SVG viewBox or root element.
+ * Returns null if bounding box cannot be determined.
+ */
+declare function extractBoundingBox(svg: string): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+} | null;
+
+/**
+ * Fuzzy Anchoring for W3C Web Annotation TextQuoteSelector
+ *
+ * Uses prefix/suffix context to disambiguate when the same text appears multiple times.
+ * Implements fuzzy matching as specified in the W3C Web Annotation Data Model.
+ *
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
+ */
+interface TextPosition {
+    start: number;
+    end: number;
+}
+type MatchQuality = 'exact' | 'normalized' | 'case-insensitive' | 'fuzzy';
+/**
+ * Normalize text for comparison - handles common document editing changes
+ *
+ * Collapses whitespace, converts curly quotes to straight quotes,
+ * and normalizes common punctuation variations.
+ */
+declare function normalizeText(text: string): string;
+/**
+ * Find best match for text in content using multi-strategy search
+ *
+ * Shared core logic used by both findTextWithContext and validateAndCorrectOffsets.
+ *
+ * @param content - Full text content to search within
+ * @param searchText - The text to find
+ * @param positionHint - Optional hint for where to search (TextPositionSelector.start)
+ * @returns Match with position and quality, or null if not found
+ */
+declare function findBestTextMatch(content: string, searchText: string, positionHint?: number): {
+    start: number;
+    end: number;
+    matchQuality: MatchQuality;
+} | null;
+/**
+ * Find text using exact match with optional prefix/suffix context
+ *
+ * When the exact text appears multiple times in the content, prefix and suffix
+ * are used to disambiguate and find the correct occurrence.
+ *
+ * If exact text is not found, uses multi-strategy fuzzy matching (normalization,
+ * case-insensitive, Levenshtein distance) to locate changed text.
+ *
+ * @param content - Full text content to search within
+ * @param exact - The exact text to find
+ * @param prefix - Optional text that should appear immediately before the match
+ * @param suffix - Optional text that should appear immediately after the match
+ * @param positionHint - Optional position hint (from TextPositionSelector) for fuzzy search
+ * @returns Position of the matched text, or null if not found
+ *
+ * @example
+ * ```typescript
+ * const content = "The cat sat. The cat ran.";
+ * // Find second "The cat" occurrence
+ * const pos = findTextWithContext(content, "The cat", "sat. ", " ran");
+ * // Returns { start: 13, end: 20 }
+ * ```
+ */
+declare function findTextWithContext(content: string, exact: string, prefix?: string, suffix?: string, positionHint?: number): TextPosition | null;
+/**
+ * Verify that a position correctly points to the exact text
+ * Useful for debugging and validation
+ */
+declare function verifyPosition(content: string, position: TextPosition, expectedExact: string): boolean;
+
+/**
+ * Locale information
+ * Copied from SDK for frontend use
+ */
+interface LocaleInfo {
+    code: string;
+    nativeName: string;
+    englishName: string;
+}
+declare const LOCALES: readonly LocaleInfo[];
+/**
+ * Get locale information by code
+ */
+declare function getLocaleInfo(code: string | undefined): LocaleInfo | undefined;
+/**
+ * Get the native name of a language by its locale code
+ */
+declare function getLocaleNativeName(code: string | undefined): string | undefined;
+/**
+ * Get the English name of a language by its locale code
+ */
+declare function getLocaleEnglishName(code: string | undefined): string | undefined;
+/**
+ * Format locale code for display as "Native Name (code)"
+ */
+declare function formatLocaleDisplay(code: string | undefined): string | undefined;
+/**
+ * Get all supported locale codes
+ */
+declare function getAllLocaleCodes(): readonly string[];
+
+/**
+ * Helper functions for working with W3C ResourceDescriptor
+ */
+
+type ResourceDescriptor = components['schemas']['ResourceDescriptor'];
+type Representation = components['schemas']['Representation'];
+/**
+ * Get the resource ID from @id property
+ *
+ * For internal resources: extracts UUID from "http://localhost:4000/resources/{uuid}"
+ * For external resources: returns undefined
+ *
+ * This is used for routing - the frontend URL should contain only the resource ID,
+ * not the full HTTP URI.
+ */
+declare function getResourceId(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Get the primary representation (first or only representation)
+ */
+declare function getPrimaryRepresentation(resource: ResourceDescriptor | undefined): Representation | undefined;
+/**
+ * Get the media type from the primary representation
+ */
+declare function getPrimaryMediaType(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Get the checksum from the primary representation
+ */
+declare function getChecksum(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Get the language from the primary representation
+ */
+declare function getLanguage(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Get storage URI from primary representation
+ *
+ * @param resource - ResourceDescriptor
+ * @returns Storage URI or undefined
+ */
+declare function getStorageUri(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Get creator agent from wasAttributedTo
+ * Handles both single agent and array of agents
+ *
+ * @param resource - ResourceDescriptor
+ * @returns First agent or undefined
+ */
+declare function getCreator(resource: ResourceDescriptor | undefined): components['schemas']['Agent'] | undefined;
+/**
+ * Get derived-from URI
+ * Handles both single URI and array of URIs
+ *
+ * @param resource - ResourceDescriptor
+ * @returns First derivation URI or undefined
+ */
+declare function getDerivedFrom(resource: ResourceDescriptor | undefined): string | undefined;
+/**
+ * Check if resource is archived (application-specific field)
+ *
+ * @param resource - ResourceDescriptor
+ * @returns True if archived, false otherwise
+ */
+declare function isArchived(resource: ResourceDescriptor | undefined): boolean;
+/**
+ * Get entity types from resource (application-specific field)
+ *
+ * @param resource - ResourceDescriptor
+ * @returns Array of entity types, empty if not set
+ */
+declare function getResourceEntityTypes(resource: ResourceDescriptor | undefined): string[];
+/**
+ * Check if resource is a draft (application-specific field)
+ *
+ * @param resource - ResourceDescriptor
+ * @returns True if draft, false otherwise
+ */
+declare function isDraft(resource: ResourceDescriptor | undefined): boolean;
+/**
+ * Map charset names to Node.js Buffer encoding names
+ * Node.js Buffer.toString() supports: 'utf8', 'utf16le', 'latin1', 'base64', 'hex', 'ascii', 'binary', 'ucs2'
+ *
+ * @param charset - Charset name (e.g., "UTF-8", "ISO-8859-1", "Windows-1252")
+ * @returns Node.js BufferEncoding
+ */
+declare function getNodeEncoding(charset: string): BufferEncoding;
+/**
+ * Decode a representation buffer to string using the correct charset
+ * Extracts charset from media type and uses appropriate encoding
+ *
+ * @param buffer - The raw representation data
+ * @param mediaType - Media type with optional charset (e.g., "text/plain; charset=iso-8859-1")
+ * @returns Decoded string
+ *
+ * @example
+ * ```typescript
+ * const content = decodeRepresentation(buffer, "text/plain; charset=utf-8");
+ * const legacy = decodeRepresentation(buffer, "text/plain; charset=windows-1252");
+ * ```
+ */
+declare function decodeRepresentation(buffer: Buffer, mediaType: string): string;
+
+/**
+ * SVG Utility Functions
+ *
+ * Utilities for creating, parsing, and manipulating W3C-compliant SVG selectors
+ * for image annotation.
+ */
+interface Point {
+    x: number;
+    y: number;
+}
+interface BoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Create W3C-compliant SVG rectangle selector
+ */
+declare function createRectangleSvg(start: Point, end: Point): string;
+/**
+ * Create W3C-compliant SVG polygon selector
+ */
+declare function createPolygonSvg(points: Point[]): string;
+/**
+ * Create W3C-compliant SVG circle selector
+ */
+declare function createCircleSvg(center: Point, radius: number): string;
+/**
+ * Parse SVG selector to extract shape type and data
+ */
+declare function parseSvgSelector(svg: string): {
+    type: 'rect' | 'polygon' | 'circle' | 'path';
+    data: any;
+} | null;
+/**
+ * Normalize coordinates from display space to image native resolution
+ */
+declare function normalizeCoordinates(point: Point, displayWidth: number, displayHeight: number, imageWidth: number, imageHeight: number): Point;
+/**
+ * Scale entire SVG selector from display space to image native resolution
+ */
+declare function scaleSvgToNative(svg: string, displayWidth: number, displayHeight: number, imageWidth: number, imageHeight: number): string;
+
+/**
+ * Text context extraction utilities for W3C Web Annotation TextQuoteSelector
+ *
+ * Provides robust prefix/suffix context extraction with word boundary detection
+ * to ensure fuzzy anchoring works correctly when the same text appears multiple times.
+ *
+ * Also provides AI offset validation and correction for handling AI-generated annotations
+ * where the model may return slightly incorrect character offsets.
+ *
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
+ */
+
+/**
+ * Extract prefix and suffix context for TextQuoteSelector
+ *
+ * Extracts up to 64 characters before and after the selected text,
+ * extending to word boundaries to avoid cutting words in half.
+ * This ensures prefix/suffix are meaningful context for fuzzy anchoring.
+ *
+ * @param content - Full text content
+ * @param start - Start offset of selection
+ * @param end - End offset of selection
+ * @returns Object with prefix and suffix (undefined if at boundaries)
+ *
+ * @example
+ * ```typescript
+ * const content = "The United States Congress...";
+ * const context = extractContext(content, 4, 17); // "United States"
+ * // Returns: { prefix: "The ", suffix: " Congress..." }
+ * // NOT: { prefix: "nited ", suffix: "gress..." }
+ * ```
+ */
+declare function extractContext(content: string, start: number, end: number): {
+    prefix?: string;
+    suffix?: string;
+};
+/**
+ * Result of validating and correcting AI-provided annotation offsets
+ */
+interface ValidatedAnnotation {
+    start: number;
+    end: number;
+    exact: string;
+    prefix?: string;
+    suffix?: string;
+    corrected: boolean;
+    fuzzyMatched?: boolean;
+    matchQuality?: MatchQuality;
+}
+/**
+ * Validate and correct AI-provided annotation offsets with fuzzy matching tolerance
+ *
+ * AI models sometimes return offsets that don't match the actual text position,
+ * or provide text with minor variations (case differences, whitespace, typos).
+ *
+ * This function uses a multi-strategy approach:
+ * 1. Check if AI's offsets are exactly correct
+ * 2. Try exact case-sensitive search
+ * 3. Try case-insensitive search
+ * 4. Try fuzzy matching with Levenshtein distance (5% tolerance)
+ *
+ * This ensures we're maximally tolerant of AI errors while still maintaining
+ * annotation quality and logging what corrections were made.
+ *
+ * @param content - Full text content
+ * @param aiStart - Start offset from AI
+ * @param aiEnd - End offset from AI
+ * @param exact - The exact text that should be at this position (from AI)
+ * @returns Validated annotation with corrected offsets and context
+ * @throws Error if no acceptable match can be found
+ *
+ * @example
+ * ```typescript
+ * // AI said start=1143, but actual text is at 1161
+ * const result = validateAndCorrectOffsets(
+ *   content,
+ *   1143,
+ *   1289,
+ *   "the question \"whether..."
+ * );
+ * // Returns: { start: 1161, end: 1303, exact: "...", corrected: true, matchQuality: 'exact', ... }
+ * ```
+ */
+declare function validateAndCorrectOffsets(content: string, aiStart: number, aiEnd: number, exact: string): ValidatedAnnotation;
+
+/**
+ * Text encoding utilities for consistent charset handling
+ *
+ * Ensures frontend decoding matches backend decoding by respecting
+ * charset parameters in mediaType (e.g., "text/plain; charset=iso-8859-1")
+ */
+/**
+ * Extract charset from mediaType parameter
+ *
+ * @param mediaType - Media type with optional charset (e.g., "text/plain; charset=utf-8")
+ * @returns Charset name in lowercase (defaults to "utf-8")
+ *
+ * @example
+ * extractCharset("text/plain; charset=iso-8859-1") // "iso-8859-1"
+ * extractCharset("text/plain") // "utf-8"
+ */
+declare function extractCharset(mediaType: string): string;
+/**
+ * Decode ArrayBuffer to string using charset from mediaType
+ *
+ * Uses TextDecoder with the charset extracted from mediaType parameter.
+ * This ensures the same character space is used for both annotation creation
+ * (backend) and rendering (frontend).
+ *
+ * @param buffer - Binary data to decode
+ * @param mediaType - Media type with optional charset parameter
+ * @returns Decoded string in the original character space
+ *
+ * @example
+ * const buffer = new Uint8Array([...]);
+ * const text = decodeWithCharset(buffer, "text/plain; charset=iso-8859-1");
+ */
+declare function decodeWithCharset(buffer: ArrayBuffer, mediaType: string): string;
+
+/**
+ * Generic validation utilities for @semiont/api-client
+ *
+ * Pure TypeScript validation with no external dependencies.
+ * Safe to use in any JavaScript environment (Node.js, browser, Deno, etc.)
+ */
+/**
+ * Validation result types
+ */
+type ValidationSuccess<T> = {
+    success: true;
+    data: T;
+};
+type ValidationFailure = {
+    success: false;
+    error: string;
+    details?: string[];
+};
+type ValidationResult<T> = ValidationSuccess<T> | ValidationFailure;
+/**
+ * JWT Token validation
+ *
+ * Validates JWT token format (header.payload.signature).
+ * Does not verify signature - use for format validation only.
+ */
+declare const JWTTokenSchema: {
+    parse(token: unknown): string;
+    safeParse(token: unknown): ValidationResult<string>;
+};
+/**
+ * Generic validation helper with error formatting
+ *
+ * Wraps any schema's parse method with try/catch and returns ValidationResult.
+ *
+ * @example
+ * ```typescript
+ * const result = validateData(JWTTokenSchema, 'eyJ...');
+ * if (result.success) {
+ *   console.log('Valid token:', result.data);
+ * } else {
+ *   console.error('Invalid:', result.error);
+ * }
+ * ```
+ */
+declare function validateData<T>(schema: {
+    parse(data: unknown): T;
+}, data: unknown): ValidationResult<T>;
+/**
+ * Email validation helper
+ *
+ * Validates email format using RFC 5322 simplified regex.
+ *
+ * @param email - Email address to validate
+ * @returns true if valid email format
+ */
+declare function isValidEmail(email: string): boolean;
+
+export { type BoundingBox, type FragmentSelector, JWTTokenSchema, LOCALES, type LocaleInfo, type MatchQuality, type Point, type Selector, type SvgSelector, type TextPosition, type TextPositionSelector, type TextQuoteSelector, type ValidatedAnnotation, type ValidationFailure, type ValidationResult, type ValidationSuccess, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isHighlight, isReference, isResolvedReference, isStubReference, isTag, isValidEmail, normalizeCoordinates, normalizeText, parseSvgSelector, scaleSvgToNative, validateAndCorrectOffsets, validateData, validateSvgMarkup, verifyPosition };

package/dist/utils/index.js

@@ -1,10 +1,4 @@
-// src/branded-types.ts
-function resourceUri(uri) {
-  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-    throw new TypeError(`Expected ResourceUri, got: ${uri}`);
-  }
-  return uri;
-}
+import { resourceUri } from '@semiont/core';
 
 // src/utils/annotations.ts
 function getBodySource(body) {