@effortlessmotion/pdf-to-md 0.2.0 → 0.2.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/dist/cjs/analyze.js.map +1 -1
  2. package/dist/cjs/audit.js.map +1 -1
  3. package/dist/cjs/cli/audit.js.map +1 -1
  4. package/dist/cjs/cli/extract.js.map +1 -1
  5. package/dist/cjs/cli/index.js.map +1 -1
  6. package/dist/cjs/cli/render.js.map +1 -1
  7. package/dist/cjs/cli/types.js.map +1 -1
  8. package/dist/cjs/cli.js.map +1 -1
  9. package/dist/cjs/collect.js.map +1 -1
  10. package/dist/cjs/dict.js.map +1 -1
  11. package/dist/cjs/emit.js.map +1 -1
  12. package/dist/cjs/engines/tesseract.js.map +1 -1
  13. package/dist/cjs/errors.js.map +1 -1
  14. package/dist/cjs/extract.js.map +1 -1
  15. package/dist/cjs/geometry.js.map +1 -1
  16. package/dist/cjs/index.js.map +1 -1
  17. package/dist/cjs/lines.js.map +1 -1
  18. package/dist/cjs/markdown.js.map +1 -1
  19. package/dist/cjs/page-marker.js.map +1 -1
  20. package/dist/cjs/pdf-open.js.map +1 -1
  21. package/dist/cjs/raster.js.map +1 -1
  22. package/dist/cjs/render-analysis.js.map +1 -1
  23. package/dist/cjs/report.js.map +1 -1
  24. package/dist/cjs/resolve.js.map +1 -1
  25. package/dist/cjs/text-analysis.js.map +1 -1
  26. package/dist/cjs/types.js.map +1 -1
  27. package/dist/cjs/validate.js.map +1 -1
  28. package/dist/esm/analyze.js.map +1 -1
  29. package/dist/esm/audit.js.map +1 -1
  30. package/dist/esm/cli/audit.js.map +1 -1
  31. package/dist/esm/cli/extract.js.map +1 -1
  32. package/dist/esm/cli/index.js.map +1 -1
  33. package/dist/esm/cli/render.js.map +1 -1
  34. package/dist/esm/cli/types.js.map +1 -1
  35. package/dist/esm/cli.js.map +1 -1
  36. package/dist/esm/collect.js.map +1 -1
  37. package/dist/esm/dict.js.map +1 -1
  38. package/dist/esm/emit.js.map +1 -1
  39. package/dist/esm/engines/tesseract.js.map +1 -1
  40. package/dist/esm/errors.js.map +1 -1
  41. package/dist/esm/extract.js.map +1 -1
  42. package/dist/esm/geometry.js.map +1 -1
  43. package/dist/esm/index.js.map +1 -1
  44. package/dist/esm/lines.js.map +1 -1
  45. package/dist/esm/markdown.js.map +1 -1
  46. package/dist/esm/page-marker.js.map +1 -1
  47. package/dist/esm/pdf-open.js.map +1 -1
  48. package/dist/esm/raster.js.map +1 -1
  49. package/dist/esm/render-analysis.js.map +1 -1
  50. package/dist/esm/report.js.map +1 -1
  51. package/dist/esm/resolve.js.map +1 -1
  52. package/dist/esm/text-analysis.js.map +1 -1
  53. package/dist/esm/types.js.map +1 -1
  54. package/dist/esm/validate.js.map +1 -1
  55. package/package.json +1 -1
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/engines/tesseract.ts"],"sourcesContent":["// engines/tesseract.ts — THE OCR engine: tesseract.js on every platform.\n//\n// Seam contract: words come back in normalized 0-1 page coordinates, origin\n// bottom-left, y increasing upward — the y-flip happens here, and nowhere else.\n//\n// Pure WASM, in-process, no native dependency: no crash containment needed.\nimport { mkdirSync } from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\nimport type { Page as TesseractPage } from 'tesseract.js';\nimport { createWorker, PSM } from 'tesseract.js';\nimport type { PageWord, Word } from '../geometry.ts';\nimport { foldTypographic } from '../lines.ts';\nimport { awaitPdfOpen, openPdfForRender } from '../pdf-open.ts';\nimport { renderLoadedPage } from '../raster.ts';\nimport { resolvePackagePath } from '../resolve.ts';\n\n// 288 dpi: the render resolution the engine's word-overlap numbers were\n// measured at (test/fixtures/ocr-engine-poc/) — the known-good operating point.\nexport const OCR_RENDER_DPI = 288;\n\n// Chart pages starve PSM.AUTO (unrecognized text can't be marked for review).\n// Prose-fraction retry trigger, measured (sparse-retry.test.ts): chart 0.442 vs prose 0.767-0.938, cut 0.6.\nexport const SPARSE_RETRY_PROSE_FRACTION = 0.6;\n\n/** Share of `words` whose text contains a run of 3+ letters (`src/emit.ts`'s isUnstructured canary, applied per-page instead of per-block). */\nfunction proseFraction(words: { text: string }[]): number {\n if (words.length === 0) return 0;\n return words.filter((w) => /[A-Za-z]{3}/.test(w.text)).length / words.length;\n}\n\n/** Does this page's PSM.AUTO pass look chart-like enough to re-recognize\n * with PSM.SPARSE_TEXT? A page with 0 words never retries (nothing to take a prose fraction of). */\nexport function shouldRetrySparse(words: { text: string }[]): boolean {\n return words.length > 0 && proseFraction(words) < SPARSE_RETRY_PROSE_FRACTION;\n}\n\n// The locally installed traineddata (npm package @tesseract.js-data/eng),\n// resolved dynamically so depcheck won't flag it \"unused\" — it's a genuine runtime dependency, listed in .depcheckrc's `ignores`.\nconst TESSDATA_DIR = path.join(path.dirname(resolvePackagePath('@tesseract.js-data/eng/package.json')), '4.0.0');\n\n/** Per-page recognition progress, delivered once per page as it finishes.\n * Engine chatter goes through `onWarning`/`warnings` instead — this is timing/count data only. */\nexport type OcrProgressEvent = { type: 'page'; page: number; words: number; ms: number };\n\nexport interface RecognizeResult {\n words: PageWord[];\n /** pages (1-based) where the engine returned zero words */\n emptyPages: number[];\n /** wall-clock ms per page (render + recognize), keyed by page number */\n msPerPage: Map<number, number>;\n}\n\n/** tesseract.js's nested blocks/paragraphs/lines/words -> this repo's flat Word contract (normalize + y-flip). Same shape regardless of which PSM produced `page`, so both the AUTO pass and the SPARSE_TEXT retry share it. */\nfunction wordsFromPage(page: TesseractPage, width: number, height: number): Word[] {\n const pageWords: Word[] = [];\n for (const block of page.blocks ?? []) {\n for (const para of block.paragraphs ?? []) {\n for (const line of para.lines ?? []) {\n for (const w of line.words ?? []) {\n const { x0, y0, x1, y1 } = w.bbox;\n pageWords.push({\n // Same typographic folding as the text path (src/lines.ts) — both\n // paths must agree on how a printed apostrophe is spelled.\n text: foldTypographic(w.text),\n x: x0 / width,\n y: (height - y1) / height, // y-flip: top-left px -> bottom-left normalized\n w: (x1 - x0) / width,\n h: (y1 - y0) / height,\n // Plumbed through unmodified — tesseract.js's own 0-100\n // per-word confidence. See src/report.ts's LOW_CONFIDENCE_THRESHOLD.\n confidence: w.confidence,\n });\n }\n }\n }\n }\n return pageWords;\n}\n\n// tesseract.js-core's WASM build writes native diagnostics straight to this\n// process's stdout/stderr, with no override to silence them at the source.\n//\n// Suppression must span the whole run: worker-thread stdio arrives\n// asynchronously, on later event-loop turns; the synchronous carve-out below (`withRealStdio`) is the only safe exit.\nlet suppressDepth = 0;\nlet savedStdoutWrite: typeof process.stdout.write | null = null;\nlet savedStderrWrite: typeof process.stderr.write | null = null;\nasync function withSuppressedStdio<T>(fn: () => Promise<T>): Promise<T> {\n if (suppressDepth === 0) {\n savedStdoutWrite = process.stdout.write.bind(process.stdout);\n savedStderrWrite = process.stderr.write.bind(process.stderr);\n process.stdout.write = (() => true) as typeof process.stdout.write;\n process.stderr.write = (() => true) as typeof process.stderr.write;\n }\n suppressDepth++;\n try {\n return await fn();\n } finally {\n suppressDepth--;\n if (suppressDepth === 0) {\n if (savedStdoutWrite) process.stdout.write = savedStdoutWrite;\n if (savedStderrWrite) process.stderr.write = savedStderrWrite;\n savedStdoutWrite = null;\n savedStderrWrite = null;\n }\n }\n}\n\n/** Pierces an active `withSuppressedStdio` region SYNCHRONOUSLY to let this\n * module's own onProgress/onWarning calls through. No-op outside any suppressed region. */\nfunction withRealStdio<T>(fn: () => T): T {\n if (suppressDepth === 0) return fn();\n const realOut = savedStdoutWrite;\n const realErr = savedStderrWrite;\n if (realOut) process.stdout.write = realOut;\n if (realErr) process.stderr.write = realErr;\n try {\n return fn();\n } finally {\n process.stdout.write = (() => true) as typeof process.stdout.write;\n process.stderr.write = (() => true) as typeof process.stderr.write;\n }\n}\n\n/** Recognize words on pages [first..last] of a PDF (renders at `dpi`,\n * default OCR_RENDER_DPI). Progress via `onProgress`; diagnostics via `onWarning` — this module never writes to stdout/stderr itself. */\nexport async function recognizePdf(pdfPath: string, first: number, last: number, { dpi = OCR_RENDER_DPI, onProgress, onWarning }: { dpi?: number; onProgress?: (e: OcrProgressEvent) => void; onWarning?: (message: string) => void } = {}): Promise<RecognizeResult> {\n // tesseract.js writes its decompressed traineddata cache here by default,\n // dropping a model file into the user's cwd — redirect it under tmpdir() instead.\n const cachePath = path.join(os.tmpdir(), 'pdf-to-md-engine');\n mkdirSync(cachePath, { recursive: true });\n\n const words: PageWord[] = [];\n const emptyPages: number[] = [];\n const msPerPage = new Map<number, number>();\n\n // ONE continuous suppressed region for the whole run; onProgress/onWarning\n // below go through `withRealStdio`, the only sanctioned way out of it.\n await withSuppressedStdio(async () => {\n // OEM 1 (LSTM only, tesseract.js's own default): measured 99.0% recall\n // on the hard benchmark pages (2026-08-16).\n const worker = await createWorker('eng', 1, {\n langPath: TESSDATA_DIR,\n cachePath,\n });\n try {\n // NOT optional: tesseract.js's own default PSM (SINGLE_BLOCK) measured\n // 3-8 percentage points worse than AUTO on two-column pages.\n await worker.setParameters({ tessedit_pageseg_mode: PSM.AUTO });\n\n const loadingTask = openPdfForRender(pdfPath);\n try {\n const pdf = await awaitPdfOpen(loadingTask, pdfPath);\n for (let pn = first; pn <= Math.min(last, pdf.numPages); pn++) {\n const t0 = Date.now();\n const { png, width, height } = await renderLoadedPage(pdf, pn, dpi);\n const { data } = await worker.recognize(png, {}, { blocks: true });\n let pageWords: Word[] = wordsFromPage(data, width, height);\n\n // Adaptive second pass: re-recognizes the SAME rendered PNG, so\n // this costs one extra recognize() call only on chart-like pages.\n if (shouldRetrySparse(pageWords)) {\n const autoFraction = proseFraction(pageWords);\n const autoWords = pageWords;\n // setParameters on the shared worker is reversible, so one\n // in-process worker can alternate PSM per page instead of paying for a second worker.\n await worker.setParameters({ tessedit_pageseg_mode: PSM.SPARSE_TEXT });\n const sparse = await worker.recognize(png, {}, { blocks: true });\n const sparseWords = wordsFromPage(sparse.data, width, height);\n await worker.setParameters({ tessedit_pageseg_mode: PSM.AUTO });\n\n if (sparseWords.length > autoWords.length) {\n pageWords = sparseWords;\n const autoCount = autoWords.length;\n const sparseCount = sparseWords.length;\n withRealStdio(() => onWarning?.(`p${pn}: chart-like page (prose fraction ${autoFraction.toFixed(2)}) — retried with sparse-text segmentation, ${autoCount} -> ${sparseCount} words`));\n }\n }\n\n const ms = Date.now() - t0;\n for (const w of pageWords) words.push({ page: pn, ...w });\n if (pageWords.length === 0) emptyPages.push(pn);\n msPerPage.set(pn, ms);\n const wordCount = pageWords.length;\n withRealStdio(() => onProgress?.({ type: 'page', page: pn, words: wordCount, ms }));\n }\n } finally {\n await loadingTask.destroy();\n }\n } finally {\n await worker.terminate();\n }\n });\n\n return { words, emptyPages, msPerPage };\n}\n"],"names":["OCR_RENDER_DPI","SPARSE_RETRY_PROSE_FRACTION","recognizePdf","shouldRetrySparse","proseFraction","words","length","filter","w","test","text","TESSDATA_DIR","path","join","dirname","resolvePackagePath","wordsFromPage","page","width","height","pageWords","blocks","block","paragraphs","para","lines","line","bbox","x0","y0","x1","y1","push","foldTypographic","x","y","h","confidence","suppressDepth","savedStdoutWrite","savedStderrWrite","withSuppressedStdio","fn","process","stdout","write","bind","stderr","withRealStdio","realOut","realErr","pdfPath","first","last","dpi","onProgress","onWarning","cachePath","emptyPages","msPerPage","os","tmpdir","mkdirSync","recursive","Map","worker","loadingTask","pdf","pn","createWorker","langPath","setParameters","tessedit_pageseg_mode","PSM","AUTO","openPdfForRender","t0","png","data","autoFraction","autoWords","sparse","sparseWords","autoCount","sparseCount","ms","wordCount","Date","now","renderLoadedPage","recognize","SPARSE_TEXT","toFixed","set","type","awaitPdfOpen","Math","min","numPages","destroy","terminate"],"mappings":"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"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/engines/tesseract.ts"],"sourcesContent":["// engines/tesseract.ts — THE OCR engine: tesseract.js on every platform.\n//\n// Seam contract: words come back in normalized 0-1 page coordinates, origin\n// bottom-left, y increasing upward — the y-flip happens here, and nowhere else.\n//\n// Pure WASM, in-process, no native dependency: no crash containment needed.\nimport { mkdirSync } from 'node:fs';\nimport os from 'node:os';\nimport path from 'node:path';\nimport type { Page as TesseractPage } from 'tesseract.js';\nimport { createWorker, PSM } from 'tesseract.js';\nimport type { PageWord, Word } from '../geometry.ts';\nimport { foldTypographic } from '../lines.ts';\nimport { awaitPdfOpen, openPdfForRender } from '../pdf-open.ts';\nimport { renderLoadedPage } from '../raster.ts';\nimport { resolvePackagePath } from '../resolve.ts';\n\n// 288 dpi: the render resolution the engine's word-overlap numbers were\n// measured at (test/fixtures/ocr-engine-poc/) — the known-good operating point.\nexport const OCR_RENDER_DPI = 288;\n\n// Chart pages starve PSM.AUTO (unrecognized text can't be marked for review).\n// Prose-fraction retry trigger, measured (sparse-retry.test.ts): chart 0.442 vs prose 0.767-0.938, cut 0.6.\nexport const SPARSE_RETRY_PROSE_FRACTION = 0.6;\n\n/** Share of `words` whose text contains a run of 3+ letters (`src/emit.ts`'s isUnstructured canary, applied per-page instead of per-block). */\nfunction proseFraction(words: { text: string }[]): number {\n if (words.length === 0) return 0;\n return words.filter((w) => /[A-Za-z]{3}/.test(w.text)).length / words.length;\n}\n\n/** Does this page's PSM.AUTO pass look chart-like enough to re-recognize\n * with PSM.SPARSE_TEXT? A page with 0 words never retries (nothing to take a prose fraction of). */\nexport function shouldRetrySparse(words: { text: string }[]): boolean {\n return words.length > 0 && proseFraction(words) < SPARSE_RETRY_PROSE_FRACTION;\n}\n\n// The locally installed traineddata (npm package @tesseract.js-data/eng),\n// resolved dynamically so depcheck won't flag it \"unused\" — it's a genuine runtime dependency, listed in .depcheckrc's `ignores`.\nconst TESSDATA_DIR = path.join(path.dirname(resolvePackagePath('@tesseract.js-data/eng/package.json')), '4.0.0');\n\n/** Per-page recognition progress, delivered once per page as it finishes.\n * Engine chatter goes through `onWarning`/`warnings` instead — this is timing/count data only. */\nexport type OcrProgressEvent = { type: 'page'; page: number; words: number; ms: number };\n\nexport interface RecognizeResult {\n words: PageWord[];\n /** pages (1-based) where the engine returned zero words */\n emptyPages: number[];\n /** wall-clock ms per page (render + recognize), keyed by page number */\n msPerPage: Map<number, number>;\n}\n\n/** tesseract.js's nested blocks/paragraphs/lines/words -> this repo's flat Word contract (normalize + y-flip). Same shape regardless of which PSM produced `page`, so both the AUTO pass and the SPARSE_TEXT retry share it. */\nfunction wordsFromPage(page: TesseractPage, width: number, height: number): Word[] {\n const pageWords: Word[] = [];\n for (const block of page.blocks ?? []) {\n for (const para of block.paragraphs ?? []) {\n for (const line of para.lines ?? []) {\n for (const w of line.words ?? []) {\n const { x0, y0, x1, y1 } = w.bbox;\n pageWords.push({\n // Same typographic folding as the text path (src/lines.ts) — both\n // paths must agree on how a printed apostrophe is spelled.\n text: foldTypographic(w.text),\n x: x0 / width,\n y: (height - y1) / height, // y-flip: top-left px -> bottom-left normalized\n w: (x1 - x0) / width,\n h: (y1 - y0) / height,\n // Plumbed through unmodified — tesseract.js's own 0-100\n // per-word confidence. See src/report.ts's LOW_CONFIDENCE_THRESHOLD.\n confidence: w.confidence,\n });\n }\n }\n }\n }\n return pageWords;\n}\n\n// tesseract.js-core's WASM build writes native diagnostics straight to this\n// process's stdout/stderr, with no override to silence them at the source.\n//\n// Suppression must span the whole run: worker-thread stdio arrives\n// asynchronously, on later event-loop turns; the synchronous carve-out below (`withRealStdio`) is the only safe exit.\nlet suppressDepth = 0;\nlet savedStdoutWrite: typeof process.stdout.write | null = null;\nlet savedStderrWrite: typeof process.stderr.write | null = null;\nasync function withSuppressedStdio<T>(fn: () => Promise<T>): Promise<T> {\n if (suppressDepth === 0) {\n savedStdoutWrite = process.stdout.write.bind(process.stdout);\n savedStderrWrite = process.stderr.write.bind(process.stderr);\n process.stdout.write = (() => true) as typeof process.stdout.write;\n process.stderr.write = (() => true) as typeof process.stderr.write;\n }\n suppressDepth++;\n try {\n return await fn();\n } finally {\n suppressDepth--;\n if (suppressDepth === 0) {\n if (savedStdoutWrite) process.stdout.write = savedStdoutWrite;\n if (savedStderrWrite) process.stderr.write = savedStderrWrite;\n savedStdoutWrite = null;\n savedStderrWrite = null;\n }\n }\n}\n\n/** Pierces an active `withSuppressedStdio` region SYNCHRONOUSLY to let this\n * module's own onProgress/onWarning calls through. No-op outside any suppressed region. */\nfunction withRealStdio<T>(fn: () => T): T {\n if (suppressDepth === 0) return fn();\n const realOut = savedStdoutWrite;\n const realErr = savedStderrWrite;\n if (realOut) process.stdout.write = realOut;\n if (realErr) process.stderr.write = realErr;\n try {\n return fn();\n } finally {\n process.stdout.write = (() => true) as typeof process.stdout.write;\n process.stderr.write = (() => true) as typeof process.stderr.write;\n }\n}\n\n/** Recognize words on pages [first..last] of a PDF (renders at `dpi`,\n * default OCR_RENDER_DPI). Progress via `onProgress`; diagnostics via `onWarning` — this module never writes to stdout/stderr itself. */\nexport async function recognizePdf(pdfPath: string, first: number, last: number, { dpi = OCR_RENDER_DPI, onProgress, onWarning }: { dpi?: number; onProgress?: (e: OcrProgressEvent) => void; onWarning?: (message: string) => void } = {}): Promise<RecognizeResult> {\n // tesseract.js writes its decompressed traineddata cache here by default,\n // dropping a model file into the user's cwd — redirect it under tmpdir() instead.\n const cachePath = path.join(os.tmpdir(), 'pdf-to-md-engine');\n mkdirSync(cachePath, { recursive: true });\n\n const words: PageWord[] = [];\n const emptyPages: number[] = [];\n const msPerPage = new Map<number, number>();\n\n // ONE continuous suppressed region for the whole run; onProgress/onWarning\n // below go through `withRealStdio`, the only sanctioned way out of it.\n await withSuppressedStdio(async () => {\n // OEM 1 (LSTM only, tesseract.js's own default): measured 99.0% recall\n // on the hard benchmark pages (2026-08-16).\n const worker = await createWorker('eng', 1, {\n langPath: TESSDATA_DIR,\n cachePath,\n });\n try {\n // NOT optional: tesseract.js's own default PSM (SINGLE_BLOCK) measured\n // 3-8 percentage points worse than AUTO on two-column pages.\n await worker.setParameters({ tessedit_pageseg_mode: PSM.AUTO });\n\n const loadingTask = openPdfForRender(pdfPath);\n try {\n const pdf = await awaitPdfOpen(loadingTask, pdfPath);\n for (let pn = first; pn <= Math.min(last, pdf.numPages); pn++) {\n const t0 = Date.now();\n const { png, width, height } = await renderLoadedPage(pdf, pn, dpi);\n const { data } = await worker.recognize(png, {}, { blocks: true });\n let pageWords: Word[] = wordsFromPage(data, width, height);\n\n // Adaptive second pass: re-recognizes the SAME rendered PNG, so\n // this costs one extra recognize() call only on chart-like pages.\n if (shouldRetrySparse(pageWords)) {\n const autoFraction = proseFraction(pageWords);\n const autoWords = pageWords;\n // setParameters on the shared worker is reversible, so one\n // in-process worker can alternate PSM per page instead of paying for a second worker.\n await worker.setParameters({ tessedit_pageseg_mode: PSM.SPARSE_TEXT });\n const sparse = await worker.recognize(png, {}, { blocks: true });\n const sparseWords = wordsFromPage(sparse.data, width, height);\n await worker.setParameters({ tessedit_pageseg_mode: PSM.AUTO });\n\n if (sparseWords.length > autoWords.length) {\n pageWords = sparseWords;\n const autoCount = autoWords.length;\n const sparseCount = sparseWords.length;\n withRealStdio(() => onWarning?.(`p${pn}: chart-like page (prose fraction ${autoFraction.toFixed(2)}) — retried with sparse-text segmentation, ${autoCount} -> ${sparseCount} words`));\n }\n }\n\n const ms = Date.now() - t0;\n for (const w of pageWords) words.push({ page: pn, ...w });\n if (pageWords.length === 0) emptyPages.push(pn);\n msPerPage.set(pn, ms);\n const wordCount = pageWords.length;\n withRealStdio(() => onProgress?.({ type: 'page', page: pn, words: wordCount, ms }));\n }\n } finally {\n await loadingTask.destroy();\n }\n } finally {\n await worker.terminate();\n }\n });\n\n return { words, emptyPages, msPerPage };\n}\n"],"names":["OCR_RENDER_DPI","SPARSE_RETRY_PROSE_FRACTION","recognizePdf","shouldRetrySparse","proseFraction","words","length","filter","w","test","text","TESSDATA_DIR","path","join","dirname","resolvePackagePath","wordsFromPage","page","width","height","pageWords","blocks","block","paragraphs","para","lines","line","bbox","x0","y0","x1","y1","push","foldTypographic","x","y","h","confidence","suppressDepth","savedStdoutWrite","savedStderrWrite","withSuppressedStdio","fn","process","stdout","write","bind","stderr","withRealStdio","realOut","realErr","pdfPath","first","last","dpi","onProgress","onWarning","cachePath","emptyPages","msPerPage","os","tmpdir","mkdirSync","recursive","Map","worker","loadingTask","pdf","pn","createWorker","langPath","setParameters","tessedit_pageseg_mode","PSM","AUTO","openPdfForRender","t0","png","data","autoFraction","autoWords","sparse","sparseWords","autoCount","sparseCount","ms","wordCount","Date","now","renderLoadedPage","recognize","SPARSE_TEXT","toFixed","set","type","awaitPdfOpen","Math","min","numPages","destroy","terminate"],"mappings":"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"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/errors.ts"],"sourcesContent":["// Library code throws; only src/cli.ts prints and exits.\n\n/** The closed set of error codes every `PdfToMdError` carries — switch on\n * `code` instead of parsing `message`. */\nexport type PdfToMdErrorCode =\n /** input missing/unreadable/not a PDF */\n | 'PDF_OPEN'\n /** malformed page selection (validated before any work) */\n | 'PAGE_RANGE'\n /** rendering an opened, in-range page to PNG failed */\n | 'PAGE_RENDER'\n /** the OCR engine crashed twice on one page (message names it) */\n | 'OCR_PAGE_FAILED'\n /** malformed word-dump input (--words-json / extractOcr words) */\n | 'WORDS_INPUT'\n /** malformed or insufficient evidence passed to auditWords */\n | 'AUDIT_INPUT'\n /** malformed Analysis handed to toMarkdown/toText (e.g. an out-of-range\n * wordIndexes entry) — validated fail-fast, whole object checked before any output. */\n | 'ANALYSIS_INPUT';\n\n/** The error every entry point throws — never a bare `Error`. */\nexport class PdfToMdError extends Error {\n code: PdfToMdErrorCode;\n\n constructor(code: PdfToMdErrorCode, message: string) {\n super(message);\n this.name = 'PdfToMdError';\n this.code = code;\n }\n}\n"],"names":["PdfToMdError","code","message","name","Error"],"mappings":"AAAA,yDAAyD;AAEzD;wCACwC;;;;+BAmB3BA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAA,AAAMA,6BAAN;;cAAMA;aAAAA,aAGCC,IAAsB,EAAEC,OAAe;gCAHxCF;;gBAIT,kBAJSA;YAIHE;;QACN,MAAKC,IAAI,GAAG;QACZ,MAAKF,IAAI,GAAGA;;;WANHD;qBAAqBI"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/errors.ts"],"sourcesContent":["// Library code throws; only src/cli.ts prints and exits.\n\n/** The closed set of error codes every `PdfToMdError` carries — switch on\n * `code` instead of parsing `message`. */\nexport type PdfToMdErrorCode =\n /** input missing/unreadable/not a PDF */\n | 'PDF_OPEN'\n /** malformed page selection (validated before any work) */\n | 'PAGE_RANGE'\n /** rendering an opened, in-range page to PNG failed */\n | 'PAGE_RENDER'\n /** the OCR engine crashed twice on one page (message names it) */\n | 'OCR_PAGE_FAILED'\n /** malformed word-dump input (--words-json / extractOcr words) */\n | 'WORDS_INPUT'\n /** malformed or insufficient evidence passed to auditWords */\n | 'AUDIT_INPUT'\n /** malformed Analysis handed to toMarkdown/toText (e.g. an out-of-range\n * wordIndexes entry) — validated fail-fast, whole object checked before any output. */\n | 'ANALYSIS_INPUT';\n\n/** The error every entry point throws — never a bare `Error`. */\nexport class PdfToMdError extends Error {\n code: PdfToMdErrorCode;\n\n constructor(code: PdfToMdErrorCode, message: string) {\n super(message);\n this.name = 'PdfToMdError';\n this.code = code;\n }\n}\n"],"names":["PdfToMdError","code","message","name","Error"],"mappings":"AAAA,yDAAyD;AAEzD;wCACwC;;;;+BAmB3BA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAN,IAAA,AAAMA,6BAAN;;cAAMA;aAAAA,aAGCC,IAAsB,EAAEC,OAAe;gCAHxCF;;gBAIT,kBAJSA;YAIHE;;QACN,MAAKC,IAAI,GAAG;QACZ,MAAKF,IAAI,GAAGA;;;WANHD;qBAAqBI"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/extract.ts"],"sourcesContent":["// The library layer for PDF -> markdown conversion: extractText/extractOcr/\n// pdfToMarkdown each take plain args, return plain data, and throw PdfToMdError — no process.exit, no console.*, no file writing.\n//\n// Warnings are DATA: every notice is returned in `warnings` verbatim and also\n// delivered incrementally via `onWarning` — the exact strings are load-bearing (the test suite asserts them).\nimport { buildOcrAnalysisPages } from './analyze.ts';\nimport { collect } from './collect.ts';\nimport { dictAvailable, dictUnavailableWarning } from './dict.ts';\nimport type { OcrProgressEvent } from './engines/tesseract.ts';\nimport type { PageWord, Tuning } from './geometry.ts';\nimport { renderPagesToMarkdown } from './render-analysis.ts';\nimport { AUTO_OCR_CHARS_PER_PAGE, buildOcrReport } from './report.ts';\nimport { buildTextAnalysis, selectCollectedPages } from './text-analysis.ts';\nimport type { Analysis, AnalysisPage, CollectResult, Report } from './types.ts';\nimport { validatePages } from './validate.ts';\n\nexport type { OcrProgressEvent } from './engines/tesseract.ts';\n\n// A plain-JS caller (or `.ts` with `as any`) gets no compile-time check on\n// `pages`, so it's validated once at runtime — see src/validate.ts's `validatePages`.\n\n/** One recognized word with its page — the OCR replay input contract (same\n * shape as `geometry.ts`'s `PageWord`, re-exported under this module's public name). */\nexport type OcrWordInput = PageWord;\n\n/** A 1-based, inclusive page range — the shape every entry point's `pages`\n * option takes (the CLI's own `--pages N[-M]` parses into this). */\nexport interface PageSelection {\n first: number;\n /** inclusive; defaults to `first` */\n last?: number;\n}\n\n/** extractText/extractOcr/pdfToMarkdown's common return shape. */\nexport interface ExtractResult {\n markdown: string;\n /** per-document and per-page QA metrics — see `Report` (`src/types.ts`) */\n report: Report;\n /** every notice also delivered incrementally via `onWarning`, collected\n * here in full (hybrid pages, auto-OCR-fallback, empty OCR pages, sparse-retry) */\n warnings: string[];\n}\n\ninterface CommonOptions {\n /** convert only this page range (1-based, inclusive); defaults to the\n * whole document */\n pages?: PageSelection;\n /** delivered as each warning happens (also returned, in full, as\n * `warnings` on the resolved result) */\n onWarning?: (message: string) => void;\n}\n\n/** Options for {@link extractText}. */\nexport interface ExtractTextOptions extends CommonOptions {\n /** emit a `### pN` marker before each page's content (output formatting\n * only — `report.pageStats` is always populated regardless) */\n pageMarkers?: boolean;\n /** source PDF text runs entering layout, delivered once for the selected\n * final result. Runs retain measured bounds and are not fabricated words. */\n onWords?: (words: OcrWordInput[]) => void;\n}\n\n/** Options for {@link extractOcr}. */\nexport interface ExtractOcrOptions extends CommonOptions {\n /** override any subset of the OCR-path geometry defaults — see\n * DEFAULT_TUNING (`src/geometry.ts`) for each knob's measured default */\n tuning?: Partial<Tuning>;\n /** page-render resolution for engine recognition (default 288, measured;\n * >~400 measured WORSE on ordinary pages — not a \"bigger is safer\" knob) */\n dpi?: number;\n /** marks report.ocrFallback — set by pdfToMarkdown's auto-fallback */\n fallback?: boolean;\n /** one event per page as recognition finishes (timing/count only — engine\n * chatter and the sparse-retry notice arrive via `onWarning` instead) */\n onProgress?: (e: OcrProgressEvent) => void;\n /** every recognized word entering the geometry, delivered once after\n * recognition — the severity-1 audit instrument (--debug-words) */\n onWords?: (words: OcrWordInput[]) => void;\n}\n\n/** Options for {@link pdfToMarkdown}. */\nexport interface PdfToMarkdownOptions extends ExtractTextOptions, Omit<ExtractOcrOptions, 'fallback'> {\n /** force the OCR path even when a text layer exists */\n ocr?: boolean;\n /** never fall back to OCR, even for image-only pages */\n noOcr?: boolean;\n}\n\n// One collector per entry point: collects into `warnings`, streams via\n// onWarning, and emits the dictionary-unavailable notice exactly once up front.\nfunction warnCollector(onWarning?: (message: string) => void): { warnings: string[]; warn: (m: string) => void } {\n const warnings: string[] = [];\n const warn = (m: string) => {\n warnings.push(m);\n onWarning?.(m);\n };\n if (!dictAvailable()) warn(dictUnavailableWarning());\n return { warnings, warn };\n}\n\n/** Extract embedded text with a QA report and warnings; never runs OCR.\n * @param pdfPath path to the PDF file\n * @param opts see {@link ExtractTextOptions}\n */\nexport async function extractText(pdfPath: string, opts: ExtractTextOptions = {}): Promise<ExtractResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n const range = opts.pages ? { first: opts.pages.first, last: opts.pages.last ?? opts.pages.first } : {};\n const collected = await collect(pdfPath, range);\n const text = buildTextAnalysis(collected, opts.pageMarkers ?? false);\n textNotices(collected, new Set(), warn);\n opts.onWords?.(text.words);\n return { markdown: text.markdown, report: text.analysis.report, warnings };\n}\n\n/**\n * OCR extraction. Input is either a PDF (pages render at `dpi` and the\n * engine recognizes them, imported lazily) or an already-recognized word dump (the offline replay input — see `--words-json`).\n *\n * @param input `{ pdfPath }` to recognize, or `{ words }` to replay a dump\n * @param opts see {@link ExtractOcrOptions}\n */\nexport async function extractOcr(input: { pdfPath: string } | { words: OcrWordInput[] }, opts: ExtractOcrOptions = {}): Promise<ExtractResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n\n // Shared with analyze(pdf, {path:'ocr'}) — see that module's header for\n // why this makes the two byte-identical by construction, not by hand.\n const { pages, words } = await buildOcrAnalysisPages(input, opts, warn);\n const md = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n\n const report = buildOcrReport({\n md,\n fallback: opts.fallback,\n // Confidence is on `words` — see report.ts's low-confidence detector for\n // how it handles a confidence-less replay honestly.\n words,\n });\n return { markdown: md, report, warnings };\n}\n\n/** A page needs OCR only when its image signal accompanies an unusable text\n * layer. The caller supplies the image part of that decision. */\nfunction needsPageOcr(chars: number): boolean {\n return chars < AUTO_OCR_CHARS_PER_PAGE;\n}\n\nfunction textNotices(collected: CollectResult, ocrPages: Set<number>, warn: (message: string) => void): void {\n for (const page of collected.pages) {\n if (page.textChars !== 0 || ocrPages.has(page.page)) continue;\n if (page.hasImage) warn(`p${page.page}: no extractable text; page has image content and OCR was not selected`);\n else warn(`p${page.page}: no extractable text; the page may be blank or contain only vector content`);\n }\n for (const page of collected.pages) {\n if (!page.largeImage || ocrPages.has(page.page)) continue;\n warn(`p${page.page}: text layer used but page carries large image(s); if it has baked-in text this output won't have it — compare (don't blindly replace) against --pages ${page.page} --ocr, which can itself introduce errors`);\n }\n}\n\nfunction analysisWords(pages: AnalysisPage[]): OcrWordInput[] {\n return pages.flatMap((page) => page.words.map((word) => ({ page: page.page, text: word.text, ...word.box, confidence: word.confidence })));\n}\n\ninterface AutoAnalysisResult {\n analysis: Analysis;\n markdown: string;\n warnings: string[];\n}\n\n/** Shared automatic route for the library's Markdown result and the CLI's\n * raw/plain-text formats. A page changes producer only when it has image\n * evidence and an unusable text layer, so a blank or vector-only page never\n * becomes speculative OCR input. */\nexport async function analyzePdfAuto(pdfPath: string, opts: PdfToMarkdownOptions = {}): Promise<AutoAnalysisResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n const range = opts.pages ? { first: opts.pages.first, last: opts.pages.last ?? opts.pages.first } : {};\n\n if (opts.ocr) {\n const { pages, words } = await buildOcrAnalysisPages({ pdfPath }, { ...opts, onWords: undefined }, warn);\n const markdown = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n const report = buildOcrReport({ md: markdown, words });\n const analysis: Analysis = { outputVersion: report.outputVersion, report, pages };\n opts.onWords?.(words);\n return { analysis, markdown, warnings };\n }\n\n const collected = await collect(pdfPath, range);\n const ocrPageNumbers = new Set(!opts.noOcr ? collected.pages.filter((page) => page.hasImage && needsPageOcr(page.textChars)).map((page) => page.page) : []);\n if (!ocrPageNumbers.size) {\n const text = buildTextAnalysis(collected, opts.pageMarkers ?? false);\n textNotices(collected, ocrPageNumbers, warn);\n opts.onWords?.(text.words);\n return { analysis: text.analysis, markdown: text.markdown, warnings };\n }\n\n const textPageNumbers = new Set(collected.pages.filter((page) => !ocrPageNumbers.has(page.page)).map((page) => page.page));\n const text = textPageNumbers.size ? buildTextAnalysis(selectCollectedPages(collected, textPageNumbers), true) : undefined;\n const textByPage = new Map(text?.analysis.pages.map((page) => [page.page, page]));\n const ocrByPage = new Map<number, AnalysisPage>();\n const ocrWords: OcrWordInput[] = [];\n const ocrRanges: Array<{ first: number; last: number }> = [];\n for (const page of collected.pages) {\n if (!ocrPageNumbers.has(page.page)) continue;\n warn(`p${page.page}: sparse text layer with image content; using OCR for this page`);\n const lastRange = ocrRanges.at(-1);\n if (lastRange && lastRange.last + 1 === page.page) lastRange.last = page.page;\n else ocrRanges.push({ first: page.page, last: page.page });\n }\n for (const range of ocrRanges) {\n const result = await buildOcrAnalysisPages({ pdfPath }, { ...opts, pages: range, onWords: undefined }, warn);\n for (const page of result.pages) ocrByPage.set(page.page, page);\n ocrWords.push(...result.words);\n }\n textNotices(collected, ocrPageNumbers, warn);\n const pages = collected.pages.map((page) => ocrByPage.get(page.page) ?? (textByPage.get(page.page) as AnalysisPage));\n const markdown = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n const pagePaths = new Map(pages.map((page) => [page.page, page.path]));\n const report = buildOcrReport({\n md: markdown,\n fallback: true,\n words: ocrWords,\n pagePaths,\n hybridPages: text?.analysis.report.hybridPages,\n });\n if (text) {\n report.bodyFontHeight = text.analysis.report.bodyFontHeight;\n report.headingSizes = text.analysis.report.headingSizes;\n report.listItems = text.analysis.report.listItems;\n report.joinedPairs = text.analysis.report.joinedPairs;\n report.closedHyphens = text.analysis.report.closedHyphens;\n report.hybridPages = text.analysis.report.hybridPages;\n }\n const analysis: Analysis = { outputVersion: report.outputVersion, report, pages };\n opts.onWords?.(analysisWords(pages));\n return { analysis, markdown, warnings };\n}\n\n/**\n * Extract each page from embedded text, using OCR only when the page has\n * image content and fewer than `AUTO_OCR_CHARS_PER_PAGE` text characters.\n *\n * @param pdfPath path to the PDF file\n * @param opts see {@link PdfToMarkdownOptions}\n */\nexport async function pdfToMarkdown(pdfPath: string, opts: PdfToMarkdownOptions = {}): Promise<ExtractResult> {\n const result = await analyzePdfAuto(pdfPath, opts);\n return { markdown: result.markdown, report: result.analysis.report, warnings: result.warnings };\n}\n"],"names":["analyzePdfAuto","extractOcr","extractText","pdfToMarkdown","warnCollector","onWarning","warnings","warn","m","push","dictAvailable","dictUnavailableWarning","pdfPath","opts","range","collected","text","validatePages","pages","first","last","collect","buildTextAnalysis","pageMarkers","textNotices","Set","onWords","words","markdown","report","analysis","input","md","buildOcrAnalysisPages","renderPagesToMarkdown","forcePageMarkers","buildOcrReport","fallback","needsPageOcr","chars","AUTO_OCR_CHARS_PER_PAGE","ocrPages","page","textChars","has","hasImage","largeImage","analysisWords","flatMap","map","word","box","confidence","ocrPageNumbers","textPageNumbers","textByPage","ocrByPage","ocrWords","ocrRanges","lastRange","result","pagePaths","ocr","undefined","outputVersion","noOcr","filter","size","selectCollectedPages","Map","at","set","get","path","hybridPages","bodyFontHeight","headingSizes","listItems","joinedPairs","closedHyphens"],"mappings":"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"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/extract.ts"],"sourcesContent":["// The library layer for PDF -> markdown conversion: extractText/extractOcr/\n// pdfToMarkdown each take plain args, return plain data, and throw PdfToMdError — no process.exit, no console.*, no file writing.\n//\n// Warnings are DATA: every notice is returned in `warnings` verbatim and also\n// delivered incrementally via `onWarning` — the exact strings are load-bearing (the test suite asserts them).\nimport { buildOcrAnalysisPages } from './analyze.ts';\nimport { collect } from './collect.ts';\nimport { dictAvailable, dictUnavailableWarning } from './dict.ts';\nimport type { OcrProgressEvent } from './engines/tesseract.ts';\nimport type { PageWord, Tuning } from './geometry.ts';\nimport { renderPagesToMarkdown } from './render-analysis.ts';\nimport { AUTO_OCR_CHARS_PER_PAGE, buildOcrReport } from './report.ts';\nimport { buildTextAnalysis, selectCollectedPages } from './text-analysis.ts';\nimport type { Analysis, AnalysisPage, CollectResult, Report } from './types.ts';\nimport { validatePages } from './validate.ts';\n\nexport type { OcrProgressEvent } from './engines/tesseract.ts';\n\n// A plain-JS caller (or `.ts` with `as any`) gets no compile-time check on\n// `pages`, so it's validated once at runtime — see src/validate.ts's `validatePages`.\n\n/** One recognized word with its page — the OCR replay input contract (same\n * shape as `geometry.ts`'s `PageWord`, re-exported under this module's public name). */\nexport type OcrWordInput = PageWord;\n\n/** A 1-based, inclusive page range — the shape every entry point's `pages`\n * option takes (the CLI's own `--pages N[-M]` parses into this). */\nexport interface PageSelection {\n first: number;\n /** inclusive; defaults to `first` */\n last?: number;\n}\n\n/** extractText/extractOcr/pdfToMarkdown's common return shape. */\nexport interface ExtractResult {\n markdown: string;\n /** per-document and per-page QA metrics — see `Report` (`src/types.ts`) */\n report: Report;\n /** every notice also delivered incrementally via `onWarning`, collected\n * here in full (hybrid pages, auto-OCR-fallback, empty OCR pages, sparse-retry) */\n warnings: string[];\n}\n\ninterface CommonOptions {\n /** convert only this page range (1-based, inclusive); defaults to the\n * whole document */\n pages?: PageSelection;\n /** delivered as each warning happens (also returned, in full, as\n * `warnings` on the resolved result) */\n onWarning?: (message: string) => void;\n}\n\n/** Options for {@link extractText}. */\nexport interface ExtractTextOptions extends CommonOptions {\n /** emit a `### pN` marker before each page's content (output formatting\n * only — `report.pageStats` is always populated regardless) */\n pageMarkers?: boolean;\n /** source PDF text runs entering layout, delivered once for the selected\n * final result. Runs retain measured bounds and are not fabricated words. */\n onWords?: (words: OcrWordInput[]) => void;\n}\n\n/** Options for {@link extractOcr}. */\nexport interface ExtractOcrOptions extends CommonOptions {\n /** override any subset of the OCR-path geometry defaults — see\n * DEFAULT_TUNING (`src/geometry.ts`) for each knob's measured default */\n tuning?: Partial<Tuning>;\n /** page-render resolution for engine recognition (default 288, measured;\n * >~400 measured WORSE on ordinary pages — not a \"bigger is safer\" knob) */\n dpi?: number;\n /** marks report.ocrFallback — set by pdfToMarkdown's auto-fallback */\n fallback?: boolean;\n /** one event per page as recognition finishes (timing/count only — engine\n * chatter and the sparse-retry notice arrive via `onWarning` instead) */\n onProgress?: (e: OcrProgressEvent) => void;\n /** every recognized word entering the geometry, delivered once after\n * recognition — the severity-1 audit instrument (--debug-words) */\n onWords?: (words: OcrWordInput[]) => void;\n}\n\n/** Options for {@link pdfToMarkdown}. */\nexport interface PdfToMarkdownOptions extends ExtractTextOptions, Omit<ExtractOcrOptions, 'fallback'> {\n /** force the OCR path even when a text layer exists */\n ocr?: boolean;\n /** never fall back to OCR, even for image-only pages */\n noOcr?: boolean;\n}\n\n// One collector per entry point: collects into `warnings`, streams via\n// onWarning, and emits the dictionary-unavailable notice exactly once up front.\nfunction warnCollector(onWarning?: (message: string) => void): { warnings: string[]; warn: (m: string) => void } {\n const warnings: string[] = [];\n const warn = (m: string) => {\n warnings.push(m);\n onWarning?.(m);\n };\n if (!dictAvailable()) warn(dictUnavailableWarning());\n return { warnings, warn };\n}\n\n/** Extract embedded text with a QA report and warnings; never runs OCR.\n * @param pdfPath path to the PDF file\n * @param opts see {@link ExtractTextOptions}\n */\nexport async function extractText(pdfPath: string, opts: ExtractTextOptions = {}): Promise<ExtractResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n const range = opts.pages ? { first: opts.pages.first, last: opts.pages.last ?? opts.pages.first } : {};\n const collected = await collect(pdfPath, range);\n const text = buildTextAnalysis(collected, opts.pageMarkers ?? false);\n textNotices(collected, new Set(), warn);\n opts.onWords?.(text.words);\n return { markdown: text.markdown, report: text.analysis.report, warnings };\n}\n\n/**\n * OCR extraction. Input is either a PDF (pages render at `dpi` and the\n * engine recognizes them, imported lazily) or an already-recognized word dump (the offline replay input — see `--words-json`).\n *\n * @param input `{ pdfPath }` to recognize, or `{ words }` to replay a dump\n * @param opts see {@link ExtractOcrOptions}\n */\nexport async function extractOcr(input: { pdfPath: string } | { words: OcrWordInput[] }, opts: ExtractOcrOptions = {}): Promise<ExtractResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n\n // Shared with analyze(pdf, {path:'ocr'}) — see that module's header for\n // why this makes the two byte-identical by construction, not by hand.\n const { pages, words } = await buildOcrAnalysisPages(input, opts, warn);\n const md = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n\n const report = buildOcrReport({\n md,\n fallback: opts.fallback,\n // Confidence is on `words` — see report.ts's low-confidence detector for\n // how it handles a confidence-less replay honestly.\n words,\n });\n return { markdown: md, report, warnings };\n}\n\n/** A page needs OCR only when its image signal accompanies an unusable text\n * layer. The caller supplies the image part of that decision. */\nfunction needsPageOcr(chars: number): boolean {\n return chars < AUTO_OCR_CHARS_PER_PAGE;\n}\n\nfunction textNotices(collected: CollectResult, ocrPages: Set<number>, warn: (message: string) => void): void {\n for (const page of collected.pages) {\n if (page.textChars !== 0 || ocrPages.has(page.page)) continue;\n if (page.hasImage) warn(`p${page.page}: no extractable text; page has image content and OCR was not selected`);\n else warn(`p${page.page}: no extractable text; the page may be blank or contain only vector content`);\n }\n for (const page of collected.pages) {\n if (!page.largeImage || ocrPages.has(page.page)) continue;\n warn(`p${page.page}: text layer used but page carries large image(s); if it has baked-in text this output won't have it — compare (don't blindly replace) against --pages ${page.page} --ocr, which can itself introduce errors`);\n }\n}\n\nfunction analysisWords(pages: AnalysisPage[]): OcrWordInput[] {\n return pages.flatMap((page) => page.words.map((word) => ({ page: page.page, text: word.text, ...word.box, confidence: word.confidence })));\n}\n\ninterface AutoAnalysisResult {\n analysis: Analysis;\n markdown: string;\n warnings: string[];\n}\n\n/** Shared automatic route for the library's Markdown result and the CLI's\n * raw/plain-text formats. A page changes producer only when it has image\n * evidence and an unusable text layer, so a blank or vector-only page never\n * becomes speculative OCR input. */\nexport async function analyzePdfAuto(pdfPath: string, opts: PdfToMarkdownOptions = {}): Promise<AutoAnalysisResult> {\n validatePages(opts.pages);\n const { warnings, warn } = warnCollector(opts.onWarning);\n const range = opts.pages ? { first: opts.pages.first, last: opts.pages.last ?? opts.pages.first } : {};\n\n if (opts.ocr) {\n const { pages, words } = await buildOcrAnalysisPages({ pdfPath }, { ...opts, onWords: undefined }, warn);\n const markdown = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n const report = buildOcrReport({ md: markdown, words });\n const analysis: Analysis = { outputVersion: report.outputVersion, report, pages };\n opts.onWords?.(words);\n return { analysis, markdown, warnings };\n }\n\n const collected = await collect(pdfPath, range);\n const ocrPageNumbers = new Set(!opts.noOcr ? collected.pages.filter((page) => page.hasImage && needsPageOcr(page.textChars)).map((page) => page.page) : []);\n if (!ocrPageNumbers.size) {\n const text = buildTextAnalysis(collected, opts.pageMarkers ?? false);\n textNotices(collected, ocrPageNumbers, warn);\n opts.onWords?.(text.words);\n return { analysis: text.analysis, markdown: text.markdown, warnings };\n }\n\n const textPageNumbers = new Set(collected.pages.filter((page) => !ocrPageNumbers.has(page.page)).map((page) => page.page));\n const text = textPageNumbers.size ? buildTextAnalysis(selectCollectedPages(collected, textPageNumbers), true) : undefined;\n const textByPage = new Map(text?.analysis.pages.map((page) => [page.page, page]));\n const ocrByPage = new Map<number, AnalysisPage>();\n const ocrWords: OcrWordInput[] = [];\n const ocrRanges: Array<{ first: number; last: number }> = [];\n for (const page of collected.pages) {\n if (!ocrPageNumbers.has(page.page)) continue;\n warn(`p${page.page}: sparse text layer with image content; using OCR for this page`);\n const lastRange = ocrRanges.at(-1);\n if (lastRange && lastRange.last + 1 === page.page) lastRange.last = page.page;\n else ocrRanges.push({ first: page.page, last: page.page });\n }\n for (const range of ocrRanges) {\n const result = await buildOcrAnalysisPages({ pdfPath }, { ...opts, pages: range, onWords: undefined }, warn);\n for (const page of result.pages) ocrByPage.set(page.page, page);\n ocrWords.push(...result.words);\n }\n textNotices(collected, ocrPageNumbers, warn);\n const pages = collected.pages.map((page) => ocrByPage.get(page.page) ?? (textByPage.get(page.page) as AnalysisPage));\n const markdown = renderPagesToMarkdown(pages, { forcePageMarkers: true, pageMarkers: true });\n const pagePaths = new Map(pages.map((page) => [page.page, page.path]));\n const report = buildOcrReport({\n md: markdown,\n fallback: true,\n words: ocrWords,\n pagePaths,\n hybridPages: text?.analysis.report.hybridPages,\n });\n if (text) {\n report.bodyFontHeight = text.analysis.report.bodyFontHeight;\n report.headingSizes = text.analysis.report.headingSizes;\n report.listItems = text.analysis.report.listItems;\n report.joinedPairs = text.analysis.report.joinedPairs;\n report.closedHyphens = text.analysis.report.closedHyphens;\n report.hybridPages = text.analysis.report.hybridPages;\n }\n const analysis: Analysis = { outputVersion: report.outputVersion, report, pages };\n opts.onWords?.(analysisWords(pages));\n return { analysis, markdown, warnings };\n}\n\n/**\n * Extract each page from embedded text, using OCR only when the page has\n * image content and fewer than `AUTO_OCR_CHARS_PER_PAGE` text characters.\n *\n * @param pdfPath path to the PDF file\n * @param opts see {@link PdfToMarkdownOptions}\n */\nexport async function pdfToMarkdown(pdfPath: string, opts: PdfToMarkdownOptions = {}): Promise<ExtractResult> {\n const result = await analyzePdfAuto(pdfPath, opts);\n return { markdown: result.markdown, report: result.analysis.report, warnings: result.warnings };\n}\n"],"names":["analyzePdfAuto","extractOcr","extractText","pdfToMarkdown","warnCollector","onWarning","warnings","warn","m","push","dictAvailable","dictUnavailableWarning","pdfPath","opts","range","collected","text","validatePages","pages","first","last","collect","buildTextAnalysis","pageMarkers","textNotices","Set","onWords","words","markdown","report","analysis","input","md","buildOcrAnalysisPages","renderPagesToMarkdown","forcePageMarkers","buildOcrReport","fallback","needsPageOcr","chars","AUTO_OCR_CHARS_PER_PAGE","ocrPages","page","textChars","has","hasImage","largeImage","analysisWords","flatMap","map","word","box","confidence","ocrPageNumbers","textPageNumbers","textByPage","ocrByPage","ocrWords","ocrRanges","lastRange","result","pagePaths","ocr","undefined","outputVersion","noOcr","filter","size","selectCollectedPages","Map","at","set","get","path","hybridPages","bodyFontHeight","headingSizes","listItems","joinedPairs","closedHyphens"],"mappings":"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"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/geometry.ts"],"sourcesContent":["// geometry.ts — OCR-path pass 2: words -> lines/columns/floats. Input is\n// flat words (normalized page coords, origin bottom-left, y up), not pre-clustered line observations.\nexport interface Word {\n text: string;\n x: number; // rect.minX\n y: number; // rect.minY\n w: number; // rect.width\n h: number; // rect.height\n // 0-100 (tesseract.js's own `confidence` field, not `conf`). Optional —\n // passthrough only; see report.ts's LOW_CONFIDENCE_THRESHOLD for the consumer.\n confidence?: number;\n}\n\n/** A `Word` with its page number — the shared shape behind both the OCR\n * engine's own output (tesseract.ts) and the replay input contract (extract.ts's OcrWordInput). */\nexport interface PageWord extends Word {\n page: number;\n}\n\nexport interface OcrLine {\n text: string;\n x: number; // rect.minX, used for float-alignment and indentation checks\n width: number; // rect.width, used for the float width check\n midY: number;\n h: number; // char-weighted dominant constituent height\n col: number;\n // Constituent words, left-to-right (same order as `text`'s tokens) — carries\n // word identity through row-building for analyze()'s block->word linkage.\n words: Word[];\n}\n\nexport interface PageOCR {\n lines: OcrLine[];\n // Decorative fragment candidates (src/emit.ts's floats aside), kept as full\n // OcrLine so callers recover both the printed text and constituent words.\n floats: OcrLine[];\n pitch: number;\n}\n\n/** Tuning knobs for the OCR-path geometry pass (CLI: `--float-*`/`--para-gap`/\n * `--heading-scale`/`--col-*`/`--line-*`). See DEFAULT_TUNING for defaults. */\nexport interface Tuning {\n /** fragments with more words than this are body text, not decoration */\n floatMaxWords: number;\n /** fraction of page width above which a fragment is too wide to be\n * decoration */\n floatMaxWidth: number;\n /** how far a fragment's left edge must sit from its column edge to be\n * decoration */\n floatMargin: number;\n /** a vertical gap this many times the line pitch is a paragraph break */\n paraGap: number;\n /** lines taller than this times body height are headings */\n headingScale: number;\n /** boxes wider than this are excluded from gutter detection */\n colMaxWidth: number;\n /** fractional x of the two-column midpoint */\n colSplit: number;\n /** vertical distance within which two boxes are the same line */\n lineYTol: number;\n /** same-line boxes with a larger height ratio don't merge */\n lineHeightRatio: number;\n}\n\n/** Measured defaults; derivation in `test/unit/tuning.test.ts`. lineHeightRatio\n * 2.4 = pair-F1 plateau edge (0.924@1.6 -> 0.995@2.4, 9,471 pairs, 2026-08-16). */\nexport const DEFAULT_TUNING: Tuning = {\n floatMaxWords: 3,\n floatMaxWidth: 0.15,\n floatMargin: 0.008,\n paraGap: 1.6,\n headingScale: 2.0,\n colMaxWidth: 0.55,\n colSplit: 0.5,\n lineYTol: 0.006,\n lineHeightRatio: 2.4,\n};\n\n// Two-column decision (test/unit/column-break.test.ts): gutter ink <=0.017\n// (2-col) vs >=0.047 (1-col) measured over 100 baseline pages, cut 0.03.\nexport const MAX_GUTTER_INK_FRAC = 0.03;\n\n// Near-empty pages (e.g. a 2-word title page) have no gutter ink either, so\n// a word-count floor is needed too; genuine columns measure >=76 words.\nexport const MIN_COL_WORDS = 10;\n\n// lineYTol is an absolute page fraction measured on body text, but a word's\n// box grows downward with its descenders, so its midpoint sits lower than a\n// descenderless neighbour's on the same printed line. At body size that offset\n// is ~0.003 (inside the tolerance); on 56pt display type it is ~0.007 (outside\n// it), which splits one heading into two rows that then emit in midY order\n// (\"Open Road\" -> \"Road Open\"). A descender is ~21% of the em, so the offset is\n// ~11% of the taller box; 0.2 clears it with margin and still sits far below any\n// line pitch. Body rows are unaffected: 0.2 * a body height stays under the floor.\nexport const LINE_Y_TOL_HEIGHT_FRAC = 0.2;\n\n// Measured: a thin data rail is 11% of body words; the thinnest genuine\n// column is 31% — 0.2 sits between.\nexport const MIN_COL_SHARE = 0.2;\n\ninterface Rect {\n x: number;\n y: number;\n w: number;\n h: number;\n}\ntype Range = readonly [number, number];\n\nconst maxX = (r: Rect): number => r.x + r.w;\nconst maxY = (r: Rect): number => r.y + r.h;\nconst midX = (r: Rect): number => r.x + r.w / 2;\nconst midY = (r: Rect): number => r.y + r.h / 2;\n\nfunction union(a: Rect, b: Rect): Rect {\n const x0 = Math.min(a.x, b.x);\n const y0 = Math.min(a.y, b.y);\n const x1 = Math.max(maxX(a), maxX(b));\n const y1 = Math.max(maxY(a), maxY(b));\n return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };\n}\n\n// Overlap of a rect's x-span with a column x-range.\nfunction xOverlap(r: Rect, range: Range): number {\n return Math.max(0, Math.min(maxX(r), range[1]) - Math.max(r.x, range[0]));\n}\n\nfunction median(xs: number[]): number | undefined {\n if (!xs.length) return undefined;\n return [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];\n}\n\n// Char-weighted dominant height: most characters wins (ties keep first) —\n// same rule as src/lines.ts, so a small merged fragment can't promote a heading.\nfunction dominantHeight(parts: Word[]): number {\n let best = parts[0];\n for (let i = 1; i < parts.length; i++) {\n if (parts[i].text.length > best.text.length) best = parts[i];\n }\n return best.h;\n}\n\nfunction assignColumn(rect: Rect, colRanges: Range[]): number {\n if (colRanges.length !== 2) return 0;\n const l = xOverlap(rect, colRanges[0]);\n const r = xOverlap(rect, colRanges[1]);\n if (l !== r) return l > r ? 0 : 1;\n const centers = colRanges.map((rg) => (rg[0] + rg[1]) / 2);\n return Math.abs(midX(rect) - centers[0]) <= Math.abs(midX(rect) - centers[1]) ? 0 : 1;\n}\n\n// A column x-range from full-width body rows: short paragraph-final rows and\n// decorative fragments must not stretch it.\nfunction range(rects: Rect[]): Range | undefined {\n if (rects.length < 2) return undefined;\n return [Math.min(...rects.map((r) => r.x)), Math.max(...rects.map(maxX))];\n}\n\ninterface Row {\n rect: Rect;\n words: Word[];\n band: number; // -1 (gutter band / n/a), 0 (left or single column), 1 (right)\n}\n\n// Groups same-visual-line words via lineYTol/lineHeightRatio, requiring band\n// agreement; searches ALL open rows since per-word y drifts ~0.001 across a\n// printed line, enough to interleave two lines' words in y-sorted order. The y\n// tolerance scales with box height (LINE_Y_TOL_HEIGHT_FRAC) so display type,\n// whose descenders shift a word's midpoint further, still groups as one row.\nfunction buildRows(words: Word[], tuning: Tuning, bandOf: (w: Word) => number): Row[] {\n const rows: Row[] = [];\n // Sort order only affects which compatible row a tie lands in (every row\n // is searched) — top-to-bottom, left-to-right keeps results deterministic.\n const sorted = [...words].sort((a, b) => midY(b) - midY(a) || a.x - b.x);\n for (const w of sorted) {\n const band = bandOf(w);\n const target = rows.find((r) => {\n if (r.band !== band) return false;\n const yTol = Math.max(tuning.lineYTol, Math.max(r.rect.h, w.h) * LINE_Y_TOL_HEIGHT_FRAC);\n return Math.abs(midY(r.rect) - midY(w)) <= yTol && Math.max(r.rect.h, w.h) < Math.min(r.rect.h, w.h) * tuning.lineHeightRatio;\n });\n if (target) {\n target.words.push(w);\n target.rect = union(target.rect, w);\n } else {\n rows.push({ rect: { x: w.x, y: w.y, w: w.w, h: w.h }, words: [w], band });\n }\n }\n return rows;\n}\n\nfunction makeLine(parts: Word[], rect: Rect, col: number): OcrLine {\n const sorted = [...parts].sort((a, b) => a.x - b.x);\n const text = sorted.map((p) => p.text).join(' ');\n return {\n text,\n x: rect.x,\n width: rect.w,\n midY: midY(rect),\n h: dominantHeight(parts),\n col,\n words: sorted,\n };\n}\n\n// Word-geometry pass (render/recognize happens upstream, in the OCR engine).\n// Body-height words band left/right before row-grouping; heading-height words group across the full width, so a title stays one line.\nexport function buildPageOCR(words: Word[], tuning: Tuning): PageOCR {\n if (!words.length) return { lines: [], floats: [], pitch: 0.012 };\n\n const colBand = 0.02;\n const colLeftCut = tuning.colSplit - colBand;\n const colRightCut = tuning.colSplit + colBand;\n\n const medianH = median(words.map((w) => w.h)) ?? 0.017;\n // Same literal `medianH * 2` used elsewhere for this gate — not\n // `tuning.headingScale`, a separate constant that happens to share the 2.0 default.\n const tallGate = medianH * 2;\n\n // Two-column decision (test/unit/column-break.test.ts): gutter ink <=0.017\n // (2-col) vs >=0.047 (1-col), cut 0.03; floors >=0.2 share/>=10 words per side.\n const bodyWords = words.filter((w) => w.h < tallGate);\n const gutterInk = bodyWords.filter((w) => w.x < tuning.colSplit && maxX(w) > tuning.colSplit).length;\n const leftPop = bodyWords.filter((w) => midX(w) < colLeftCut).length;\n const rightPop = bodyWords.filter((w) => midX(w) > colRightCut).length;\n const twoCol = leftPop >= MIN_COL_WORDS && rightPop >= MIN_COL_WORDS && leftPop >= bodyWords.length * MIN_COL_SHARE && rightPop >= bodyWords.length * MIN_COL_SHARE && gutterInk <= bodyWords.length * MAX_GUTTER_INK_FRAC;\n\n // Band by word CENTER, no dead band: a word box can touch the split exactly\n // (a box can touch the split exactly) and still belongs to its center's column — the twoCol\n // gate above already guarantees near-zero gutter ink.\n const bandOf = (w: Word): number => {\n if (!twoCol) return 0;\n return midX(w) < tuning.colSplit ? 0 : 1;\n };\n const tallRows = buildRows(\n words.filter((w) => w.h >= tallGate),\n tuning,\n () => 0\n );\n const normalRows = buildRows(\n words.filter((w) => w.h < tallGate),\n tuning,\n bandOf\n );\n const rows = [...tallRows, ...normalRows];\n\n // Column ranges from body rows (height <= medianH*1.6): two-col ranges use\n // rows 0.2-0.55 wide; single-col has no upper bound (full-width rows ARE the column).\n let colRanges: Range[];\n if (twoCol) {\n const wideRows = rows.filter((r) => r.rect.w >= 0.2 && r.rect.w <= 0.55 && r.rect.h <= medianH * 1.6);\n const left = range(wideRows.filter((r) => r.band === 0).map((r) => r.rect));\n const right = range(wideRows.filter((r) => r.band === 1).map((r) => r.rect));\n colRanges = [left, right].filter((r): r is Range => r !== undefined);\n } else {\n const wideRows = rows.filter((r) => r.rect.w >= 0.2 && r.rect.h <= medianH * 1.6);\n const single = range(wideRows.map((r) => r.rect));\n colRanges = single !== undefined ? [single] : [];\n }\n\n const lines: OcrLine[] = rows.map((row) => makeLine(row.words, row.rect, assignColumn(row.rect, colRanges)));\n lines.sort((a, b) => a.col - b.col || b.midY - a.midY);\n\n // Float detection: short+narrow+misaligned, rescued into body when it\n // hangs under a body line like a paragraph continuation (same col, gap<=paraGap x pitch, x-overlap) — protects a centered paragraph's short last line.\n const preGaps: number[] = [];\n for (let k = 1; k < lines.length; k++) {\n if (lines[k].col === lines[k - 1].col) {\n const g = lines[k - 1].midY - lines[k].midY;\n if (g > 0.0005) preGaps.push(g);\n }\n }\n const provisionalPitch = median(preGaps) ?? 0.012;\n const colStarts = new Map<number, number>();\n colRanges.forEach((r, i) => {\n colStarts.set(i, r[0]);\n });\n const body: OcrLine[] = [];\n const floatCandidates: OcrLine[] = [];\n // Display-size junk (e.g. \"1/3\" at 68pt, 0.179 wide vs the 0.15 cap)\n // escapes the narrow float test; caught here by junk text + isolation (no adjacent tall line within 2.2x height).\n const tallLines = lines.filter((l) => l.h >= tallGate);\n for (const line of lines) {\n const wordCount = line.text.split(' ').filter(Boolean).length;\n const start = colStarts.get(line.col);\n const short = wordCount <= tuning.floatMaxWords && start !== undefined && Math.abs(line.x - start) > tuning.floatMargin;\n const displayJunkFragment =\n short &&\n line.h >= tallGate &&\n !/[A-Za-z]{3}/.test(line.text) &&\n // Same-column only, matching emitPage's heading-run gather — a heading\n // in the OTHER column can be y-adjacent without composing with this one.\n !tallLines.some((other) => other !== line && other.col === line.col && Math.abs(other.midY - line.midY) < Math.max(other.h, line.h) * 2.2);\n const looksDecorative = displayJunkFragment || (short && line.width < tuning.floatMaxWidth);\n const paragraphAdjacent =\n looksDecorative &&\n body.some((b) => {\n if (b.col !== line.col) return false;\n const gap = b.midY - line.midY;\n if (gap <= 0 || gap > tuning.paraGap * provisionalPitch) return false;\n const overlap = Math.min(b.x + b.width, line.x + line.width) - Math.max(b.x, line.x);\n return overlap >= line.width * 0.5;\n });\n if (looksDecorative && !paragraphAdjacent) {\n floatCandidates.push(line);\n } else {\n body.push(line);\n }\n }\n // One float per candidate row, in line order — no clustering of adjacent\n // candidates: replay against the frozen baseline regressed ~30 pages when tried.\n const floats = floatCandidates;\n\n // Line pitch = median vertical gap between consecutive same-column lines.\n const gaps: number[] = [];\n for (let k = 1; k < body.length; k++) {\n if (body[k].col === body[k - 1].col) {\n const g = body[k - 1].midY - body[k].midY;\n if (g > 0.0005) gaps.push(g);\n }\n }\n return { lines: body, floats, pitch: median(gaps) ?? 0.012 };\n}\n\n// Document-wide height histogram -> heading levels\n\n// Bucket heights to 0.002 of page height so histogram keys are stable.\nexport function bucket(h: number): number {\n return Math.round(h * 500) / 500;\n}\n\n// `pages` are the already-body-only (post-float-filtering) PageOCR results.\nexport function headingLevels(pages: PageOCR[], tuning: Tuning): { bodyH: number; levelOf: Map<number, number> } {\n const chars = new Map<number, number>();\n for (const p of pages) {\n for (const l of p.lines) {\n const b = bucket(l.h);\n chars.set(b, (chars.get(b) ?? 0) + l.text.length);\n }\n }\n // Most-common height wins; ties broken by first-encountered (deterministic;\n // char-count ties across real documents are not observed).\n let bodyH = 0;\n let bestCount = -1;\n for (const [k, v] of chars) {\n if (v > bestCount) {\n bestCount = v;\n bodyH = k;\n }\n }\n\n const levelOf = new Map<number, number>();\n let level = 3; // \"### pN\" page markers occupy level 3\n let rep: number | null = null;\n const sizes = [...chars.keys()].filter((s) => s > bodyH * tuning.headingScale).sort((a, b) => b - a);\n for (const s of sizes) {\n if (rep === null || s < rep * 0.8) {\n level = Math.min(6, level + 1);\n rep = s;\n }\n levelOf.set(s, level);\n }\n return { bodyH, levelOf };\n}\n"],"names":["DEFAULT_TUNING","LINE_Y_TOL_HEIGHT_FRAC","MAX_GUTTER_INK_FRAC","MIN_COL_SHARE","MIN_COL_WORDS","bucket","buildPageOCR","headingLevels","floatMaxWords","floatMaxWidth","floatMargin","paraGap","headingScale","colMaxWidth","colSplit","lineYTol","lineHeightRatio","maxX","r","x","w","maxY","y","h","midX","midY","union","a","b","x0","Math","min","y0","x1","max","y1","xOverlap","range","median","xs","length","undefined","sort","floor","dominantHeight","parts","best","i","text","assignColumn","rect","colRanges","l","centers","map","rg","abs","rects","buildRows","words","tuning","bandOf","rows","sorted","band","target","find","yTol","push","makeLine","col","p","join","width","lines","floats","pitch","colBand","colLeftCut","colRightCut","medianH","tallGate","bodyWords","filter","gutterInk","leftPop","rightPop","twoCol","tallRows","normalRows","wideRows","left","right","single","row","preGaps","k","g","provisionalPitch","colStarts","Map","forEach","set","body","floatCandidates","tallLines","line","wordCount","split","Boolean","start","get","short","displayJunkFragment","test","some","other","looksDecorative","paragraphAdjacent","gap","overlap","gaps","round","pages","chars","bodyH","bestCount","v","levelOf","level","rep","sizes","keys","s"],"mappings":"AAAA,yEAAyE;AACzE,sGAAsG;;;;;;;;;;;;QAiEzFA;eAAAA;;QA4BAC;eAAAA;;QAdAC;eAAAA;;QAkBAC;eAAAA;;QAdAC;eAAAA;;QAkPGC;eAAAA;;QAxHAC;eAAAA;;QA6HAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAzQT,IAAMP,iBAAyB;IACpCQ,eAAe;IACfC,eAAe;IACfC,aAAa;IACbC,SAAS;IACTC,cAAc;IACdC,aAAa;IACbC,UAAU;IACVC,UAAU;IACVC,iBAAiB;AACnB;AAIO,IAAMd,sBAAsB;AAI5B,IAAME,gBAAgB;AAUtB,IAAMH,yBAAyB;AAI/B,IAAME,gBAAgB;AAU7B,IAAMc,OAAO,cAACC;WAAoBA,EAAEC,CAAC,GAAGD,EAAEE,CAAC;;AAC3C,IAAMC,OAAO,cAACH;WAAoBA,EAAEI,CAAC,GAAGJ,EAAEK,CAAC;;AAC3C,IAAMC,OAAO,cAACN;WAAoBA,EAAEC,CAAC,GAAGD,EAAEE,CAAC,GAAG;;AAC9C,IAAMK,OAAO,cAACP;WAAoBA,EAAEI,CAAC,GAAGJ,EAAEK,CAAC,GAAG;;AAE9C,SAASG,MAAMC,CAAO,EAAEC,CAAO;IAC7B,IAAMC,KAAKC,KAAKC,GAAG,CAACJ,EAAER,CAAC,EAAES,EAAET,CAAC;IAC5B,IAAMa,KAAKF,KAAKC,GAAG,CAACJ,EAAEL,CAAC,EAAEM,EAAEN,CAAC;IAC5B,IAAMW,KAAKH,KAAKI,GAAG,CAACjB,KAAKU,IAAIV,KAAKW;IAClC,IAAMO,KAAKL,KAAKI,GAAG,CAACb,KAAKM,IAAIN,KAAKO;IAClC,OAAO;QAAET,GAAGU;QAAIP,GAAGU;QAAIZ,GAAGa,KAAKJ;QAAIN,GAAGY,KAAKH;IAAG;AAChD;AAEA,oDAAoD;AACpD,SAASI,SAASlB,CAAO,EAAEmB,KAAY;IACrC,OAAOP,KAAKI,GAAG,CAAC,GAAGJ,KAAKC,GAAG,CAACd,KAAKC,IAAImB,KAAK,CAAC,EAAE,IAAIP,KAAKI,GAAG,CAAChB,EAAEC,CAAC,EAAEkB,KAAK,CAAC,EAAE;AACzE;AAEA,SAASC,OAAOC,EAAY;IAC1B,IAAI,CAACA,GAAGC,MAAM,EAAE,OAAOC;IACvB,OAAO,AAAC,qBAAGF,IAAIG,IAAI,CAAC,SAACf,GAAGC;eAAMD,IAAIC;MAAE,CAACE,KAAKa,KAAK,CAACJ,GAAGC,MAAM,GAAG,GAAG;AACjE;AAEA,0EAA0E;AAC1E,iFAAiF;AACjF,SAASI,eAAeC,KAAa;IACnC,IAAIC,OAAOD,KAAK,CAAC,EAAE;IACnB,IAAK,IAAIE,IAAI,GAAGA,IAAIF,MAAML,MAAM,EAAEO,IAAK;QACrC,IAAIF,KAAK,CAACE,EAAE,CAACC,IAAI,CAACR,MAAM,GAAGM,KAAKE,IAAI,CAACR,MAAM,EAAEM,OAAOD,KAAK,CAACE,EAAE;IAC9D;IACA,OAAOD,KAAKvB,CAAC;AACf;AAEA,SAAS0B,aAAaC,IAAU,EAAEC,SAAkB;IAClD,IAAIA,UAAUX,MAAM,KAAK,GAAG,OAAO;IACnC,IAAMY,IAAIhB,SAASc,MAAMC,SAAS,CAAC,EAAE;IACrC,IAAMjC,IAAIkB,SAASc,MAAMC,SAAS,CAAC,EAAE;IACrC,IAAIC,MAAMlC,GAAG,OAAOkC,IAAIlC,IAAI,IAAI;IAChC,IAAMmC,UAAUF,UAAUG,GAAG,CAAC,SAACC;eAAO,AAACA,CAAAA,EAAE,CAAC,EAAE,GAAGA,EAAE,CAAC,EAAE,AAAD,IAAK;;IACxD,OAAOzB,KAAK0B,GAAG,CAAChC,KAAK0B,QAAQG,OAAO,CAAC,EAAE,KAAKvB,KAAK0B,GAAG,CAAChC,KAAK0B,QAAQG,OAAO,CAAC,EAAE,IAAI,IAAI;AACtF;AAEA,6EAA6E;AAC7E,4CAA4C;AAC5C,SAAShB,MAAMoB,KAAa;QAElB3B,OAAoCA;IAD5C,IAAI2B,MAAMjB,MAAM,GAAG,GAAG,OAAOC;IAC7B,OAAO;QAACX,CAAAA,QAAAA,MAAKC,GAAG,OAARD,OAAS,qBAAG2B,MAAMH,GAAG,CAAC,SAACpC;mBAAMA,EAAEC,CAAC;;QAAIW,CAAAA,SAAAA,MAAKI,GAAG,OAARJ,QAAS,qBAAG2B,MAAMH,GAAG,CAACrC;KAAO;AAC3E;AAQA,6EAA6E;AAC7E,4EAA4E;AAC5E,+EAA+E;AAC/E,6EAA6E;AAC7E,6EAA6E;AAC7E,SAASyC,UAAUC,KAAa,EAAEC,MAAc,EAAEC,MAA2B;IAC3E,IAAMC,OAAc,EAAE;IACtB,yEAAyE;IACzE,2EAA2E;IAC3E,IAAMC,SAAS,AAAC,qBAAGJ,OAAOjB,IAAI,CAAC,SAACf,GAAGC;eAAMH,KAAKG,KAAKH,KAAKE,MAAMA,EAAER,CAAC,GAAGS,EAAET,CAAC;;QAClE,kCAAA,2BAAA;;;YAAA,IAAMC,IAAN;YACH,IAAM4C,OAAOH,OAAOzC;YACpB,IAAM6C,SAASH,KAAKI,IAAI,CAAC,SAAChD;gBACxB,IAAIA,EAAE8C,IAAI,KAAKA,MAAM,OAAO;gBAC5B,IAAMG,OAAOrC,KAAKI,GAAG,CAAC0B,OAAO7C,QAAQ,EAAEe,KAAKI,GAAG,CAAChB,EAAEgC,IAAI,CAAC3B,CAAC,EAAEH,EAAEG,CAAC,IAAItB;gBACjE,OAAO6B,KAAK0B,GAAG,CAAC/B,KAAKP,EAAEgC,IAAI,IAAIzB,KAAKL,OAAO+C,QAAQrC,KAAKI,GAAG,CAAChB,EAAEgC,IAAI,CAAC3B,CAAC,EAAEH,EAAEG,CAAC,IAAIO,KAAKC,GAAG,CAACb,EAAEgC,IAAI,CAAC3B,CAAC,EAAEH,EAAEG,CAAC,IAAIqC,OAAO5C,eAAe;YAC/H;YACA,IAAIiD,QAAQ;gBACVA,OAAON,KAAK,CAACS,IAAI,CAAChD;gBAClB6C,OAAOf,IAAI,GAAGxB,MAAMuC,OAAOf,IAAI,EAAE9B;YACnC,OAAO;gBACL0C,KAAKM,IAAI,CAAC;oBAAElB,MAAM;wBAAE/B,GAAGC,EAAED,CAAC;wBAAEG,GAAGF,EAAEE,CAAC;wBAAEF,GAAGA,EAAEA,CAAC;wBAAEG,GAAGH,EAAEG,CAAC;oBAAC;oBAAGoC,OAAO;wBAACvC;qBAAE;oBAAE4C,MAAAA;gBAAK;YACzE;QACF;QAbA,QAAK,YAAWD,2BAAX,SAAA,6BAAA,QAAA,yBAAA;;QAAA;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAcL,OAAOD;AACT;AAEA,SAASO,SAASxB,KAAa,EAAEK,IAAU,EAAEoB,GAAW;IACtD,IAAMP,SAAS,AAAC,qBAAGlB,OAAOH,IAAI,CAAC,SAACf,GAAGC;eAAMD,EAAER,CAAC,GAAGS,EAAET,CAAC;;IAClD,IAAM6B,OAAOe,OAAOT,GAAG,CAAC,SAACiB;eAAMA,EAAEvB,IAAI;OAAEwB,IAAI,CAAC;IAC5C,OAAO;QACLxB,MAAAA;QACA7B,GAAG+B,KAAK/B,CAAC;QACTsD,OAAOvB,KAAK9B,CAAC;QACbK,MAAMA,KAAKyB;QACX3B,GAAGqB,eAAeC;QAClByB,KAAAA;QACAX,OAAOI;IACT;AACF;AAIO,SAASzD,aAAaqD,KAAa,EAAEC,MAAc;QAOxCtB,SA0DSA,UAiDYA;IAjHrC,IAAI,CAACqB,MAAMnB,MAAM,EAAE,OAAO;QAAEkC,OAAO,EAAE;QAAEC,QAAQ,EAAE;QAAEC,OAAO;IAAM;IAEhE,IAAMC,UAAU;IAChB,IAAMC,aAAalB,OAAO9C,QAAQ,GAAG+D;IACrC,IAAME,cAAcnB,OAAO9C,QAAQ,GAAG+D;IAEtC,IAAMG,WAAU1C,UAAAA,OAAOqB,MAAML,GAAG,CAAC,SAAClC;eAAMA,EAAEG,CAAC;qBAA3Be,qBAAAA,UAAiC;IACjD,gEAAgE;IAChE,oFAAoF;IACpF,IAAM2C,WAAWD,UAAU;IAE3B,2EAA2E;IAC3E,gFAAgF;IAChF,IAAME,YAAYvB,MAAMwB,MAAM,CAAC,SAAC/D;eAAMA,EAAEG,CAAC,GAAG0D;;IAC5C,IAAMG,YAAYF,UAAUC,MAAM,CAAC,SAAC/D;eAAMA,EAAED,CAAC,GAAGyC,OAAO9C,QAAQ,IAAIG,KAAKG,KAAKwC,OAAO9C,QAAQ;OAAE0B,MAAM;IACpG,IAAM6C,UAAUH,UAAUC,MAAM,CAAC,SAAC/D;eAAMI,KAAKJ,KAAK0D;OAAYtC,MAAM;IACpE,IAAM8C,WAAWJ,UAAUC,MAAM,CAAC,SAAC/D;eAAMI,KAAKJ,KAAK2D;OAAavC,MAAM;IACtE,IAAM+C,SAASF,WAAWjF,iBAAiBkF,YAAYlF,iBAAiBiF,WAAWH,UAAU1C,MAAM,GAAGrC,iBAAiBmF,YAAYJ,UAAU1C,MAAM,GAAGrC,iBAAiBiF,aAAaF,UAAU1C,MAAM,GAAGtC;IAEvM,4EAA4E;IAC5E,4FAA4F;IAC5F,sDAAsD;IACtD,IAAM2D,SAAS,gBAACzC;QACd,IAAI,CAACmE,QAAQ,OAAO;QACpB,OAAO/D,KAAKJ,KAAKwC,OAAO9C,QAAQ,GAAG,IAAI;IACzC;IACA,IAAM0E,WAAW9B,UACfC,MAAMwB,MAAM,CAAC,SAAC/D;eAAMA,EAAEG,CAAC,IAAI0D;QAC3BrB,QACA;eAAM;;IAER,IAAM6B,aAAa/B,UACjBC,MAAMwB,MAAM,CAAC,SAAC/D;eAAMA,EAAEG,CAAC,GAAG0D;QAC1BrB,QACAC;IAEF,IAAMC,OAAO,AAAC,qBAAG0B,iBAAU,qBAAGC;IAE9B,2EAA2E;IAC3E,sFAAsF;IACtF,IAAItC;IACJ,IAAIoC,QAAQ;QACV,IAAMG,WAAW5B,KAAKqB,MAAM,CAAC,SAACjE;mBAAMA,EAAEgC,IAAI,CAAC9B,CAAC,IAAI,OAAOF,EAAEgC,IAAI,CAAC9B,CAAC,IAAI,QAAQF,EAAEgC,IAAI,CAAC3B,CAAC,IAAIyD,UAAU;;QACjG,IAAMW,OAAOtD,MAAMqD,SAASP,MAAM,CAAC,SAACjE;mBAAMA,EAAE8C,IAAI,KAAK;WAAGV,GAAG,CAAC,SAACpC;mBAAMA,EAAEgC,IAAI;;QACzE,IAAM0C,QAAQvD,MAAMqD,SAASP,MAAM,CAAC,SAACjE;mBAAMA,EAAE8C,IAAI,KAAK;WAAGV,GAAG,CAAC,SAACpC;mBAAMA,EAAEgC,IAAI;;QAC1EC,YAAY;YAACwC;YAAMC;SAAM,CAACT,MAAM,CAAC,SAACjE;mBAAkBA,MAAMuB;;IAC5D,OAAO;QACL,IAAMiD,YAAW5B,KAAKqB,MAAM,CAAC,SAACjE;mBAAMA,EAAEgC,IAAI,CAAC9B,CAAC,IAAI,OAAOF,EAAEgC,IAAI,CAAC3B,CAAC,IAAIyD,UAAU;;QAC7E,IAAMa,SAASxD,MAAMqD,UAASpC,GAAG,CAAC,SAACpC;mBAAMA,EAAEgC,IAAI;;QAC/CC,YAAY0C,WAAWpD,YAAY;YAACoD;SAAO,GAAG,EAAE;IAClD;IAEA,IAAMnB,QAAmBZ,KAAKR,GAAG,CAAC,SAACwC;eAAQzB,SAASyB,IAAInC,KAAK,EAAEmC,IAAI5C,IAAI,EAAED,aAAa6C,IAAI5C,IAAI,EAAEC;;IAChGuB,MAAMhC,IAAI,CAAC,SAACf,GAAGC;eAAMD,EAAE2C,GAAG,GAAG1C,EAAE0C,GAAG,IAAI1C,EAAEH,IAAI,GAAGE,EAAEF,IAAI;;IAErD,sEAAsE;IACtE,uJAAuJ;IACvJ,IAAMsE,UAAoB,EAAE;IAC5B,IAAK,IAAIC,IAAI,GAAGA,IAAItB,MAAMlC,MAAM,EAAEwD,IAAK;QACrC,IAAItB,KAAK,CAACsB,EAAE,CAAC1B,GAAG,KAAKI,KAAK,CAACsB,IAAI,EAAE,CAAC1B,GAAG,EAAE;YACrC,IAAM2B,IAAIvB,KAAK,CAACsB,IAAI,EAAE,CAACvE,IAAI,GAAGiD,KAAK,CAACsB,EAAE,CAACvE,IAAI;YAC3C,IAAIwE,IAAI,QAAQF,QAAQ3B,IAAI,CAAC6B;QAC/B;IACF;IACA,IAAMC,oBAAmB5D,WAAAA,OAAOyD,sBAAPzD,sBAAAA,WAAmB;IAC5C,IAAM6D,YAAY,IAAIC;IACtBjD,UAAUkD,OAAO,CAAC,SAACnF,GAAG6B;QACpBoD,UAAUG,GAAG,CAACvD,GAAG7B,CAAC,CAAC,EAAE;IACvB;IACA,IAAMqF,OAAkB,EAAE;IAC1B,IAAMC,kBAA6B,EAAE;IACrC,qEAAqE;IACrE,kHAAkH;IAClH,IAAMC,YAAY/B,MAAMS,MAAM,CAAC,SAAC/B;eAAMA,EAAE7B,CAAC,IAAI0D;;QACxC,kCAAA,2BAAA;;;YAAA,IAAMyB,OAAN;YACH,IAAMC,YAAYD,KAAK1D,IAAI,CAAC4D,KAAK,CAAC,KAAKzB,MAAM,CAAC0B,SAASrE,MAAM;YAC7D,IAAMsE,QAAQX,UAAUY,GAAG,CAACL,KAAKpC,GAAG;YACpC,IAAM0C,QAAQL,aAAa/C,OAAOpD,aAAa,IAAIsG,UAAUrE,aAAaX,KAAK0B,GAAG,CAACkD,KAAKvF,CAAC,GAAG2F,SAASlD,OAAOlD,WAAW;YACvH,IAAMuG,sBACJD,SACAN,KAAKnF,CAAC,IAAI0D,YACV,CAAC,cAAciC,IAAI,CAACR,KAAK1D,IAAI,KAC7B,uEAAuE;YACvE,yEAAyE;YACzE,CAACyD,UAAUU,IAAI,CAAC,SAACC;uBAAUA,UAAUV,QAAQU,MAAM9C,GAAG,KAAKoC,KAAKpC,GAAG,IAAIxC,KAAK0B,GAAG,CAAC4D,MAAM3F,IAAI,GAAGiF,KAAKjF,IAAI,IAAIK,KAAKI,GAAG,CAACkF,MAAM7F,CAAC,EAAEmF,KAAKnF,CAAC,IAAI;;YACxI,IAAM8F,kBAAkBJ,uBAAwBD,SAASN,KAAKjC,KAAK,GAAGb,OAAOnD,aAAa;YAC1F,IAAM6G,oBACJD,mBACAd,KAAKY,IAAI,CAAC,SAACvF;gBACT,IAAIA,EAAE0C,GAAG,KAAKoC,KAAKpC,GAAG,EAAE,OAAO;gBAC/B,IAAMiD,MAAM3F,EAAEH,IAAI,GAAGiF,KAAKjF,IAAI;gBAC9B,IAAI8F,OAAO,KAAKA,MAAM3D,OAAOjD,OAAO,GAAGuF,kBAAkB,OAAO;gBAChE,IAAMsB,UAAU1F,KAAKC,GAAG,CAACH,EAAET,CAAC,GAAGS,EAAE6C,KAAK,EAAEiC,KAAKvF,CAAC,GAAGuF,KAAKjC,KAAK,IAAI3C,KAAKI,GAAG,CAACN,EAAET,CAAC,EAAEuF,KAAKvF,CAAC;gBACnF,OAAOqG,WAAWd,KAAKjC,KAAK,GAAG;YACjC;YACF,IAAI4C,mBAAmB,CAACC,mBAAmB;gBACzCd,gBAAgBpC,IAAI,CAACsC;YACvB,OAAO;gBACLH,KAAKnC,IAAI,CAACsC;YACZ;QACF;QA1BA,QAAK,YAAchC,0BAAd,SAAA,6BAAA,QAAA,yBAAA;;QAAA;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IA2BL,yEAAyE;IACzE,iFAAiF;IACjF,IAAMC,SAAS6B;IAEf,0EAA0E;IAC1E,IAAMiB,OAAiB,EAAE;IACzB,IAAK,IAAIzB,KAAI,GAAGA,KAAIO,KAAK/D,MAAM,EAAEwD,KAAK;QACpC,IAAIO,IAAI,CAACP,GAAE,CAAC1B,GAAG,KAAKiC,IAAI,CAACP,KAAI,EAAE,CAAC1B,GAAG,EAAE;YACnC,IAAM2B,KAAIM,IAAI,CAACP,KAAI,EAAE,CAACvE,IAAI,GAAG8E,IAAI,CAACP,GAAE,CAACvE,IAAI;YACzC,IAAIwE,KAAI,QAAQwB,KAAKrD,IAAI,CAAC6B;QAC5B;IACF;IACA,OAAO;QAAEvB,OAAO6B;QAAM5B,QAAAA;QAAQC,KAAK,GAAEtC,WAAAA,OAAOmF,mBAAPnF,sBAAAA,WAAgB;IAAM;AAC7D;AAKO,SAASjC,OAAOkB,CAAS;IAC9B,OAAOO,KAAK4F,KAAK,CAACnG,IAAI,OAAO;AAC/B;AAGO,SAAShB,cAAcoH,KAAgB,EAAE/D,MAAc;IAC5D,IAAMgE,QAAQ,IAAIxB;QACb,kCAAA,2BAAA;;QAAL,QAAK,YAAWuB,0BAAX,SAAA,6BAAA,QAAA,yBAAA,iCAAkB;YAAlB,IAAMpD,IAAN;gBACE,mCAAA,4BAAA;;gBAAL,QAAK,aAAWA,EAAEG,KAAK,qBAAlB,UAAA,8BAAA,SAAA,0BAAA,kCAAoB;oBAApB,IAAMtB,IAAN;wBAEWwE;oBADd,IAAMhG,IAAIvB,OAAO+C,EAAE7B,CAAC;oBACpBqG,MAAMtB,GAAG,CAAC1E,GAAG,EAACgG,aAAAA,MAAMb,GAAG,CAACnF,gBAAVgG,wBAAAA,aAAgB,KAAKxE,EAAEJ,IAAI,CAACR,MAAM;gBAClD;;gBAHK;gBAAA;;;yBAAA,8BAAA;wBAAA;;;wBAAA;8BAAA;;;;QAIP;;QALK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAML,4EAA4E;IAC5E,2DAA2D;IAC3D,IAAIqF,QAAQ;IACZ,IAAIC,YAAY,CAAC;QACZ,mCAAA,4BAAA;;QAAL,QAAK,aAAgBF,0BAAhB,UAAA,8BAAA,SAAA,0BAAA,kCAAuB;YAAvB,mCAAA,kBAAO5B,oBAAG+B;YACb,IAAIA,IAAID,WAAW;gBACjBA,YAAYC;gBACZF,QAAQ7B;YACV;QACF;;QALK;QAAA;;;iBAAA,8BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAOL,IAAMgC,UAAU,IAAI5B;IACpB,IAAI6B,QAAQ,GAAG,uCAAuC;IACtD,IAAIC,MAAqB;IACzB,IAAMC,QAAQ,AAAC,qBAAGP,MAAMQ,IAAI,IAAIjD,MAAM,CAAC,SAACkD;eAAMA,IAAIR,QAAQjE,OAAOhD,YAAY;OAAE8B,IAAI,CAAC,SAACf,GAAGC;eAAMA,IAAID;;QAC7F,mCAAA,4BAAA;;QAAL,QAAK,aAAWwG,0BAAX,UAAA,8BAAA,SAAA,0BAAA,kCAAkB;YAAlB,IAAME,IAAN;YACH,IAAIH,QAAQ,QAAQG,IAAIH,MAAM,KAAK;gBACjCD,QAAQnG,KAAKC,GAAG,CAAC,GAAGkG,QAAQ;gBAC5BC,MAAMG;YACR;YACAL,QAAQ1B,GAAG,CAAC+B,GAAGJ;QACjB;;QANK;QAAA;;;iBAAA,8BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAOL,OAAO;QAAEJ,OAAAA;QAAOG,SAAAA;IAAQ;AAC1B"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/geometry.ts"],"sourcesContent":["// geometry.ts — OCR-path pass 2: words -> lines/columns/floats. Input is\n// flat words (normalized page coords, origin bottom-left, y up), not pre-clustered line observations.\nexport interface Word {\n text: string;\n x: number; // rect.minX\n y: number; // rect.minY\n w: number; // rect.width\n h: number; // rect.height\n // 0-100 (tesseract.js's own `confidence` field, not `conf`). Optional —\n // passthrough only; see report.ts's LOW_CONFIDENCE_THRESHOLD for the consumer.\n confidence?: number;\n}\n\n/** A `Word` with its page number — the shared shape behind both the OCR\n * engine's own output (tesseract.ts) and the replay input contract (extract.ts's OcrWordInput). */\nexport interface PageWord extends Word {\n page: number;\n}\n\nexport interface OcrLine {\n text: string;\n x: number; // rect.minX, used for float-alignment and indentation checks\n width: number; // rect.width, used for the float width check\n midY: number;\n h: number; // char-weighted dominant constituent height\n col: number;\n // Constituent words, left-to-right (same order as `text`'s tokens) — carries\n // word identity through row-building for analyze()'s block->word linkage.\n words: Word[];\n}\n\nexport interface PageOCR {\n lines: OcrLine[];\n // Decorative fragment candidates (src/emit.ts's floats aside), kept as full\n // OcrLine so callers recover both the printed text and constituent words.\n floats: OcrLine[];\n pitch: number;\n}\n\n/** Tuning knobs for the OCR-path geometry pass (CLI: `--float-*`/`--para-gap`/\n * `--heading-scale`/`--col-*`/`--line-*`). See DEFAULT_TUNING for defaults. */\nexport interface Tuning {\n /** fragments with more words than this are body text, not decoration */\n floatMaxWords: number;\n /** fraction of page width above which a fragment is too wide to be\n * decoration */\n floatMaxWidth: number;\n /** how far a fragment's left edge must sit from its column edge to be\n * decoration */\n floatMargin: number;\n /** a vertical gap this many times the line pitch is a paragraph break */\n paraGap: number;\n /** lines taller than this times body height are headings */\n headingScale: number;\n /** boxes wider than this are excluded from gutter detection */\n colMaxWidth: number;\n /** fractional x of the two-column midpoint */\n colSplit: number;\n /** vertical distance within which two boxes are the same line */\n lineYTol: number;\n /** same-line boxes with a larger height ratio don't merge */\n lineHeightRatio: number;\n}\n\n/** Measured defaults; derivation in `test/unit/tuning.test.ts`. lineHeightRatio\n * 2.4 = pair-F1 plateau edge (0.924@1.6 -> 0.995@2.4, 9,471 pairs, 2026-08-16). */\nexport const DEFAULT_TUNING: Tuning = {\n floatMaxWords: 3,\n floatMaxWidth: 0.15,\n floatMargin: 0.008,\n paraGap: 1.6,\n headingScale: 2.0,\n colMaxWidth: 0.55,\n colSplit: 0.5,\n lineYTol: 0.006,\n lineHeightRatio: 2.4,\n};\n\n// Two-column decision (test/unit/column-break.test.ts): gutter ink <=0.017\n// (2-col) vs >=0.047 (1-col) measured over 100 baseline pages, cut 0.03.\nexport const MAX_GUTTER_INK_FRAC = 0.03;\n\n// Near-empty pages (e.g. a 2-word title page) have no gutter ink either, so\n// a word-count floor is needed too; genuine columns measure >=76 words.\nexport const MIN_COL_WORDS = 10;\n\n// lineYTol is an absolute page fraction measured on body text, but a word's\n// box grows downward with its descenders, so its midpoint sits lower than a\n// descenderless neighbour's on the same printed line. At body size that offset\n// is ~0.003 (inside the tolerance); on 56pt display type it is ~0.007 (outside\n// it), which splits one heading into two rows that then emit in midY order\n// (\"Open Road\" -> \"Road Open\"). A descender is ~21% of the em, so the offset is\n// ~11% of the taller box; 0.2 clears it with margin and still sits far below any\n// line pitch. Body rows are unaffected: 0.2 * a body height stays under the floor.\nexport const LINE_Y_TOL_HEIGHT_FRAC = 0.2;\n\n// Measured: a thin data rail is 11% of body words; the thinnest genuine\n// column is 31% — 0.2 sits between.\nexport const MIN_COL_SHARE = 0.2;\n\ninterface Rect {\n x: number;\n y: number;\n w: number;\n h: number;\n}\ntype Range = readonly [number, number];\n\nconst maxX = (r: Rect): number => r.x + r.w;\nconst maxY = (r: Rect): number => r.y + r.h;\nconst midX = (r: Rect): number => r.x + r.w / 2;\nconst midY = (r: Rect): number => r.y + r.h / 2;\n\nfunction union(a: Rect, b: Rect): Rect {\n const x0 = Math.min(a.x, b.x);\n const y0 = Math.min(a.y, b.y);\n const x1 = Math.max(maxX(a), maxX(b));\n const y1 = Math.max(maxY(a), maxY(b));\n return { x: x0, y: y0, w: x1 - x0, h: y1 - y0 };\n}\n\n// Overlap of a rect's x-span with a column x-range.\nfunction xOverlap(r: Rect, range: Range): number {\n return Math.max(0, Math.min(maxX(r), range[1]) - Math.max(r.x, range[0]));\n}\n\nfunction median(xs: number[]): number | undefined {\n if (!xs.length) return undefined;\n return [...xs].sort((a, b) => a - b)[Math.floor(xs.length / 2)];\n}\n\n// Char-weighted dominant height: most characters wins (ties keep first) —\n// same rule as src/lines.ts, so a small merged fragment can't promote a heading.\nfunction dominantHeight(parts: Word[]): number {\n let best = parts[0];\n for (let i = 1; i < parts.length; i++) {\n if (parts[i].text.length > best.text.length) best = parts[i];\n }\n return best.h;\n}\n\nfunction assignColumn(rect: Rect, colRanges: Range[]): number {\n if (colRanges.length !== 2) return 0;\n const l = xOverlap(rect, colRanges[0]);\n const r = xOverlap(rect, colRanges[1]);\n if (l !== r) return l > r ? 0 : 1;\n const centers = colRanges.map((rg) => (rg[0] + rg[1]) / 2);\n return Math.abs(midX(rect) - centers[0]) <= Math.abs(midX(rect) - centers[1]) ? 0 : 1;\n}\n\n// A column x-range from full-width body rows: short paragraph-final rows and\n// decorative fragments must not stretch it.\nfunction range(rects: Rect[]): Range | undefined {\n if (rects.length < 2) return undefined;\n return [Math.min(...rects.map((r) => r.x)), Math.max(...rects.map(maxX))];\n}\n\ninterface Row {\n rect: Rect;\n words: Word[];\n band: number; // -1 (gutter band / n/a), 0 (left or single column), 1 (right)\n}\n\n// Groups same-visual-line words via lineYTol/lineHeightRatio, requiring band\n// agreement; searches ALL open rows since per-word y drifts ~0.001 across a\n// printed line, enough to interleave two lines' words in y-sorted order. The y\n// tolerance scales with box height (LINE_Y_TOL_HEIGHT_FRAC) so display type,\n// whose descenders shift a word's midpoint further, still groups as one row.\nfunction buildRows(words: Word[], tuning: Tuning, bandOf: (w: Word) => number): Row[] {\n const rows: Row[] = [];\n // Sort order only affects which compatible row a tie lands in (every row\n // is searched) — top-to-bottom, left-to-right keeps results deterministic.\n const sorted = [...words].sort((a, b) => midY(b) - midY(a) || a.x - b.x);\n for (const w of sorted) {\n const band = bandOf(w);\n const target = rows.find((r) => {\n if (r.band !== band) return false;\n const yTol = Math.max(tuning.lineYTol, Math.max(r.rect.h, w.h) * LINE_Y_TOL_HEIGHT_FRAC);\n return Math.abs(midY(r.rect) - midY(w)) <= yTol && Math.max(r.rect.h, w.h) < Math.min(r.rect.h, w.h) * tuning.lineHeightRatio;\n });\n if (target) {\n target.words.push(w);\n target.rect = union(target.rect, w);\n } else {\n rows.push({ rect: { x: w.x, y: w.y, w: w.w, h: w.h }, words: [w], band });\n }\n }\n return rows;\n}\n\nfunction makeLine(parts: Word[], rect: Rect, col: number): OcrLine {\n const sorted = [...parts].sort((a, b) => a.x - b.x);\n const text = sorted.map((p) => p.text).join(' ');\n return {\n text,\n x: rect.x,\n width: rect.w,\n midY: midY(rect),\n h: dominantHeight(parts),\n col,\n words: sorted,\n };\n}\n\n// Word-geometry pass (render/recognize happens upstream, in the OCR engine).\n// Body-height words band left/right before row-grouping; heading-height words group across the full width, so a title stays one line.\nexport function buildPageOCR(words: Word[], tuning: Tuning): PageOCR {\n if (!words.length) return { lines: [], floats: [], pitch: 0.012 };\n\n const colBand = 0.02;\n const colLeftCut = tuning.colSplit - colBand;\n const colRightCut = tuning.colSplit + colBand;\n\n const medianH = median(words.map((w) => w.h)) ?? 0.017;\n // Same literal `medianH * 2` used elsewhere for this gate — not\n // `tuning.headingScale`, a separate constant that happens to share the 2.0 default.\n const tallGate = medianH * 2;\n\n // Two-column decision (test/unit/column-break.test.ts): gutter ink <=0.017\n // (2-col) vs >=0.047 (1-col), cut 0.03; floors >=0.2 share/>=10 words per side.\n const bodyWords = words.filter((w) => w.h < tallGate);\n const gutterInk = bodyWords.filter((w) => w.x < tuning.colSplit && maxX(w) > tuning.colSplit).length;\n const leftPop = bodyWords.filter((w) => midX(w) < colLeftCut).length;\n const rightPop = bodyWords.filter((w) => midX(w) > colRightCut).length;\n const twoCol = leftPop >= MIN_COL_WORDS && rightPop >= MIN_COL_WORDS && leftPop >= bodyWords.length * MIN_COL_SHARE && rightPop >= bodyWords.length * MIN_COL_SHARE && gutterInk <= bodyWords.length * MAX_GUTTER_INK_FRAC;\n\n // Band by word CENTER, no dead band: a word box can touch the split exactly\n // (a box can touch the split exactly) and still belongs to its center's column — the twoCol\n // gate above already guarantees near-zero gutter ink.\n const bandOf = (w: Word): number => {\n if (!twoCol) return 0;\n return midX(w) < tuning.colSplit ? 0 : 1;\n };\n const tallRows = buildRows(\n words.filter((w) => w.h >= tallGate),\n tuning,\n () => 0\n );\n const normalRows = buildRows(\n words.filter((w) => w.h < tallGate),\n tuning,\n bandOf\n );\n const rows = [...tallRows, ...normalRows];\n\n // Column ranges from body rows (height <= medianH*1.6): two-col ranges use\n // rows 0.2-0.55 wide; single-col has no upper bound (full-width rows ARE the column).\n let colRanges: Range[];\n if (twoCol) {\n const wideRows = rows.filter((r) => r.rect.w >= 0.2 && r.rect.w <= 0.55 && r.rect.h <= medianH * 1.6);\n const left = range(wideRows.filter((r) => r.band === 0).map((r) => r.rect));\n const right = range(wideRows.filter((r) => r.band === 1).map((r) => r.rect));\n colRanges = [left, right].filter((r): r is Range => r !== undefined);\n } else {\n const wideRows = rows.filter((r) => r.rect.w >= 0.2 && r.rect.h <= medianH * 1.6);\n const single = range(wideRows.map((r) => r.rect));\n colRanges = single !== undefined ? [single] : [];\n }\n\n const lines: OcrLine[] = rows.map((row) => makeLine(row.words, row.rect, assignColumn(row.rect, colRanges)));\n lines.sort((a, b) => a.col - b.col || b.midY - a.midY);\n\n // Float detection: short+narrow+misaligned, rescued into body when it\n // hangs under a body line like a paragraph continuation (same col, gap<=paraGap x pitch, x-overlap) — protects a centered paragraph's short last line.\n const preGaps: number[] = [];\n for (let k = 1; k < lines.length; k++) {\n if (lines[k].col === lines[k - 1].col) {\n const g = lines[k - 1].midY - lines[k].midY;\n if (g > 0.0005) preGaps.push(g);\n }\n }\n const provisionalPitch = median(preGaps) ?? 0.012;\n const colStarts = new Map<number, number>();\n colRanges.forEach((r, i) => {\n colStarts.set(i, r[0]);\n });\n const body: OcrLine[] = [];\n const floatCandidates: OcrLine[] = [];\n // Display-size junk (e.g. \"1/3\" at 68pt, 0.179 wide vs the 0.15 cap)\n // escapes the narrow float test; caught here by junk text + isolation (no adjacent tall line within 2.2x height).\n const tallLines = lines.filter((l) => l.h >= tallGate);\n for (const line of lines) {\n const wordCount = line.text.split(' ').filter(Boolean).length;\n const start = colStarts.get(line.col);\n const short = wordCount <= tuning.floatMaxWords && start !== undefined && Math.abs(line.x - start) > tuning.floatMargin;\n const displayJunkFragment =\n short &&\n line.h >= tallGate &&\n !/[A-Za-z]{3}/.test(line.text) &&\n // Same-column only, matching emitPage's heading-run gather — a heading\n // in the OTHER column can be y-adjacent without composing with this one.\n !tallLines.some((other) => other !== line && other.col === line.col && Math.abs(other.midY - line.midY) < Math.max(other.h, line.h) * 2.2);\n const looksDecorative = displayJunkFragment || (short && line.width < tuning.floatMaxWidth);\n const paragraphAdjacent =\n looksDecorative &&\n body.some((b) => {\n if (b.col !== line.col) return false;\n const gap = b.midY - line.midY;\n if (gap <= 0 || gap > tuning.paraGap * provisionalPitch) return false;\n const overlap = Math.min(b.x + b.width, line.x + line.width) - Math.max(b.x, line.x);\n return overlap >= line.width * 0.5;\n });\n if (looksDecorative && !paragraphAdjacent) {\n floatCandidates.push(line);\n } else {\n body.push(line);\n }\n }\n // One float per candidate row, in line order — no clustering of adjacent\n // candidates: replay against the frozen baseline regressed ~30 pages when tried.\n const floats = floatCandidates;\n\n // Line pitch = median vertical gap between consecutive same-column lines.\n const gaps: number[] = [];\n for (let k = 1; k < body.length; k++) {\n if (body[k].col === body[k - 1].col) {\n const g = body[k - 1].midY - body[k].midY;\n if (g > 0.0005) gaps.push(g);\n }\n }\n return { lines: body, floats, pitch: median(gaps) ?? 0.012 };\n}\n\n// Document-wide height histogram -> heading levels\n\n// Bucket heights to 0.002 of page height so histogram keys are stable.\nexport function bucket(h: number): number {\n return Math.round(h * 500) / 500;\n}\n\n// `pages` are the already-body-only (post-float-filtering) PageOCR results.\nexport function headingLevels(pages: PageOCR[], tuning: Tuning): { bodyH: number; levelOf: Map<number, number> } {\n const chars = new Map<number, number>();\n for (const p of pages) {\n for (const l of p.lines) {\n const b = bucket(l.h);\n chars.set(b, (chars.get(b) ?? 0) + l.text.length);\n }\n }\n // Most-common height wins; ties broken by first-encountered (deterministic;\n // char-count ties across real documents are not observed).\n let bodyH = 0;\n let bestCount = -1;\n for (const [k, v] of chars) {\n if (v > bestCount) {\n bestCount = v;\n bodyH = k;\n }\n }\n\n const levelOf = new Map<number, number>();\n let level = 3; // \"### pN\" page markers occupy level 3\n let rep: number | null = null;\n const sizes = [...chars.keys()].filter((s) => s > bodyH * tuning.headingScale).sort((a, b) => b - a);\n for (const s of sizes) {\n if (rep === null || s < rep * 0.8) {\n level = Math.min(6, level + 1);\n rep = s;\n }\n levelOf.set(s, level);\n }\n return { bodyH, levelOf };\n}\n"],"names":["DEFAULT_TUNING","LINE_Y_TOL_HEIGHT_FRAC","MAX_GUTTER_INK_FRAC","MIN_COL_SHARE","MIN_COL_WORDS","bucket","buildPageOCR","headingLevels","floatMaxWords","floatMaxWidth","floatMargin","paraGap","headingScale","colMaxWidth","colSplit","lineYTol","lineHeightRatio","maxX","r","x","w","maxY","y","h","midX","midY","union","a","b","x0","Math","min","y0","x1","max","y1","xOverlap","range","median","xs","length","undefined","sort","floor","dominantHeight","parts","best","i","text","assignColumn","rect","colRanges","l","centers","map","rg","abs","rects","buildRows","words","tuning","bandOf","rows","sorted","band","target","find","yTol","push","makeLine","col","p","join","width","lines","floats","pitch","colBand","colLeftCut","colRightCut","medianH","tallGate","bodyWords","filter","gutterInk","leftPop","rightPop","twoCol","tallRows","normalRows","wideRows","left","right","single","row","preGaps","k","g","provisionalPitch","colStarts","Map","forEach","set","body","floatCandidates","tallLines","line","wordCount","split","Boolean","start","get","short","displayJunkFragment","test","some","other","looksDecorative","paragraphAdjacent","gap","overlap","gaps","round","pages","chars","bodyH","bestCount","v","levelOf","level","rep","sizes","keys","s"],"mappings":"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"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/index.ts"],"sourcesContent":["// Public library API. Deliberately small: every export is a stability\n// promise; internals stay module-private behind these.\n\nexport type { AnalyzeOcrOptions, AnalyzeOptions, AnalyzeTextOptions } from './analyze.ts';\nexport { analyze } from './analyze.ts';\nexport type { AuditResult } from './audit.ts';\nexport { auditWords } from './audit.ts';\nexport type { PdfToMdErrorCode } from './errors.ts';\nexport { PdfToMdError } from './errors.ts';\nexport type {\n ExtractOcrOptions,\n ExtractResult,\n ExtractTextOptions,\n OcrProgressEvent,\n OcrWordInput,\n PageSelection,\n PdfToMarkdownOptions,\n} from './extract.ts';\nexport { extractOcr, extractText, pdfToMarkdown } from './extract.ts';\nexport type { PageWord, Tuning } from './geometry.ts';\nexport { DEFAULT_TUNING } from './geometry.ts';\nexport type { RenderPageResult } from './raster.ts';\nexport { renderPageToPNG } from './raster.ts';\nexport { toMarkdown, toText } from './render-analysis.ts';\nexport { OUTPUT_VERSION } from './report.ts';\nexport type { Analysis, AnalysisBlock, AnalysisPage, AnalysisWord, PageStatsRow, Report } from './types.ts';\n"],"names":["DEFAULT_TUNING","OUTPUT_VERSION","PdfToMdError","analyze","auditWords","extractOcr","extractText","pdfToMarkdown","renderPageToPNG","toMarkdown","toText"],"mappings":"AAAA,sEAAsE;AACtE,uDAAuD;;;;;;;;;;;;QAmB9CA;eAAAA,0BAAc;;QAIdC;eAAAA,wBAAc;;QAhBdC;eAAAA,sBAAY;;QAJZC;eAAAA,kBAAO;;QAEPC;eAAAA,mBAAU;;QAYVC;eAAAA,qBAAU;;QAAEC;eAAAA,sBAAW;;QAAEC;eAAAA,wBAAa;;QAItCC;eAAAA,yBAAe;;QACfC;eAAAA,4BAAU;;QAAEC;eAAAA,wBAAM;;;yBAnBH;uBAEG;wBAEE;yBAU0B;0BAExB;wBAEC;gCACG;wBACJ"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/index.ts"],"sourcesContent":["// Public library API. Deliberately small: every export is a stability\n// promise; internals stay module-private behind these.\n\nexport type { AnalyzeOcrOptions, AnalyzeOptions, AnalyzeTextOptions } from './analyze.ts';\nexport { analyze } from './analyze.ts';\nexport type { AuditResult } from './audit.ts';\nexport { auditWords } from './audit.ts';\nexport type { PdfToMdErrorCode } from './errors.ts';\nexport { PdfToMdError } from './errors.ts';\nexport type {\n ExtractOcrOptions,\n ExtractResult,\n ExtractTextOptions,\n OcrProgressEvent,\n OcrWordInput,\n PageSelection,\n PdfToMarkdownOptions,\n} from './extract.ts';\nexport { extractOcr, extractText, pdfToMarkdown } from './extract.ts';\nexport type { PageWord, Tuning } from './geometry.ts';\nexport { DEFAULT_TUNING } from './geometry.ts';\nexport type { RenderPageResult } from './raster.ts';\nexport { renderPageToPNG } from './raster.ts';\nexport { toMarkdown, toText } from './render-analysis.ts';\nexport { OUTPUT_VERSION } from './report.ts';\nexport type { Analysis, AnalysisBlock, AnalysisPage, AnalysisWord, PageStatsRow, Report } from './types.ts';\n"],"names":["DEFAULT_TUNING","OUTPUT_VERSION","PdfToMdError","analyze","auditWords","extractOcr","extractText","pdfToMarkdown","renderPageToPNG","toMarkdown","toText"],"mappings":"AAAA,sEAAsE;AACtE,uDAAuD;;;;;;;;;;;;QAmB9CA;eAAAA,0BAAc;;QAIdC;eAAAA,wBAAc;;QAhBdC;eAAAA,sBAAY;;QAJZC;eAAAA,kBAAO;;QAEPC;eAAAA,mBAAU;;QAYVC;eAAAA,qBAAU;;QAAEC;eAAAA,sBAAW;;QAAEC;eAAAA,wBAAa;;QAItCC;eAAAA,yBAAe;;QACfC;eAAAA,4BAAU;;QAAEC;eAAAA,wBAAM;;;yBAnBH;uBAEG;wBAEE;yBAU0B;0BAExB;wBAEC;gCACG;wBACJ"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/lines.ts"],"sourcesContent":["// Pass 2: glyphs -> visual lines — de-braids two-column pages (spanning\n// lines like headings sort with the left column), joins words by measured horizontal gap, and folds typographic codepoints to ASCII so search doesn't miss half the hits.\nimport type { CollectedPage, Glyph, Line } from './types.ts';\n\nconst FOLD: Record<string, string> = {\n ʼ: \"'\",\n '’': \"'\",\n '‘': \"'\",\n '“': '\"',\n '”': '\"',\n '–': '-',\n};\n// Exported for the OCR engine seam (src/engines/tesseract.ts): both paths\n// must fold identically or the same printed apostrophe surfaces as two spellings depending on which path read the page.\nexport const foldTypographic = (s: string): string => s.replace(/[ʼ‘’“”–]/g, (c) => FOLD[c]);\nconst normalize = foldTypographic;\n\n// Intermediate row while grouping glyphs by visual line, before the final\n// text/height reduction below.\ninterface LineDraft {\n col: number;\n y: number;\n parts: Array<{ glyph: Glyph; index: number }>;\n}\n\nexport function toLines({ glyphs, width }: Pick<CollectedPage, 'glyphs' | 'width'>): Line[] {\n if (!glyphs.length) return [];\n\n const mid = width / 2;\n // A real two-column page has a gutter: clusters each side, almost nothing crossing mid.\n // Label/value layouts also cluster but their values cross mid — de-braiding would reorder them.\n const twoCol = glyphs.filter((g) => g.x + g.w < mid).length > glyphs.length * 0.25 && glyphs.filter((g) => g.x > mid).length > glyphs.length * 0.25 && glyphs.filter((g) => g.x < mid && g.x + g.w > mid).length < glyphs.length * 0.15;\n\n // Group on y with a tolerance that scales with font size.\n const lines: LineDraft[] = [];\n const indexedGlyphs = glyphs.map((glyph, index) => ({ glyph, index }));\n for (const part of indexedGlyphs.sort((a, b) => a.glyph.y - b.glyph.y || a.glyph.x - b.glyph.x)) {\n const { glyph: g } = part;\n // NOTE: start-x assignment can misfile a gutter-straddling glyph; an\n // overlap-based alternative was tried and reshuffled stray numerals with\n // no measured win, so start-x stays (src/geometry.ts's OCR path assigns by x-span overlap instead, where the mis-assignment is measured).\n const col = twoCol && g.x > mid ? 1 : 0;\n const last = lines.at(-1);\n if (last && last.col === col && Math.abs(last.y - g.y) < Math.max(2, g.h * 0.5)) {\n last.parts.push(part);\n last.y = (last.y + g.y) / 2;\n } else lines.push({ col, y: g.y, parts: [part] });\n }\n lines.sort((a, b) => a.col - b.col || a.y - b.y); // column, then down the page\n\n return lines\n .map((l): Line => {\n const parts = l.parts.sort((a, b) => a.glyph.x - b.glyph.x);\n let t = '';\n let prev: Glyph | null = null;\n for (const { glyph: cur } of parts) {\n // insert a space when the measured gap is wider than intra-word kerning\n if (prev && cur.x - (prev.x + prev.w) > prev.h * 0.12 && !/\\s$/.test(t) && !/^\\s/.test(cur.s)) t += ' ';\n t += cur.s;\n prev = cur;\n }\n // Line height = the char-weighted dominant height, not the max: a small\n // decorative large-face numeral must not promote a body line to a heading.\n const byH = new Map<number, number>();\n for (const { glyph: p } of parts) byH.set(p.h, (byH.get(p.h) || 0) + p.s.length);\n return {\n text: normalize(t).replace(/\\s+/g, ' ').trim(),\n x: parts[0].glyph.x,\n y: l.y,\n h: [...byH.entries()].sort((a, b) => b[1] - a[1])[0][0],\n col: l.col,\n wordIndexes: parts.map(({ index }) => index),\n };\n })\n .filter((l) => l.text);\n}\n"],"names":["foldTypographic","toLines","FOLD","ʼ","s","replace","c","normalize","glyphs","width","length","mid","twoCol","filter","g","x","w","lines","indexedGlyphs","map","glyph","index","sort","a","b","y","part","col","last","at","Math","abs","max","h","parts","push","l","t","prev","cur","test","byH","Map","p","set","get","text","trim","entries","wordIndexes"],"mappings":"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"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/lines.ts"],"sourcesContent":["// Pass 2: glyphs -> visual lines — de-braids two-column pages (spanning\n// lines like headings sort with the left column), joins words by measured horizontal gap, and folds typographic codepoints to ASCII so search doesn't miss half the hits.\nimport type { CollectedPage, Glyph, Line } from './types.ts';\n\nconst FOLD: Record<string, string> = {\n ʼ: \"'\",\n '’': \"'\",\n '‘': \"'\",\n '“': '\"',\n '”': '\"',\n '–': '-',\n};\n// Exported for the OCR engine seam (src/engines/tesseract.ts): both paths\n// must fold identically or the same printed apostrophe surfaces as two spellings depending on which path read the page.\nexport const foldTypographic = (s: string): string => s.replace(/[ʼ‘’“”–]/g, (c) => FOLD[c]);\nconst normalize = foldTypographic;\n\n// Intermediate row while grouping glyphs by visual line, before the final\n// text/height reduction below.\ninterface LineDraft {\n col: number;\n y: number;\n parts: Array<{ glyph: Glyph; index: number }>;\n}\n\nexport function toLines({ glyphs, width }: Pick<CollectedPage, 'glyphs' | 'width'>): Line[] {\n if (!glyphs.length) return [];\n\n const mid = width / 2;\n // A real two-column page has a gutter: clusters each side, almost nothing crossing mid.\n // Label/value layouts also cluster but their values cross mid — de-braiding would reorder them.\n const twoCol = glyphs.filter((g) => g.x + g.w < mid).length > glyphs.length * 0.25 && glyphs.filter((g) => g.x > mid).length > glyphs.length * 0.25 && glyphs.filter((g) => g.x < mid && g.x + g.w > mid).length < glyphs.length * 0.15;\n\n // Group on y with a tolerance that scales with font size.\n const lines: LineDraft[] = [];\n const indexedGlyphs = glyphs.map((glyph, index) => ({ glyph, index }));\n for (const part of indexedGlyphs.sort((a, b) => a.glyph.y - b.glyph.y || a.glyph.x - b.glyph.x)) {\n const { glyph: g } = part;\n // NOTE: start-x assignment can misfile a gutter-straddling glyph; an\n // overlap-based alternative was tried and reshuffled stray numerals with\n // no measured win, so start-x stays (src/geometry.ts's OCR path assigns by x-span overlap instead, where the mis-assignment is measured).\n const col = twoCol && g.x > mid ? 1 : 0;\n const last = lines.at(-1);\n if (last && last.col === col && Math.abs(last.y - g.y) < Math.max(2, g.h * 0.5)) {\n last.parts.push(part);\n last.y = (last.y + g.y) / 2;\n } else lines.push({ col, y: g.y, parts: [part] });\n }\n lines.sort((a, b) => a.col - b.col || a.y - b.y); // column, then down the page\n\n return lines\n .map((l): Line => {\n const parts = l.parts.sort((a, b) => a.glyph.x - b.glyph.x);\n let t = '';\n let prev: Glyph | null = null;\n for (const { glyph: cur } of parts) {\n // insert a space when the measured gap is wider than intra-word kerning\n if (prev && cur.x - (prev.x + prev.w) > prev.h * 0.12 && !/\\s$/.test(t) && !/^\\s/.test(cur.s)) t += ' ';\n t += cur.s;\n prev = cur;\n }\n // Line height = the char-weighted dominant height, not the max: a small\n // decorative large-face numeral must not promote a body line to a heading.\n const byH = new Map<number, number>();\n for (const { glyph: p } of parts) byH.set(p.h, (byH.get(p.h) || 0) + p.s.length);\n return {\n text: normalize(t).replace(/\\s+/g, ' ').trim(),\n x: parts[0].glyph.x,\n y: l.y,\n h: [...byH.entries()].sort((a, b) => b[1] - a[1])[0][0],\n col: l.col,\n wordIndexes: parts.map(({ index }) => index),\n };\n })\n .filter((l) => l.text);\n}\n"],"names":["foldTypographic","toLines","FOLD","ʼ","s","replace","c","normalize","glyphs","width","length","mid","twoCol","filter","g","x","w","lines","indexedGlyphs","map","glyph","index","sort","a","b","y","part","col","last","at","Math","abs","max","h","parts","push","l","t","prev","cur","test","byH","Map","p","set","get","text","trim","entries","wordIndexes"],"mappings":"AAAA,wEAAwE;AACxE,0KAA0K;;;;;;;;;;;;QAa7JA;eAAAA;;QAWGC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AArBhB,IAAMC,OAA+B;IACnCC,GAAG;IACH,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;IACL,KAAK;AACP;AAGO,IAAMH,kBAAkB,yBAACI;WAAsBA,EAAEC,OAAO,CAAC,aAAa,SAACC;eAAMJ,IAAI,CAACI,EAAE;;;AAC3F,IAAMC,YAAYP;AAUX,SAASC,QAAQ,KAA0D;QAAxDO,SAAF,MAAEA,QAAQC,QAAV,MAAUA;IAChC,IAAI,CAACD,OAAOE,MAAM,EAAE,OAAO,EAAE;IAE7B,IAAMC,MAAMF,QAAQ;IACpB,wFAAwF;IACxF,gGAAgG;IAChG,IAAMG,SAASJ,OAAOK,MAAM,CAAC,SAACC;eAAMA,EAAEC,CAAC,GAAGD,EAAEE,CAAC,GAAGL;OAAKD,MAAM,GAAGF,OAAOE,MAAM,GAAG,QAAQF,OAAOK,MAAM,CAAC,SAACC;eAAMA,EAAEC,CAAC,GAAGJ;OAAKD,MAAM,GAAGF,OAAOE,MAAM,GAAG,QAAQF,OAAOK,MAAM,CAAC,SAACC;eAAMA,EAAEC,CAAC,GAAGJ,OAAOG,EAAEC,CAAC,GAAGD,EAAEE,CAAC,GAAGL;OAAKD,MAAM,GAAGF,OAAOE,MAAM,GAAG;IAEnO,0DAA0D;IAC1D,IAAMO,QAAqB,EAAE;IAC7B,IAAMC,gBAAgBV,OAAOW,GAAG,CAAC,SAACC,OAAOC;eAAW;YAAED,OAAAA;YAAOC,OAAAA;QAAM;;QAC9D,kCAAA,2BAAA;;QAAL,QAAK,YAAcH,cAAcI,IAAI,CAAC,SAACC,GAAGC;mBAAMD,EAAEH,KAAK,CAACK,CAAC,GAAGD,EAAEJ,KAAK,CAACK,CAAC,IAAIF,EAAEH,KAAK,CAACL,CAAC,GAAGS,EAAEJ,KAAK,CAACL,CAAC;+BAAzF,SAAA,6BAAA,QAAA,yBAAA,iCAA4F;YAA5F,IAAMW,OAAN;YACH,IAAQN,AAAON,IAAMY,KAAbN;YACR,qEAAqE;YACrE,yEAAyE;YACzE,0IAA0I;YAC1I,IAAMO,MAAMf,UAAUE,EAAEC,CAAC,GAAGJ,MAAM,IAAI;YACtC,IAAMiB,OAAOX,MAAMY,EAAE,CAAC,CAAC;YACvB,IAAID,QAAQA,KAAKD,GAAG,KAAKA,OAAOG,KAAKC,GAAG,CAACH,KAAKH,CAAC,GAAGX,EAAEW,CAAC,IAAIK,KAAKE,GAAG,CAAC,GAAGlB,EAAEmB,CAAC,GAAG,MAAM;gBAC/EL,KAAKM,KAAK,CAACC,IAAI,CAACT;gBAChBE,KAAKH,CAAC,GAAG,AAACG,CAAAA,KAAKH,CAAC,GAAGX,EAAEW,CAAC,AAADA,IAAK;YAC5B,OAAOR,MAAMkB,IAAI,CAAC;gBAAER,KAAAA;gBAAKF,GAAGX,EAAEW,CAAC;gBAAES,OAAO;oBAACR;iBAAK;YAAC;QACjD;;QAXK;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IAYLT,MAAMK,IAAI,CAAC,SAACC,GAAGC;eAAMD,EAAEI,GAAG,GAAGH,EAAEG,GAAG,IAAIJ,EAAEE,CAAC,GAAGD,EAAEC,CAAC;QAAG,6BAA6B;IAE/E,OAAOR,MACJE,GAAG,CAAC,SAACiB;QACJ,IAAMF,QAAQE,EAAEF,KAAK,CAACZ,IAAI,CAAC,SAACC,GAAGC;mBAAMD,EAAEH,KAAK,CAACL,CAAC,GAAGS,EAAEJ,KAAK,CAACL,CAAC;;QAC1D,IAAIsB,IAAI;QACR,IAAIC,OAAqB;YACpB,kCAAA,2BAAA;;YAAL,QAAK,YAAwBJ,0BAAxB,SAAA,6BAAA,QAAA,yBAAA,iCAA+B;gBAA/B,kBAAA,aAAQd,AAAOmB,kBAAPnB;gBACX,wEAAwE;gBACxE,IAAIkB,QAAQC,IAAIxB,CAAC,GAAIuB,CAAAA,KAAKvB,CAAC,GAAGuB,KAAKtB,CAAC,AAADA,IAAKsB,KAAKL,CAAC,GAAG,QAAQ,CAAC,MAAMO,IAAI,CAACH,MAAM,CAAC,MAAMG,IAAI,CAACD,IAAInC,CAAC,GAAGiC,KAAK;gBACpGA,KAAKE,IAAInC,CAAC;gBACVkC,OAAOC;YACT;;YALK;YAAA;;;qBAAA,6BAAA;oBAAA;;;oBAAA;0BAAA;;;;QAML,wEAAwE;QACxE,2EAA2E;QAC3E,IAAME,MAAM,IAAIC;YACX,mCAAA,4BAAA;;YAAL,QAAK,aAAsBR,0BAAtB,UAAA,8BAAA,SAAA,0BAAA;gBAAA,mBAAA,cAAQd,AAAOuB,iBAAPvB;gBAAqBqB,IAAIG,GAAG,CAACD,EAAEV,CAAC,EAAE,AAACQ,CAAAA,IAAII,GAAG,CAACF,EAAEV,CAAC,KAAK,CAAA,IAAKU,EAAEvC,CAAC,CAACM,MAAM;;;YAA1E;YAAA;;;qBAAA,8BAAA;oBAAA;;;oBAAA;0BAAA;;;;QACL,OAAO;YACLoC,MAAMvC,UAAU8B,GAAGhC,OAAO,CAAC,QAAQ,KAAK0C,IAAI;YAC5ChC,GAAGmB,KAAK,CAAC,EAAE,CAACd,KAAK,CAACL,CAAC;YACnBU,GAAGW,EAAEX,CAAC;YACNQ,GAAG,AAAC,qBAAGQ,IAAIO,OAAO,IAAI1B,IAAI,CAAC,SAACC,GAAGC;uBAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE;cAAC,CAAC,EAAE,CAAC,EAAE;YACvDI,KAAKS,EAAET,GAAG;YACVsB,aAAaf,MAAMf,GAAG,CAAC;oBAAGE,cAAAA;uBAAYA;;QACxC;IACF,GACCR,MAAM,CAAC,SAACuB;eAAMA,EAAEU,IAAI;;AACzB"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/markdown.ts"],"sourcesContent":["// Pass 3: lines -> markdown. Structure is measured, not guessed — heading\n// levels come from the font-height histogram, hyphen-closes only against a dictionary (see the inline comments below for each rule).\nimport { getDict } from './dict.ts';\nimport { pageMarkerLine } from './page-marker.ts';\nimport type { AnalysisBlock, BuildMarkdownOptions, Line, MarkdownPage, MarkdownResult, MarkdownStats, PageLines } from './types.ts';\n\nconst GLYPH = /^[•◦▪▫●○·‣⁃]$/;\nconst BULLETS = /^(?:[•◦▪▫●○·‣⁃]\\s*)+/;\n\nexport function buildMarkdown(pageLines: PageLines[], heightChars: Map<number, number>, opts: BuildMarkdownOptions = {}): MarkdownResult {\n // body height = char-weighted mode; headings are the rarer, larger sizes.\n // The 1.35 multiplier keeps emphasized body text out of the outline.\n const bodyH = [...heightChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;\n const headingSizes = [...heightChars.keys()].filter((h) => h > bodyH * 1.35).sort((a, b) => b - a);\n // with page markers on, content headings start below the page ### level;\n // sizes beyond the ###### budget share level 6 rather than being dropped\n const offset = opts.pageMarkers ? 3 : 0;\n const levelOf = new Map(headingSizes.slice(0, 6).map((h, i) => [h, Math.min(6, i + 1 + offset)]));\n\n const out: string[] = [];\n const blockPages = new Map<number, AnalysisBlock[]>();\n const stats: MarkdownStats = {\n headings: 0,\n listItems: 0,\n paragraphs: 0,\n joinedPairs: 0,\n reflowed: 0,\n callouts: 0,\n closedHyphens: 0,\n };\n let currentPage = 0;\n let para: { text: string; wordIndexes: number[] }[] = [];\n\n const addBlock = (block: AnalysisBlock) => {\n const blocks = blockPages.get(currentPage);\n if (blocks) blocks.push(block);\n else blockPages.set(currentPage, [block]);\n };\n\n // a label line ending in ':' whose next line is a bare number belongs on one line\n function attachValue(label: string, lines: Line[], i: number): { text: string; last: number } {\n const j = i + 1;\n if (/[::]\\s*$/.test(label) && j < lines.length && /^[0-9][\\d.,]*%?$/.test(lines[j].text)) {\n stats.joinedPairs++;\n return { text: `${label} ${lines[j].text}`, last: j };\n }\n return { text: label, last: i };\n }\n const flush = () => {\n if (!para.length) return;\n const text = para\n .map((part) => part.text)\n .join(' ')\n .replace(/\\s+([,.;:%])/g, '$1');\n out.push(text);\n out.push('');\n addBlock({ type: 'paragraph', text, wordIndexes: para.flatMap((part) => part.wordIndexes) });\n stats.paragraphs++;\n para = [];\n };\n // append a wrapped line to the open paragraph, resolving a line-final hyphen\n const appendToPara = (line: Line, text: string) => {\n const prev = para.at(-1);\n if (prev && /\\w-$/.test(prev.text)) {\n // a bare \" -\" is punctuation, not a wrapped word\n const head = prev.text.replace(/-$/, '').split(/\\s/).pop() as string;\n const tail = (text.split(/\\s/)[0] ?? '').replace(/[^A-Za-z-]/g, '').split('-')[0];\n const close = getDict().has((head + tail).toLowerCase());\n if (close) stats.closedHyphens++;\n para[para.length - 1].text = prev.text.replace(/-$/, close ? '' : '-') + text;\n para[para.length - 1].wordIndexes.push(...line.wordIndexes);\n } else para.push({ text, wordIndexes: [...line.wordIndexes] });\n };\n\n for (const { page, lines } of pageLines) {\n currentPage = page;\n if (opts.pageMarkers) {\n flush();\n out.push(pageMarkerLine(page));\n out.push('');\n }\n if (!lines.length) continue;\n const indentBase = Math.min(...lines.map((l) => l.x));\n\n for (let i = 0; i < lines.length; i++) {\n let { text, h, x } = lines[i];\n const prevLine = i > 0 ? lines[i - 1] : null;\n // a column change or a vertical jump wider than a blank line ends the paragraph\n if (para.length && prevLine && (lines[i].col !== prevLine.col || lines[i].y - prevLine.y > h * 2.2)) flush();\n\n // A large-font line opens a run: gather the consecutive same-size lines\n // below it (a title wraps across lines). A short merged run is one heading; a long one is a callout/pull-quote in a bigger face — prose, not structure — and becomes a blockquote.\n if (levelOf.has(h) && !BULLETS.test(text)) {\n const run = [lines[i]];\n while (i + 1 < lines.length && lines[i + 1].h === h && lines[i + 1].col === lines[i].col && lines[i + 1].y - lines[i].y < h * 2.2 && !BULLETS.test(lines[i + 1].text)) run.push(lines[++i]);\n // join wrapped title lines, resolving line-final hyphens like body text\n const merged = run\n .map((line) => line.text)\n .reduce((acc, part) => (/\\w-$/.test(acc) ? acc.replace(/-$/, getDict().has(((acc.replace(/-$/, '').split(/\\s/).pop() as string) + (part.split(/\\s/)[0] ?? '').replace(/[^A-Za-z-]/g, '').split('-')[0]).toLowerCase()) ? '' : '-') + part : `${acc} ${part}`))\n .replace(/\\s+([,.;:%])/g, '$1');\n const wordIndexes = run.flatMap((line) => line.wordIndexes);\n flush();\n if (merged.length > 150) {\n out.push(`> ${merged}`);\n out.push('');\n addBlock({ type: 'paragraph', text: `> ${merged}`, wordIndexes });\n stats.callouts++;\n } else {\n const level = levelOf.get(h) as number;\n out.push(`${'#'.repeat(level)} ${merged}`);\n out.push('');\n addBlock({ type: 'heading', text: merged, level, wordIndexes });\n stats.headings++;\n }\n continue;\n }\n\n // Lines can carry several stacked glyphs (\"• ▪\") from nested source lists.\n const stripped = text.replace(BULLETS, '').trim();\n const wasBullet = stripped !== text;\n if (wasBullet) text = stripped;\n\n // bullet with nothing left on the line: attach the following line's text\n if ((!text || GLYPH.test(text)) && i + 1 < lines.length) {\n flush();\n const depth = Math.max(0, Math.round((x - indentBase) / 18));\n const itemLines = [lines[i], lines[++i]];\n let label = lines[i].text.replace(BULLETS, '').trim();\n while (!label && i + 1 < lines.length) {\n // stacked glyphs\n itemLines.push(lines[++i]);\n label = lines[i].text.replace(BULLETS, '').trim();\n }\n const attached = attachValue(label, lines, i);\n if (attached.last !== i) itemLines.push(lines[attached.last]);\n i = attached.last;\n const itemText = `${' '.repeat(depth)}- ${attached.text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: itemLines.flatMap((line) => line.wordIndexes) });\n stats.listItems++;\n continue;\n }\n // glyph(s) followed by text on the same line\n if (wasBullet) {\n flush();\n const depth = Math.max(0, Math.round((x - indentBase) / 18));\n const itemLines = [lines[i]];\n const attached = attachValue(text, lines, i);\n if (attached.last !== i) itemLines.push(lines[attached.last]);\n i = attached.last;\n const itemText = `${' '.repeat(depth)}- ${attached.text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: itemLines.flatMap((line) => line.wordIndexes) });\n stats.listItems++;\n continue;\n }\n // `label:` on its own line followed by a bare value -> keep together\n if (/[::]\\s*$/.test(text) && i + 1 < lines.length && /^[0-9][\\d.,]*%?$/.test(lines[i + 1].text)) {\n flush();\n const itemText = `- ${text} ${lines[++i].text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: [...lines[i - 1].wordIndexes, ...lines[i].wordIndexes] });\n stats.joinedPairs++;\n continue;\n }\n // otherwise body text: re-flow wrapped lines into a paragraph\n appendToPara(lines[i], text);\n if (/[.!?:]$/.test(text)) flush();\n else stats.reflowed++;\n }\n flush();\n }\n flush();\n\n const md = `${out\n .join('\\n')\n .replace(/\\n{3,}/g, '\\n\\n')\n .trim()}\\n`;\n const pages: MarkdownPage[] = pageLines.map(({ page }) => ({ page, blocks: blockPages.get(page) ?? [] }));\n return { md, stats, bodyH, headingSizes, pages };\n}\n"],"names":["buildMarkdown","GLYPH","BULLETS","pageLines","heightChars","opts","bodyH","entries","sort","a","b","headingSizes","keys","filter","h","offset","pageMarkers","levelOf","Map","slice","map","i","Math","min","out","blockPages","stats","headings","listItems","paragraphs","joinedPairs","reflowed","callouts","closedHyphens","currentPage","para","addBlock","block","blocks","get","push","set","attachValue","label","lines","j","test","length","text","last","flush","part","join","replace","type","wordIndexes","flatMap","appendToPara","line","prev","at","head","split","pop","tail","close","getDict","has","toLowerCase","page","pageMarkerLine","indentBase","l","x","prevLine","col","y","run","merged","reduce","acc","level","repeat","stripped","trim","wasBullet","depth","max","round","itemLines","attached","itemText","tight","md","pages"],"mappings":"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"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/markdown.ts"],"sourcesContent":["// Pass 3: lines -> markdown. Structure is measured, not guessed — heading\n// levels come from the font-height histogram, hyphen-closes only against a dictionary (see the inline comments below for each rule).\nimport { getDict } from './dict.ts';\nimport { pageMarkerLine } from './page-marker.ts';\nimport type { AnalysisBlock, BuildMarkdownOptions, Line, MarkdownPage, MarkdownResult, MarkdownStats, PageLines } from './types.ts';\n\nconst GLYPH = /^[•◦▪▫●○·‣⁃]$/;\nconst BULLETS = /^(?:[•◦▪▫●○·‣⁃]\\s*)+/;\n\nexport function buildMarkdown(pageLines: PageLines[], heightChars: Map<number, number>, opts: BuildMarkdownOptions = {}): MarkdownResult {\n // body height = char-weighted mode; headings are the rarer, larger sizes.\n // The 1.35 multiplier keeps emphasized body text out of the outline.\n const bodyH = [...heightChars.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? 0;\n const headingSizes = [...heightChars.keys()].filter((h) => h > bodyH * 1.35).sort((a, b) => b - a);\n // with page markers on, content headings start below the page ### level;\n // sizes beyond the ###### budget share level 6 rather than being dropped\n const offset = opts.pageMarkers ? 3 : 0;\n const levelOf = new Map(headingSizes.slice(0, 6).map((h, i) => [h, Math.min(6, i + 1 + offset)]));\n\n const out: string[] = [];\n const blockPages = new Map<number, AnalysisBlock[]>();\n const stats: MarkdownStats = {\n headings: 0,\n listItems: 0,\n paragraphs: 0,\n joinedPairs: 0,\n reflowed: 0,\n callouts: 0,\n closedHyphens: 0,\n };\n let currentPage = 0;\n let para: { text: string; wordIndexes: number[] }[] = [];\n\n const addBlock = (block: AnalysisBlock) => {\n const blocks = blockPages.get(currentPage);\n if (blocks) blocks.push(block);\n else blockPages.set(currentPage, [block]);\n };\n\n // a label line ending in ':' whose next line is a bare number belongs on one line\n function attachValue(label: string, lines: Line[], i: number): { text: string; last: number } {\n const j = i + 1;\n if (/[::]\\s*$/.test(label) && j < lines.length && /^[0-9][\\d.,]*%?$/.test(lines[j].text)) {\n stats.joinedPairs++;\n return { text: `${label} ${lines[j].text}`, last: j };\n }\n return { text: label, last: i };\n }\n const flush = () => {\n if (!para.length) return;\n const text = para\n .map((part) => part.text)\n .join(' ')\n .replace(/\\s+([,.;:%])/g, '$1');\n out.push(text);\n out.push('');\n addBlock({ type: 'paragraph', text, wordIndexes: para.flatMap((part) => part.wordIndexes) });\n stats.paragraphs++;\n para = [];\n };\n // append a wrapped line to the open paragraph, resolving a line-final hyphen\n const appendToPara = (line: Line, text: string) => {\n const prev = para.at(-1);\n if (prev && /\\w-$/.test(prev.text)) {\n // a bare \" -\" is punctuation, not a wrapped word\n const head = prev.text.replace(/-$/, '').split(/\\s/).pop() as string;\n const tail = (text.split(/\\s/)[0] ?? '').replace(/[^A-Za-z-]/g, '').split('-')[0];\n const close = getDict().has((head + tail).toLowerCase());\n if (close) stats.closedHyphens++;\n para[para.length - 1].text = prev.text.replace(/-$/, close ? '' : '-') + text;\n para[para.length - 1].wordIndexes.push(...line.wordIndexes);\n } else para.push({ text, wordIndexes: [...line.wordIndexes] });\n };\n\n for (const { page, lines } of pageLines) {\n currentPage = page;\n if (opts.pageMarkers) {\n flush();\n out.push(pageMarkerLine(page));\n out.push('');\n }\n if (!lines.length) continue;\n const indentBase = Math.min(...lines.map((l) => l.x));\n\n for (let i = 0; i < lines.length; i++) {\n let { text, h, x } = lines[i];\n const prevLine = i > 0 ? lines[i - 1] : null;\n // a column change or a vertical jump wider than a blank line ends the paragraph\n if (para.length && prevLine && (lines[i].col !== prevLine.col || lines[i].y - prevLine.y > h * 2.2)) flush();\n\n // A large-font line opens a run: gather the consecutive same-size lines\n // below it (a title wraps across lines). A short merged run is one heading; a long one is a callout/pull-quote in a bigger face — prose, not structure — and becomes a blockquote.\n if (levelOf.has(h) && !BULLETS.test(text)) {\n const run = [lines[i]];\n while (i + 1 < lines.length && lines[i + 1].h === h && lines[i + 1].col === lines[i].col && lines[i + 1].y - lines[i].y < h * 2.2 && !BULLETS.test(lines[i + 1].text)) run.push(lines[++i]);\n // join wrapped title lines, resolving line-final hyphens like body text\n const merged = run\n .map((line) => line.text)\n .reduce((acc, part) => (/\\w-$/.test(acc) ? acc.replace(/-$/, getDict().has(((acc.replace(/-$/, '').split(/\\s/).pop() as string) + (part.split(/\\s/)[0] ?? '').replace(/[^A-Za-z-]/g, '').split('-')[0]).toLowerCase()) ? '' : '-') + part : `${acc} ${part}`))\n .replace(/\\s+([,.;:%])/g, '$1');\n const wordIndexes = run.flatMap((line) => line.wordIndexes);\n flush();\n if (merged.length > 150) {\n out.push(`> ${merged}`);\n out.push('');\n addBlock({ type: 'paragraph', text: `> ${merged}`, wordIndexes });\n stats.callouts++;\n } else {\n const level = levelOf.get(h) as number;\n out.push(`${'#'.repeat(level)} ${merged}`);\n out.push('');\n addBlock({ type: 'heading', text: merged, level, wordIndexes });\n stats.headings++;\n }\n continue;\n }\n\n // Lines can carry several stacked glyphs (\"• ▪\") from nested source lists.\n const stripped = text.replace(BULLETS, '').trim();\n const wasBullet = stripped !== text;\n if (wasBullet) text = stripped;\n\n // bullet with nothing left on the line: attach the following line's text\n if ((!text || GLYPH.test(text)) && i + 1 < lines.length) {\n flush();\n const depth = Math.max(0, Math.round((x - indentBase) / 18));\n const itemLines = [lines[i], lines[++i]];\n let label = lines[i].text.replace(BULLETS, '').trim();\n while (!label && i + 1 < lines.length) {\n // stacked glyphs\n itemLines.push(lines[++i]);\n label = lines[i].text.replace(BULLETS, '').trim();\n }\n const attached = attachValue(label, lines, i);\n if (attached.last !== i) itemLines.push(lines[attached.last]);\n i = attached.last;\n const itemText = `${' '.repeat(depth)}- ${attached.text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: itemLines.flatMap((line) => line.wordIndexes) });\n stats.listItems++;\n continue;\n }\n // glyph(s) followed by text on the same line\n if (wasBullet) {\n flush();\n const depth = Math.max(0, Math.round((x - indentBase) / 18));\n const itemLines = [lines[i]];\n const attached = attachValue(text, lines, i);\n if (attached.last !== i) itemLines.push(lines[attached.last]);\n i = attached.last;\n const itemText = `${' '.repeat(depth)}- ${attached.text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: itemLines.flatMap((line) => line.wordIndexes) });\n stats.listItems++;\n continue;\n }\n // `label:` on its own line followed by a bare value -> keep together\n if (/[::]\\s*$/.test(text) && i + 1 < lines.length && /^[0-9][\\d.,]*%?$/.test(lines[i + 1].text)) {\n flush();\n const itemText = `- ${text} ${lines[++i].text}`;\n out.push(itemText);\n addBlock({ type: 'paragraph', text: itemText, tight: true, wordIndexes: [...lines[i - 1].wordIndexes, ...lines[i].wordIndexes] });\n stats.joinedPairs++;\n continue;\n }\n // otherwise body text: re-flow wrapped lines into a paragraph\n appendToPara(lines[i], text);\n if (/[.!?:]$/.test(text)) flush();\n else stats.reflowed++;\n }\n flush();\n }\n flush();\n\n const md = `${out\n .join('\\n')\n .replace(/\\n{3,}/g, '\\n\\n')\n .trim()}\\n`;\n const pages: MarkdownPage[] = pageLines.map(({ page }) => ({ page, blocks: blockPages.get(page) ?? [] }));\n return { md, stats, bodyH, headingSizes, pages };\n}\n"],"names":["buildMarkdown","GLYPH","BULLETS","pageLines","heightChars","opts","bodyH","entries","sort","a","b","headingSizes","keys","filter","h","offset","pageMarkers","levelOf","Map","slice","map","i","Math","min","out","blockPages","stats","headings","listItems","paragraphs","joinedPairs","reflowed","callouts","closedHyphens","currentPage","para","addBlock","block","blocks","get","push","set","attachValue","label","lines","j","test","length","text","last","flush","part","join","replace","type","wordIndexes","flatMap","appendToPara","line","prev","at","head","split","pop","tail","close","getDict","has","toLowerCase","page","pageMarkerLine","indentBase","l","x","prevLine","col","y","run","merged","reduce","acc","level","repeat","stripped","trim","wasBullet","depth","max","round","itemLines","attached","itemText","tight","md","pages"],"mappings":"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"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/page-marker.ts"],"sourcesContent":["// page-marker.ts — page provenance shared by Markdown producers and readers.\n\n/** The marker heading for page N, with no surrounding whitespace/newlines\n * (callers own their own blank-line formatting). */\nexport function pageMarkerLine(page: number): string {\n return `### p${page}`;\n}\n\n// Visible headings are emitted by this package; invisible comments preserve\n// page provenance when a caller does not want headings in its final Markdown.\nconst MARKER_RE_SOURCE = '^(?:### p(\\\\d+)|<!-- p(\\\\d+) -->)\\\\r?$';\n\nfunction markerPage(match: RegExpExecArray): number {\n return Number(match[1] ?? match[2]);\n}\n\n/** Is this line (already split, no trailing newline) a page-marker heading? */\nexport function isPageMarkerLine(line: string): boolean {\n return new RegExp(MARKER_RE_SOURCE, 'u').test(line);\n}\n\n/** Split markdown into per-marker body slices, in document order — one entry\n * PER OCCURRENCE (a duplicate \"### pN\" yields two entries; no slice is ever dropped). */\nexport function splitByPageMarker(md: string): { page: number; body: string }[] {\n const re = new RegExp(MARKER_RE_SOURCE, 'gmu');\n const markers: { page: number; index: number; end: number }[] = [];\n for (let m = re.exec(md); m !== null; m = re.exec(md)) markers.push({ page: markerPage(m), index: m.index, end: m.index + m[0].length });\n const out: { page: number; body: string }[] = [];\n for (let i = 0; i < markers.length; i++) {\n const end = i + 1 < markers.length ? markers[i + 1].index : md.length;\n out.push({ page: markers[i].page, body: md.slice(markers[i].end, end) });\n }\n return out;\n}\n\n/** Per-page body text, duplicate-marker slices CONCATENATED — a word anywhere\n * on page N counts as on page N (the auditor's membership semantics). */\nexport function bodyByPage(md: string): Map<number, string> {\n const out = new Map<number, string>();\n for (const { page, body } of splitByPageMarker(md)) out.set(page, (out.get(page) ?? '') + body);\n return out;\n}\n\n/** Count of visible or invisible page-provenance marker lines in `md`. */\nexport function countPageMarkers(md: string): number {\n return [...md.matchAll(new RegExp(MARKER_RE_SOURCE, 'gmu'))].length;\n}\n"],"names":["bodyByPage","countPageMarkers","isPageMarkerLine","pageMarkerLine","splitByPageMarker","page","MARKER_RE_SOURCE","markerPage","match","Number","line","RegExp","test","md","re","markers","m","exec","push","index","end","length","out","i","body","slice","Map","set","get","matchAll"],"mappings":"AAAA,6EAA6E;AAE7E;kDACkD;;;;;;;;;;;QAkClCA;eAAAA;;QAOAC;eAAAA;;QA3BAC;eAAAA;;QAbAC;eAAAA;;QAmBAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAnBT,SAASD,eAAeE,IAAY;IACzC,OAAO,AAAC,QAAY,OAALA;AACjB;AAEA,4EAA4E;AAC5E,8EAA8E;AAC9E,IAAMC,mBAAmB;AAEzB,SAASC,WAAWC,KAAsB;QAC1BA;IAAd,OAAOC,QAAOD,UAAAA,KAAK,CAAC,EAAE,cAARA,qBAAAA,UAAYA,KAAK,CAAC,EAAE;AACpC;AAGO,SAASN,iBAAiBQ,IAAY;IAC3C,OAAO,IAAIC,OAAOL,kBAAkB,KAAKM,IAAI,CAACF;AAChD;AAIO,SAASN,kBAAkBS,EAAU;IAC1C,IAAMC,KAAK,IAAIH,OAAOL,kBAAkB;IACxC,IAAMS,UAA0D,EAAE;IAClE,IAAK,IAAIC,IAAIF,GAAGG,IAAI,CAACJ,KAAKG,MAAM,MAAMA,IAAIF,GAAGG,IAAI,CAACJ,IAAKE,QAAQG,IAAI,CAAC;QAAEb,MAAME,WAAWS;QAAIG,OAAOH,EAAEG,KAAK;QAAEC,KAAKJ,EAAEG,KAAK,GAAGH,CAAC,CAAC,EAAE,CAACK,MAAM;IAAC;IACtI,IAAMC,MAAwC,EAAE;IAChD,IAAK,IAAIC,IAAI,GAAGA,IAAIR,QAAQM,MAAM,EAAEE,IAAK;QACvC,IAAMH,MAAMG,IAAI,IAAIR,QAAQM,MAAM,GAAGN,OAAO,CAACQ,IAAI,EAAE,CAACJ,KAAK,GAAGN,GAAGQ,MAAM;QACrEC,IAAIJ,IAAI,CAAC;YAAEb,MAAMU,OAAO,CAACQ,EAAE,CAAClB,IAAI;YAAEmB,MAAMX,GAAGY,KAAK,CAACV,OAAO,CAACQ,EAAE,CAACH,GAAG,EAAEA;QAAK;IACxE;IACA,OAAOE;AACT;AAIO,SAAStB,WAAWa,EAAU;QAEgCS;IADnE,IAAMA,MAAM,IAAII;QACX,kCAAA,2BAAA;;QAAL,QAAK,YAAwBtB,kBAAkBS,wBAA1C,SAAA,6BAAA,QAAA,yBAAA;YAAA,kBAAA,aAAQR,mBAAAA,MAAMmB,mBAAAA;YAAiCF,IAAIK,GAAG,CAACtB,MAAM,EAACiB,WAAAA,IAAIM,GAAG,CAACvB,mBAARiB,sBAAAA,WAAiB,MAAME;;;QAArF;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IACL,OAAOF;AACT;AAGO,SAASrB,iBAAiBY,EAAU;IACzC,OAAO,AAAC,qBAAGA,GAAGgB,QAAQ,CAAC,IAAIlB,OAAOL,kBAAkB,SAASe,MAAM;AACrE"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/page-marker.ts"],"sourcesContent":["// page-marker.ts — page provenance shared by Markdown producers and readers.\n\n/** The marker heading for page N, with no surrounding whitespace/newlines\n * (callers own their own blank-line formatting). */\nexport function pageMarkerLine(page: number): string {\n return `### p${page}`;\n}\n\n// Visible headings are emitted by this package; invisible comments preserve\n// page provenance when a caller does not want headings in its final Markdown.\nconst MARKER_RE_SOURCE = '^(?:### p(\\\\d+)|<!-- p(\\\\d+) -->)\\\\r?$';\n\nfunction markerPage(match: RegExpExecArray): number {\n return Number(match[1] ?? match[2]);\n}\n\n/** Is this line (already split, no trailing newline) a page-marker heading? */\nexport function isPageMarkerLine(line: string): boolean {\n return new RegExp(MARKER_RE_SOURCE, 'u').test(line);\n}\n\n/** Split markdown into per-marker body slices, in document order — one entry\n * PER OCCURRENCE (a duplicate \"### pN\" yields two entries; no slice is ever dropped). */\nexport function splitByPageMarker(md: string): { page: number; body: string }[] {\n const re = new RegExp(MARKER_RE_SOURCE, 'gmu');\n const markers: { page: number; index: number; end: number }[] = [];\n for (let m = re.exec(md); m !== null; m = re.exec(md)) markers.push({ page: markerPage(m), index: m.index, end: m.index + m[0].length });\n const out: { page: number; body: string }[] = [];\n for (let i = 0; i < markers.length; i++) {\n const end = i + 1 < markers.length ? markers[i + 1].index : md.length;\n out.push({ page: markers[i].page, body: md.slice(markers[i].end, end) });\n }\n return out;\n}\n\n/** Per-page body text, duplicate-marker slices CONCATENATED — a word anywhere\n * on page N counts as on page N (the auditor's membership semantics). */\nexport function bodyByPage(md: string): Map<number, string> {\n const out = new Map<number, string>();\n for (const { page, body } of splitByPageMarker(md)) out.set(page, (out.get(page) ?? '') + body);\n return out;\n}\n\n/** Count of visible or invisible page-provenance marker lines in `md`. */\nexport function countPageMarkers(md: string): number {\n return [...md.matchAll(new RegExp(MARKER_RE_SOURCE, 'gmu'))].length;\n}\n"],"names":["bodyByPage","countPageMarkers","isPageMarkerLine","pageMarkerLine","splitByPageMarker","page","MARKER_RE_SOURCE","markerPage","match","Number","line","RegExp","test","md","re","markers","m","exec","push","index","end","length","out","i","body","slice","Map","set","get","matchAll"],"mappings":"AAAA,6EAA6E;AAE7E;kDACkD;;;;;;;;;;;QAkClCA;eAAAA;;QAOAC;eAAAA;;QA3BAC;eAAAA;;QAbAC;eAAAA;;QAmBAC;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAnBT,SAASD,eAAeE,IAAY;IACzC,OAAO,AAAC,QAAY,OAALA;AACjB;AAEA,4EAA4E;AAC5E,8EAA8E;AAC9E,IAAMC,mBAAmB;AAEzB,SAASC,WAAWC,KAAsB;QAC1BA;IAAd,OAAOC,QAAOD,UAAAA,KAAK,CAAC,EAAE,cAARA,qBAAAA,UAAYA,KAAK,CAAC,EAAE;AACpC;AAGO,SAASN,iBAAiBQ,IAAY;IAC3C,OAAO,IAAIC,OAAOL,kBAAkB,KAAKM,IAAI,CAACF;AAChD;AAIO,SAASN,kBAAkBS,EAAU;IAC1C,IAAMC,KAAK,IAAIH,OAAOL,kBAAkB;IACxC,IAAMS,UAA0D,EAAE;IAClE,IAAK,IAAIC,IAAIF,GAAGG,IAAI,CAACJ,KAAKG,MAAM,MAAMA,IAAIF,GAAGG,IAAI,CAACJ,IAAKE,QAAQG,IAAI,CAAC;QAAEb,MAAME,WAAWS;QAAIG,OAAOH,EAAEG,KAAK;QAAEC,KAAKJ,EAAEG,KAAK,GAAGH,CAAC,CAAC,EAAE,CAACK,MAAM;IAAC;IACtI,IAAMC,MAAwC,EAAE;IAChD,IAAK,IAAIC,IAAI,GAAGA,IAAIR,QAAQM,MAAM,EAAEE,IAAK;QACvC,IAAMH,MAAMG,IAAI,IAAIR,QAAQM,MAAM,GAAGN,OAAO,CAACQ,IAAI,EAAE,CAACJ,KAAK,GAAGN,GAAGQ,MAAM;QACrEC,IAAIJ,IAAI,CAAC;YAAEb,MAAMU,OAAO,CAACQ,EAAE,CAAClB,IAAI;YAAEmB,MAAMX,GAAGY,KAAK,CAACV,OAAO,CAACQ,EAAE,CAACH,GAAG,EAAEA;QAAK;IACxE;IACA,OAAOE;AACT;AAIO,SAAStB,WAAWa,EAAU;QAEgCS;IADnE,IAAMA,MAAM,IAAII;QACX,kCAAA,2BAAA;;QAAL,QAAK,YAAwBtB,kBAAkBS,wBAA1C,SAAA,6BAAA,QAAA,yBAAA;YAAA,kBAAA,aAAQR,mBAAAA,MAAMmB,mBAAAA;YAAiCF,IAAIK,GAAG,CAACtB,MAAM,EAACiB,WAAAA,IAAIM,GAAG,CAACvB,mBAARiB,sBAAAA,WAAiB,MAAME;;;QAArF;QAAA;;;iBAAA,6BAAA;gBAAA;;;gBAAA;sBAAA;;;;IACL,OAAOF;AACT;AAGO,SAASrB,iBAAiBY,EAAU;IACzC,OAAO,AAAC,qBAAGA,GAAGgB,QAAQ,CAAC,IAAIlB,OAAOL,kBAAkB,SAASe,MAAM;AACrE"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/pdf-open.ts"],"sourcesContent":["// pdf-open.ts — the one seam that opens a PDF via pdfjs-dist, in the two\n// shapes callers need: openDocument (data-based, already-open doc) and openPdfForRender (url-based, task you must await + destroy()).\n// Both wrap a failure the same way: PdfToMdError/PDF_OPEN, original message preserved.\nimport { readFileSync } from 'node:fs';\nimport path from 'node:path';\nimport type { PDFDocumentLoadingTask, PDFDocumentProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { getDocument, VerbosityLevel } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { PdfToMdError } from './errors.ts';\nimport { resolvePackagePath } from './resolve.ts';\n\n// `verbosity: VerbosityLevel.ERRORS` silences pdfjs's own console.warn calls\n// — the library's documented promise is it never writes to stdout/stderr on its own.\n\n/** Data-based open (collect.ts's seam): no cMaps/fonts — text-layer extraction\n * only, verified to decode CJK correctly. Wraps missing/unreadable and non-PDF files as PdfToMdError/PDF_OPEN. */\nexport async function openDocument(src: string): Promise<PDFDocumentProxy> {\n let data: Uint8Array;\n try {\n data = new Uint8Array(readFileSync(src));\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `cannot read ${src}: ${(err as Error).message}`);\n }\n try {\n return await getDocument({\n data,\n useSystemFonts: true,\n verbosity: VerbosityLevel.ERRORS,\n }).promise;\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `cannot open ${src} as a PDF: ${(err as Error).message}`);\n }\n}\n\n// Wires up pdfjs's bundled cmaps/standard_fonts so CJK and non-embedded\n// standard fonts resolve instead of falling back to substitute glyphs.\n//\n// GOTCHA: despite the `...Url` name, pdfjs's Node loader does `fs.readFile`\n// on the string directly — a `file://` URL silently fails every lookup (only a stderr warning); plain filesystem paths are required.\n// The trailing \"/\" must be literal (pdfjs rejects a trailing \"\\\"); Windows' fs accepts \"/\" after a \"\\\" path.\nconst PDFJS_DIST_ROOT = path.dirname(resolvePackagePath('pdfjs-dist/package.json'));\nconst CMAP_URL = `${path.join(PDFJS_DIST_ROOT, 'cmaps')}/`;\nconst STANDARD_FONT_DATA_URL = `${path.join(PDFJS_DIST_ROOT, 'standard_fonts')}/`;\n// JBIG2/JPEG2000 decoding lives in pdfjs's WASM modules: without this, bitonal\n// scans (the usual encoding for B&W page images) decode to a BLANK page and OCR sees nothing.\nconst WASM_URL = `${path.join(PDFJS_DIST_ROOT, 'wasm')}/`;\n\n/**\n * Open a PDF for rendering (raster.ts/tesseract.ts's seam): cMaps + standard\n * fonts wired up, url-based. Callers must `await` the returned task's `.promise` (via `awaitPdfOpen`) and call `.destroy()` when done.\n */\nexport function openPdfForRender(pdfPath: string): PDFDocumentLoadingTask {\n // No `worker` option: this pdfjs-dist Node build needs no real Worker thread wired up to run.\n return getDocument({\n url: pdfPath,\n cMapUrl: CMAP_URL,\n cMapPacked: true,\n standardFontDataUrl: STANDARD_FONT_DATA_URL,\n wasmUrl: WASM_URL,\n verbosity: VerbosityLevel.ERRORS,\n });\n}\n\n/** Shared error wrapping for `openPdfForRender`'s task: a raw pdfjs open\n * failure becomes PdfToMdError/PDF_OPEN, original message preserved. */\nexport async function awaitPdfOpen(loadingTask: PDFDocumentLoadingTask, pdfPath: string): Promise<PDFDocumentProxy> {\n try {\n return await loadingTask.promise;\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `could not open PDF: ${pdfPath} (${(err as Error).message})`);\n }\n}\n"],"names":["awaitPdfOpen","openDocument","openPdfForRender","src","data","err","Uint8Array","readFileSync","PdfToMdError","message","getDocument","useSystemFonts","verbosity","VerbosityLevel","ERRORS","promise","PDFJS_DIST_ROOT","path","dirname","resolvePackagePath","CMAP_URL","join","STANDARD_FONT_DATA_URL","WASM_URL","pdfPath","url","cMapUrl","cMapPacked","standardFontDataUrl","wasmUrl","loadingTask"],"mappings":"AAAA,yEAAyE;AACzE,sIAAsI;AACtI,uFAAuF;;;;;;;;;;;;QA8DjEA;eAAAA;;QAjDAC;eAAAA;;QAmCNC;eAAAA;;;sBA/Ca;+DACZ;mBAE2B;wBACf;yBACM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAO5B,SAAeD,aAAaE,GAAW;;YACxCC,MAYKC;;;;oBAXT,IAAI;wBACFD,OAAO,IAAIE,WAAWC,IAAAA,oBAAY,EAACJ;oBACrC,EAAE,OAAOE,KAAK;wBACZ,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,eAAsB,OAARL,KAAI,MAA2B,OAAvB,AAACE,IAAcI,OAAO;oBAClF;;;;;;;;;oBAES;;wBAAMC,IAAAA,gBAAW,EAAC;4BACvBN,MAAAA;4BACAO,gBAAgB;4BAChBC,WAAWC,mBAAc,CAACC,MAAM;wBAClC,GAAGC,OAAO;;;oBAJV;;wBAAO;;;oBAKAV;oBACP,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,eAA+B,OAAjBL,KAAI,eAAoC,OAAvB,AAACE,IAAcI,OAAO;;;;;;;IAE7F;;AAEA,wEAAwE;AACxE,uEAAuE;AACvE,EAAE;AACF,4EAA4E;AAC5E,qIAAqI;AACrI,6GAA6G;AAC7G,IAAMO,kBAAkBC,iBAAI,CAACC,OAAO,CAACC,IAAAA,6BAAkB,EAAC;AACxD,IAAMC,WAAW,AAAC,GAAsC,OAApCH,iBAAI,CAACI,IAAI,CAACL,iBAAiB,UAAS;AACxD,IAAMM,yBAAyB,AAAC,GAA+C,OAA7CL,iBAAI,CAACI,IAAI,CAACL,iBAAiB,mBAAkB;AAC/E,+EAA+E;AAC/E,8FAA8F;AAC9F,IAAMO,WAAW,AAAC,GAAqC,OAAnCN,iBAAI,CAACI,IAAI,CAACL,iBAAiB,SAAQ;AAMhD,SAASd,iBAAiBsB,OAAe;IAC9C,8FAA8F;IAC9F,OAAOd,IAAAA,gBAAW,EAAC;QACjBe,KAAKD;QACLE,SAASN;QACTO,YAAY;QACZC,qBAAqBN;QACrBO,SAASN;QACTX,WAAWC,mBAAc,CAACC,MAAM;IAClC;AACF;AAIO,SAAed,aAAa8B,WAAmC,EAAEN,OAAe;;YAG5EnB;;;;;;;;;;oBADA;;wBAAMyB,YAAYf,OAAO;;;oBAAhC;;wBAAO;;;oBACAV;oBACP,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,uBAAkC,OAAZgB,SAAQ,MAA2B,OAAvB,AAACnB,IAAcI,OAAO,EAAC;;;;;;;IAEjG"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/pdf-open.ts"],"sourcesContent":["// pdf-open.ts — the one seam that opens a PDF via pdfjs-dist, in the two\n// shapes callers need: openDocument (data-based, already-open doc) and openPdfForRender (url-based, task you must await + destroy()).\n// Both wrap a failure the same way: PdfToMdError/PDF_OPEN, original message preserved.\nimport { readFileSync } from 'node:fs';\nimport path from 'node:path';\nimport type { PDFDocumentLoadingTask, PDFDocumentProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { getDocument, VerbosityLevel } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { PdfToMdError } from './errors.ts';\nimport { resolvePackagePath } from './resolve.ts';\n\n// `verbosity: VerbosityLevel.ERRORS` silences pdfjs's own console.warn calls\n// — the library's documented promise is it never writes to stdout/stderr on its own.\n\n/** Data-based open (collect.ts's seam): no cMaps/fonts — text-layer extraction\n * only, verified to decode CJK correctly. Wraps missing/unreadable and non-PDF files as PdfToMdError/PDF_OPEN. */\nexport async function openDocument(src: string): Promise<PDFDocumentProxy> {\n let data: Uint8Array;\n try {\n data = new Uint8Array(readFileSync(src));\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `cannot read ${src}: ${(err as Error).message}`);\n }\n try {\n return await getDocument({\n data,\n useSystemFonts: true,\n verbosity: VerbosityLevel.ERRORS,\n }).promise;\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `cannot open ${src} as a PDF: ${(err as Error).message}`);\n }\n}\n\n// Wires up pdfjs's bundled cmaps/standard_fonts so CJK and non-embedded\n// standard fonts resolve instead of falling back to substitute glyphs.\n//\n// GOTCHA: despite the `...Url` name, pdfjs's Node loader does `fs.readFile`\n// on the string directly — a `file://` URL silently fails every lookup (only a stderr warning); plain filesystem paths are required.\n// The trailing \"/\" must be literal (pdfjs rejects a trailing \"\\\"); Windows' fs accepts \"/\" after a \"\\\" path.\nconst PDFJS_DIST_ROOT = path.dirname(resolvePackagePath('pdfjs-dist/package.json'));\nconst CMAP_URL = `${path.join(PDFJS_DIST_ROOT, 'cmaps')}/`;\nconst STANDARD_FONT_DATA_URL = `${path.join(PDFJS_DIST_ROOT, 'standard_fonts')}/`;\n// JBIG2/JPEG2000 decoding lives in pdfjs's WASM modules: without this, bitonal\n// scans (the usual encoding for B&W page images) decode to a BLANK page and OCR sees nothing.\nconst WASM_URL = `${path.join(PDFJS_DIST_ROOT, 'wasm')}/`;\n\n/**\n * Open a PDF for rendering (raster.ts/tesseract.ts's seam): cMaps + standard\n * fonts wired up, url-based. Callers must `await` the returned task's `.promise` (via `awaitPdfOpen`) and call `.destroy()` when done.\n */\nexport function openPdfForRender(pdfPath: string): PDFDocumentLoadingTask {\n // No `worker` option: this pdfjs-dist Node build needs no real Worker thread wired up to run.\n return getDocument({\n url: pdfPath,\n cMapUrl: CMAP_URL,\n cMapPacked: true,\n standardFontDataUrl: STANDARD_FONT_DATA_URL,\n wasmUrl: WASM_URL,\n verbosity: VerbosityLevel.ERRORS,\n });\n}\n\n/** Shared error wrapping for `openPdfForRender`'s task: a raw pdfjs open\n * failure becomes PdfToMdError/PDF_OPEN, original message preserved. */\nexport async function awaitPdfOpen(loadingTask: PDFDocumentLoadingTask, pdfPath: string): Promise<PDFDocumentProxy> {\n try {\n return await loadingTask.promise;\n } catch (err) {\n throw new PdfToMdError('PDF_OPEN', `could not open PDF: ${pdfPath} (${(err as Error).message})`);\n }\n}\n"],"names":["awaitPdfOpen","openDocument","openPdfForRender","src","data","err","Uint8Array","readFileSync","PdfToMdError","message","getDocument","useSystemFonts","verbosity","VerbosityLevel","ERRORS","promise","PDFJS_DIST_ROOT","path","dirname","resolvePackagePath","CMAP_URL","join","STANDARD_FONT_DATA_URL","WASM_URL","pdfPath","url","cMapUrl","cMapPacked","standardFontDataUrl","wasmUrl","loadingTask"],"mappings":"AAAA,yEAAyE;AACzE,sIAAsI;AACtI,uFAAuF;;;;;;;;;;;;QA8DjEA;eAAAA;;QAjDAC;eAAAA;;QAmCNC;eAAAA;;;sBA/Ca;+DACZ;mBAE2B;wBACf;yBACM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAO5B,SAAeD,aAAaE,GAAW;;YACxCC,MAYKC;;;;oBAXT,IAAI;wBACFD,OAAO,IAAIE,WAAWC,IAAAA,oBAAY,EAACJ;oBACrC,EAAE,OAAOE,KAAK;wBACZ,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,eAAsB,OAARL,KAAI,MAA2B,OAAvB,AAACE,IAAcI,OAAO;oBAClF;;;;;;;;;oBAES;;wBAAMC,IAAAA,gBAAW,EAAC;4BACvBN,MAAAA;4BACAO,gBAAgB;4BAChBC,WAAWC,mBAAc,CAACC,MAAM;wBAClC,GAAGC,OAAO;;;oBAJV;;wBAAO;;;oBAKAV;oBACP,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,eAA+B,OAAjBL,KAAI,eAAoC,OAAvB,AAACE,IAAcI,OAAO;;;;;;;IAE7F;;AAEA,wEAAwE;AACxE,uEAAuE;AACvE,EAAE;AACF,4EAA4E;AAC5E,qIAAqI;AACrI,6GAA6G;AAC7G,IAAMO,kBAAkBC,iBAAI,CAACC,OAAO,CAACC,IAAAA,6BAAkB,EAAC;AACxD,IAAMC,WAAW,AAAC,GAAsC,OAApCH,iBAAI,CAACI,IAAI,CAACL,iBAAiB,UAAS;AACxD,IAAMM,yBAAyB,AAAC,GAA+C,OAA7CL,iBAAI,CAACI,IAAI,CAACL,iBAAiB,mBAAkB;AAC/E,+EAA+E;AAC/E,8FAA8F;AAC9F,IAAMO,WAAW,AAAC,GAAqC,OAAnCN,iBAAI,CAACI,IAAI,CAACL,iBAAiB,SAAQ;AAMhD,SAASd,iBAAiBsB,OAAe;IAC9C,8FAA8F;IAC9F,OAAOd,IAAAA,gBAAW,EAAC;QACjBe,KAAKD;QACLE,SAASN;QACTO,YAAY;QACZC,qBAAqBN;QACrBO,SAASN;QACTX,WAAWC,mBAAc,CAACC,MAAM;IAClC;AACF;AAIO,SAAed,aAAa8B,WAAmC,EAAEN,OAAe;;YAG5EnB;;;;;;;;;;oBADA;;wBAAMyB,YAAYf,OAAO;;;oBAAhC;;wBAAO;;;oBACAV;oBACP,MAAM,IAAIG,sBAAY,CAAC,YAAY,AAAC,uBAAkC,OAAZgB,SAAQ,MAA2B,OAAvB,AAACnB,IAAcI,OAAO,EAAC;;;;;;;IAEjG"}
@@ -1 +1 @@
1
- {"version":3,"sources":["/Users/kevin/Dev/OpenSource/formats/pdf-to-md/src/raster.ts"],"sourcesContent":["// Renders PDF pages to PNG with pdfjs-dist + @napi-rs/canvas. Shared by the\n// `render` CLI command (human/vision-model page verification) and src/engines/tesseract.ts (OCR page images).\n\nimport { createCanvas } from '@napi-rs/canvas';\nimport type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { PdfToMdError } from './errors.ts';\nimport { awaitPdfOpen, openPdfForRender } from './pdf-open.ts';\n\n// pdfjs-dist doesn't export RenderParameters from the package root; derive\n// it from PDFPageProxy['render'] rather than hand-declaring a shape that could drift.\ntype RenderParams = Parameters<PDFPageProxy['render']>[0];\n\n// No CanvasFactory shim needed: pdfjs-dist detects `@napi-rs/canvas` itself\n// and uses it internally (patterns, SMasks, Type3 glyphs); we only hand it a `canvasContext` for the page itself, created directly below.\n\nexport { openPdfForRender } from './pdf-open.ts';\n\n/** One rendered page, from renderPageToPNG (or the `pdf-to-md render` CLI\n * command it backs). */\nexport interface RenderPageResult {\n /** the rendered page, PNG-encoded */\n png: Buffer;\n /** pixel width at the requested dpi */\n width: number;\n /** pixel height at the requested dpi */\n height: number;\n /** the page's own /Rotate entry, baked into `png`/`width`/`height` already\n * — informational, not something a caller needs to apply again */\n rotation: number;\n}\n\n/** Render one already-open document's page to a PNG buffer at the given DPI. */\nexport async function renderLoadedPage(doc: PDFDocumentProxy, pageNum: number, dpi: number): Promise<RenderPageResult> {\n if (!(pageNum >= 1) || pageNum > doc.numPages) {\n throw new PdfToMdError('PAGE_RANGE', `page ${pageNum} is outside this document (1-${doc.numPages})`);\n }\n const page = await doc.getPage(pageNum);\n\n // getViewport({scale}) bakes in the page's own /Rotate entry AND its\n // mediaBox origin automatically — no manual origin translate needed on top of it.\n const scale = dpi / 72;\n const viewport = page.getViewport({ scale });\n const width = Math.round(viewport.width);\n const height = Math.round(viewport.height);\n if (width <= 0 || height <= 0) throw new PdfToMdError('PAGE_RENDER', `page ${pageNum} has non-positive dimensions ${width}x${height}`);\n\n const canvas = createCanvas(width, height);\n const context = canvas.getContext('2d');\n\n // Paint white first: an unpainted @napi-rs/canvas context is transparent,\n // which would encode as black/checkered rather than a white page.\n context.fillStyle = 'white';\n context.fillRect(0, 0, width, height);\n\n // pdfjs's RenderParameters types canvas/context against DOM types;\n // @napi-rs/canvas's are API-compatible at runtime but not that DOM type — the interop boundary the \"no any\" rule allows a cast for.\n const renderTask = page.render({\n canvas: canvas as unknown as RenderParams['canvas'],\n canvasContext: context as unknown as RenderParams['canvasContext'],\n viewport,\n });\n await renderTask.promise;\n\n const png = await canvas.encode('png');\n return { png, width, height, rotation: viewport.rotation };\n}\n\n/**\n * Render one page of a PDF to a PNG buffer at the given DPI. Opens and\n * closes the document itself — for more than one page from the same PDF, use `openPdfForRender` + `renderLoadedPage` instead.\n *\n * @param pdfPath path to the PDF file\n * @param pageNum 1-based page number\n * @param dpi PDF user space is 72 units/inch, so scale = dpi / 72\n */\nexport async function renderPageToPNG(pdfPath: string, pageNum: number, dpi: number): Promise<RenderPageResult> {\n const loadingTask = openPdfForRender(pdfPath);\n try {\n const doc = await awaitPdfOpen(loadingTask, pdfPath);\n return await renderLoadedPage(doc, pageNum, dpi);\n } finally {\n await loadingTask.destroy();\n }\n}\n"],"names":["openPdfForRender","renderLoadedPage","renderPageToPNG","doc","pageNum","dpi","page","scale","viewport","width","height","canvas","context","renderTask","png","numPages","PdfToMdError","getPage","getViewport","Math","round","createCanvas","getContext","fillStyle","fillRect","render","canvasContext","promise","encode","rotation","pdfPath","loadingTask","awaitPdfOpen","destroy"],"mappings":"AAAA,4EAA4E;AAC5E,8GAA8G;;;;;;;;;;;;QAcrGA;eAAAA,2BAAgB;;QAiBHC;eAAAA;;QA2CAC;eAAAA;;;sBAxEO;wBAEA;yBACkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BxC,SAAeD,iBAAiBE,GAAqB,EAAEC,OAAe,EAAEC,GAAW;;YAIlFC,MAIAC,OACAC,UACAC,OACAC,QAGAC,QACAC,SASAC,YAOAC;;;;oBA9BN,IAAI,CAAEV,CAAAA,WAAW,CAAA,KAAMA,UAAUD,IAAIY,QAAQ,EAAE;wBAC7C,MAAM,IAAIC,sBAAY,CAAC,cAAc,AAAC,QAA8Cb,OAAvCC,SAAQ,iCAA4C,OAAbD,IAAIY,QAAQ,EAAC;oBACnG;oBACa;;wBAAMZ,IAAIc,OAAO,CAACb;;;oBAAzBE,OAAO;oBAEb,qEAAqE;oBACrE,kFAAkF;oBAC5EC,QAAQF,MAAM;oBACdG,WAAWF,KAAKY,WAAW,CAAC;wBAAEX,OAAAA;oBAAM;oBACpCE,QAAQU,KAAKC,KAAK,CAACZ,SAASC,KAAK;oBACjCC,SAASS,KAAKC,KAAK,CAACZ,SAASE,MAAM;oBACzC,IAAID,SAAS,KAAKC,UAAU,GAAG,MAAM,IAAIM,sBAAY,CAAC,eAAe,AAAC,QAA8CP,OAAvCL,SAAQ,iCAAwCM,OAATD,OAAM,KAAU,OAAPC;oBAEvHC,SAASU,IAAAA,oBAAY,EAACZ,OAAOC;oBAC7BE,UAAUD,OAAOW,UAAU,CAAC;oBAElC,0EAA0E;oBAC1E,kEAAkE;oBAClEV,QAAQW,SAAS,GAAG;oBACpBX,QAAQY,QAAQ,CAAC,GAAG,GAAGf,OAAOC;oBAE9B,mEAAmE;oBACnE,oIAAoI;oBAC9HG,aAAaP,KAAKmB,MAAM,CAAC;wBAC7Bd,QAAQA;wBACRe,eAAed;wBACfJ,UAAAA;oBACF;oBACA;;wBAAMK,WAAWc,OAAO;;;oBAAxB;oBAEY;;wBAAMhB,OAAOiB,MAAM,CAAC;;;oBAA1Bd,MAAM;oBACZ;;wBAAO;4BAAEA,KAAAA;4BAAKL,OAAAA;4BAAOC,QAAAA;4BAAQmB,UAAUrB,SAASqB,QAAQ;wBAAC;;;;IAC3D;;AAUO,SAAe3B,gBAAgB4B,OAAe,EAAE1B,OAAe,EAAEC,GAAW;;YAC3E0B,aAEE5B;;;;oBAFF4B,cAAc/B,IAAAA,2BAAgB,EAAC8B;;;;;;;;;oBAEvB;;wBAAME,IAAAA,uBAAY,EAACD,aAAaD;;;oBAAtC3B,MAAM;oBACL;;wBAAMF,iBAAiBE,KAAKC,SAASC;;;oBAA5C;;wBAAO;;;oBAEP;;wBAAM0B,YAAYE,OAAO;;;oBAAzB;;;;;;;;;;IAEJ"}
1
+ {"version":3,"sources":["/Users/kevin/Dev/open-source/formats/pdf-to-md/src/raster.ts"],"sourcesContent":["// Renders PDF pages to PNG with pdfjs-dist + @napi-rs/canvas. Shared by the\n// `render` CLI command (human/vision-model page verification) and src/engines/tesseract.ts (OCR page images).\n\nimport { createCanvas } from '@napi-rs/canvas';\nimport type { PDFDocumentProxy, PDFPageProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';\nimport { PdfToMdError } from './errors.ts';\nimport { awaitPdfOpen, openPdfForRender } from './pdf-open.ts';\n\n// pdfjs-dist doesn't export RenderParameters from the package root; derive\n// it from PDFPageProxy['render'] rather than hand-declaring a shape that could drift.\ntype RenderParams = Parameters<PDFPageProxy['render']>[0];\n\n// No CanvasFactory shim needed: pdfjs-dist detects `@napi-rs/canvas` itself\n// and uses it internally (patterns, SMasks, Type3 glyphs); we only hand it a `canvasContext` for the page itself, created directly below.\n\nexport { openPdfForRender } from './pdf-open.ts';\n\n/** One rendered page, from renderPageToPNG (or the `pdf-to-md render` CLI\n * command it backs). */\nexport interface RenderPageResult {\n /** the rendered page, PNG-encoded */\n png: Buffer;\n /** pixel width at the requested dpi */\n width: number;\n /** pixel height at the requested dpi */\n height: number;\n /** the page's own /Rotate entry, baked into `png`/`width`/`height` already\n * — informational, not something a caller needs to apply again */\n rotation: number;\n}\n\n/** Render one already-open document's page to a PNG buffer at the given DPI. */\nexport async function renderLoadedPage(doc: PDFDocumentProxy, pageNum: number, dpi: number): Promise<RenderPageResult> {\n if (!(pageNum >= 1) || pageNum > doc.numPages) {\n throw new PdfToMdError('PAGE_RANGE', `page ${pageNum} is outside this document (1-${doc.numPages})`);\n }\n const page = await doc.getPage(pageNum);\n\n // getViewport({scale}) bakes in the page's own /Rotate entry AND its\n // mediaBox origin automatically — no manual origin translate needed on top of it.\n const scale = dpi / 72;\n const viewport = page.getViewport({ scale });\n const width = Math.round(viewport.width);\n const height = Math.round(viewport.height);\n if (width <= 0 || height <= 0) throw new PdfToMdError('PAGE_RENDER', `page ${pageNum} has non-positive dimensions ${width}x${height}`);\n\n const canvas = createCanvas(width, height);\n const context = canvas.getContext('2d');\n\n // Paint white first: an unpainted @napi-rs/canvas context is transparent,\n // which would encode as black/checkered rather than a white page.\n context.fillStyle = 'white';\n context.fillRect(0, 0, width, height);\n\n // pdfjs's RenderParameters types canvas/context against DOM types;\n // @napi-rs/canvas's are API-compatible at runtime but not that DOM type — the interop boundary the \"no any\" rule allows a cast for.\n const renderTask = page.render({\n canvas: canvas as unknown as RenderParams['canvas'],\n canvasContext: context as unknown as RenderParams['canvasContext'],\n viewport,\n });\n await renderTask.promise;\n\n const png = await canvas.encode('png');\n return { png, width, height, rotation: viewport.rotation };\n}\n\n/**\n * Render one page of a PDF to a PNG buffer at the given DPI. Opens and\n * closes the document itself — for more than one page from the same PDF, use `openPdfForRender` + `renderLoadedPage` instead.\n *\n * @param pdfPath path to the PDF file\n * @param pageNum 1-based page number\n * @param dpi PDF user space is 72 units/inch, so scale = dpi / 72\n */\nexport async function renderPageToPNG(pdfPath: string, pageNum: number, dpi: number): Promise<RenderPageResult> {\n const loadingTask = openPdfForRender(pdfPath);\n try {\n const doc = await awaitPdfOpen(loadingTask, pdfPath);\n return await renderLoadedPage(doc, pageNum, dpi);\n } finally {\n await loadingTask.destroy();\n }\n}\n"],"names":["openPdfForRender","renderLoadedPage","renderPageToPNG","doc","pageNum","dpi","page","scale","viewport","width","height","canvas","context","renderTask","png","numPages","PdfToMdError","getPage","getViewport","Math","round","createCanvas","getContext","fillStyle","fillRect","render","canvasContext","promise","encode","rotation","pdfPath","loadingTask","awaitPdfOpen","destroy"],"mappings":"AAAA,4EAA4E;AAC5E,8GAA8G;;;;;;;;;;;;QAcrGA;eAAAA,2BAAgB;;QAiBHC;eAAAA;;QA2CAC;eAAAA;;;sBAxEO;wBAEA;yBACkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BxC,SAAeD,iBAAiBE,GAAqB,EAAEC,OAAe,EAAEC,GAAW;;YAIlFC,MAIAC,OACAC,UACAC,OACAC,QAGAC,QACAC,SASAC,YAOAC;;;;oBA9BN,IAAI,CAAEV,CAAAA,WAAW,CAAA,KAAMA,UAAUD,IAAIY,QAAQ,EAAE;wBAC7C,MAAM,IAAIC,sBAAY,CAAC,cAAc,AAAC,QAA8Cb,OAAvCC,SAAQ,iCAA4C,OAAbD,IAAIY,QAAQ,EAAC;oBACnG;oBACa;;wBAAMZ,IAAIc,OAAO,CAACb;;;oBAAzBE,OAAO;oBAEb,qEAAqE;oBACrE,kFAAkF;oBAC5EC,QAAQF,MAAM;oBACdG,WAAWF,KAAKY,WAAW,CAAC;wBAAEX,OAAAA;oBAAM;oBACpCE,QAAQU,KAAKC,KAAK,CAACZ,SAASC,KAAK;oBACjCC,SAASS,KAAKC,KAAK,CAACZ,SAASE,MAAM;oBACzC,IAAID,SAAS,KAAKC,UAAU,GAAG,MAAM,IAAIM,sBAAY,CAAC,eAAe,AAAC,QAA8CP,OAAvCL,SAAQ,iCAAwCM,OAATD,OAAM,KAAU,OAAPC;oBAEvHC,SAASU,IAAAA,oBAAY,EAACZ,OAAOC;oBAC7BE,UAAUD,OAAOW,UAAU,CAAC;oBAElC,0EAA0E;oBAC1E,kEAAkE;oBAClEV,QAAQW,SAAS,GAAG;oBACpBX,QAAQY,QAAQ,CAAC,GAAG,GAAGf,OAAOC;oBAE9B,mEAAmE;oBACnE,oIAAoI;oBAC9HG,aAAaP,KAAKmB,MAAM,CAAC;wBAC7Bd,QAAQA;wBACRe,eAAed;wBACfJ,UAAAA;oBACF;oBACA;;wBAAMK,WAAWc,OAAO;;;oBAAxB;oBAEY;;wBAAMhB,OAAOiB,MAAM,CAAC;;;oBAA1Bd,MAAM;oBACZ;;wBAAO;4BAAEA,KAAAA;4BAAKL,OAAAA;4BAAOC,QAAAA;4BAAQmB,UAAUrB,SAASqB,QAAQ;wBAAC;;;;IAC3D;;AAUO,SAAe3B,gBAAgB4B,OAAe,EAAE1B,OAAe,EAAEC,GAAW;;YAC3E0B,aAEE5B;;;;oBAFF4B,cAAc/B,IAAAA,2BAAgB,EAAC8B;;;;;;;;;oBAEvB;;wBAAME,IAAAA,uBAAY,EAACD,aAAaD;;;oBAAtC3B,MAAM;oBACL;;wBAAMF,iBAAiBE,KAAKC,SAASC;;;oBAA5C;;wBAAO;;;oBAEP;;wBAAM0B,YAAYE,OAAO;;;oBAAzB;;;;;;;;;;IAEJ"}