react-native-pageindex 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+---
+
+## [0.1.0] — 2026-03-07
+
+### Added
+- Initial release — TypeScript port of the Python PageIndex project
+- **`pageIndex()`** — PDF hierarchical tree index pipeline (13-step with progress)
+- **`pageIndexMd()`** — Markdown hierarchical tree index pipeline (8-step with progress)
+- **`pageIndexDocument()`** — Unified multi-format entrypoint; auto-detects format from filename
+- **`buildReverseIndex()`** — Inverted index from a forward-index result; `'keyword'` and `'llm'` modes
+- **`searchReverseIndex()`** — Multi-term query with partial-match scoring
+- **Format parsers:**
+  - `extractPdfPages()` — PDF via pdfjs-dist (optional dep)
+  - `extractDocxPages()` — DOCX via mammoth (optional dep)
+  - `extractCsvPages()` — CSV, pure JS, zero dependencies
+  - `extractXlsxPages()` — XLSX / XLS via SheetJS (optional dep)
+- **Progress tracking** — `onProgress` callback on all pipelines and `buildReverseIndex`
+- **Provider-agnostic LLM** — pass any `LLMProvider` callback (OpenAI, Anthropic, Ollama, Gemini…)
+- Full TypeScript types and `.d.ts` declarations

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 subham11 (https://github.com/subham11)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,405 @@
+# react-native-pageindex
+
+[![npm version](https://img.shields.io/npm/v/react-native-pageindex.svg)](https://www.npmjs.com/package/react-native-pageindex)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**Vectorless, reasoning-based RAG** — builds a hierarchical tree index from any document using any LLM provider. Works in React Native, Node.js, and the browser.
+
+No vector database required. Instead of embeddings, the library uses the LLM to *reason* about document structure, producing a navigable tree that lets your AI answer questions with precise source attribution.
+
+---
+
+## Features
+
+| Feature | Detail |
+|---|---|
+| **Multi-format** | PDF, Word (.docx), CSV, Spreadsheet (.xlsx/.xls), Markdown |
+| **Forward index** | Hierarchical tree: chapters → sections → subsections |
+| **Reverse index** | Inverted index: term → node locations for fast lookup |
+| **Provider-agnostic** | Pass any LLM (OpenAI, Anthropic, Ollama, Gemini…) |
+| **Progress tracking** | Fine-grained per-step callbacks (13 PDF steps, 8 MD steps) |
+| **Fully typed** | 100% TypeScript, `.d.ts` declarations included |
+| **Optional deps** | pdfjs-dist / mammoth / xlsx are opt-in; CSV & MD have zero deps |
+
+---
+
+## Installation
+
+```bash
+npm install react-native-pageindex
+```
+
+### Optional format dependencies
+
+Install only what you need:
+
+```bash
+# PDF support
+npm install pdfjs-dist
+
+# Word .docx support
+npm install mammoth
+
+# Excel / spreadsheet support
+npm install xlsx
+```
+
+---
+
+## Quick Start
+
+### 1. Wire up your LLM provider
+
+```ts
+import OpenAI from 'openai';
+import { LLMProvider } from 'react-native-pageindex';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+const llm: LLMProvider = async (prompt, opts) => {
+  const res = await openai.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [
+      ...(opts?.chatHistory ?? []),
+      { role: 'user', content: prompt },
+    ],
+  });
+  return {
+    content: res.choices[0].message.content ?? '',
+    finishReason: res.choices[0].finish_reason ?? 'stop',
+  };
+};
+```
+
+### 2. Index any document
+
+```ts
+import { pageIndexDocument } from 'react-native-pageindex';
+import { readFileSync } from 'fs';
+
+// Works with PDF, DOCX, XLSX, CSV, or Markdown
+const data = readFileSync('report.pdf');
+
+const result = await pageIndexDocument({
+  data,
+  fileName: 'report.pdf',   // used to auto-detect format
+  docName: 'Annual Report 2024',
+  llm,
+  options: {
+    onProgress: ({ step, percent, detail }) =>
+      console.log(`[${percent}%] ${step}${detail ? ` — ${detail}` : ''}`),
+  },
+});
+
+console.log(result.structure);  // hierarchical tree
+```
+
+### 3. Build a reverse index for fast search
+
+```ts
+import { buildReverseIndex, searchReverseIndex } from 'react-native-pageindex';
+
+const reverseIndex = await buildReverseIndex({
+  result,          // forward index from pageIndexDocument()
+  options: {
+    mode: 'keyword',   // 'keyword' (fast, no LLM) | 'llm' (semantic)
+  },
+});
+
+const hits = searchReverseIndex(reverseIndex, 'revenue growth', 5);
+// hits[0] = { nodeTitle, nodeId, score, matchedTerm, totalScore, ... }
+```
+
+---
+
+## API
+
+### `pageIndexDocument(input)` — Unified entrypoint
+
+Accepts any supported file format and returns a hierarchical `PageIndexResult`.
+
+```ts
+interface PageIndexDocumentInput {
+  data?:     ArrayBuffer | Uint8Array | string;  // binary for PDF/DOCX/XLSX; string for CSV/MD
+  text?:     string;                             // convenience alias for Markdown / CSV
+  fileType?: 'pdf' | 'docx' | 'csv' | 'xlsx' | 'md';  // inferred from fileName if omitted
+  fileName?: string;
+  docName?:  string;
+  llm:       LLMProvider;
+  options?:  PageIndexDocumentOptions;
+}
+```
+
+`PageIndexDocumentOptions`:
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `onProgress` | `ProgressCallback` | — | Per-step progress updates |
+| `pdfOptions` | `PageIndexOptions` | — | Forwarded to the PDF pipeline |
+| `mdOptions` | `MdPageIndexOptions` | — | Forwarded to the Markdown pipeline |
+| `csvOptions` | `CsvParseOptions` | — | CSV row-grouping & delimiter options |
+| `xlsxOptions` | `XlsxParseOptions` | — | XLSX sheet selection & row-grouping |
+| `tokenCounter` | `TokenCounter` | `~4 chars/token` | Custom tokeniser |
+
+---
+
+### `pageIndex(input)` — PDF pipeline (direct)
+
+Use when you already have extracted pages or want PDF-specific options.
+
+```ts
+import { pageIndex, extractPdfPages } from 'react-native-pageindex';
+
+const pages = await extractPdfPages(pdfBuffer);   // requires pdfjs-dist
+
+const result = await pageIndex({ pages, llm, docName: 'Report' });
+```
+
+`PageIndexOptions`:
+
+| Option | Default | Description |
+|---|---|---|
+| `tocCheckPageNum` | `20` | Pages to scan for table of contents |
+| `maxPageNumEachNode` | `10` | Max pages per tree node |
+| `maxTokenNumEachNode` | `20000` | Max tokens per tree node |
+| `ifAddNodeId` | `true` | Attach unique IDs to each node |
+| `ifAddNodeSummary` | `true` | LLM-generated summary per node |
+| `ifAddDocDescription` | `false` | Generate overall document description |
+| `ifAddNodeText` | `false` | Attach raw page text to nodes |
+
+---
+
+### `pageIndexMd(input)` — Markdown pipeline (direct)
+
+```ts
+import { pageIndexMd } from 'react-native-pageindex';
+
+const result = await pageIndexMd({
+  content: markdownString,
+  docName: 'README',
+  llm,
+  options: { ifThinning: true, minTokenThreshold: 3000 },
+});
+```
+
+`MdPageIndexOptions`:
+
+| Option | Default | Description |
+|---|---|---|
+| `ifThinning` | `false` | Merge small sections below threshold |
+| `minTokenThreshold` | `5000` | Min tokens before thinning kicks in |
+| `ifAddNodeSummary` | `true` | LLM-generated summary per node |
+| `summaryTokenThreshold` | `200` | Only summarise nodes above this size |
+| `ifAddDocDescription` | `false` | Generate overall document description |
+| `ifAddNodeText` | `false` | Attach raw section text to nodes |
+
+---
+
+### `buildReverseIndex(input)` — Inverted index
+
+```ts
+const reverseIndex = await buildReverseIndex({
+  result,          // PageIndexResult
+  pages?,          // original PageData[] (optional enrichment)
+  llm?,            // required only for mode: 'llm'
+  options?: {
+    mode: 'keyword' | 'llm',   // default: 'keyword'
+    minTermLength: number,      // default: 3
+    maxTermsPerNode: number,    // default: 10
+    onProgress: ProgressCallback,
+  },
+});
+```
+
+---
+
+### `searchReverseIndex(index, query, topK?)` — Query the index
+
+```ts
+const results = searchReverseIndex(reverseIndex, 'machine learning', 10);
+
+// SearchResult[]
+results.forEach(r => {
+  console.log(r.nodeTitle, r.totalScore, r.matchedTerm);
+});
+```
+
+---
+
+### Format parsers (lower-level)
+
+```ts
+import {
+  extractPdfPages,   // requires pdfjs-dist
+  extractDocxPages,  // requires mammoth
+  extractCsvPages,   // no deps
+  extractXlsxPages,  // requires xlsx
+} from 'react-native-pageindex';
+
+// All return: Promise<PageData[]>
+// PageData = { text: string; tokenCount: number }
+```
+
+---
+
+### Key Types
+
+```ts
+// LLM provider — wire up any AI
+type LLMProvider = (
+  prompt: string,
+  options?: { chatHistory?: LLMMessage[] }
+) => Promise<{ content: string; finishReason: string }>;
+
+// Progress tracking
+type ProgressCallback = (info: {
+  step: string;
+  percent: number;
+  detail?: string;
+}) => void;
+
+// Forward index result
+interface PageIndexResult {
+  structure: TreeNode;    // root of the hierarchy
+  doc_name: string;
+  description?: string;
+}
+
+// Tree node
+interface TreeNode {
+  title?: string;
+  node_id?: string;
+  summary?: string;
+  start_index?: number;
+  end_index?: number;
+  children?: TreeNode[];
+  [key: string]: unknown;
+}
+
+// Reverse index search result
+interface SearchResult extends ReverseIndexEntry {
+  matchedTerm: string;
+  totalScore: number;
+}
+```
+
+---
+
+## Progress Tracking
+
+Both pipelines emit fine-grained progress events:
+
+```ts
+options: {
+  onProgress: ({ step, percent, detail }) => {
+    // PDF pipeline steps (0–100%):
+    // Initializing → Extracting PDF pages → Scanning for table of contents
+    // → Transforming TOC → Mapping page numbers → Building tree
+    // → Verifying TOC → Fixing inaccuracies → Resolving large sections
+    // → Attaching page text → Generating node summaries
+    // → Generating document description → Done
+
+    // Markdown pipeline steps:
+    // Initializing → Parsing headings → Extracting section text
+    // → Optimizing tree → Building tree → Generating summaries
+    // → Generating description → Done
+
+    updateProgressBar(percent);
+    setStatusText(`${step}${detail ? ': ' + detail : ''}`);
+  },
+}
+```
+
+---
+
+## LLM Provider Examples
+
+### Anthropic Claude
+
+```ts
+import Anthropic from '@anthropic-ai/sdk';
+
+const client = new Anthropic();
+const llm: LLMProvider = async (prompt) => {
+  const msg = await client.messages.create({
+    model: 'claude-opus-4-5',
+    max_tokens: 4096,
+    messages: [{ role: 'user', content: prompt }],
+  });
+  const block = msg.content[0];
+  return {
+    content: block.type === 'text' ? block.text : '',
+    finishReason: msg.stop_reason ?? 'stop',
+  };
+};
+```
+
+### Ollama (local)
+
+```ts
+const llm: LLMProvider = async (prompt) => {
+  const res = await fetch('http://localhost:11434/api/generate', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ model: 'llama3', prompt, stream: false }),
+  });
+  const data = await res.json();
+  return { content: data.response, finishReason: 'stop' };
+};
+```
+
+### Google Gemini
+
+```ts
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);
+const model = genAI.getGenerativeModel({ model: 'gemini-1.5-pro' });
+
+const llm: LLMProvider = async (prompt) => {
+  const result = await model.generateContent(prompt);
+  return {
+    content: result.response.text(),
+    finishReason: 'stop',
+  };
+};
+```
+
+---
+
+## React Native Usage
+
+```ts
+// Use RNFS or fetch to get file bytes
+import RNFS from 'react-native-fs';
+import { pageIndexDocument } from 'react-native-pageindex';
+
+const base64 = await RNFS.readFile(filePath, 'base64');
+const bytes = Uint8Array.from(atob(base64), c => c.charCodeAt(0));
+
+const result = await pageIndexDocument({
+  data: bytes,
+  fileName: 'document.pdf',
+  llm,
+  options: { onProgress: setProgress },
+});
+```
+
+> **Note:** pdfjs-dist has a web worker that may need special Metro configuration.
+> Alternatively, pass pre-extracted `pages: PageData[]` directly to `pageIndex()` to skip pdfjs entirely.
+
+---
+
+## Versioning
+
+This package follows [Semantic Versioning](https://semver.org/):
+
+- **Patch** (`0.1.x`) — bug fixes, no API changes
+- **Minor** (`0.x.0`) — new features, backward compatible
+- **Major** (`x.0.0`) — breaking changes to the public API
+
+---
+
+## License
+
+MIT © [subham11](https://github.com/subham11)

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { PageIndexOptions, MdPageIndexOptions } from './types';
+export declare const DEFAULT_PDF_OPTIONS: Required<Omit<PageIndexOptions, 'tokenCounter' | 'onProgress'>>;
+export declare const DEFAULT_MD_OPTIONS: Required<Omit<MdPageIndexOptions, 'tokenCounter' | 'onProgress'>>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAEpE,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,IAAI,CAAC,gBAAgB,EAAE,cAAc,GAAG,YAAY,CAAC,CAQ/F,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,IAAI,CAAC,kBAAkB,EAAE,cAAc,GAAG,YAAY,CAAC,CAQhG,CAAC"}

package/dist/config.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MD_OPTIONS = exports.DEFAULT_PDF_OPTIONS = void 0;
+exports.DEFAULT_PDF_OPTIONS = {
+    tocCheckPageNum: 20,
+    maxPageNumEachNode: 10,
+    maxTokenNumEachNode: 20000,
+    ifAddNodeId: true,
+    ifAddNodeSummary: true,
+    ifAddDocDescription: false,
+    ifAddNodeText: false,
+};
+exports.DEFAULT_MD_OPTIONS = {
+    ifThinning: false,
+    minTokenThreshold: 5000,
+    ifAddNodeSummary: true,
+    summaryTokenThreshold: 200,
+    ifAddDocDescription: false,
+    ifAddNodeText: false,
+    ifAddNodeId: true,
+};
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAEa,QAAA,mBAAmB,GAAoE;IAClG,eAAe,EAAE,EAAE;IACnB,kBAAkB,EAAE,EAAE;IACtB,mBAAmB,EAAE,KAAK;IAC1B,WAAW,EAAE,IAAI;IACjB,gBAAgB,EAAE,IAAI;IACtB,mBAAmB,EAAE,KAAK;IAC1B,aAAa,EAAE,KAAK;CACrB,CAAC;AAEW,QAAA,kBAAkB,GAAsE;IACnG,UAAU,EAAE,KAAK;IACjB,iBAAiB,EAAE,IAAI;IACvB,gBAAgB,EAAE,IAAI;IACtB,qBAAqB,EAAE,GAAG;IAC1B,mBAAmB,EAAE,KAAK;IAC1B,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,IAAI;CAClB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * react-native-pageindex
+ *
+ * Vectorless, reasoning-based RAG — builds a hierarchical tree index from
+ * PDF or Markdown documents using any LLM provider.
+ *
+ * @example — Quick start with OpenAI
+ * ```ts
+ * import { pageIndex, pageIndexMd } from 'react-native-pageindex';
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * // LLM provider callback (works with any AI provider)
+ * const llm = async (prompt, opts) => {
+ *   const res = await openai.chat.completions.create({
+ *     model: 'gpt-4o',
+ *     messages: [
+ *       ...(opts?.chatHistory ?? []),
+ *       { role: 'user', content: prompt },
+ *     ],
+ *   });
+ *   return {
+ *     content: res.choices[0].message.content ?? '',
+ *     finishReason: res.choices[0].finish_reason ?? 'stop',
+ *   };
+ * };
+ *
+ * // PDF (pre-extracted pages)
+ * const result = await pageIndex({ pages: myPages, llm, docName: 'report' });
+ *
+ * // Markdown
+ * const result = await pageIndexMd({ content: markdownString, llm });
+ * ```
+ */
+export { pageIndex } from './pageIndex';
+export { pageIndexMd } from './pageIndexMd';
+export { pageIndexDocument } from './pageIndexDocument';
+export type { PageIndexDocumentInput, PageIndexDocumentOptions } from './pageIndexDocument';
+export { buildReverseIndex, searchReverseIndex } from './reverseIndex';
+export { extractPdfPages } from './utils/pdf';
+export { extractDocxPages } from './parsers/docx';
+export { extractCsvPages } from './parsers/csv';
+export { extractXlsxPages } from './parsers/xlsx';
+export type { PageData, LLMMessage, LLMResult, LLMFinishReason, LLMProvider, TokenCounter, ProgressInfo, ProgressCallback, TreeNode, PageIndexResult, PageIndexOptions, MdPageIndexOptions, DocumentFileType, CsvParseOptions, XlsxParseOptions, ReverseIndex, ReverseIndexEntry, SearchResult, ReverseIndexOptions, } from './types';
+export { defaultTokenCounter } from './utils/tokens';
+export { extractJson, getJsonContent } from './utils/json';
+export { writeNodeId, structureToList, getNodes, getLeafNodes, addNodeText, removeStructureText, removeFields, deepClone, } from './utils/tree';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,sBAAsB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAG5F,OAAO,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGlD,YAAY,EACV,QAAQ,EACR,UAAU,EACV,SAAS,EACT,eAAe,EACf,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,QAAQ,EACR,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,GACpB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,EACL,WAAW,EACX,eAAe,EACf,QAAQ,EACR,YAAY,EACZ,WAAW,EACX,mBAAmB,EACnB,YAAY,EACZ,SAAS,GACV,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * react-native-pageindex
+ *
+ * Vectorless, reasoning-based RAG — builds a hierarchical tree index from
+ * PDF or Markdown documents using any LLM provider.
+ *
+ * @example — Quick start with OpenAI
+ * ```ts
+ * import { pageIndex, pageIndexMd } from 'react-native-pageindex';
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+ *
+ * // LLM provider callback (works with any AI provider)
+ * const llm = async (prompt, opts) => {
+ *   const res = await openai.chat.completions.create({
+ *     model: 'gpt-4o',
+ *     messages: [
+ *       ...(opts?.chatHistory ?? []),
+ *       { role: 'user', content: prompt },
+ *     ],
+ *   });
+ *   return {
+ *     content: res.choices[0].message.content ?? '',
+ *     finishReason: res.choices[0].finish_reason ?? 'stop',
+ *   };
+ * };
+ *
+ * // PDF (pre-extracted pages)
+ * const result = await pageIndex({ pages: myPages, llm, docName: 'report' });
+ *
+ * // Markdown
+ * const result = await pageIndexMd({ content: markdownString, llm });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepClone = exports.removeFields = exports.removeStructureText = exports.addNodeText = exports.getLeafNodes = exports.getNodes = exports.structureToList = exports.writeNodeId = exports.getJsonContent = exports.extractJson = exports.defaultTokenCounter = exports.extractXlsxPages = exports.extractCsvPages = exports.extractDocxPages = exports.extractPdfPages = exports.searchReverseIndex = exports.buildReverseIndex = exports.pageIndexDocument = exports.pageIndexMd = exports.pageIndex = void 0;
+// Main APIs
+var pageIndex_1 = require("./pageIndex");
+Object.defineProperty(exports, "pageIndex", { enumerable: true, get: function () { return pageIndex_1.pageIndex; } });
+var pageIndexMd_1 = require("./pageIndexMd");
+Object.defineProperty(exports, "pageIndexMd", { enumerable: true, get: function () { return pageIndexMd_1.pageIndexMd; } });
+// Unified multi-format entrypoint
+var pageIndexDocument_1 = require("./pageIndexDocument");
+Object.defineProperty(exports, "pageIndexDocument", { enumerable: true, get: function () { return pageIndexDocument_1.pageIndexDocument; } });
+// Reverse / inverted index
+var reverseIndex_1 = require("./reverseIndex");
+Object.defineProperty(exports, "buildReverseIndex", { enumerable: true, get: function () { return reverseIndex_1.buildReverseIndex; } });
+Object.defineProperty(exports, "searchReverseIndex", { enumerable: true, get: function () { return reverseIndex_1.searchReverseIndex; } });
+// Format-specific parsers (each requires an optional dep — see README)
+var pdf_1 = require("./utils/pdf");
+Object.defineProperty(exports, "extractPdfPages", { enumerable: true, get: function () { return pdf_1.extractPdfPages; } });
+var docx_1 = require("./parsers/docx");
+Object.defineProperty(exports, "extractDocxPages", { enumerable: true, get: function () { return docx_1.extractDocxPages; } });
+var csv_1 = require("./parsers/csv");
+Object.defineProperty(exports, "extractCsvPages", { enumerable: true, get: function () { return csv_1.extractCsvPages; } });
+var xlsx_1 = require("./parsers/xlsx");
+Object.defineProperty(exports, "extractXlsxPages", { enumerable: true, get: function () { return xlsx_1.extractXlsxPages; } });
+// Utilities (useful for downstream tree-search / RAG pipelines)
+var tokens_1 = require("./utils/tokens");
+Object.defineProperty(exports, "defaultTokenCounter", { enumerable: true, get: function () { return tokens_1.defaultTokenCounter; } });
+var json_1 = require("./utils/json");
+Object.defineProperty(exports, "extractJson", { enumerable: true, get: function () { return json_1.extractJson; } });
+Object.defineProperty(exports, "getJsonContent", { enumerable: true, get: function () { return json_1.getJsonContent; } });
+var tree_1 = require("./utils/tree");
+Object.defineProperty(exports, "writeNodeId", { enumerable: true, get: function () { return tree_1.writeNodeId; } });
+Object.defineProperty(exports, "structureToList", { enumerable: true, get: function () { return tree_1.structureToList; } });
+Object.defineProperty(exports, "getNodes", { enumerable: true, get: function () { return tree_1.getNodes; } });
+Object.defineProperty(exports, "getLeafNodes", { enumerable: true, get: function () { return tree_1.getLeafNodes; } });
+Object.defineProperty(exports, "addNodeText", { enumerable: true, get: function () { return tree_1.addNodeText; } });
+Object.defineProperty(exports, "removeStructureText", { enumerable: true, get: function () { return tree_1.removeStructureText; } });
+Object.defineProperty(exports, "removeFields", { enumerable: true, get: function () { return tree_1.removeFields; } });
+Object.defineProperty(exports, "deepClone", { enumerable: true, get: function () { return tree_1.deepClone; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;;;AAEH,YAAY;AACZ,yCAAwC;AAA/B,sGAAA,SAAS,OAAA;AAClB,6CAA4C;AAAnC,0GAAA,WAAW,OAAA;AAEpB,kCAAkC;AAClC,yDAAwD;AAA/C,sHAAA,iBAAiB,OAAA;AAG1B,2BAA2B;AAC3B,+CAAuE;AAA9D,iHAAA,iBAAiB,OAAA;AAAE,kHAAA,kBAAkB,OAAA;AAE9C,uEAAuE;AACvE,mCAA8C;AAArC,sGAAA,eAAe,OAAA;AACxB,uCAAkD;AAAzC,wGAAA,gBAAgB,OAAA;AACzB,qCAAgD;AAAvC,sGAAA,eAAe,OAAA;AACxB,uCAAkD;AAAzC,wGAAA,gBAAgB,OAAA;AAyBzB,gEAAgE;AAChE,yCAAqD;AAA5C,6GAAA,mBAAmB,OAAA;AAC5B,qCAA2D;AAAlD,mGAAA,WAAW,OAAA;AAAE,sGAAA,cAAc,OAAA;AACpC,qCASsB;AARpB,mGAAA,WAAW,OAAA;AACX,uGAAA,eAAe,OAAA;AACf,gGAAA,QAAQ,OAAA;AACR,oGAAA,YAAY,OAAA;AACZ,mGAAA,WAAW,OAAA;AACX,2GAAA,mBAAmB,OAAA;AACnB,oGAAA,YAAY,OAAA;AACZ,iGAAA,SAAS,OAAA"}

package/dist/pageIndex.d.ts

@@ -0,0 +1,48 @@
+/**
+ * PDF pipeline — port of pageindex/page_index.py
+ *
+ * Processes PDF pages (as pre-extracted text + token counts) and builds a
+ * hierarchical tree index using LLM reasoning.  No PDF parser is included
+ * here — pass `PageData[]` directly, or use the `extractPdfPages()` helper
+ * from `./utils/pdf` (requires pdfjs-dist to be installed).
+ */
+import type { LLMProvider, PageData, PageIndexOptions, PageIndexResult } from './types';
+/**
+ * Builds a hierarchical tree index from a PDF document.
+ *
+ * Supply either `pdf` (raw PDF bytes, requires pdfjs-dist) or pre-extracted
+ * `pages` (array of `{text, tokenCount}` — one entry per page).
+ *
+ * @example — with OpenAI + progress bar
+ * ```ts
+ * import { pageIndex } from 'react-native-pageindex';
+ * import OpenAI from 'openai';
+ *
+ * const openai = new OpenAI({ apiKey: '...' });
+ *
+ * const result = await pageIndex({
+ *   pages: myExtractedPages,
+ *   docName: 'annual-report',
+ *   llm: async (prompt, opts) => {
+ *     const res = await openai.chat.completions.create({
+ *       model: 'gpt-4o',
+ *       messages: [...(opts?.chatHistory ?? []), { role: 'user', content: prompt }],
+ *     });
+ *     return { content: res.choices[0].message.content ?? '', finishReason: res.choices[0].finish_reason ?? 'stop' };
+ *   },
+ *   options: {
+ *     onProgress: ({ step, percent, detail }) => {
+ *       console.log(`[${percent}%] ${step}${detail ? ` — ${detail}` : ''}`);
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export declare function pageIndex(input: {
+    pdf?: ArrayBuffer | Uint8Array;
+    pages?: PageData[];
+    llm: LLMProvider;
+    docName?: string;
+    options?: PageIndexOptions;
+}): Promise<PageIndexResult>;
+//# sourceMappingURL=pageIndex.d.ts.map

package/dist/pageIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageIndex.d.ts","sourceRoot":"","sources":["../src/pageIndex.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,WAAW,EAEX,QAAQ,EACR,gBAAgB,EAChB,eAAe,EAEhB,MAAM,SAAS,CAAC;AAulCjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAsB,SAAS,CAAC,KAAK,EAAE;IACrC,GAAG,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC;IAC/B,KAAK,CAAC,EAAE,QAAQ,EAAE,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,gBAAgB,CAAC;CAC5B,GAAG,OAAO,CAAC,eAAe,CAAC,CAwD3B"}