hazo_scrape 1.5.2 → 1.6.1

package/CHANGE_LOG.md

@@ -1,5 +1,47 @@
 # hazo_scrape — Change Log
 
+## 1.6.1 — 2026-07-29
+
+Four `extractTable` correctness fixes. Kept as a **separate version** rather than folded into the (unpublished) 1.6.0: three of the four regress behaviour that shipped in **1.3.0** and is live on npm, so they deserve their own visible `Fixed` entry attributable to a version consumers can upgrade *to*, instead of being buried inside 1.6.0's `Added` list.
+
+### Fixed — grid mode duplicated the header row when `headerRow` matched nothing
+- `extractTable(html, { grid: { …, headerRow } })` with a typo'd/stale `headerRow` selector emitted the header as **data row 0**. The fallback correctly re-read row 0 as the header, but the "skip row 0" guard was gated on `grid.headerRow == null`, so it could never fire once `headerRow` was supplied. A `headerRow` that matches nothing now degrades to exactly the same behaviour as omitting it.
+
+### Fixed — the repeated-in-cell-header strip truncated legitimate values
+- The responsive-label strip (1.3.0) only tested `text.startsWith(header)`, which butchered real values: header `2025` + cell `2025-06-30` → `-06-30` (then `parseDate` → `null`); header `Total` + cell `Total dividend` → `dividend`. The strip now requires a genuine **DOM-concatenation seam**, matching the pattern it exists for (`<div>Payment date</div><div>2 July 2026</div>` → `"Payment date2 July 2026"`):
+  - the header must **not** be followed by whitespace — whitespace means the cell reads as one natural phrase, not two glued nodes; and
+  - the remainder must not continue the header's own token — if the header ends in a digit and the remainder opens with a digit or a numeric joiner (`-` `/` `.` `:`), the "header" is really a prefix of one longer number/date.
+- Everything else (letter → digit, letter → letter with no space) is still stripped, so the NAB responsive case is unchanged.
+
+### Fixed — row-header alignment when the header row has NO corner cell
+- 1.3.0's `td` → `th, td` change fixed tables that pair a `<th scope="row">` row label with a corner cell in the header row, but broke the equally common **cornerless** variant: header `<th>Ex date</th><th>Amount</th>` with row `<th scope="row">FY25 Final</th><td>1 Jan 2026</td><td>45c</td>` shifted every column right by one (`Ex date` read as `"FY25 Final"`). Data rows are now reconciled against the header width: when a row is wider than the header and the excess is fully explained by leading `<th>` cells, exactly that many leading row-header cells are dropped. **Both** shapes now map correctly; a merely ragged row (extra `<td>`s, or a leading `<td>`) is untouched.
+
+### Fixed — combine mode leaked unrelated tables past a non-table sibling
+- `combine` documented "stopping at the first sibling that doesn't match", but the walk used `nextAll('table')`, which **filters out** non-table siblings rather than stopping at them — so an intervening `<h2>`/`<p>` never triggered the `break` and a later, unrelated same-width table was absorbed as data. The walk now visits every following sibling and breaks on the first that is not a `<table>` (as well as on the first width mismatch), matching the documented contract.
+
+### Docs
+- `README.md`'s `extractTable` entry documented only `opts.select`. It now documents `grid`, `combine`, `cellIgnoreSelectors`, precedence between the modes, and row-header reconciliation; `mapRows`/`parseDate` gained the `dateYearPivot`/`yearPivot` options added in 1.6.0.
+
+### Known remaining (out of scope, pre-existing)
+- `parseNumber('1.234,56')` (European locale) is misread — only comma-as-thousands is handled.
+- Accounting-style negatives (`(1.23)`) are not recognised as `-1.23`.
+- `extractTableFromPdf` keeps a multi-page PDF's per-page repeated header as data rows.
+
+## 1.6.0 — 2026-07-25
+
+### Added — `parseNumber` tokenizes a trailing bare cent marker
+- `parseNumber('45c')` → `45`, `parseNumber('14.5c')` → `14.5`, `parseNumber('45¢')` → `45`. This is the symbol/abbreviation form of the `cents` word already stripped (many AU/UK IR tables write `45c` rather than `45 cents`), so it is tokenized identically — the cents→dollars **scaling stays the caller's job** (via a domain `amount_unit`). Anchored to a digit immediately before the marker and to end-of-string, so it never touches a `c` inside a word (`recent`) or a mid-string letter. Surfaced by Woolworths (`45c`) and Harvey Norman (`14.5c`) dividend tables.
+
+### Added — `parseDate` optional 2-digit-year support (`opts.yearPivot`)
+- `parseDate('10 Mar 26', { yearPivot: 2000 })` → `2026-03-10`. 2-digit years remain **rejected by default** (returning `null`, true to the "never guess the century" contract); a caller that knows the source's convention opts in with `yearPivot`, the base of a sliding 100-year window (`2000` reads `26`→2026/`99`→2099; `1950` reads `26`→2026/`99`→1999). Applies to the named-month formats (`D Mon YY`, `Mon D, YY`); slash dates stay 4-digit-only (a 2-digit slash year compounds day/month AND century ambiguity). Surfaced by Coles, whose live table writes `10 Mar 26`.
+- `mapRows` gains `opts.dateYearPivot?: number`, forwarded verbatim to `parseDate` for every date-typed cell.
+
+### Added — `extractTable` `cellIgnoreSelectors` (strip in-cell noise)
+- `extractTable(html, { cellIgnoreSelectors: ['sup'] })` removes matching descendants from every cell (and header) **before** its text is read, so `100<sup>4</sup>` reads as `100`, not `1004`. Off by default (cells read verbatim). Applies to real-table, grid, and combine modes alike; the removal is done on a per-cell clone, never mutating the shared document. Surfaced by Wesfarmers, whose franking cells staple a footnote superscript onto the number.
+
+### Added — `extractTable` `combine` mode (header-only table + per-section sibling tables)
+- `extractTable(html, { combine: { headerSelector, dropLabelRows? } })` reconstructs one logical table from a header-only `<table>` followed by one `<table>` per section (e.g. per year), each led by a section-label row — a common Computershare-style IR layout. Headers come from `headerSelector`'s first row; data rows are gathered from that table plus its immediately-following sibling `<table>`s **that share its column count** (stopping at the first that doesn't, so an unrelated later table can't leak in). `dropLabelRows: true` drops bare section-divider rows (only the first cell non-empty). Takes precedence over `select`; `grid` still wins over it. Surfaced by JB Hi-Fi, whose dividend history is a header table plus one table per year.
+
 ## 1.5.2 — 2026-07-24
 
 ### Fixed — `extractTableFromPdf` mid-word text-run splits

package/README.md

@@ -61,13 +61,54 @@ console.log(rows[0].exDate[0].value); // "2026-03-05"
 
 ## API
 
-### `extractTable(html: string, opts?: { select?: string }): { headers: string[]; rows: string[][]; warning?: string }`
+### `extractTable(html, opts?): { headers: string[]; rows: string[][]; warning?: string }`
+
+```ts
+extractTable(html: string, opts?: {
+  select?: string;
+  grid?: { container?: string; row: string; cell: string; headerRow?: string };
+  combine?: { headerSelector: string; dropLabelRows?: boolean };
+  cellIgnoreSelectors?: string[];
+}): ExtractTableResult
+```
 
 Parses network-free HTML and returns the best-guess data table as raw header
-and row strings. Pass `opts.select` (a CSS selector) to target a specific
-`<table>` instead of letting the built-in scoring heuristic pick one. A
-`warning` is returned (never thrown) when no table-like element is found, or
-when `select` matches nothing.
+and row strings. With no options a scoring heuristic picks the most
+data-table-like `<table>` on the page. A `warning` is returned (never thrown)
+when no table-like element is found, or when a selector matches nothing.
+
+Precedence: `grid` > `combine` > `select`.
+
+- **`select`** — a CSS selector targeting a specific `<table>` instead of
+  letting the scoring heuristic choose.
+
+- **`grid`** — read a "table" built from styled `<div>`s (CSS grid/flex)
+  rather than a real `<table>`; common on IR pages whose real table is
+  JS-rendered. `row`/`cell` are required; `container` scopes the search (when
+  it matches several grids, the one with the most data rows wins); `headerRow`
+  identifies the header among the `row` matches (rows matching it are never
+  data). Omit `headerRow` — or give one that matches nothing — and the first
+  row is used as the header and excluded from the data.
+
+- **`combine`** — reconstruct one logical table from a header-only `<table>`
+  followed by one `<table>` per section (e.g. per year), a common
+  Computershare-style layout. Headers come from `headerSelector`'s first row;
+  data rows are gathered from that table plus each **immediately-following
+  sibling**, stopping at the first sibling that is not a `<table>` or whose
+  column count differs — so an unrelated later section can't leak in. Set
+  `dropLabelRows: true` to drop bare section-divider rows (only the first cell
+  non-empty, e.g. a lone `2025`).
+
+- **`cellIgnoreSelectors`** — CSS selectors whose matching descendants are
+  removed from every cell **and header** before its text is read, e.g.
+  `['sup']` so `100<sup>4</sup>` reads as `100`, not `1004`. Off by default
+  (cells are read verbatim); applies to all three modes; the removal happens
+  on a per-cell clone and never mutates the document.
+
+**Row-header columns.** Data cells are read as `th, td`, so an accessible
+table whose first column is a `<th scope="row">` label stays column-aligned.
+When the header row omits the matching corner cell, the leading row-header
+cell(s) are dropped so the row still lines up with the headers.
 
 ### `mapColumns(headers: string[], keywords: ColumnKeywords, opts?: { dateGuard?: boolean; required?: string[] }): ColumnMap`
 
@@ -77,14 +118,24 @@ 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, opts?: { dateFormats?: string[]; dateExtractLeading?: boolean }): MappedRow[]`
+### `mapRows(table, map, keywords, opts?): MappedRow[]`
+
+```ts
+mapRows(
+  table: { headers: string[]; rows: string[][] },
+  map: ColumnMap,
+  keywords: ColumnKeywords,
+  opts?: { dateFormats?: string[]; dateExtractLeading?: boolean; dateYearPivot?: number },
+): 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`. `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.
+each parsed according to that key's declared `type`. `opts.dateFormats`,
+`opts.dateExtractLeading` and `opts.dateYearPivot` are forwarded verbatim to
+`parseDate`'s `opts.formats`, `opts.extractLeading` and `opts.yearPivot` for
+every date-typed cell; all three default off, so omitting `opts` preserves the
+exact prior behaviour.
 
 ### `parseNumber(raw: string): number | null`
 
@@ -93,7 +144,7 @@ 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[]; extractLeading?: boolean }): string | null`
+### `parseDate(raw: string, opts?: { formats?: string[]; extractLeading?: boolean; yearPivot?: number }): 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
@@ -108,6 +159,13 @@ 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.
 
+`opts.yearPivot` (default off) enables 2-digit years, which are otherwise
+**rejected** (`null`) rather than guessed. It is the base of a sliding 100-year
+window: `parseDate('10 Mar 26', { yearPivot: 2000 })` → `'2026-03-10'`, while
+`yearPivot: 1950` reads `26`→2026 and `99`→1999. Applies to the named-month
+formats only (`D Mon YY`, `Mon D, YY`); slash dates stay 4-digit-only, since a
+2-digit slash year compounds day/month **and** century ambiguity.
+
 ### Types
 
 ```ts

package/dist/parse/extract_table.d.ts

@@ -25,14 +25,52 @@ export type GridSelector = {
     /**
      * 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.
+     * the column headers. Omit to treat the first row as the header — as does a
+     * selector that matches NOTHING (a typo'd/stale selector degrades to the
+     * omitted behaviour rather than emitting the header as data row 0).
      */
     headerRow?: string;
 };
+/**
+ * Combine-mode selector — for pages that split one logical table across
+ * several sibling <table>s: a header-only <table> followed by one <table>
+ * per section (e.g. per year), each led by a section-label row. Common on
+ * Computershare-style IR pages (e.g. JB Hi-Fi's dividend history). The header
+ * comes from `headerSelector`'s first row; data rows are gathered from that
+ * table plus its immediately-following sibling <table>s that share its column
+ * count. The walk stops at the first following sibling that is not a <table>
+ * (e.g. an <h2> introducing an unrelated section) or whose column count
+ * differs, so an unrelated later table can't leak in.
+ */
+export type CombineSelector = {
+    /** Selector matching the ONE table whose first row supplies the shared headers. */
+    headerSelector: string;
+    /**
+     * Drop "section-label" rows — a row in which only the first cell holds text
+     * and every other cell is empty (e.g. a bare "2025" year divider). Off by
+     * default. Column-mapping/parsing would already null such a row out, but
+     * dropping it keeps the raw row set clean and honest.
+     */
+    dropLabelRows?: boolean;
+};
 export type ExtractTableOptions = {
     select?: string;
     /** Read a <div>-based pseudo-table instead of a real <table>. Takes precedence over `select`. */
     grid?: GridSelector;
+    /**
+     * Combine a header-only table with its per-section sibling tables into one
+     * table (see CombineSelector). Takes precedence over `select`; `grid` still
+     * wins over this.
+     */
+    combine?: CombineSelector;
+    /**
+     * CSS selectors whose matching descendants are removed from every cell
+     * BEFORE its text is read — for stripping in-cell noise that corrupts
+     * parsing, e.g. `['sup']` to drop footnote-reference superscripts so
+     * "100<sup>4</sup>" reads as "100" not "1004". Applies to real-table, grid,
+     * and combine modes alike. Omit to read cells verbatim (the default).
+     */
+    cellIgnoreSelectors?: string[];
 };
 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;;;;;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"}
+{"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;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,mFAAmF;IACnF,cAAc,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iGAAiG;IACjG,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;CAChC,CAAC;AAkTF,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAkCzF"}

package/dist/parse/extract_table.js

@@ -25,6 +25,18 @@ const NO_TABLE_WARNING = 'No table-like element found on the page (it may be Jav
 function normalizeCell(raw) {
     return raw.replace(/\s+/g, ' ').trim();
 }
+// Read a cell's normalized text, optionally removing noise descendants
+// (`ignore`) first — e.g. footnote <sup>s — so they never reach the parsed
+// value. Clones the cell so the removal is local to this read and never
+// mutates the shared document (other cells / re-reads see the original).
+function readCellText(cellSel, ignore) {
+    if (ignore && ignore.length > 0) {
+        const clone = cellSel.clone();
+        clone.find(ignore.join(',')).remove();
+        return normalizeCell(clone.text());
+    }
+    return normalizeCell(cellSel.text());
+}
 // Rows that belong directly to THIS table — not to any table nested inside a
 // cell. `tr` may be a direct child of <table>, or a child of a direct
 // <thead>/<tbody>/<tfoot> child. Collecting via `.children()` at each level
@@ -68,19 +80,42 @@ function scoreTable(tableSel) {
     const consistencyRatio = numDataRows > 0 ? numConsistent / numDataRows : 0;
     return numHeaderCells * 2 + (hasTh ? 5 : 0) + numDataRows * 3 + consistencyRatio * 10;
 }
-function readTable(tableSel) {
-    const rows = tableRows(tableSel);
-    if (rows.length === 0)
-        return { headers: [], rows: [] };
-    const headerCells = rows.eq(0).children('th, td');
-    const headers = [];
-    for (let i = 0; i < headerCells.length; i++) {
-        headers.push(normalizeCell(headerCells.eq(i).text()));
-    }
-    const dataRowsSel = rows.slice(1);
+// Decide whether a leading copy of `header` inside `text` is a REPEATED DOM
+// LABEL (which must be stripped) or genuinely part of the value (which must
+// not). The responsive-table pattern that motivates the strip glues two sibling
+// nodes together with no separator — `<div>Payment date</div><div>2 July
+// 2026</div>` reads as `"Payment date2 July 2026"` — so the seam is the tell:
+//
+//   1. Whitespace after the header => prose, one natural phrase, not a seam.
+//      Header "Total" + "Total dividend" is a value that happens to start with
+//      the header word; stripping it would leave the bare word "dividend".
+//   2. The remainder must not continue the header's OWN token. If the header
+//      ends in a digit and the remainder opens with a digit or a numeric
+//      joiner (`-`, `/`, `.`, `:`), the "header" is really a prefix of one
+//      longer number/date — header "2025" + "2025-06-30" would be butchered
+//      into "-06-30".
+//
+// Everything else (letter -> digit, letter -> letter with no space) is the
+// concatenation signature the strip exists for and is stripped as before.
+function isRepeatedHeaderLabel(text, header) {
+    if (header === '' || text.length <= header.length || !text.startsWith(header))
+        return false;
+    const rest = text.slice(header.length);
+    if (/^\s/.test(rest))
+        return false; // (1) prose, not a DOM seam
+    const headerEndsDigit = /\d$/.test(header);
+    if (headerEndsDigit && /^[\d\-/.:]/.test(rest))
+        return false; // (2) same token cut in half
+    return rest.trim() !== '';
+}
+// Read the data rows (everything after the header row) of one real <table>,
+// aligning each cell against `headers` (for the repeated-in-cell-label strip)
+// and removing `ignore` descendants first. Shared by readTable and combine
+// mode so both handle ragged/label/responsive rows identically.
+function readTableDataRows(rows, headers, ignore, startIndex) {
     const dataRows = [];
-    for (let i = 0; i < dataRowsSel.length; i++) {
-        const rowSel = dataRowsSel.eq(i);
+    for (let i = startIndex; i < rows.length; i++) {
+        const rowSel = rows.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
@@ -90,39 +125,121 @@ function readTable(tableSel) {
         if (rowSel.children('td').length === 0)
             continue;
         const cellEls = rowSel.children('th, td');
+        // Row-header reconciliation. Two real shapes exist:
+        //   (a) the header row carries a (usually blank) CORNER cell for the
+        //       row-label column — widths already agree, keep every cell;
+        //   (b) the header row OMITS it — the row is then wider than the header
+        //       and reading the <th> would shift every column right by one.
+        // Detect (b) by an excess that is fully explained by leading <th> cells,
+        // and drop exactly that many. A row that is merely ragged (excess <td>s,
+        // or a leading <td>) is untouched.
+        let offset = 0;
+        if (headers.length > 0 && cellEls.length > headers.length) {
+            let leadingTh = 0;
+            while (leadingTh < cellEls.length && cellEls.eq(leadingTh).is('th'))
+                leadingTh += 1;
+            const excess = cellEls.length - headers.length;
+            if (excess <= leadingTh)
+                offset = excess;
+        }
         const cells = [];
-        for (let j = 0; j < cellEls.length; j++) {
-            let text = normalizeCell(cellEls.eq(j).text());
+        for (let j = offset; j < cellEls.length; j++) {
+            let text = readCellText(cellEls.eq(j), ignore);
             // 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)) {
+            // the value — but only at a genuine DOM seam (see
+            // isRepeatedHeaderLabel), so a legitimate value is never truncated.
+            const header = headers[j - offset];
+            if (header != null && isRepeatedHeaderLabel(text, header)) {
                 text = text.slice(header.length).trim();
             }
             cells.push(text);
         }
         dataRows.push(cells);
     }
-    return { headers, rows: dataRows };
+    return dataRows;
+}
+function readTable(tableSel, ignore) {
+    const rows = tableRows(tableSel);
+    if (rows.length === 0)
+        return { headers: [], rows: [] };
+    const headerCells = rows.eq(0).children('th, td');
+    const headers = [];
+    for (let i = 0; i < headerCells.length; i++) {
+        headers.push(readCellText(headerCells.eq(i), ignore));
+    }
+    return { headers, rows: readTableDataRows(rows, headers, ignore, 1) };
+}
+// True when a row is a "section-label" row: exactly one non-empty cell, and
+// it's the first — e.g. a bare "2025" year divider between per-year tables.
+function isLabelRow(cells) {
+    if (cells.length === 0 || cells[0].trim() === '')
+        return false;
+    for (let i = 1; i < cells.length; i++) {
+        if (cells[i].trim() !== '')
+            return false;
+    }
+    return true;
+}
+// Combine mode — a header-only table plus its per-section sibling tables.
+function readCombined($, combine, ignore) {
+    const headerTable = $(combine.headerSelector).first();
+    if (headerTable.length === 0) {
+        return { headers: [], rows: [], warning: `The selector "${combine.headerSelector}" matched no element on the page.` };
+    }
+    const headerRows = tableRows(headerTable);
+    if (headerRows.length === 0)
+        return { headers: [], rows: [], warning: NO_TABLE_WARNING };
+    const headerCells = headerRows.eq(0).children('th, td');
+    const headers = [];
+    for (let i = 0; i < headerCells.length; i++)
+        headers.push(readCellText(headerCells.eq(i), ignore));
+    const allRows = [];
+    // Any data rows in the header table itself (a header-only table has none).
+    allRows.push(...readTableDataRows(headerRows, headers, ignore, 1));
+    // Following-sibling tables that share the header's column count; stop at the
+    // first sibling that doesn't (or a non-table sibling) so an unrelated later
+    // table with a coincidentally-equal width can't leak in.
+    // Walk EVERY following sibling, not just the <table> ones: filtering to
+    // tables first would silently skip over an intervening <h2>/<p>, so the
+    // documented "stop at the first sibling that doesn't match" could never fire
+    // and an unrelated later section's table could leak in.
+    const siblings = headerTable.nextAll();
+    for (let i = 0; i < siblings.length; i++) {
+        const sib = siblings.eq(i);
+        if (!sib.is('table'))
+            break;
+        const sibRows = tableRows(sib);
+        if (sibRows.length === 0)
+            break;
+        const firstRowCols = sibRows.eq(0).children('th, td').length;
+        if (firstRowCols !== headers.length)
+            break;
+        // Every row of a section table is data here (its first row is a section
+        // label, NOT a repeated header) — read from index 0.
+        allRows.push(...readTableDataRows(sibRows, headers, ignore, 0));
+    }
+    const rows = combine.dropLabelRows ? allRows.filter((cells) => !isLabelRow(cells)) : allRows;
+    if (headers.length === 0 && rows.length === 0)
+        return { headers, rows, warning: NO_TABLE_WARNING };
+    return { headers, rows };
 }
 // 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) {
+function gridRowCells(rowSel, cellSelector, ignore) {
     const cellEls = rowSel.find(cellSelector);
     const cells = [];
     for (let j = 0; j < cellEls.length; j++)
-        cells.push(normalizeCell(cellEls.eq(j).text()));
+        cells.push(readCellText(cellEls.eq(j), ignore));
     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) {
+function readGridContainer(container, grid, ignore) {
     const allRows = container.find(grid.row);
     if (allRows.length === 0)
         return { headers: [], rows: [] };
@@ -131,10 +248,10 @@ function readGridContainer(container, grid) {
     if (grid.headerRow != null) {
         const headerRows = allRows.filter(grid.headerRow);
         if (headerRows.length > 0)
-            headers = gridRowCells(headerRows.eq(0), grid.cell);
+            headers = gridRowCells(headerRows.eq(0), grid.cell, ignore);
     }
     if (headers.length === 0) {
-        headers = gridRowCells(allRows.eq(0), grid.cell);
+        headers = gridRowCells(allRows.eq(0), grid.cell, ignore);
         firstRowIsHeader = true;
     }
     const dataRows = [];
@@ -142,16 +259,20 @@ function readGridContainer(container, grid) {
         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);
+        // First row already consumed as header — either because no headerRow
+        // selector was given, OR because one was given and matched nothing (a
+        // typo'd/stale selector must degrade to "first row is the header", never
+        // silently emit the header as data row 0).
+        if (firstRowIsHeader && i === 0)
+            continue;
+        const cells = gridRowCells(rowSel, grid.cell, ignore);
         if (cells.length === 0)
             continue;
         dataRows.push(cells);
     }
     return { headers, rows: dataRows };
 }
-function readGrid($, grid) {
+function readGrid($, grid, ignore) {
     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.` };
@@ -161,7 +282,7 @@ function readGrid($, grid) {
     // 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);
+        const parsed = readGridContainer(containers.eq(i), grid, ignore);
         if (best === null || parsed.rows.length > best.rows.length)
             best = parsed;
     }
@@ -190,8 +311,12 @@ function pickBestTable($) {
 }
 export function extractTable(html, opts) {
     const $ = load(html);
+    const ignore = opts?.cellIgnoreSelectors;
     if (opts?.grid != null) {
-        return readGrid($, opts.grid);
+        return readGrid($, opts.grid, ignore);
+    }
+    if (opts?.combine != null) {
+        return readCombined($, opts.combine, ignore);
     }
     if (opts?.select != null) {
         const matched = $(opts.select);
@@ -202,7 +327,7 @@ export function extractTable(html, opts) {
                 warning: `The selector "${opts.select}" matched no element on the page.`,
             };
         }
-        const { headers, rows } = readTable(matched.eq(0));
+        const { headers, rows } = readTable(matched.eq(0), ignore);
         if (headers.length === 0 && rows.length === 0) {
             return { headers, rows, warning: NO_TABLE_WARNING };
         }
@@ -212,5 +337,5 @@ export function extractTable(html, opts) {
     if (best === null) {
         return { headers: [], rows: [], warning: NO_TABLE_WARNING };
     }
-    return readTable(best);
+    return readTable(best, ignore);
 }

package/dist/parse/map_rows.d.ts

@@ -2,6 +2,7 @@ import type { ColumnKeywords, ColumnMap, MappedRow } from './types.js';
 export interface MapRowsOptions {
     dateFormats?: string[];
     dateExtractLeading?: boolean;
+    dateYearPivot?: number;
 }
 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;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"}
+{"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;IAM7B,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAqBD,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,CA0Bb"}

package/dist/parse/map_rows.js

@@ -26,13 +26,14 @@
 // 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, dateExtractLeading) {
+function cellValue(type, raw, dateFormats, dateExtractLeading, dateYearPivot) {
     if (type === 'number')
         return parseNumber(raw);
     if (type === 'date') {
         return parseDate(raw, {
             ...(dateFormats ? { formats: dateFormats } : {}),
             ...(dateExtractLeading ? { extractLeading: true } : {}),
+            ...(dateYearPivot != null ? { yearPivot: dateYearPivot } : {}),
         });
     }
     const trimmed = raw.trim();
@@ -42,6 +43,7 @@ export function mapRows(table, map, keywords, opts) {
     const keys = Object.keys(map.matched);
     const dateFormats = opts?.dateFormats;
     const dateExtractLeading = opts?.dateExtractLeading;
+    const dateYearPivot = opts?.dateYearPivot;
     return table.rows.map((row) => {
         const mappedRow = {};
         for (const key of keys) {
@@ -53,7 +55,7 @@ export function mapRows(table, map, keywords, opts) {
                     header: candidate.header,
                     index: candidate.index,
                     raw,
-                    value: cellValue(type, raw, dateFormats, dateExtractLeading),
+                    value: cellValue(type, raw, dateFormats, dateExtractLeading, dateYearPivot),
                 };
             });
         }

package/dist/parse/parse_date.d.ts

@@ -1,5 +1,6 @@
 export declare function parseDate(raw: string, opts?: {
     formats?: string[];
     extractLeading?: boolean;
+    yearPivot?: number;
 }): 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":"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"}
+{"version":3,"file":"parse_date.d.ts","sourceRoot":"","sources":["../../src/parse/parse_date.ts"],"names":[],"mappings":"AA6GA,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1E,MAAM,GAAG,IAAI,CAoDf"}

package/dist/parse/parse_date.js

@@ -57,6 +57,29 @@ function monthFromName(name) {
     const key = name.toLowerCase().slice(0, 3);
     return MONTHS[key] ?? null;
 }
+/**
+ * Resolve a year token that may be 2- or 4-digit into a full year.
+ *
+ * 4-digit years are returned as-is. A 2-digit year is a GUESS (which century?)
+ * — so, true to the engine's "never guess" contract, it is only accepted when
+ * the caller opts in with `yearPivot`, and returns null otherwise. When opted
+ * in, `yearPivot` is the base of a sliding 100-year window: the 2-digit value
+ * maps to the single year in `[yearPivot, yearPivot + 99]`. E.g. `yearPivot:
+ * 2000` reads "26" -> 2026 and "99" -> 2099; `yearPivot: 1950` reads "26" ->
+ * 2026 and "99" -> 1999. A 3-digit token is treated as a literal year (padded
+ * on output), matching prior 4-digit-only strictness closely enough for the
+ * rare case.
+ */
+function resolveYear(raw, yearPivot) {
+    if (raw.length >= 3)
+        return Number(raw);
+    if (yearPivot == null)
+        return null; // 2-digit year without opt-in — never guess
+    const yy = Number(raw);
+    const base = yearPivot - (yearPivot % 100);
+    const candidate = base + yy;
+    return candidate < yearPivot ? candidate + 100 : candidate;
+}
 function pickSlashHint(formats) {
     if (!formats)
         return undefined;
@@ -90,6 +113,7 @@ export function parseDate(raw, opts) {
     const s = String(raw).trim();
     if (s === '')
         return null;
+    const yearPivot = opts?.yearPivot;
     // 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
@@ -97,26 +121,34 @@ export function parseDate(raw, opts) {
     // 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
+    // ISO: yyyy-mm-dd (always 4-digit year — never abbreviated in ISO form).
     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(re('(\\d{1,2})\\s+([A-Za-z]{3,})\\s+(\\d{4})'));
+    // "D Mon YYYY" / "D Month YYYY", e.g. "5 Mar 2026", "18 November 2025".
+    // The year is 2–4 digits; a 2-digit year resolves only under `yearPivot`
+    // (see resolveYear), otherwise it stays null — preserving strict default.
+    m = s.match(re('(\\d{1,2})\\s+([A-Za-z]{3,})\\s+(\\d{2,4})'));
     if (m) {
         const month = monthFromName(m[2]);
         if (month == null)
             return null;
-        return toIsoIfValid(Number(m[3]), month, Number(m[1]));
+        const year = resolveYear(m[3], yearPivot);
+        if (year == null)
+            return null;
+        return toIsoIfValid(year, month, Number(m[1]));
     }
     // "Mon D, YYYY" / "Month D YYYY", comma optional, e.g. "Mar 5, 2026"
-    m = s.match(re('([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{2,4})'));
     if (m) {
         const month = monthFromName(m[1]);
         if (month == null)
             return null;
-        return toIsoIfValid(Number(m[3]), month, Number(m[2]));
+        const year = resolveYear(m[3], yearPivot);
+        if (year == null)
+            return null;
+        return toIsoIfValid(year, month, Number(m[2]));
     }
     // 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

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,CA4BtD"}
+{"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,CA8CtD"}

package/dist/parse/parse_number.js

@@ -29,6 +29,22 @@ export function parseNumber(raw) {
     // 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, '');
+    // Strip a trailing per-unit annotation — "$2.05/share", "1.2/unit". The
+    // slash-plus-word denominator states the amount's unit basis (per share, per
+    // security); it's not part of the number. Letters required after the slash,
+    // so a bare fraction like "3/4" is left untouched (and then fails to parse,
+    // as before). Runs before the bare-cent strip so "2c/share"-style oddities
+    // reduce cleanly.
+    s = s.replace(/\/[A-Za-z]+\.?$/, '');
+    s = s.trim();
+    // Strip a trailing bare cent marker — "45c" / "14.5 c" / "45¢". This is the
+    // symbol/abbreviation form of the "cents" word stripped above (many AU/UK IR
+    // tables write "45c" rather than "45 cents"), so it's tokenized the same way:
+    // the SCALING to dollars stays the caller's job (amount_unit). Anchored to a
+    // digit immediately before it and to end-of-string, so it only ever removes a
+    // genuine trailing unit — never a 'c' inside a word ("recent" ends in 't', and
+    // "abc" has no leading digit) and never a mid-string letter.
+    s = s.replace(/(\d)\s*[c¢]$/i, '$1');
     s = s.trim();
     if (s === '')
         return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hazo_scrape",
-  "version": "1.5.2",
+  "version": "1.6.1",
   "description": "Generic source-agnostic web scraping engine with a network-free parse core.",
   "type": "module",
   "module": "./dist/index.js",
@@ -35,7 +35,7 @@
     "build:test-app": "npm run build && cd test-app && npm run build"
   },
   "peerDependencies": {
-    "hazo_core": "^1.0.1",
+    "hazo_core": "^1.3.0",
     "react": "^18.0.0 || ^19.0.0",
     "react-dom": "^18.0.0 || ^19.0.0"
   },