hazo_scrape 1.2.1 → 1.5.2

package/CHANGE_LOG.md

@@ -1,5 +1,51 @@
 # hazo_scrape — Change Log
 
+## 1.5.2 — 2026-07-24
+
+### Fixed — `extractTableFromPdf` mid-word text-run splits
+- A word a PDF splits across two adjacent text runs (pdfjs reports the second run beginning, within 1px, exactly where the first ended, with no whitespace at either boundary — e.g. `"Septemb"` + `"er"`) is now glued back with **no space** (`"September"`) instead of joined with a space (`"Septemb er"`). Genuinely separate tokens on the same line — which render a visible gap and/or carry a boundary space in the run text — still get their single separating space. Surfaced by BHP's historical dividend PDF, where a split month name (`"4 Septemb er 2020"`) made a record-date cell unparseable. `lineToCells` now decides spacing per-item from each text run's `x + width` and boundary whitespace rather than blindly space-joining.
+
+## 1.5.1 — 2026-07-24
+
+### Fixed — `extractTableFromPdf` multi-page row merging
+- Visual lines are now clustered **per page** instead of over the concatenation of all pages' text items. Text-item y-coordinates repeat page to page (row N sits at the same y on every page), so the previous cross-page clustering collapsed each page's row N into a single garbled line — a multi-page table (e.g. BHP's 6-page historical dividend list) came out unusable. Column-band detection still spans all items (column geometry is page-independent); page order is preserved; a single-page document is unaffected.
+
+## 1.5.0 — 2026-07-24
+
+### Added — `extractTableFromPdf` (PDF text-layer → table)
+- `extractTableFromPdf(data, opts?)` reconstructs a `{ headers, rows }` grid — the same `ExtractTableResult` shape `extractTable(html)` produces — from a PDF's positioned text layer, via `pdfjs-dist`. It clusters text items into visual lines by y-position and into columns by x-band, so a caller's existing `mapColumns`/`mapRows` pipeline consumes HTML and PDF tables identically.
+- `opts.columnBands?: number[]` — left x-edges of each column; omit to auto-detect by x-gap (a 25px gap starts a new column).
+- `opts.headerLabels?: string[]` — verbatim headers positionally aligned to the bands; when set, every clustered line is treated as a data row (for PDFs whose header spans multiple visual lines or uses columns no keyword classifier should see).
+- `opts.headerRows?: number` — else merge the first N lines into headers (default 1); ignored when `headerLabels` is set.
+- `opts.mergeContinuationRows?: boolean` — a line whose leftmost band is empty is folded into the previous row (per-band, space-joined) instead of becoming its own row — for PDFs that wrap a cell's overflow (e.g. a dual-currency amount) onto a second line.
+- `opts.rowTolerance?: number` (default 3) and `opts.maxPages?: number` round out the tuning surface.
+- New export surface: `src/pdf/` re-exported from the package root (`.`) — SERVER-ONLY (pulls in `pdfjs-dist`), never from the client-safe `./parse` entry.
+- New dependency: `pdfjs-dist@^4.10.38` (imported from `pdfjs-dist/legacy/build/pdf.mjs`; no worker/font setup needed for text-only extraction).
+
+### Added — `fetchPdf` + `FetchOptions.binary` (raw-byte fetch)
+- `fetchPdf(url, opts?)` fetches a PDF (or any binary document) as raw bytes, reusing `fetchDocument`'s robots / rate-limit / retry / proxy machinery. On a 2xx response, `result.bytes` (`Uint8Array`) holds the payload.
+- `FetchOptions` gains `binary?: boolean`; `FetchResult` gains `bytes?: Uint8Array`. When `binary: true`, `fetchDocument` reads the response as bytes instead of text (`body` is `''`) and the response is never written to the on-disk cache.
+- Motivation: `extractTableFromPdf` needs raw bytes, not decoded text, and a caller (e.g. `extractor_asx`) should not have to hand-roll a second fetch path to get them.
+
+## 1.4.0 — 2026-07-24
+
+### Added — `parseDate` optional `opts.extractLeading` (+ `mapRows` `opts.dateExtractLeading`)
+- `parseDate(raw, { extractLeading: true })` accepts a date at the START of the cell even when trailing text follows it — e.g. `parseDate('25/06/2024 - special dividend', { formats: ['DD/MM/YYYY'], extractLeading: true })` now returns `'2024-06-25'` (previously `null`, since every date pattern was `^…$`-anchored). Only the leading date token is read; trailing text is ignored, never parsed. Leading junk is still rejected (the date must be the first token), a partial year is guarded against (`'25/06/20245'` → `null`), and the date itself is still matched exactly and disambiguated by the same rules — the "never guess" contract holds. Default off; omitting it preserves the exact prior whole-string behaviour.
+- `mapRows(table, map, keywords, { dateExtractLeading: true })` forwards this to `parseDate` for every date-typed cell (alongside the existing `dateFormats`). Purely additive.
+- Motivation: real IR pages (e.g. WBC's dividend history) staple a label onto a date cell — `"25/06/2024 - special dividend"` — which the strict parser correctly refused, dropping the payment date to `null`. A caller that KNOWS a source does this can now opt in via `SourceRegistryEntry.nuances` without this engine ever guessing.
+
+## 1.3.0 — 2026-07-24
+
+### Added — `extractTable` div-grid mode (`opts.grid`)
+- `extractTable(html, { grid })` reads a "table" built from styled `<div>`s (CSS grid/flex) instead of a real `<table>`. `GridSelector = { container?, row, cell, headerRow? }` — all plain CSS selectors. When `container` matches more than one grid, the wrapper with the most data rows wins (mirrors the existing pickBestTable "the real data grid is the biggest" bias). Motivation: IR pages like CBA's `dividend-information.html` render dividend history as `.complex-table` div-grids that a static fetch sees in markup but `extractTable` (table-only) could not read — surfacing as `0 rows × 0 cols`. Purely additive; omit `grid` for unchanged behavior. Takes precedence over `select`.
+
+### Fixed — `extractTable` row-header alignment + repeated in-cell header labels
+- Data-row cells are now read as `th, td` (not `td` alone), so an accessible table whose first column is a `<th scope="row">` row-label (e.g. NAB's payment-history table) stays column-aligned with its header row instead of shifting every column left by one. Pure-`<th>` section rows (zero `<td>`) are still skipped as before.
+- A leading copy of a cell's own column header baked INTO the cell is stripped (responsive-label pattern: NAB emits `<div>Payment date</div><div>2 July 2026</div>`, so `.text()` collapses to `"Payment date2 July 2026"`). Guarded to an exact non-empty header prefix leaving a non-empty remainder, so a legitimate value is never truncated. Together these were why NAB scraped 90 rows but mapped 0.
+
+### Fixed — `parseNumber` "cents" unit word
+- `parseNumber('85 cents')` now returns `85` (previously `null` — `Number('85 cents')` is `NaN`). Only TOKENIZES the minor-unit word; the cents→dollars SCALING remains the caller's job via a domain `amount_unit` (unchanged, per the file's no-cents-conversion contract). Word-boundaried, so `'recent'` is untouched.
+
 ## 1.2.1 — 2026-07-23
 
 ### Fixed — republish of 1.2.0's `dist`

package/README.md

@@ -77,11 +77,14 @@ the first. `opts.dateGuard` drops date-looking headers from any key whose
 `type !== 'date'`. `opts.required` lists keys that must have at least one
 candidate for `map.ok` to be `true`.
 
-### `mapRows(table: { headers; rows }, map: ColumnMap, keywords: ColumnKeywords): MappedRow[]`
+### `mapRows(table: { headers; rows }, map: ColumnMap, keywords: ColumnKeywords, opts?: { dateFormats?: string[]; dateExtractLeading?: boolean }): MappedRow[]`
 
 Joins a `ColumnMap` back onto `table.rows`, producing one `MappedRow` per data
 row. Each matched key holds an array of `Cell`s (one per candidate header),
-each parsed according to that key's declared `type`.
+each parsed according to that key's declared `type`. `opts.dateFormats` and
+`opts.dateExtractLeading` are forwarded verbatim to `parseDate`'s `opts.formats`
+and `opts.extractLeading` for every date-typed cell; both default off, so
+omitting `opts` preserves the exact prior behaviour.
 
 ### `parseNumber(raw: string): number | null`
 
@@ -90,13 +93,21 @@ and `%`, then parses what remains as a number. Returns `null` when nothing
 parseable is left. Does **not** convert cents to dollars — domain scaling is
 the caller's job.
 
-### `parseDate(raw: string, opts?: { formats?: string[] }): string | null`
+### `parseDate(raw: string, opts?: { formats?: string[]; extractLeading?: boolean }): string | null`
 
 Parses a handful of common date text formats (ISO, `D Mon YYYY`, `Mon D,
 YYYY`, and `D/M/Y` slash dates) into an ISO `yyyy-mm-dd` string. Returns
 `null` — never a guess — for anything unrecognised or genuinely ambiguous
 (e.g. `05/03/2026` with no `opts.formats` hint and both components `<= 12`).
 
+`opts.extractLeading` (default off) accepts a date at the **start** of the cell
+even when trailing text follows it — `parseDate('25/06/2024 - special dividend',
+{ formats: ['DD/MM/YYYY'], extractLeading: true })` → `'2024-06-25'`. Only the
+leading date token is read; the trailing text is ignored, never parsed. Leading
+junk is still rejected (the date must be the first token) and the date itself is
+still matched exactly and disambiguated by the same rules — so the "never guess"
+contract holds. For real IR pages that staple a label onto a date cell.
+
 ### Types
 
 ```ts

package/dist/fetch/index.d.ts

@@ -7,4 +7,10 @@ export type { ScrapeTableOptions, TableResult } from './scrape.js';
 /** Clears all cached ProxyPools. For tests. */
 export declare function resetProxyPools(): void;
 export declare function fetchDocument(url: string, opts?: FetchOptions): Promise<FetchResult>;
+/**
+ * Fetch a PDF (or any binary document) as raw bytes, reusing fetchDocument's
+ * robots / rate-limit / retry / proxy machinery. On a 2xx, `result.bytes` holds
+ * the payload; binary responses are never cached.
+ */
+export declare function fetchPdf(url: string, opts?: FetchOptions): Promise<FetchResult>;
 //# sourceMappingURL=index.d.ts.map

package/dist/fetch/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fetch/index.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAOnE,+CAA+C;AAC/C,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AA0GD,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAiN9F"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/fetch/index.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE5D,OAAO,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAC9E,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAOnE,+CAA+C;AAC/C,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AA0GD,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAoN9F;AAED;;;;GAIG;AACH,wBAAsB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,YAAiB,GAAG,OAAO,CAAC,WAAW,CAAC,CAEzF"}

package/dist/fetch/index.js

@@ -251,14 +251,16 @@ export async function fetchDocument(url, opts = {}) {
             }
             // Terminal: 2xx/3xx, or a terminal 4xx not in retryOn. Returned as a
             // FetchResult (ok:false for 4xx) — never thrown.
-            const body = await res.text();
+            const isBinary = opts.binary === true;
+            const bytes = isBinary ? new Uint8Array(await res.arrayBuffer()) : undefined;
+            const body = isBinary ? '' : await res.text();
             const finalUrl = res.url || url;
             const responseHeaders = collectHeaders(res);
             const contentType = res.headers.get('content-type') ?? undefined;
             // [Phase 5] Only 2xx responses are cache-worthy — terminal 4xx/etc are
             // never stored. Written under the same pre-redirect `url`-derived key
             // used for the lookup in step 3.
-            if (res.ok && cfg.cache.enabled && cacheKey) {
+            if (res.ok && !isBinary && cfg.cache.enabled && cacheKey) {
                 await writeCache(cfg.cache, cacheKey, {
                     finalUrl,
                     status: res.status,
@@ -277,6 +279,7 @@ export async function fetchDocument(url, opts = {}) {
                 ok: res.ok,
                 headers: responseHeaders,
                 body,
+                bytes,
                 contentType,
                 fromCache: false,
                 attempts: attempt,
@@ -324,3 +327,11 @@ export async function fetchDocument(url, opts = {}) {
         ...(lastError !== undefined ? { cause: lastError } : {}),
     });
 }
+/**
+ * Fetch a PDF (or any binary document) as raw bytes, reusing fetchDocument's
+ * robots / rate-limit / retry / proxy machinery. On a 2xx, `result.bytes` holds
+ * the payload; binary responses are never cached.
+ */
+export async function fetchPdf(url, opts = {}) {
+    return fetchDocument(url, { ...opts, binary: true });
+}

package/dist/fetch/types.d.ts

@@ -37,6 +37,8 @@ export interface FetchOptions {
     };
     /** Test seam — passed through to safeFetch's `deps.fetchImpl`. */
     fetchImpl?: typeof fetch;
+    /** When true, read the response as raw bytes into `FetchResult.bytes` instead of text. Not cached. */
+    binary?: boolean;
 }
 export interface FetchResult {
     url: string;
@@ -51,5 +53,7 @@ export interface FetchResult {
     attempts: number;
     timingMs: number;
     usedProxy?: string;
+    /** Raw response bytes — populated only when the request was made with `binary: true`. */
+    bytes?: Uint8Array;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/fetch/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/fetch/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAKvD,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAElD,MAAM,WAAW,YAAY;IAC3B,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,SAAS,CAAC,EAAE;QACV,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CAC1B;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/fetch/types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAKvD,MAAM,MAAM,eAAe,GAAG,mBAAmB,CAAC;AAElD,MAAM,WAAW,YAAY;IAC3B,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE;QACN,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,SAAS,CAAC,EAAE;QACV,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,KAAK,CAAC,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,KAAK,CAAC,EAAE;QACN,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,MAAM,CAAC,EAAE;QACP,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,CAAC;IACF,kEAAkE;IAClE,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,sGAAsG;IACtG,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,yFAAyF;IACzF,KAAK,CAAC,EAAE,UAAU,CAAC;CACpB"}

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from './lib/index.js';
 export * from './fetch/index.js';
+export * from './pdf/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAQA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -7,3 +7,4 @@
 // client-safe, network-free entry (pure HTML parsing, no I/O).
 export * from './lib/index.js';
 export * from './fetch/index.js';
+export * from './pdf/index.js';

package/dist/parse/extract_table.d.ts

@@ -3,8 +3,36 @@ export type ExtractTableResult = {
     rows: string[][];
     warning?: string;
 };
+/**
+ * Div-grid mode selectors — for "tables" built from styled <div>s (CSS
+ * grid/flex) instead of a real <table>. A static HTML fetch sees these in
+ * the markup even when the page's data table proper is JS-rendered (e.g.
+ * CBA's `.complex-table`). All selectors are plain CSS.
+ */
+export type GridSelector = {
+    /**
+     * Element(s) that wrap one grid. When the selector matches MORE than one,
+     * the wrapper holding the most data rows wins — mirroring pickBestTable's
+     * "the real data grid is the biggest one" bias, so an upcoming-dividend
+     * teaser grid never shadows the full history grid. Omit to search the
+     * whole document.
+     */
+    container?: string;
+    /** Selector (searched under the container) matching every row — header and data alike. */
+    row: string;
+    /** Selector (searched under a row) matching each cell. */
+    cell: string;
+    /**
+     * Selector identifying the header row among the `row` matches. Rows that
+     * match it are treated as headers (never data); the first such row supplies
+     * the column headers. Omit to treat the first row as the header.
+     */
+    headerRow?: string;
+};
 export type ExtractTableOptions = {
     select?: string;
+    /** Read a <div>-based pseudo-table instead of a real <table>. Takes precedence over `select`. */
+    grid?: GridSelector;
 };
 export declare function extractTable(html: string, opts?: ExtractTableOptions): ExtractTableResult;
 //# sourceMappingURL=extract_table.d.ts.map

package/dist/parse/extract_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract_table.d.ts","sourceRoot":"","sources":["../../src/parse/extract_table.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAwGF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAyBzF"}
+{"version":3,"file":"extract_table.d.ts","sourceRoot":"","sources":["../../src/parse/extract_table.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,0FAA0F;IAC1F,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,IAAI,CAAC,EAAE,YAAY,CAAC;CACrB,CAAC;AAwLF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CA6BzF"}

package/dist/parse/extract_table.js

@@ -80,17 +80,96 @@ function readTable(tableSel) {
     const dataRowsSel = rows.slice(1);
     const dataRows = [];
     for (let i = 0; i < dataRowsSel.length; i++) {
-        const tds = dataRowsSel.eq(i).children('td');
-        if (tds.length === 0)
-            continue; // skip non-data rows (prototype behaviour)
+        const rowSel = dataRowsSel.eq(i);
+        // A genuine data row has at least one <td>; a pure-<th> row (a section
+        // divider spanning the table) is skipped — prototype behaviour. But the
+        // cells themselves are then read as `th, td`, not `td` alone, so a
+        // row-header cell (<th scope="row">, common in accessible IR tables
+        // whose first column labels the row) is kept and the row stays
+        // column-aligned with the header row (which is likewise read as th,td).
+        if (rowSel.children('td').length === 0)
+            continue;
+        const cellEls = rowSel.children('th, td');
         const cells = [];
-        for (let j = 0; j < tds.length; j++) {
-            cells.push(normalizeCell(tds.eq(j).text()));
+        for (let j = 0; j < cellEls.length; j++) {
+            let text = normalizeCell(cellEls.eq(j).text());
+            // Responsive-table pattern: some IR pages repeat the column header
+            // INSIDE each cell as a (visually-hidden on desktop) label, e.g. NAB's
+            // "<div>Payment date</div><div>2 July 2026</div>", whose .text()
+            // collapses to "Payment date2 July 2026". Strip a leading copy of this
+            // cell's own column header so downstream number/date parsing sees just
+            // the value. Guarded to an exact non-empty header prefix that leaves a
+            // non-empty remainder, so a legitimate value is never truncated.
+            const header = headers[j];
+            if (header != null && header !== '' && text.length > header.length && text.startsWith(header)) {
+                text = text.slice(header.length).trim();
+            }
+            cells.push(text);
         }
         dataRows.push(cells);
     }
     return { headers, rows: dataRows };
 }
+// Read one cell's normalized text list from a row selection, using a cell
+// sub-selector (div-grid mode — see GridSelector).
+function gridRowCells(rowSel, cellSelector) {
+    const cellEls = rowSel.find(cellSelector);
+    const cells = [];
+    for (let j = 0; j < cellEls.length; j++)
+        cells.push(normalizeCell(cellEls.eq(j).text()));
+    return cells;
+}
+// Read a single div-grid wrapper into the same {headers, rows} shape a real
+// <table> yields, so every downstream stage (mapColumns/mapRows) is oblivious
+// to which markup the data came from.
+function readGridContainer(container, grid) {
+    const allRows = container.find(grid.row);
+    if (allRows.length === 0)
+        return { headers: [], rows: [] };
+    let headers = [];
+    let firstRowIsHeader = false;
+    if (grid.headerRow != null) {
+        const headerRows = allRows.filter(grid.headerRow);
+        if (headerRows.length > 0)
+            headers = gridRowCells(headerRows.eq(0), grid.cell);
+    }
+    if (headers.length === 0) {
+        headers = gridRowCells(allRows.eq(0), grid.cell);
+        firstRowIsHeader = true;
+    }
+    const dataRows = [];
+    for (let i = 0; i < allRows.length; i++) {
+        const rowSel = allRows.eq(i);
+        if (grid.headerRow != null && rowSel.is(grid.headerRow))
+            continue; // never treat a header row as data
+        if (grid.headerRow == null && firstRowIsHeader && i === 0)
+            continue; // first row already consumed as header
+        const cells = gridRowCells(rowSel, grid.cell);
+        if (cells.length === 0)
+            continue;
+        dataRows.push(cells);
+    }
+    return { headers, rows: dataRows };
+}
+function readGrid($, grid) {
+    const containers = grid.container != null ? $(grid.container) : $.root();
+    if (grid.container != null && containers.length === 0) {
+        return { headers: [], rows: [], warning: `The selector "${grid.container}" matched no element on the page.` };
+    }
+    // When the container selector matches several grids, keep the one with the
+    // most data rows (same "the real data is the biggest grid" heuristic
+    // pickBestTable uses for real tables). Ties keep the first encountered.
+    let best = null;
+    for (let i = 0; i < containers.length; i++) {
+        const parsed = readGridContainer(containers.eq(i), grid);
+        if (best === null || parsed.rows.length > best.rows.length)
+            best = parsed;
+    }
+    if (best === null || (best.headers.length === 0 && best.rows.length === 0)) {
+        return { headers: [], rows: [], warning: NO_TABLE_WARNING };
+    }
+    return best;
+}
 function pickBestTable($) {
     const tables = $('table');
     let best = null;
@@ -111,6 +190,9 @@ function pickBestTable($) {
 }
 export function extractTable(html, opts) {
     const $ = load(html);
+    if (opts?.grid != null) {
+        return readGrid($, opts.grid);
+    }
     if (opts?.select != null) {
         const matched = $(opts.select);
         if (matched.length === 0) {

package/dist/parse/map_rows.d.ts

@@ -1,6 +1,7 @@
 import type { ColumnKeywords, ColumnMap, MappedRow } from './types.js';
 export interface MapRowsOptions {
     dateFormats?: string[];
+    dateExtractLeading?: boolean;
 }
 export declare function mapRows(table: {
     headers: string[];

package/dist/parse/map_rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map_rows.d.ts","sourceRoot":"","sources":["../../src/parse/map_rows.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAQ,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAaD,wBAAgB,OAAO,CACrB,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAA;CAAE,EAC9C,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,cAAc,GACpB,SAAS,EAAE,CAwBb"}
+{"version":3,"file":"map_rows.d.ts","sourceRoot":"","sources":["../../src/parse/map_rows.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAQ,cAAc,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAI7E,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IAMvB,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAmBD,wBAAgB,OAAO,CACrB,KAAK,EAAE;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAA;CAAE,EAC9C,GAAG,EAAE,SAAS,EACd,QAAQ,EAAE,cAAc,EACxB,IAAI,CAAC,EAAE,cAAc,GACpB,SAAS,EAAE,CAyBb"}

package/dist/parse/map_rows.js

@@ -26,17 +26,22 @@
 // the exact prior behavior — this is purely additive.
 import { parseNumber } from './parse_number.js';
 import { parseDate } from './parse_date.js';
-function cellValue(type, raw, dateFormats) {
+function cellValue(type, raw, dateFormats, dateExtractLeading) {
     if (type === 'number')
         return parseNumber(raw);
-    if (type === 'date')
-        return parseDate(raw, dateFormats ? { formats: dateFormats } : undefined);
+    if (type === 'date') {
+        return parseDate(raw, {
+            ...(dateFormats ? { formats: dateFormats } : {}),
+            ...(dateExtractLeading ? { extractLeading: true } : {}),
+        });
+    }
     const trimmed = raw.trim();
     return trimmed === '' ? null : trimmed;
 }
 export function mapRows(table, map, keywords, opts) {
     const keys = Object.keys(map.matched);
     const dateFormats = opts?.dateFormats;
+    const dateExtractLeading = opts?.dateExtractLeading;
     return table.rows.map((row) => {
         const mappedRow = {};
         for (const key of keys) {
@@ -48,7 +53,7 @@ export function mapRows(table, map, keywords, opts) {
                     header: candidate.header,
                     index: candidate.index,
                     raw,
-                    value: cellValue(type, raw, dateFormats),
+                    value: cellValue(type, raw, dateFormats, dateExtractLeading),
                 };
             });
         }

package/dist/parse/parse_date.d.ts

@@ -1,4 +1,5 @@
 export declare function parseDate(raw: string, opts?: {
     formats?: string[];
+    extractLeading?: boolean;
 }): string | null;
 //# sourceMappingURL=parse_date.d.ts.map

package/dist/parse/parse_date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse_date.d.ts","sourceRoot":"","sources":["../../src/parse/parse_date.ts"],"names":[],"mappings":"AA6EA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CAoCnF"}
+{"version":3,"file":"parse_date.d.ts","sourceRoot":"","sources":["../../src/parse/parse_date.ts"],"names":[],"mappings":"AAuFA,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,IAAI,CA4C7G"}

package/dist/parse/parse_date.js

@@ -8,6 +8,16 @@
 //     blindly assuming day-first. Slash dates are only resolved without a
 //     hint when one ordering is calendar-impossible (a component > 12), or
 //     when the caller supplies `opts.formats` to disambiguate.
+//
+// opts.extractLeading (added 2026-07-24): OFF by default. When true, a date
+// at the START of the cell is accepted even if trailing text follows it
+// (e.g. "25/06/2024 - special dividend" -> "2024-06-25"). Only the leading
+// date token is read; the trailing text is ignored, never parsed. Leading
+// junk is still rejected — the date must be the first token. This preserves
+// the "never guess" contract (the date itself is still matched exactly and
+// still disambiguated by the same rules) while tolerating real IR pages that
+// staple a label onto a date cell. Omitting it preserves exact prior
+// behaviour (a whole-string anchored match) — this is purely additive.
 const MONTHS = {
     jan: 1,
     feb: 2,
@@ -80,13 +90,20 @@ export function parseDate(raw, opts) {
     const s = String(raw).trim();
     if (s === '')
         return null;
+    // End-of-token anchor. Strict mode (default) anchors to end-of-string, so
+    // any trailing text fails the match. `extractLeading` relaxes that to "no
+    // further word char or slash follows the date" — enough to end the date
+    // token cleanly (a following space, hyphen-with-space, punctuation, or EOS)
+    // without letting a partial number ("2024" out of "20245") slip through.
+    const tail = opts?.extractLeading ? '(?![\\w/])' : '$';
+    const re = (body) => new RegExp(`^${body}${tail}`);
     // ISO: yyyy-mm-dd
-    let m = s.match(/^(\d{4})-(\d{2})-(\d{2})$/);
+    let m = s.match(re('(\\d{4})-(\\d{2})-(\\d{2})'));
     if (m) {
         return toIsoIfValid(Number(m[1]), Number(m[2]), Number(m[3]));
     }
     // "D Mon YYYY" / "D Month YYYY", e.g. "5 Mar 2026", "18 November 2025"
-    m = s.match(/^(\d{1,2})\s+([A-Za-z]{3,})\s+(\d{4})$/);
+    m = s.match(re('(\\d{1,2})\\s+([A-Za-z]{3,})\\s+(\\d{4})'));
     if (m) {
         const month = monthFromName(m[2]);
         if (month == null)
@@ -94,7 +111,7 @@ export function parseDate(raw, opts) {
         return toIsoIfValid(Number(m[3]), month, Number(m[1]));
     }
     // "Mon D, YYYY" / "Month D YYYY", comma optional, e.g. "Mar 5, 2026"
-    m = s.match(/^([A-Za-z]{3,})\s+(\d{1,2}),?\s+(\d{4})$/);
+    m = s.match(re('([A-Za-z]{3,})\\s+(\\d{1,2}),?\\s+(\\d{4})'));
     if (m) {
         const month = monthFromName(m[1]);
         if (month == null)
@@ -104,7 +121,7 @@ export function parseDate(raw, opts) {
     // Slash dates: D/M/Y or M/D/Y — ambiguous without a hint or a proof by
     // calendar impossibility (see resolveSlashDate). Two-digit years are
     // intentionally rejected: the year group below requires exactly 4 digits.
-    m = s.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+    m = s.match(re('(\\d{1,2})\\/(\\d{1,2})\\/(\\d{4})'));
     if (m) {
         return resolveSlashDate(Number(m[1]), Number(m[2]), Number(m[3]), opts?.formats);
     }

package/dist/parse/parse_number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse_number.d.ts","sourceRoot":"","sources":["../../src/parse/parse_number.ts"],"names":[],"mappings":"AAaA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAqBtD"}
+{"version":3,"file":"parse_number.d.ts","sourceRoot":"","sources":["../../src/parse/parse_number.ts"],"names":[],"mappings":"AAaA,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4BtD"}

package/dist/parse/parse_number.js

@@ -23,6 +23,12 @@ export function parseNumber(raw) {
     // Strip thousands separators and percent signs.
     s = s.replace(/,/g, '');
     s = s.replace(/%/g, '');
+    // Strip a trailing minor-unit word — some IR pages write an amount as
+    // "85 cents". This only TOKENIZES ("85 cents" -> "85"); the cents->dollars
+    // SCALING remains the caller's job via a domain amount_unit (see the file
+    // header's no-cents-conversion note). Word-boundaried so it never touches
+    // the digits or an unrelated word like "recent".
+    s = s.replace(/\bcents?\b/gi, '');
     s = s.trim();
     if (s === '')
         return null;

package/dist/pdf/extract_table_pdf.d.ts

@@ -0,0 +1,11 @@
+import type { ExtractTableResult } from '../parse/extract_table.js';
+export type ExtractTablePdfOptions = {
+    headerLabels?: string[];
+    headerRows?: number;
+    columnBands?: number[];
+    mergeContinuationRows?: boolean;
+    rowTolerance?: number;
+    maxPages?: number;
+};
+export declare function extractTableFromPdf(data: Uint8Array, opts?: ExtractTablePdfOptions): Promise<ExtractTableResult>;
+//# sourceMappingURL=extract_table_pdf.d.ts.map

package/dist/pdf/extract_table_pdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract_table_pdf.d.ts","sourceRoot":"","sources":["../../src/pdf/extract_table_pdf.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,MAAM,MAAM,sBAAsB,GAAG;IACnC,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AA4EF,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,UAAU,EAChB,IAAI,GAAE,sBAA2B,GAChC,OAAO,CAAC,kBAAkB,CAAC,CAwD7B"}

package/dist/pdf/extract_table_pdf.js

@@ -0,0 +1,141 @@
+// hazo_scrape/src/pdf/extract_table_pdf.ts — deterministic PDF text-layer → table.
+//
+// Reconstructs a {headers, rows} grid from a PDF's positioned text items by
+// clustering items into visual lines (by y) and columns (by x-band), mirroring
+// the ExtractTableResult shape of extract_table.ts so a caller's
+// mapColumns/mapRows pipeline consumes HTML and PDF tables identically.
+//
+// SERVER-ONLY: pulls in pdfjs-dist. Exported from the package root ('.'),
+// never from the client-safe './parse' entry.
+import { getDocument } from 'pdfjs-dist/legacy/build/pdf.mjs';
+/** Cluster items into visual lines by y within `tol`, ordered top→bottom. */
+function clusterLines(items, tol) {
+    const sorted = [...items].sort((a, b) => b.y - a.y);
+    const lines = [];
+    for (const it of sorted) {
+        const line = lines.find((l) => Math.abs(l.y - it.y) <= tol);
+        if (line)
+            line.items.push(it);
+        else
+            lines.push({ y: it.y, items: [it] });
+    }
+    return lines;
+}
+/** Auto-detect column left-edges by cutting the sorted x-starts at the widest gaps. */
+function detectBands(items) {
+    const xs = [...new Set(items.map((i) => Math.round(i.x)))].sort((a, b) => a - b);
+    if (xs.length === 0)
+        return [0];
+    const bands = [xs[0]];
+    for (let i = 1; i < xs.length; i++) {
+        if (xs[i] - xs[i - 1] > 25)
+            bands.push(xs[i]); // 25px gap = new column
+    }
+    return bands;
+}
+/** Assign x to the last band whose left-edge is <= x. */
+function bandIndex(bands, x) {
+    let idx = 0;
+    for (let i = 0; i < bands.length; i++)
+        if (x + 3 >= bands[i])
+            idx = i;
+    return idx;
+}
+// A word the PDF split across two text runs reports the second run beginning
+// (within GLUE_PX) exactly where the first ended, with NO whitespace at either
+// run's boundary — e.g. "Septemb"|"er". A real inter-word space renders a
+// visible gap (and/or a boundary space in the run text). GLUE_PX is the max
+// horizontal gap still considered "same word".
+const GLUE_PX = 1;
+/**
+ * Join a band's items (sorted by x) into one cell string. Consecutive items
+ * that are horizontally CONTIGUOUS and carry no whitespace at their shared
+ * boundary are glued with no space (they are pieces of one word split across
+ * text runs); otherwise a single space separates them. Without this, a
+ * mid-word split surfaces as "Septemb er 2020" and fails downstream date/number
+ * parsing.
+ */
+function joinCellItems(items) {
+    let out = '';
+    let prev = null;
+    for (const it of items) {
+        if (!it.str.trim())
+            continue;
+        if (prev != null) {
+            const contiguous = it.x - (prev.x + prev.w) < GLUE_PX;
+            const boundarySpace = /\s$/.test(prev.str) || /^\s/.test(it.str);
+            out += contiguous && !boundarySpace ? '' : ' ';
+        }
+        out += it.str.trim();
+        prev = it;
+    }
+    return out.replace(/\s+/g, ' ').trim();
+}
+/** Concatenate a line's items into one cell per band (items sorted by x). */
+function lineToCells(line, bands) {
+    const cells = bands.map(() => []);
+    for (const it of [...line.items].sort((a, b) => a.x - b.x)) {
+        if (!it.str.trim())
+            continue;
+        cells[bandIndex(bands, it.x)].push(it);
+    }
+    return cells.map(joinCellItems);
+}
+export async function extractTableFromPdf(data, opts = {}) {
+    const tol = opts.rowTolerance ?? 3;
+    const doc = await getDocument({ data, isEvalSupported: false, useSystemFonts: false }).promise;
+    const pageCount = opts.maxPages ? Math.min(doc.numPages, opts.maxPages) : doc.numPages;
+    const pages = [];
+    for (let p = 1; p <= pageCount; p++) {
+        const page = await doc.getPage(p);
+        const content = await page.getTextContent();
+        const items = [];
+        for (const it of content.items) {
+            if (typeof it.str !== 'string' || !it.str.trim())
+                continue;
+            items.push({ x: it.transform[4], y: it.transform[5], w: it.width ?? 0, str: it.str });
+        }
+        pages.push(items);
+    }
+    // Column geometry is page-independent, so detect bands from every item; but
+    // cluster visual lines PER PAGE. Text-item y-coordinates repeat page to page
+    // (row N sits at the same y on every page), so clustering the concatenation
+    // would merge each page's row N into a single garbled line. Page order is
+    // preserved, and a single-page document behaves exactly as before.
+    const bands = opts.columnBands ?? detectBands(pages.flat());
+    let grid = [];
+    for (const items of pages) {
+        for (const line of clusterLines(items, tol))
+            grid.push(lineToCells(line, bands));
+    }
+    // Continuation merge: a line whose leftmost cell is empty belongs to the row above.
+    if (opts.mergeContinuationRows) {
+        const merged = [];
+        for (const row of grid) {
+            if (merged.length > 0 && row[0].trim() === '') {
+                const prev = merged[merged.length - 1];
+                for (let i = 0; i < row.length; i++) {
+                    if (row[i].trim())
+                        prev[i] = [prev[i], row[i]].filter(Boolean).join(' ').trim();
+                }
+            }
+            else {
+                merged.push([...row]);
+            }
+        }
+        grid = merged;
+    }
+    let headers;
+    let rows;
+    if (opts.headerLabels) {
+        headers = opts.headerLabels;
+        rows = grid;
+    }
+    else {
+        const n = Math.max(1, opts.headerRows ?? 1);
+        const headerLines = grid.slice(0, n);
+        headers = bands.map((_, c) => headerLines.map((l) => l[c] ?? '').join(' ').replace(/\s+/g, ' ').trim());
+        rows = grid.slice(n);
+    }
+    return { headers, rows };
+}

package/dist/pdf/index.d.ts

@@ -0,0 +1,2 @@
+export * from './extract_table_pdf.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/pdf/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pdf/index.ts"],"names":[],"mappings":"AACA,cAAc,wBAAwB,CAAC"}

package/dist/pdf/index.js

@@ -0,0 +1,2 @@
+// hazo_scrape/src/pdf/index.ts — server-only PDF table extraction surface.
+export * from './extract_table_pdf.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_scrape",
-  "version": "1.2.1",
+  "version": "1.5.2",
   "description": "Generic source-agnostic web scraping engine with a network-free parse core.",
   "type": "module",
   "module": "./dist/index.js",
@@ -62,6 +62,7 @@
     "cheerio": "^1.2.0",
     "hazo_config": "^2.4.1",
     "hazo_secure": "^1.4.0",
+    "pdfjs-dist": "^4.10.38",
     "robots-parser": "^3.0.1",
     "undici": "^7.28.0"
   }