@dragon708/docmind-markdown 1.0.0 → 1.1.1

package/dist/index.d.ts

@@ -5,8 +5,17 @@ export { DocumentBlock, DocumentPage, DocumentTable, StructuredDocumentResult }
 interface ConvertStructuredToMarkdownOptions {
     /**
      * When an `image-ref` block has no resolvable `src`, emit this string (default: HTML comment).
+     * Ignored when {@link imageMissingSrcMode} is `llm-label`.
      */
     readonly imagePlaceholder?: string;
+    /**
+     * How to render `image-ref` blocks whose resolved image has no `src` (OCR/placeholders).
+     * - `placeholder` — {@link imagePlaceholder} plus a short kind hint when known (default).
+     * - `llm-label` — plain Markdown italic label with id and alt, easy for models to read without HTML.
+     */
+    readonly imageMissingSrcMode?: "placeholder" | "llm-label";
+    /** If true, append `result.warnings` as a short Markdown section at the end (default: false). */
+    readonly appendWarningsSection?: boolean;
     /** If true, prepend a short human-readable metadata block when `result.metadata` has fields. */
     readonly includeMetadataHeader?: boolean;
     /**
@@ -30,6 +39,9 @@ type StructuredToMarkdownOptions = ConvertStructuredToMarkdownOptions;
 /**
  * Converts a {@link StructuredDocumentResult} to readable, semantic Markdown (GFM-style tables).
  *
+ * **Universal fallback** for DocMind: use when a format-specific pipeline (DOCX Mammoth, PDF OpenDataLoader, …)
+ * does not apply or fails, and for OCR / image / plain-text flows that already populate this shape.
+ *
  * Uses `blocks` in order; resolves `table` / `image-ref` via `tables` and `images`. When blocks are
  * empty or yield no output, falls back to the rollup `text`. Optional sections use `pages`, `metadata`,
  * and unreferenced `tables` / `images` according to options.
@@ -73,13 +85,29 @@ interface ConvertStructuredToLlmTextOptions {
     readonly compact?: boolean;
     /** Omit paragraph blocks whose trimmed text is empty (default `true`). */
     readonly skipEmptyParagraphs?: boolean;
+    /**
+     * Strip zero-width characters and normalize unusual spaces per line (default `true`).
+     * Keeps newlines; tuned for OCR / PDF paste noise.
+     */
+    readonly sanitizeNoise?: boolean;
+    /**
+     * When the table has two or more rows, emit a dashed rule after the first row (default `true`).
+     * Improves scanability for RAG/chat vs a flat pipe list.
+     */
+    readonly tableHeaderSeparator?: boolean;
+    /** Separator between cells in table rows (default ` | `). */
+    readonly tableColumnSeparator?: string;
 }
 /** @deprecated Use {@link ConvertStructuredToLlmTextOptions}. */
 type StructuredToLlmTextOptions = ConvertStructuredToLlmTextOptions;
 /**
  * Linearizes {@link StructuredDocumentResult} into plain text for prompts, RAG, and embeddings:
- * explicit `[Hn]` headings, readable tables, compact list lines, configurable page markers,
- * optional `[DOC]` metadata and `[WARNINGS]`. Not Markdown — tuned for density and clarity.
+ * explicit `[Hn]` headings, pipe-style tables with an optional header rule (aligned with {@link convertStructuredToMarkdown}
+ * semantics), compact list lines, configurable page markers, optional `[DOC]` metadata and `[WARNINGS]`.
+ * Not Markdown — denser and tag-oriented for models.
+ *
+ * Pairs with {@link splitStructuredIntoChunks}: per-chunk `text` uses the same formatter family (slice options omit
+ * document-level noise). Use {@link renderLlmText} as an alias for full-document export.
  */
 declare function convertStructuredToLlmText(result: StructuredDocumentResult, options?: ConvertStructuredToLlmTextOptions): string;
 /**
@@ -97,12 +125,17 @@ interface StructuredChunk {
     readonly markdown?: string;
     /** Breadcrumb of heading texts in scope for this chunk (best-effort). */
     readonly headingPath?: readonly string[];
-    /** Smallest `pageIndex` among blocks in this chunk, when any. */
+    /** Smallest `pageIndex` among blocks in this chunk, when any (0-based, same as blocks). */
     readonly pageIndex?: number;
     /** Largest `pageIndex` among blocks in this chunk, when any. */
     readonly pageEndIndex?: number;
+    /**
+     * Human-facing page span for UI or citations (1-based). E.g. `"3"` or `"2–4"`.
+     * Set when {@link SplitStructuredIntoChunksOptions.includePageSpanLabel} is true and page indices exist.
+     */
+    readonly pageSpanLabel?: string;
 }
-/** Options for {@link splitStructuredIntoChunks}. */
+/** Options for {@link splitStructuredIntoChunks} and {@link extractStructuredChunks}. */
 interface SplitStructuredIntoChunksOptions {
     /** Soft maximum characters for `text` per chunk (default `4000`). Tables may exceed this when {@link preserveTables} is true. */
     readonly maxChars?: number;
@@ -118,14 +151,26 @@ interface SplitStructuredIntoChunksOptions {
     readonly preserveTables?: boolean;
     /** When true (default), fill {@link StructuredChunk.markdown} using {@link convertStructuredToMarkdown} per slice. */
     readonly includeMarkdown?: boolean;
+    /**
+     * When true (default), set {@link StructuredChunk.pageSpanLabel} from {@link StructuredChunk.pageIndex} /
+     * {@link StructuredChunk.pageEndIndex} (1-based for display).
+     */
+    readonly includePageSpanLabel?: boolean;
 }
 /**
- * Splits a {@link StructuredDocumentResult} into ordered chunks for RAG / chat.
+ * Splits a {@link StructuredDocumentResult} into ordered chunks for RAG / chat / hybrid Markdown+text pipelines.
  *
- * First version: one unit per block, greedy packing with soft `maxChar` limits, optional heading-aligned
- * cuts, and atomic tables. Intended to refine later (finer splits, row-level tables, token limits).
+ * - **Headings:** optional hard cuts before each heading when {@link SplitStructuredIntoChunksOptions.preferHeadings} is true.
+ * - **Tables:** kept whole when {@link SplitStructuredIntoChunksOptions.preserveTables} is true (may exceed `maxChars`).
+ * - **Pages:** {@link StructuredChunk.pageIndex}, `pageEndIndex`, and optional {@link StructuredChunk.pageSpanLabel} (1-based).
+ * - **Dual serialization:** `text` uses {@link convertStructuredToLlmText}; `markdown` uses {@link convertStructuredToMarkdown}
+ *   when {@link SplitStructuredIntoChunksOptions.includeMarkdown} is true — same block semantics as full-document export.
  */
 declare function splitStructuredIntoChunks(result: StructuredDocumentResult, options?: SplitStructuredIntoChunksOptions): StructuredChunk[];
+/**
+ * Alias of {@link splitStructuredIntoChunks} — same hybrid Markdown + LLM-text chunking for structured results.
+ */
+declare const extractStructuredChunks: typeof splitStructuredIntoChunks;
 
 /** Options for {@link renderMarkdown} (same as {@link ConvertStructuredToMarkdownOptions}). */
 type RenderMarkdownOptions = ConvertStructuredToMarkdownOptions;
@@ -136,9 +181,16 @@ type RenderLlmTextOptions = ConvertStructuredToLlmTextOptions;
  */
 declare function renderMarkdown(result: StructuredDocumentResult, options?: RenderMarkdownOptions): string;
 /**
- * Ergonomic alias for {@link convertStructuredToLlmText}: full document → plain text for LLM prompts.
+ * Ergonomic alias for {@link convertStructuredToLlmText}: full document → tagged plain text for LLM / RAG / embeddings.
+ * Semantics align with {@link convertStructuredToMarkdown} (headings, tables, page flow); chunks from
+ * {@link splitStructuredIntoChunks} use the same formatter with slice-scoped options for per-segment `text`.
  */
 declare function renderLlmText(result: StructuredDocumentResult, options?: RenderLlmTextOptions): string;
+/**
+ * Same as {@link renderLlmText}: {@link StructuredDocumentResult} → tagged plain text for prompts / RAG.
+ * Use {@link extractMarkdown} when you have raw bytes or a path and optional `structuredFallback`; this entry point is **structured-only** (symmetric naming with facade `extractLlmContent` after they resolve a document).
+ */
+declare function extractLlmContent(result: StructuredDocumentResult, options?: RenderLlmTextOptions): string;
 /** One Markdown slice aligned with chunking (headings / size limits). */
 interface MarkdownSection {
     readonly index: number;
@@ -146,6 +198,8 @@ interface MarkdownSection {
     readonly headingPath?: readonly string[];
     readonly pageIndex?: number;
     readonly pageEndIndex?: number;
+    /** 1-based page span label from {@link StructuredChunk.pageSpanLabel} when present. */
+    readonly pageSpanLabel?: string;
     /** Plain-text slice for the same block span (optional embedding / preview). */
     readonly text?: string;
 }
@@ -159,4 +213,247 @@ type RenderMarkdownSectionsOptions = SplitStructuredIntoChunksOptions;
  */
 declare function renderMarkdownSections(result: StructuredDocumentResult, options?: RenderMarkdownSectionsOptions): MarkdownSection[];
 
-export { type ConvertStructuredToLlmTextOptions, type ConvertStructuredToMarkdownOptions, type MarkdownSection, type RenderLlmTextOptions, type RenderMarkdownOptions, type RenderMarkdownSectionsOptions, type SplitStructuredIntoChunksOptions, type StructuredChunk, type StructuredToLlmTextOptions, type StructuredToMarkdownOptions, convertStructuredToLlmText, convertStructuredToMarkdown, renderLlmText, renderMarkdown, renderMarkdownSections, splitStructuredIntoChunks, structuredDocumentToLlmText, structuredDocumentToMarkdown };
+/**
+ * Binary `.docx` payload accepted by {@link convertDocxToMarkdown}.
+ */
+type DocxToMarkdownInput = Buffer | Uint8Array | ArrayBuffer;
+/**
+ * Options forwarded to `mammoth.convertToHtml` (second argument).
+ * Mirrors mammoth’s `Options` shape so consumers are not forced to depend on mammoth types at compile time.
+ */
+interface MammothConvertToHtmlOptions {
+    readonly styleMap?: string | string[];
+    readonly includeEmbeddedStyleMap?: boolean;
+    readonly includeDefaultStyleMap?: boolean;
+    readonly convertImage?: unknown;
+    readonly ignoreEmptyParagraphs?: boolean;
+    readonly idPrefix?: string;
+    readonly externalFileAccess?: boolean;
+    readonly transformDocument?: (element: unknown) => unknown;
+}
+/**
+ * Optional Turndown constructor options (`headingStyle`, `bulletListMarker`, …).
+ * `turndown` ships without TypeScript types; keep this loose for consumers.
+ */
+type TurndownServiceOptions = Record<string, unknown>;
+/**
+ * Options for {@link convertDocxToMarkdown} (and {@link convertDocxBufferToMarkdown}, which delegates here).
+ *
+ * Semantic toggles apply on top of Mammoth HTML → Turndown. For pixel-perfect Word layout, use another path;
+ * this pipeline targets headings, lists, tables (GFM), and readable images for LLMs.
+ */
+interface ConvertDocxToMarkdownOptions {
+    /**
+     * Keep tables as GFM pipe tables where Mammoth emits `<table>` (uses `turndown-plugin-gfm`).
+     * @default true
+     */
+    readonly includeTables?: boolean;
+    /**
+     * Inline images as `data:` URIs in HTML before Turndown (via Mammoth).
+     * When `false`, `<img>` nodes are stripped from HTML (no figure placeholders in Markdown).
+     * @default true
+     */
+    readonly includeImages?: boolean;
+    /**
+     * Emit visible page separators for Word page breaks (`br[type=page]` → `<hr class="page-break">` → `---` in Markdown).
+     * @default true
+     */
+    readonly includePageBreaks?: boolean;
+    /**
+     * Tighter Markdown: fewer blank lines and trimmed trailing spaces on lines.
+     * @default false
+     */
+    readonly compactMode?: boolean;
+    /**
+     * When set together with {@link resolveStructured}, if the direct Markdown length (trimmed) is **below** this
+     * threshold, the structured fallback runs. Omit to only fall back on errors or completely empty output.
+     */
+    readonly minMarkdownLength?: number;
+    /** Extra mammoth options merged after DocMind-built defaults (e.g. custom `styleMap` entries). */
+    readonly mammoth?: MammothConvertToHtmlOptions;
+    /** Extra Turndown options merged after DocMind defaults. */
+    readonly turndown?: TurndownServiceOptions;
+    /**
+     * When direct Mammoth → Turndown fails, returns empty/short output (per {@link minMarkdownLength}), or you need
+     * block-level structure: provide a supplier that returns {@link StructuredDocumentResult} (e.g. from `@dragon708/docmind-docx`).
+     * The package does not call other monorepo packages by itself.
+     */
+    readonly resolveStructured?: () => Promise<StructuredDocumentResult>;
+    /** Passed to {@link convertStructuredToMarkdown} when {@link resolveStructured} is used. */
+    readonly structuredMarkdown?: ConvertStructuredToMarkdownOptions;
+}
+/** Normalized mammoth diagnostics (warnings/errors as strings). */
+interface DocxMarkdownMessage {
+    readonly type: "warning" | "error" | string;
+    readonly message: string;
+}
+/** @deprecated Prefer {@link ConvertDocxToMarkdownResult} from {@link convertDocxToMarkdown}. */
+interface DocxMarkdownResult {
+    readonly markdown: string;
+    readonly messages: readonly DocxMarkdownMessage[];
+}
+/** Which pipeline produced {@link ConvertDocxToMarkdownResult.markdown}. */
+type DocxToMarkdownSource = "mammoth-turndown" | "structured-fallback";
+interface ConvertDocxToMarkdownResult {
+    readonly markdown: string;
+    readonly source: DocxToMarkdownSource;
+    readonly messages: readonly DocxMarkdownMessage[];
+    /** Set when {@link source} is `structured-fallback`. */
+    readonly fallbackReason?: "error" | "empty" | "short";
+}
+/**
+ * **Node only.** Primary API: `.docx` bytes → semantic HTML (Mammoth) → LLM-friendly Markdown (Turndown + optional GFM).
+ *
+ * Optional peers: `mammoth`, `turndown`. Runtime dependency: `turndown-plugin-gfm` (declared on this package) when
+ * {@link ConvertDocxToMarkdownOptions.includeTables} is true.
+ *
+ * @see {@link convertDocxBufferToMarkdown} for a thin wrapper that only returns `markdown` and `messages`.
+ */
+declare function convertDocxToMarkdown(input: DocxToMarkdownInput, options?: ConvertDocxToMarkdownOptions): Promise<ConvertDocxToMarkdownResult>;
+/**
+ * **Node only.** Same as {@link convertDocxToMarkdown}, but returns only `markdown` and Mammoth `messages` for backward compatibility.
+ */
+declare function convertDocxBufferToMarkdown(input: DocxToMarkdownInput, options?: ConvertDocxToMarkdownOptions): Promise<DocxMarkdownResult>;
+
+/**
+ * Options forwarded to `@opendataloader/pdf` `convert()`, except `format` and `toStdout` (set internally).
+ * Shaped to match `ConvertOptions` from `@opendataloader/pdf` v2.x without a static type import.
+ */
+interface OpenDataLoaderPdfConvertOptions {
+    outputDir?: string;
+    password?: string;
+    quiet?: boolean;
+    contentSafetyOff?: string | string[];
+    sanitize?: boolean;
+    keepLineBreaks?: boolean;
+    replaceInvalidChars?: string;
+    useStructTree?: boolean;
+    tableMethod?: string;
+    readingOrder?: string;
+    markdownPageSeparator?: string;
+    textPageSeparator?: string;
+    htmlPageSeparator?: string;
+    imageOutput?: string;
+    imageFormat?: string;
+    imageDir?: string;
+    pages?: string;
+    includeHeaderFooter?: boolean;
+    detectStrikethrough?: boolean;
+    hybrid?: string;
+    hybridMode?: string;
+    hybridUrl?: string;
+    hybridTimeout?: string;
+    hybridFallback?: boolean;
+}
+/**
+ * Options for {@link convertPdfToMarkdown}. OpenDataLoader fields are passed through; structured fields are local.
+ */
+type ConvertPdfToMarkdownOptions = OpenDataLoaderPdfConvertOptions & {
+    /**
+     * When the OpenDataLoader path fails, returns empty output, or `@opendataloader/pdf` cannot load,
+     * call this to obtain {@link StructuredDocumentResult} (e.g. from another extractor) and serialize with
+     * {@link convertStructuredToMarkdown}. Does not import other DocMind packages.
+     */
+    readonly resolveStructured?: () => Promise<StructuredDocumentResult>;
+    /** Options for {@link convertStructuredToMarkdown} when using {@link resolveStructured}. */
+    readonly structuredMarkdown?: ConvertStructuredToMarkdownOptions;
+    /**
+     * Normalize whitespace in the final Markdown (trim, collapse 3+ newlines to 2).
+     * @default true
+     */
+    readonly cleanMarkdown?: boolean;
+};
+/** Input for {@link convertPdfToMarkdown}: filesystem path (Node) or PDF bytes. */
+type PdfToMarkdownInput = string | Buffer | Uint8Array | ArrayBuffer;
+/** Which pipeline produced {@link ConvertPdfToMarkdownResult.markdown}. */
+type PdfToMarkdownSource = "opendataloader" | "structured-fallback" | "unsupported-runtime";
+type PdfToMarkdownFallbackReason = "unsupported-runtime" | "error" | "empty" | "module-not-found";
+interface ConvertPdfToMarkdownResult {
+    readonly markdown: string;
+    /** Human-readable issues (runtime, missing module, Java/PDF errors, empty output, fallback errors). */
+    readonly warnings: readonly string[];
+    readonly source: PdfToMarkdownSource;
+    readonly fallbackReason?: PdfToMarkdownFallbackReason;
+}
+/** @deprecated Prefer {@link ConvertPdfToMarkdownResult} from {@link convertPdfToMarkdown}. */
+interface PdfMarkdownResult {
+    readonly markdown: string;
+}
+/**
+ * Primary API: PDF path or bytes → Markdown via `@opendataloader/pdf` on Node, with clear warnings and optional
+ * structured fallback. In non-Node runtimes returns an empty `markdown` and {@link PdfToMarkdownSource} `unsupported-runtime`
+ * without loading `@opendataloader/pdf`.
+ */
+declare function convertPdfToMarkdown(input: PdfToMarkdownInput, options?: ConvertPdfToMarkdownOptions): Promise<ConvertPdfToMarkdownResult>;
+/**
+ * **Node only.** PDF file path → Markdown via `@opendataloader/pdf` (`format: "markdown"`, `toStdout: true`).
+ *
+ * Throws if not Node, if conversion yields no Markdown (and no structured fallback), or on OpenDataLoader errors
+ * when no fallback is configured — same contract as before {@link convertPdfToMarkdown} existed.
+ */
+declare function convertPdfPathToMarkdown(inputPath: string, options?: ConvertPdfToMarkdownOptions): Promise<PdfMarkdownResult>;
+/**
+ * **Node only.** Same pipeline as {@link convertPdfPathToMarkdown}, but writes bytes to a temporary `.pdf`
+ * under the system temp directory (OpenDataLoader expects a file path).
+ */
+declare function convertPdfBufferToMarkdown(input: Buffer | Uint8Array | ArrayBuffer, options?: ConvertPdfToMarkdownOptions): Promise<PdfMarkdownResult>;
+
+/**
+ * Binary file payload for {@link extractMarkdown} when you have bytes (and optional name/MIME hints).
+ */
+interface ExtractMarkdownFileInput {
+    readonly data: Buffer | Uint8Array | ArrayBuffer;
+    readonly filename?: string;
+    readonly mimeType?: string;
+}
+/**
+ * Node: read a PDF/DOCX from disk. Ignored or warned in non-Node runtimes unless {@link ExtractMarkdownOptions.structuredFallback} is set.
+ */
+interface ExtractMarkdownPathInput {
+    readonly path: string;
+    readonly filename?: string;
+    readonly mimeType?: string;
+}
+type ExtractMarkdownInput = StructuredDocumentResult | ExtractMarkdownFileInput | ExtractMarkdownPathInput;
+/**
+ * Options for {@link extractMarkdown}.
+ *
+ * Top-level fields match {@link ConvertStructuredToMarkdownOptions} so passing the same object you would pass to
+ * {@link convertStructuredToMarkdown} remains valid when `input` is a {@link StructuredDocumentResult}.
+ * Additional fields configure DOCX/PDF branches and cross-strategy fallback.
+ */
+type ExtractMarkdownOptions = ConvertStructuredToMarkdownOptions & {
+    /**
+     * When a specialized binary route fails or cannot run (e.g. DOCX in the browser), this structured snapshot
+     * is passed to {@link convertStructuredToMarkdown} if nothing else produced Markdown.
+     */
+    readonly structuredFallback?: StructuredDocumentResult;
+    /** Overrides merged into {@link convertDocxToMarkdown} when the input is identified as `.docx`. */
+    readonly docx?: ConvertDocxToMarkdownOptions;
+    /** Overrides merged into {@link convertPdfToMarkdown} when the input is identified as `.pdf`. */
+    readonly pdf?: ConvertPdfToMarkdownOptions;
+};
+/** Which branch produced {@link ExtractMarkdownResult.markdown}. */
+type ExtractMarkdownStrategy = "structured" | "docx-mammoth" | "docx-structured-fallback" | "pdf-opendataloader" | "pdf-structured-fallback" | "pdf-unsupported-runtime" | "docx-requires-node" | "path-requires-node" | "binary-unidentified" | "binary-unidentified-structured-fallback";
+interface ExtractMarkdownResult {
+    readonly markdown: string;
+    /** Merged pipeline warnings (conversion, runtime, and optional {@link StructuredDocumentResult.warnings}). */
+    readonly warnings: readonly string[];
+    readonly strategy: ExtractMarkdownStrategy;
+}
+/** Type guard: file-like `{ data: … }` input for {@link extractMarkdown}. */
+declare function isExtractMarkdownFileInput(value: unknown): value is ExtractMarkdownFileInput;
+type DetectedBinaryFormat = "docx" | "pdf" | "unknown";
+/** Detect PDF / OOXML zip (DOCX) from magic bytes and optional filename / MIME. */
+declare function detectBinaryFormat(data: Buffer | Uint8Array | ArrayBuffer, filename?: string, mimeType?: string): DetectedBinaryFormat;
+/**
+ * Produces Markdown from a {@link StructuredDocumentResult}, raw file bytes, or a filesystem `path` (Node),
+ * picking DOCX / PDF specialized pipelines when possible and falling back to {@link convertStructuredToMarkdown}.
+ *
+ * - **Structured input** — always uses the structured serializer (image/OCR/text/PDF/DOCX blocks already normalized).
+ * - **DOCX bytes / path** — {@link convertDocxToMarkdown} on Node; otherwise warns and uses {@link ExtractMarkdownOptions.structuredFallback} if provided.
+ * - **PDF bytes / path** — {@link convertPdfToMarkdown} (`@opendataloader/pdf` on Node when Java is available); in non-Node runtimes returns empty Markdown with warnings unless {@link ExtractMarkdownOptions.structuredFallback} supplies content.
+ */
+declare function extractMarkdown(input: ExtractMarkdownInput, options?: ExtractMarkdownOptions): Promise<ExtractMarkdownResult>;
+
+export { type ConvertDocxToMarkdownOptions, type ConvertDocxToMarkdownResult, type ConvertPdfToMarkdownOptions, type ConvertPdfToMarkdownResult, type ConvertStructuredToLlmTextOptions, type ConvertStructuredToMarkdownOptions, type DetectedBinaryFormat, type DocxMarkdownMessage, type DocxMarkdownResult, type DocxToMarkdownInput, type DocxToMarkdownSource, type ExtractMarkdownFileInput, type ExtractMarkdownInput, type ExtractMarkdownOptions, type ExtractMarkdownPathInput, type ExtractMarkdownResult, type ExtractMarkdownStrategy, type MammothConvertToHtmlOptions, type MarkdownSection, type OpenDataLoaderPdfConvertOptions, type PdfMarkdownResult, type PdfToMarkdownFallbackReason, type PdfToMarkdownInput, type PdfToMarkdownSource, type RenderLlmTextOptions, type RenderMarkdownOptions, type RenderMarkdownSectionsOptions, type SplitStructuredIntoChunksOptions, type StructuredChunk, type StructuredToLlmTextOptions, type StructuredToMarkdownOptions, type TurndownServiceOptions, convertDocxBufferToMarkdown, convertDocxToMarkdown, convertPdfBufferToMarkdown, convertPdfPathToMarkdown, convertPdfToMarkdown, convertStructuredToLlmText, convertStructuredToMarkdown, detectBinaryFormat, extractLlmContent, extractMarkdown, extractStructuredChunks, isExtractMarkdownFileInput, renderLlmText, renderMarkdown, renderMarkdownSections, splitStructuredIntoChunks, structuredDocumentToLlmText, structuredDocumentToMarkdown };