@toolpath/tool-scraper 0.1.0 → 2.1.0

package/dist/vendors/emuge/value.js

@@ -0,0 +1,116 @@
+/**
+ * One EMUGE-FRANKEN property — its label and its value — read.
+ *
+ * The API answers every measurement as a `{ property, value }` pair of display
+ * strings, and both halves need work before they can be a CSV column and a
+ * number:
+ *
+ * ```json
+ * { "property": "cutting diameter Ød₁ [inch]", "value": "1 1/2 \"" }
+ * { "property": "overall length l₁",           "value": "38 mm" }
+ * { "property": "point angle",                 "value": "140 deg" }
+ * ```
+ *
+ * ## The unit is in the value; the label's tag is unreliable
+ *
+ * `cutting length l₂ [mm]` carries a unit tag and `overall length l₁` and
+ * `neck diameter Ød₃` do not, on the same part, in the same response. So a
+ * label's tag is stripped for the column name — the CSV states the unit once,
+ * in `conventions.UNIT_SUFFIX`'s suffix, and a label that carried `[mm]` as
+ * well would state it twice — and the reading of the unit comes from the value,
+ * which states one on every measurement seen.
+ *
+ * A stated unit that disagrees with the family's is converted and warned about
+ * rather than refused: the value is right and the column's suffix is right, so
+ * dropping the row would lose a part somebody can order. That call is not made
+ * here — it is `measure.asLength`'s, which is the one place every vendor makes
+ * it. What this module owns is the grammar below and nothing else.
+ *
+ * ## What is deliberately not read
+ *
+ * **A range.** `helix angle` is `35-38 deg` and `clamping diameter ØD₁` is
+ * `2 - 10 mm`; `measure.fractionValue` would read the first as `73`, because
+ * its mixed-number form is `1-1/2` and `35-38` fits it with the denominator
+ * absent. {@link NUMBER} admits no hyphenated form at all — EMUGE writes a
+ * mixed number space-separated, `1 1/2` — so a range has no reading here, and
+ * the columns those two land in are unmapped receipt columns anyway.
+ *
+ * **A tolerance.** `<=0,003 mm`, `± 0,0008 "`. These carry a German decimal
+ * comma where every dimensional value uses a dot, and they lead with a
+ * comparator. Guessing at what a comma means in a number this package is about
+ * to publish is exactly the kind of quiet wrong answer `measure.ts` refuses to
+ * make; they get no reading and stay in the CSV as the vendor's own text.
+ */
+import { asCount, asLength, fractionValue } from '../../measure.js';
+import { consoleWarn } from '../../scrape.js';
+/** A label's trailing unit tag: `[mm]`, `[inch]`, `[in]`. */
+const LABEL_UNIT = /\s*\[(?:mm|in|inch)\]\s*$/i;
+/**
+ * A decimal, a simple fraction, or a mixed number written with a **space**,
+ * followed by the unit the value states.
+ *
+ * Ordered longest-first, because `\d*\.?\d+` alone matches the `1` of `1 1/2`
+ * and would leave the rest unread — a 1.5 inch tool published as a 1 inch one.
+ *
+ * No hyphenated mixed number: see the module docstring. `"` is EMUGE's inch
+ * mark and `deg` its degree word; both are written with a leading space in
+ * every value seen, and the `\s*` tolerates one that is not.
+ */
+const NUMBER = /^(\d+\s+\d+\/\d+|\d*\.?\d+\/\d+|\d*\.?\d+)\s*(mm|"|deg)?$/;
+const NOTHING = { value: null, stated: null };
+const UNITS = {
+    mm: 'millimeters',
+    '"': 'inches',
+    deg: 'degrees',
+};
+/**
+ * A property label with its unit tag removed — the CSV's bare label.
+ *
+ * `'cutting diameter Ød₁ [inch]'` -> `'cutting diameter Ød₁'`. Everything else
+ * about the label is left exactly as the vendor wrote it, subscripts and `Ø`
+ * included: the CSV is the receipt, and the tag is the one part of it that the
+ * column's own `_mm`/`_in` suffix already says.
+ */
+export function bareLabel(property) {
+    return property.replace(LABEL_UNIT, '').trim();
+}
+/**
+ * One value string -> its number and the unit it states.
+ *
+ * `''`, a range, a tolerance and any other text come back stating nothing —
+ * there is no number there and 0 is not a substitute for one.
+ */
+export function parseMeasure(display) {
+    const text = display.trim();
+    if (text === '')
+        return NOTHING;
+    const matched = NUMBER.exec(text);
+    if (matched === null)
+        return NOTHING;
+    // A space-separated mixed number is the one shape `fractionValue` does not
+    // take: its own form is `1-1/2`. Normalising here rather than widening the
+    // core reader keeps the hyphen shape — and the `35-38` range that shape would
+    // swallow — out of this vendor entirely.
+    const value = fractionValue(matched[1].replace(/\s+/, '-'));
+    if (value === null)
+        return NOTHING;
+    const unit = matched[2];
+    return { value, stated: unit === undefined ? null : UNITS[unit] };
+}
+/**
+ * One value as a length in `unit`, or null where it publishes none.
+ *
+ * `measure.asLength` makes both calls — convert-and-warn a value whose stated
+ * unit disagrees with the family's, refuse an angle in a length column —
+ * because they are the same two calls for every vendor. They were a verbatim
+ * copy of `vendors/harvey/value.ts`'s, warnings included, until 2026-09-01.
+ * What is EMUGE's is above: the grammar, and that the unit is read out of the
+ * value rather than off the label.
+ */
+export function measureIn(display, unit, what, warn = consoleWarn) {
+    return asLength(parseMeasure(display), display, unit, what, warn);
+}
+/** One value as a whole count — a flute number. Null where there is none. */
+export function wholeCount(display) {
+    return asCount(parseMeasure(display));
+}

package/dist/vendors/harvey/catalog.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The category tree -> the product pages under it.
+ *
+ * Harvey publishes no sitemap and no flat index: `robots.txt`, `sitemap.xml` and
+ * `sitemap_index.xml` all 404, and `/products/all-products` lists the seven top
+ * categories and no products. Walking the catalog grid is the only way to find
+ * out what exists — see `docs/HARVEY_PRODUCT_TABLE.md` §1.1 and §1.6.
+ *
+ * Nothing in a scrape needs this: `families/harvey.ts` names all 52 product
+ * pages, and a family scrape fetches exactly one. It is here for the maintenance
+ * question that table cannot answer — *has Harvey added a page?* — and the CLI
+ * exposes it as `harvey --catalog` for that purpose.
+ *
+ * A page carries subcategory links or product links, never both, so the
+ * recursion terminates where products appear. Both selectors were verified
+ * against all 33 category pages the four roots reach.
+ */
+import type { Fetcher } from '../../fetch.js';
+import { type Warn } from '../../scrape.js';
+/**
+ * The four category trees this adapter covers.
+ *
+ * Harvey's catalog is far larger; these are the trees asked for, and adding one
+ * is a decision rather than a widening of a pattern — see the package's rule on
+ * not adding vendor scope without being asked.
+ */
+export declare const CATEGORY_ROOTS: readonly string[];
+/** What one catalog page links to. */
+export interface CategoryLinks {
+    subcategories: string[];
+    products: string[];
+}
+/**
+ * The subcategory and product links on one catalog page.
+ *
+ * Product links are identified by their **wrapper** rather than by the anchor,
+ * because the anchor carries no class of its own — the grid renders
+ * `<div class="col-md-4 col-12 item-wrapper"><a href="/products/...">`. A rule
+ * that took every `/products/` anchor on the page would take the breadcrumb and
+ * the footer with it.
+ */
+export declare function parseCategoryPage(html: string): CategoryLinks;
+/**
+ * Every product page reachable from `roots`, sorted.
+ *
+ * Sequential and paced by the package's shared politeness delay. The whole walk
+ * is about 33 requests; nothing here needs concurrency, and Cloudflare fronts
+ * this site, so raising request volume is the only real risk.
+ */
+export declare function discoverProducts(fetcher: Fetcher, roots?: readonly string[], options?: {
+    warn?: Warn;
+    delayMs?: number;
+}): Promise<string[]>;

package/dist/vendors/harvey/catalog.js

@@ -0,0 +1,120 @@
+/**
+ * The category tree -> the product pages under it.
+ *
+ * Harvey publishes no sitemap and no flat index: `robots.txt`, `sitemap.xml` and
+ * `sitemap_index.xml` all 404, and `/products/all-products` lists the seven top
+ * categories and no products. Walking the catalog grid is the only way to find
+ * out what exists — see `docs/HARVEY_PRODUCT_TABLE.md` §1.1 and §1.6.
+ *
+ * Nothing in a scrape needs this: `families/harvey.ts` names all 52 product
+ * pages, and a family scrape fetches exactly one. It is here for the maintenance
+ * question that table cannot answer — *has Harvey added a page?* — and the CLI
+ * exposes it as `harvey --catalog` for that purpose.
+ *
+ * A page carries subcategory links or product links, never both, so the
+ * recursion terminates where products appear. Both selectors were verified
+ * against all 33 category pages the four roots reach.
+ */
+import { Parser } from 'htmlparser2';
+import { compare } from '../../order.js';
+import { consoleWarn, pause, REQUEST_DELAY_MS } from '../../scrape.js';
+import { BASE } from './scrape.js';
+/**
+ * The four category trees this adapter covers.
+ *
+ * Harvey's catalog is far larger; these are the trees asked for, and adding one
+ * is a decision rather than a widening of a pattern — see the package's rule on
+ * not adding vendor scope without being asked.
+ */
+export const CATEGORY_ROOTS = [
+    '/products/miniature-end-mills/ball',
+    '/products/miniature-end-mills/corner-radius',
+    '/products/miniature-end-mills/square',
+    '/products/specialty-profiles/keyseat-cutters',
+];
+/** The class marking a link to a subcategory in the catalog grid. */
+const SUBCATEGORY_CLASS = 'img-wrapper';
+/** The classes marking the wrapper around a link to one product. */
+const PRODUCT_CLASSES = ['col-md-4', 'col-12', 'item-wrapper'];
+function classes(attribs) {
+    return (attribs['class'] ?? '').split(/\s+/).filter(Boolean);
+}
+/**
+ * The subcategory and product links on one catalog page.
+ *
+ * Product links are identified by their **wrapper** rather than by the anchor,
+ * because the anchor carries no class of its own — the grid renders
+ * `<div class="col-md-4 col-12 item-wrapper"><a href="/products/...">`. A rule
+ * that took every `/products/` anchor on the page would take the breadcrumb and
+ * the footer with it.
+ */
+export function parseCategoryPage(html) {
+    const subcategories = new Set();
+    const products = new Set();
+    // A depth counter rather than a flag, because the wrapper holds nested divs
+    // and a flag would clear on the first inner close tag.
+    let inProduct = 0;
+    const parser = new Parser({
+        onopentag: (tag, attribs) => {
+            if (inProduct > 0) {
+                inProduct++;
+                if (tag === 'a') {
+                    const href = attribs['href'] ?? '';
+                    if (href.startsWith('/products/'))
+                        products.add(href);
+                }
+                return;
+            }
+            if (tag === 'div' && PRODUCT_CLASSES.every((c) => classes(attribs).includes(c))) {
+                inProduct = 1;
+                return;
+            }
+            if (tag === 'a' && classes(attribs).includes(SUBCATEGORY_CLASS)) {
+                const href = attribs['href'] ?? '';
+                if (href.startsWith('/products/'))
+                    subcategories.add(href);
+            }
+        },
+        onclosetag: () => {
+            if (inProduct > 0)
+                inProduct--;
+        },
+    }, { decodeEntities: true });
+    parser.write(html);
+    parser.end();
+    return {
+        subcategories: [...subcategories].sort(compare),
+        products: [...products].sort(compare),
+    };
+}
+/**
+ * Every product page reachable from `roots`, sorted.
+ *
+ * Sequential and paced by the package's shared politeness delay. The whole walk
+ * is about 33 requests; nothing here needs concurrency, and Cloudflare fronts
+ * this site, so raising request volume is the only real risk.
+ */
+export async function discoverProducts(fetcher, roots = CATEGORY_ROOTS, options = {}) {
+    const { warn = consoleWarn, delayMs = REQUEST_DELAY_MS } = options;
+    const products = new Set();
+    const seen = new Set();
+    const queue = [...roots];
+    while (queue.length > 0) {
+        const path = queue.shift();
+        if (seen.has(path))
+            continue;
+        seen.add(path);
+        const { subcategories, products: found } = parseCategoryPage(await fetcher.text(BASE + path));
+        if (subcategories.length === 0 && found.length === 0) {
+            warn(`  WARNING: ${path} links to neither a subcategory nor a product`);
+        }
+        for (const product of found)
+            products.add(product);
+        for (const child of subcategories) {
+            if (child !== path)
+                queue.push(child);
+        }
+        await pause(delayMs);
+    }
+    return [...products].sort(compare);
+}

package/dist/vendors/harvey/header.d.ts

@@ -0,0 +1,89 @@
+/**
+ * A product table's two-row `<thead>` -> one flat column per `cols<N>` entry.
+ *
+ * Harvey publishes a table's header in the DOM and its data in a JavaScript
+ * literal, and the only thing joining them is position: `cols1` is
+ * `[{data:"a0"}, {data:"a1"}, ...]` and its Nth entry is the Nth column of the
+ * flattened header. That alignment is checked on every table — see
+ * `scrape.ts` — because a header that has drifted by one column produces a CSV
+ * where every dimension is labelled as its neighbour.
+ *
+ * ## Flattening
+ *
+ * The header is exactly two `<tr>`s. A top `<th>` with `rowspan >= 2` is its own
+ * column and has no sub-label (only "Add to Cart" is like this); otherwise it
+ * consumes `colspan` cells from the second row as its sub-labels. Verified
+ * against all 80 tables on the 52 product pages.
+ *
+ * ## Two things about the text
+ *
+ * **`<br>` is a space.** `CUTTER <br/>DIAMETER` is the same label as
+ * `CUTTER DIAMETER`, and collapsing the tag away instead yields
+ * `CUTTERDIAMETER` — a 51st header shape that exists only in the parser.
+ *
+ * **A sub-label's tolerance is excluded, not stripped afterwards.** The
+ * tolerance is rendered in its own `div.hpc-inline`, so skipping that subtree
+ * gives `D1` where reading the whole cell gives `D1+.0005"-.0005"`. It matters
+ * more than tidiness: Harvey's tolerance text carries typos — `D1+0005"-.0005"`,
+ * `R+.001"-001"`, `L2.020"-.000"` are all real — and every one of them would be
+ * another spelling for a post-hoc stripper to get right.
+ */
+/** The class of the `<div>` holding a sub-label's published tolerance. */
+export declare const TOLERANCE_CLASS = "hpc-inline";
+/** The class Harvey renders an unlabelled annotation column's header with. */
+export declare const HIDDEN_CLASS = "white-text";
+/** True where a header label says nothing about what the column holds. */
+export declare function isJunkLabel(label: string): boolean;
+/** One `<th>` as parsed: its text, its span, and its class attribute. */
+interface HeaderCell {
+    text: string;
+    colspan: number;
+    rowspan: number;
+    className: string;
+}
+/** One data column of a table, as the header describes it. */
+export interface HeaderColumn {
+    /** The top row's label, `<br>`s collapsed to spaces. */
+    top: string;
+    /** The second row's label with its tolerance removed, or null under a rowspan. */
+    sub: string | null;
+    /** The top `<th>`'s class attribute — `white-text` marks a hidden column. */
+    topClass: string;
+    /** How many columns the top `<th>` spanned. 1 unless it is a coating group. */
+    span: number;
+    /** This column's index inside that span. 0 on a column of its own. */
+    slot: number;
+}
+/**
+ * The `<th>` rows of the `<thead>` of the table with this id.
+ *
+ * Streams the whole document rather than slicing it: a `</table>` inside a cell
+ * would end a sliced segment early, and htmlparser2 is already this package's
+ * one parser dependency.
+ *
+ * `decodeEntities` is on because these headers carry `&nbsp;` and `&deg;` —
+ * the blank flute sub-label is literally `&nbsp;&nbsp;`, and it has to reach
+ * {@link isJunkLabel} as an empty string rather than as two characters.
+ */
+export declare function parseHeadRows(html: string, tableId: string): HeaderCell[][];
+/**
+ * One table's header, flattened to one entry per data column.
+ *
+ * Throws when the table is not in the document, rather than returning an empty
+ * header: a page that stopped serving a table it declares in `cols<N>` is a
+ * response that changed shape, and a zero-column table would reach the caller
+ * looking like a family the vendor discontinued.
+ */
+export declare function flatHeader(html: string, tableId: string): HeaderColumn[];
+/**
+ * The vendor's own symbol for a dimension column — `D1`, `L2`, `R`, `A1`, `#`.
+ *
+ * Null where the sub-label carries none, which is a real state rather than a
+ * fault: `NECK DIA.` publishes no symbol at all, and the ratio columns publish
+ * junk.
+ *
+ * A trailing `(h6)` is part of the shank tolerance class and not of the symbol,
+ * so `D2(h6)` and `D2` are the same column.
+ */
+export declare function symbolOf(sub: string | null): string | null;
+export {};

package/dist/vendors/harvey/header.js

@@ -0,0 +1,185 @@
+/**
+ * A product table's two-row `<thead>` -> one flat column per `cols<N>` entry.
+ *
+ * Harvey publishes a table's header in the DOM and its data in a JavaScript
+ * literal, and the only thing joining them is position: `cols1` is
+ * `[{data:"a0"}, {data:"a1"}, ...]` and its Nth entry is the Nth column of the
+ * flattened header. That alignment is checked on every table — see
+ * `scrape.ts` — because a header that has drifted by one column produces a CSV
+ * where every dimension is labelled as its neighbour.
+ *
+ * ## Flattening
+ *
+ * The header is exactly two `<tr>`s. A top `<th>` with `rowspan >= 2` is its own
+ * column and has no sub-label (only "Add to Cart" is like this); otherwise it
+ * consumes `colspan` cells from the second row as its sub-labels. Verified
+ * against all 80 tables on the 52 product pages.
+ *
+ * ## Two things about the text
+ *
+ * **`<br>` is a space.** `CUTTER <br/>DIAMETER` is the same label as
+ * `CUTTER DIAMETER`, and collapsing the tag away instead yields
+ * `CUTTERDIAMETER` — a 51st header shape that exists only in the parser.
+ *
+ * **A sub-label's tolerance is excluded, not stripped afterwards.** The
+ * tolerance is rendered in its own `div.hpc-inline`, so skipping that subtree
+ * gives `D1` where reading the whole cell gives `D1+.0005"-.0005"`. It matters
+ * more than tidiness: Harvey's tolerance text carries typos — `D1+0005"-.0005"`,
+ * `R+.001"-001"`, `L2.020"-.000"` are all real — and every one of them would be
+ * another spelling for a post-hoc stripper to get right.
+ */
+import { Parser } from 'htmlparser2';
+import { VendorResponseError } from '../../errors.js';
+/** The class of the `<div>` holding a sub-label's published tolerance. */
+export const TOLERANCE_CLASS = 'hpc-inline';
+/** The class Harvey renders an unlabelled annotation column's header with. */
+export const HIDDEN_CLASS = 'white-text';
+/** Sub-label text that carries nothing. `&nbsp;` collapses to empty here. */
+const JUNK = new Set(['', '.', '"', 'X']);
+/** True where a header label says nothing about what the column holds. */
+export function isJunkLabel(label) {
+    return JUNK.has(label);
+}
+/** `" a  b \n"` -> `"a b"`. */
+function collapse(text) {
+    return text.split(/\s+/).filter(Boolean).join(' ');
+}
+/**
+ * The `<th>` rows of the `<thead>` of the table with this id.
+ *
+ * Streams the whole document rather than slicing it: a `</table>` inside a cell
+ * would end a sliced segment early, and htmlparser2 is already this package's
+ * one parser dependency.
+ *
+ * `decodeEntities` is on because these headers carry `&nbsp;` and `&deg;` —
+ * the blank flute sub-label is literally `&nbsp;&nbsp;`, and it has to reach
+ * {@link isJunkLabel} as an empty string rather than as two characters.
+ */
+export function parseHeadRows(html, tableId) {
+    const rows = [];
+    let inTable = false;
+    let inHead = false;
+    let row = null;
+    let cell = null;
+    // A depth counter rather than a flag: the tolerance is a `div` inside a `div`,
+    // and a flag would re-enable the text on the inner close tag.
+    let tolerance = 0;
+    let depth = 0;
+    const parser = new Parser({
+        onopentag: (tag, attribs) => {
+            if (tag === 'table') {
+                inTable = attribs['id'] === tableId;
+                return;
+            }
+            if (!inTable)
+                return;
+            if (tag === 'thead') {
+                inHead = true;
+            }
+            else if (inHead && tag === 'tr') {
+                row = [];
+            }
+            else if (inHead && tag === 'th' && row !== null) {
+                cell = {
+                    text: '',
+                    colspan: Number.parseInt(attribs['colspan'] ?? '1', 10) || 1,
+                    rowspan: Number.parseInt(attribs['rowspan'] ?? '1', 10) || 1,
+                    className: attribs['class'] ?? '',
+                };
+                tolerance = 0;
+                depth = 0;
+            }
+            else if (cell !== null) {
+                depth++;
+                if (tolerance === 0 && (attribs['class'] ?? '').split(/\s+/).includes(TOLERANCE_CLASS)) {
+                    tolerance = depth;
+                }
+                if (tag === 'br')
+                    cell.text += ' ';
+            }
+        },
+        ontext: (text) => {
+            if (cell !== null && tolerance === 0)
+                cell.text += text;
+        },
+        onclosetag: (tag) => {
+            if (!inTable)
+                return;
+            if (tag === 'th' && cell !== null) {
+                row?.push({ ...cell, text: collapse(cell.text) });
+                cell = null;
+            }
+            else if (tag === 'tr' && row !== null) {
+                rows.push(row);
+                row = null;
+            }
+            else if (tag === 'thead') {
+                inHead = false;
+                // Everything after the head is data the literal already carries.
+                inTable = false;
+            }
+            else if (cell !== null) {
+                if (tolerance === depth)
+                    tolerance = 0;
+                depth--;
+            }
+        },
+    }, { decodeEntities: true });
+    parser.write(html);
+    parser.end();
+    return rows;
+}
+/**
+ * One table's header, flattened to one entry per data column.
+ *
+ * Throws when the table is not in the document, rather than returning an empty
+ * header: a page that stopped serving a table it declares in `cols<N>` is a
+ * response that changed shape, and a zero-column table would reach the caller
+ * looking like a family the vendor discontinued.
+ */
+export function flatHeader(html, tableId) {
+    const rows = parseHeadRows(html, tableId);
+    if (rows.length === 0) {
+        throw new VendorResponseError(tableId, 'has no <thead> on the page — the table changed shape');
+    }
+    const [top = [], sub = []] = rows;
+    const columns = [];
+    let next = 0;
+    for (const cell of top) {
+        if (cell.rowspan >= 2) {
+            columns.push({ top: cell.text, sub: null, topClass: cell.className, span: 1, slot: 0 });
+            continue;
+        }
+        for (let slot = 0; slot < cell.colspan; slot++) {
+            columns.push({
+                top: cell.text,
+                sub: sub[next]?.text ?? '',
+                topClass: cell.className,
+                span: cell.colspan,
+                slot,
+            });
+            next++;
+        }
+    }
+    if (next > sub.length) {
+        throw new VendorResponseError(tableId, `spans ${next} sub-labels across its top row but the second row has ` +
+            `${sub.length} — the header changed shape`);
+    }
+    return columns;
+}
+/**
+ * The vendor's own symbol for a dimension column — `D1`, `L2`, `R`, `A1`, `#`.
+ *
+ * Null where the sub-label carries none, which is a real state rather than a
+ * fault: `NECK DIA.` publishes no symbol at all, and the ratio columns publish
+ * junk.
+ *
+ * A trailing `(h6)` is part of the shank tolerance class and not of the symbol,
+ * so `D2(h6)` and `D2` are the same column.
+ */
+export function symbolOf(sub) {
+    if (sub === null)
+        return null;
+    const match = /^([A-Z]+\d*)/.exec(sub);
+    return match?.[1] ?? null;
+}

package/dist/vendors/harvey/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Harvey Tool — miniature end mills and keyseat cutters, from a printed-catalog
+ * table rendered as a web page.
+ *
+ * No JSON API and no XHR: a product page inlines its entire variant table as a
+ * JavaScript literal beside a `<thead>` that names the columns, and the two are
+ * joined by position. `literal.ts`, `header.ts`, `lexicon.ts` and `value.ts` are
+ * pure and hold the parsing risk; `scrape.ts` and `catalog.ts` are the only
+ * modules that read through a `Fetcher`.
+ *
+ * The one structural thing to know before reading any of it: **one HTML row is
+ * up to nine orderable parts.** See `scrape.ts`, and
+ * `docs/HARVEY_PRODUCT_TABLE.md` for the transport.
+ */
+export * from './catalog.js';
+export * from './header.js';
+export * from './lexicon.js';
+export * from './literal.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './value.js';

package/dist/vendors/harvey/index.js

@@ -0,0 +1,21 @@
+/**
+ * Harvey Tool — miniature end mills and keyseat cutters, from a printed-catalog
+ * table rendered as a web page.
+ *
+ * No JSON API and no XHR: a product page inlines its entire variant table as a
+ * JavaScript literal beside a `<thead>` that names the columns, and the two are
+ * joined by position. `literal.ts`, `header.ts`, `lexicon.ts` and `value.ts` are
+ * pure and hold the parsing risk; `scrape.ts` and `catalog.ts` are the only
+ * modules that read through a `Fetcher`.
+ *
+ * The one structural thing to know before reading any of it: **one HTML row is
+ * up to nine orderable parts.** See `scrape.ts`, and
+ * `docs/HARVEY_PRODUCT_TABLE.md` for the transport.
+ */
+export * from './catalog.js';
+export * from './header.js';
+export * from './lexicon.js';
+export * from './literal.js';
+export * from './records.js';
+export * from './scrape.js';
+export * from './value.js';