@opencraw/core 0.1.1 → 0.1.2

package/dist/src/api-steps/extract-from-document.use-case.d.ts

@@ -1,10 +1,12 @@
-import type { ExtractionScope } from '../extraction-scope/index.js';
+import type { ExtractionScope, ScopeDocument } from '../extraction-scope/index.js';
 import type { ExtractStep } from '../recipe-schema/index.js';
 /**
  * Runs an `extract` step against a static document: the value bound under
  * `from`, else the scope's current document. `css` reads HTML, `jsonpath`
- * reads JSON (or a read PDF's rows), `table` reads a PDF's tables, `regex`
- * reads any document as text; `xpath` needs a live page and is refused here.
+ * reads JSON (or a read PDF, workbook or deck as data), `table` reads the
+ * tables of a PDF, a workbook (a spreadsheet, a CSV), a deck (a presentation)
+ * or HTML (its `<table>`s), `regex` reads any document as text; `xpath` needs
+ * a live page and is refused here.
  *
  * A `jsonpath` extract whose `from` is text parses that text as JSON, and a
  * list of texts (every `<script type="application/ld+json">` of a page) becomes
@@ -25,4 +27,15 @@ export declare function extractFromDocument(step: ExtractStep, scope: Extraction
  * @returns The selector to run.
  */
 export declare function renderSelector(selector: string, scope: ExtractionScope): string;
+/**
+ * The tables a `table` extract finds in a document: a PDF's, a workbook's, a
+ * deck's, or an HTML document's `<table>`s (a fetched page, rendered Markdown,
+ * a live page's content).
+ *
+ * @param document - The document.
+ * @param step - The extract step.
+ * @param scope - Where its selector renders.
+ * @returns The tables.
+ */
+export declare function tablesIn(document: ScopeDocument, step: ExtractStep, scope: ExtractionScope): unknown[];
 //# sourceMappingURL=extract-from-document.use-case.d.ts.map

package/dist/src/api-steps/index.d.ts

@@ -1,4 +1,4 @@
 export { ApiStepRunner } from './run-api-step.use-case.js';
-export { extractFromDocument, renderSelector } from './extract-from-document.use-case.js';
+export { extractFromDocument, renderSelector, tablesIn } from './extract-from-document.use-case.js';
 export { sendRequest, documentValue } from './send-request.use-case.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/api-steps/send-request.use-case.d.ts

@@ -14,9 +14,9 @@ import type { RunGate } from '../step-flow/index.js';
  * @param recipe - The recipe: its limits, block rule and id.
  * @param gate - Spaces request starts by `delayMs`.
  * @param events - Where to report the visit.
- * @throws BlockedError when the response is a block; HttpError for any other 4xx/5xx.
+ * @throws BlockedError when the response is a block, or a captcha page under `session.captcha`; HttpError for any other 4xx/5xx.
  */
 export declare function sendRequest(step: RequestStep, scope: ExtractionScope, client: HttpSender, recipe: InputRecipe, gate: RunGate, events: EventBus): Promise<void>;
-/** What a step id holds for a document: parsed JSON, the read PDF, or the markup / text. */
+/** What a step id holds for a document: parsed JSON, the read PDF, workbook or deck, or the markup / text. */
 export declare function documentValue(body: HttpBody): unknown;
 //# sourceMappingURL=send-request.use-case.d.ts.map

package/dist/src/captcha/captcha-budget.model.d.ts

@@ -0,0 +1,21 @@
+/** Default solves a recipe run may spend. */
+export declare const DEFAULT_MAX_SOLVES = 10;
+/**
+ * The solves a recipe run may still spend. Every solve costs money: a detector
+ * that matches the wrong element would drain a balance without it. Shared by
+ * every runner of the run, rotations included.
+ */
+export declare class CaptchaBudget {
+    readonly max: number;
+    private used;
+    constructor(max?: number);
+    /** Solves spent so far. */
+    get spent(): number;
+    /**
+     * Spends one solve.
+     *
+     * @returns Whether one was left.
+     */
+    take(): boolean;
+}
+//# sourceMappingURL=captcha-budget.model.d.ts.map

package/dist/src/captcha/captcha-detection.client.d.ts

@@ -0,0 +1,28 @@
+import type { Page } from 'playwright';
+import type { CaptchaChallenge } from './captcha-solver.contract.js';
+/** The widgets detection looks for when a recipe names none: reCAPTCHA v2, hCaptcha and Turnstile, as a container or as their iframe. */
+export declare const DEFAULT_CAPTCHA_SELECTOR: string;
+/**
+ * The first visible challenge on the page, if any. An element counts only
+ * when visible: sites keep hidden widgets around after a solve, and an
+ * invisible reCAPTCHA shows nothing until it challenges.
+ *
+ * @param page - The live page.
+ * @param selector - Where challenges are; `DEFAULT_CAPTCHA_SELECTOR` when omitted.
+ * @param options - `v3`: also report a reCAPTCHA v3 script (a `captcha` step asks for it; the automatic checks do not, since v3 never blocks a page by itself).
+ * @returns The challenge, or `undefined`.
+ */
+export declare function detectChallenge(page: Page, selector?: string, options?: {
+    v3?: boolean;
+}): Promise<CaptchaChallenge | undefined>;
+/**
+ * Whether the page is clear of challenges, tolerating a page that is
+ * navigating (a solve often submits a form): an evaluation cut short by the
+ * navigation counts as not clear yet.
+ *
+ * @param page - The live page.
+ * @param selector - Where challenges are.
+ * @returns Whether no challenge is visible.
+ */
+export declare function isClear(page: Page, selector: string): Promise<boolean>;
+//# sourceMappingURL=captcha-detection.client.d.ts.map

package/dist/src/captcha/captcha-guard.use-case.d.ts

@@ -0,0 +1,64 @@
+import type { Page } from 'playwright';
+import type { AccessLease } from '../access/index.js';
+import type { EventBus } from '../crawl-events/index.js';
+import type { CaptchaStep, InputRecipe } from '../recipe-schema/index.js';
+import type { BlockedError } from '../step-flow/index.js';
+import type { CaptchaBudget } from './captcha-budget.model.js';
+import type { CaptchaSolverRegistry } from './captcha-solver-registry.store.js';
+export interface CaptchaGuardOptions {
+    recipe: InputRecipe;
+    events: EventBus;
+    solvers: CaptchaSolverRegistry;
+    /** Shared by every runner of the recipe run, rotations and the bootstrap included. */
+    budget: CaptchaBudget;
+    /** The access the page goes through, handed to solvers. */
+    lease?: AccessLease;
+}
+/**
+ * Where a web runner meets captchas: after each navigation, click and key
+ * press (`session.captcha`), on a block page (`onBlock.solve`), and at a
+ * `captcha` step.
+ */
+export declare class CaptchaGuard {
+    private readonly options;
+    constructor(options: CaptchaGuardOptions);
+    private settings;
+    private solve;
+    /** Whether a block page is searched for a challenge before the block counts. */
+    get solvesBlocks(): boolean;
+    /**
+     * The automatic check: with `session.captcha`, solves the challenge the page
+     * shows, if any. Without it, nothing is looked for.
+     *
+     * @param page - The live page.
+     * @throws CaptchaError when the challenge could not be solved.
+     */
+    check(page: Page): Promise<void>;
+    /**
+     * A block page under `onBlock.solve`: solves the challenge it shows. A block
+     * without a challenge stays a block.
+     *
+     * @param page - The page showing the block.
+     * @param blocked - The block.
+     * @throws BlockedError (`blocked`) when the page shows no challenge; CaptchaError when it could not be solved.
+     */
+    solveBlock(page: Page, blocked: BlockedError): Promise<void>;
+    /**
+     * A `captcha` step: solves the challenge the page shows, reCAPTCHA v3
+     * included; a page without one is fine.
+     *
+     * @param page - The live page.
+     * @param step - The step.
+     * @throws CaptchaError when the challenge could not be solved.
+     */
+    step(page: Page, step: CaptchaStep): Promise<void>;
+}
+/**
+ * Every solver name a recipe uses (`session.captcha` and its `captcha`
+ * steps, the bootstrap's included), to check them before the run starts.
+ *
+ * @param recipe - The input recipe.
+ * @returns The names, without repeats.
+ */
+export declare function captchaSolverNames(recipe: InputRecipe): string[];
+//# sourceMappingURL=captcha-guard.use-case.d.ts.map

package/dist/src/captcha/captcha-solver-registry.store.d.ts

@@ -0,0 +1,19 @@
+import type { CaptchaSolver } from './captcha-solver.contract.js';
+/** The captcha solvers a crawler was given, by name. */
+export declare class CaptchaSolverRegistry {
+    private readonly solvers;
+    private readonly order;
+    constructor(solvers?: readonly CaptchaSolver[]);
+    /** The registered names. */
+    get names(): string[];
+    has(name: string): boolean;
+    /**
+     * The solver of that name.
+     *
+     * @param name - As a recipe names it.
+     * @returns The solver.
+     * @throws Error naming what is registered when it is not.
+     */
+    resolve(name: string): CaptchaSolver;
+}
+//# sourceMappingURL=captcha-solver-registry.store.d.ts.map

package/dist/src/captcha/captcha-solver.contract.d.ts

@@ -0,0 +1,47 @@
+import type { Page } from 'playwright';
+import type { AccessLease } from '../access/index.js';
+/** The kinds of challenge detection tells apart. */
+export type CaptchaKind = 'recaptcha-v2' | 'recaptcha-v3' | 'hcaptcha' | 'turnstile' | 'image' | 'unknown';
+/** What the engine found on the page: enough for a token service, or for a solver that works on the page itself. */
+export interface CaptchaChallenge {
+    kind: CaptchaKind;
+    /** The page the challenge is on. */
+    url: string;
+    /** The widget's site key (`data-sitekey`, or the `k` / `sitekey` of its iframe), when it has one. */
+    siteKey?: string;
+    /** The widget's action (`data-action`), when it declares one. */
+    action?: string;
+    /** A Playwright selector for the widget, or for the image of an image captcha. */
+    selector?: string;
+}
+export type CaptchaLog = (level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: Record<string, unknown>) => void;
+/** What a solver gets besides the challenge. */
+export interface CaptchaContext {
+    /** The live page: the solver may inject a token, fill a field, click. */
+    page: Page;
+    /** The access in use: token services often need the same IP (proxy) as the browser. */
+    lease?: AccessLease;
+    /** 1, 2, … within one solve loop. */
+    attempt: number;
+    /** Aborted when the engine's timeout for this attempt runs out. */
+    signal: AbortSignal;
+    log: CaptchaLog;
+}
+/** A solver's report. The engine checks it: `solved` is a claim until the page confirms it. */
+export type CaptchaOutcome = {
+    status: 'solved';
+} | {
+    status: 'failed';
+    reason: string;
+};
+/**
+ * A captcha solver: solves a challenge and applies the answer on the page
+ * (injects a token and calls the widget's callback, types an image's text,
+ * submits). Detection, verification, retries, rotation and the budget are the
+ * engine's.
+ */
+export interface CaptchaSolver {
+    name: string;
+    solve: (challenge: CaptchaChallenge, context: CaptchaContext) => Promise<CaptchaOutcome> | CaptchaOutcome;
+}
+//# sourceMappingURL=captcha-solver.contract.d.ts.map

package/dist/src/captcha/captcha.error.d.ts

@@ -0,0 +1,13 @@
+import { BlockedError } from '../step-flow/index.js';
+/**
+ * A challenge the engine could not get past: the solver failed, the page did
+ * not confirm it, or the budget ran out. It is a block, so a recipe with
+ * `onBlock.rotate` retries the step on a new access lease (a new IP often
+ * means an easier challenge, or none), then the step's error policy applies.
+ */
+export declare class CaptchaError extends BlockedError {
+    readonly kind: string;
+    readonly attempts: number;
+    constructor(url: string, kind: string, attempts: number, reason: string);
+}
+//# sourceMappingURL=captcha.error.d.ts.map

package/dist/src/captcha/index.d.ts

@@ -0,0 +1,10 @@
+export type { CaptchaSolver, CaptchaChallenge, CaptchaContext, CaptchaOutcome, CaptchaKind, CaptchaLog } from './captcha-solver.contract.js';
+export { CaptchaError } from './captcha.error.js';
+export { CaptchaSolverRegistry } from './captcha-solver-registry.store.js';
+export { CaptchaBudget, DEFAULT_MAX_SOLVES } from './captcha-budget.model.js';
+export { DEFAULT_CAPTCHA_SELECTOR, detectChallenge } from './captcha-detection.client.js';
+export { resolveCaptcha, DEFAULT_CAPTCHA_ATTEMPTS, DEFAULT_CAPTCHA_TIMEOUT_MS } from './resolve-captcha.use-case.js';
+export type { CaptchaAttemptPlan } from './resolve-captcha.use-case.js';
+export { CaptchaGuard, captchaSolverNames } from './captcha-guard.use-case.js';
+export type { CaptchaGuardOptions } from './captcha-guard.use-case.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/captcha/resolve-captcha.use-case.d.ts

@@ -0,0 +1,40 @@
+import type { Page } from 'playwright';
+import type { AccessLease } from '../access/index.js';
+import type { EventBus } from '../crawl-events/index.js';
+import type { CaptchaCheck } from '../recipe-schema/index.js';
+import type { CaptchaBudget } from './captcha-budget.model.js';
+import type { CaptchaChallenge, CaptchaSolver } from './captcha-solver.contract.js';
+/** Default solves tried per challenge. */
+export declare const DEFAULT_CAPTCHA_ATTEMPTS = 3;
+/** Default time one solve may take: token services take 10 to 60 seconds. */
+export declare const DEFAULT_CAPTCHA_TIMEOUT_MS = 120000;
+/** One challenge to get past, and everything the loop needs for it. */
+export interface CaptchaAttemptPlan {
+    recipeId: string;
+    page: Page;
+    challenge: CaptchaChallenge;
+    solver: CaptchaSolver;
+    /** Where challenges are, to re-detect and to confirm one is gone. */
+    selector: string;
+    verify?: CaptchaCheck;
+    attempts: number;
+    timeoutMs: number;
+    budget: CaptchaBudget;
+    events: EventBus;
+    lease?: AccessLease;
+}
+/**
+ * Gets past one challenge: asks the solver, then checks the page (a solver's
+ * `solved` is a claim; the challenge must be gone and/or the `verify` element
+ * must appear), and tries again with what the page shows next, up to
+ * `attempts`. Each try spends one solve of the run's budget.
+ *
+ * A failed try re-detects the challenge (a widget re-renders after a wrong
+ * answer). When it is gone without the page confirming, the page is reloaded
+ * for a fresh one; when a reload shows none, there is nothing left to solve.
+ *
+ * @param plan - The challenge, the solver and the limits.
+ * @throws CaptchaError when every try failed, or the budget is spent.
+ */
+export declare function resolveCaptcha(plan: CaptchaAttemptPlan): Promise<void>;
+//# sourceMappingURL=resolve-captcha.use-case.d.ts.map

package/dist/src/crawl-events/crawl-event.contract.d.ts

@@ -48,6 +48,46 @@ export type CrawlEvent = (Base & {
     type: 'access:rotate';
     attempt: number;
     reason: string;
+}) | 
+/** A captcha challenge is on the page. */
+(Base & {
+    type: 'captcha:detected';
+    url: string;
+    kind: string;
+    siteKey?: string;
+}) | 
+/** A solver is trying (`attempt` counts from 1 per challenge). */
+(Base & {
+    type: 'captcha:solve';
+    url: string;
+    kind: string;
+    solver: string;
+    attempt: number;
+}) | 
+/** The page confirmed the solve. */
+(Base & {
+    type: 'captcha:solved';
+    url: string;
+    kind: string;
+    solver: string;
+    attempt: number;
+    durationMs: number;
+}) | 
+/** The solver failed, timed out, or the page still shows the challenge. */
+(Base & {
+    type: 'captcha:failed';
+    url: string;
+    kind: string;
+    solver: string;
+    attempt: number;
+    reason: string;
+}) | 
+/** A challenge was left unsolved: the run spent its `maxSolves`. */
+(Base & {
+    type: 'captcha:budget';
+    url: string;
+    kind: string;
+    max: number;
 }) | (Base & {
     type: 'step:start';
     stepType: string;

package/dist/src/crawl-execution/bootstrap-session.use-case.d.ts

@@ -1,5 +1,6 @@
 import type { AccessLease } from '../access/index.js';
 import type { BrowserClient, BrowserSession, SessionOptions, StorageState } from '../browser-session/index.js';
+import type { CaptchaGuard } from '../captcha/index.js';
 import type { EventBus } from '../crawl-events/index.js';
 import type { HookRegistry } from '../hooks/index.js';
 import type { InputRecipe } from '../recipe-schema/index.js';
@@ -30,9 +31,10 @@ export declare function accessOptions(lease: AccessLease | undefined, headers: R
  * @param recipe - The input recipe.
  * @param deps - Browser, hooks, events.
  * @param lease - The recipe run's access; direct when omitted.
+ * @param captcha - Solves the bootstrap's captchas (a login form's).
  * @returns The state, or `undefined` when the recipe declares none.
  */
-export declare function resolveStorageState(recipe: InputRecipe, deps: BootstrapDependencies, lease?: AccessLease): Promise<StorageState | undefined>;
+export declare function resolveStorageState(recipe: InputRecipe, deps: BootstrapDependencies, lease?: AccessLease, captcha?: CaptchaGuard): Promise<StorageState | undefined>;
 /**
  * The storage state saved by an earlier bootstrap (`session.storageStatePath`), if the recipe names one.
  *
@@ -49,7 +51,8 @@ export declare function readSavedState(recipe: InputRecipe, deps: Pick<Bootstrap
  * @param recipe - An input recipe with `session.bootstrap`.
  * @param browserSession - Where the steps run.
  * @param deps - Hooks, events, `storageStateDir`.
+ * @param captcha - Solves the bootstrap's captchas.
  * @returns The kept state.
  */
-export declare function runBootstrap(recipe: InputRecipe, browserSession: BrowserSession, deps: Omit<BootstrapDependencies, 'browser'>): Promise<StorageState>;
+export declare function runBootstrap(recipe: InputRecipe, browserSession: BrowserSession, deps: Omit<BootstrapDependencies, 'browser'>, captcha?: CaptchaGuard): Promise<StorageState>;
 //# sourceMappingURL=bootstrap-session.use-case.d.ts.map

package/dist/src/crawl-execution/crawl-options.config.d.ts

@@ -1,5 +1,6 @@
 import type { AccessConfig, AccessPlugin } from '../access/index.js';
 import type { BrowserSessionConfig } from '../browser-session/index.js';
+import type { CaptchaSolver } from '../captcha/index.js';
 import type { CrawlListener } from '../crawl-events/index.js';
 import type { HookMap } from '../hooks/index.js';
 import type { DedupeScope, RecordSink } from '../record-sink/index.js';
@@ -33,5 +34,7 @@ export interface CrawlOptions {
     access?: AccessConfig;
     /** Plugins `{ kind: 'plugin', name }` profiles refer to. */
     accessPlugins?: AccessPlugin[];
+    /** Solvers recipes name in `session.captcha.solver` and `captcha` steps. */
+    captchaSolvers?: CaptchaSolver[];
 }
 //# sourceMappingURL=crawl-options.config.d.ts.map

package/dist/src/crawl-execution/crawl-report.model.d.ts

@@ -12,6 +12,12 @@ export interface RecipeReport {
     stepsSkipped: number;
     pages: number;
     durationMs: number;
+    /** Captcha challenges met, solved, and solve attempts that failed; present when any was met. */
+    captchas?: {
+        detected: number;
+        solved: number;
+        failed: number;
+    };
     /** Set when the recipe stopped on a failure. */
     error?: string;
 }

package/dist/src/crawl-execution/create-crawler.use-case.d.ts

@@ -11,9 +11,10 @@ export interface Crawler {
  * Creates a crawler. The browser is launched lazily, on the first recipe or
  * bootstrap that needs it, and shared by every run until `close`.
  *
- * @param options - Hooks, sink, events, browser settings, access, policies.
+ * @param options - Hooks, sink, events, browser settings, access, captcha solvers, policies.
  * @returns The crawler.
  * @throws AccessConfigError when the access config cannot work.
+ * @throws Error when two captcha solvers share a name.
  */
 export declare function createCrawler(options?: CrawlOptions): Crawler;
 //# sourceMappingURL=create-crawler.use-case.d.ts.map

package/dist/src/crawl-execution/run-input-recipe.use-case.d.ts

@@ -1,5 +1,6 @@
 import type { AccessBroker } from '../access/index.js';
 import { BrowserClient } from '../browser-session/index.js';
+import { CaptchaSolverRegistry } from '../captcha/index.js';
 import type { EventBus } from '../crawl-events/index.js';
 import type { HookRegistry } from '../hooks/index.js';
 import type { InputRecipe, OutputRecipe } from '../recipe-schema/index.js';
@@ -20,6 +21,8 @@ export interface RecipeRunDependencies {
     debug?: boolean;
     /** Leases each recipe run its network access. */
     access: AccessBroker;
+    /** The solvers recipes name; none when omitted. */
+    captchaSolvers?: CaptchaSolverRegistry;
 }
 /**
  * Runs one input recipe end to end: session, runner, the step walk, and for

package/dist/src/deck-document/deck-document.model.d.ts

@@ -0,0 +1,58 @@
+import type { Sheet } from '../workbook-document/index.js';
+/** A text box on a slide, in points from the slide's top-left corner. */
+export interface DeckShape {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    text: string;
+    /** The placeholder it fills (`title`, `body`…). */
+    placeholder?: string;
+}
+/** A chart's data, from the values the chart caches. */
+export interface DeckChart {
+    type: string;
+    title?: string;
+    series: {
+        name: string;
+        categories: string[];
+        values: (number | null)[];
+    }[];
+}
+/** One slide. */
+export interface DeckSlide {
+    number: number;
+    title?: string;
+    hidden: boolean;
+    /** Text boxes in reading order. */
+    shapes: DeckShape[];
+    /** Native tables, as sheets (`table 1`…) with their merged cells. */
+    tables: Sheet[];
+    charts: DeckChart[];
+    notes: string;
+}
+/** A presentation read into slides: what `extract` works on. */
+export interface DeckDocument {
+    kind: 'deck';
+    /** The slide size, in points. */
+    width: number;
+    height: number;
+    slides: DeckSlide[];
+}
+/**
+ * The text a `regex` extract reads: per visible slide, its title, its text
+ * boxes in reading order, its tables' rows (cells separated by a tab) and its
+ * notes after `Notes:`; slides separated by a blank line.
+ *
+ * @param document - The deck.
+ * @returns The text.
+ */
+export declare function deckText(document: DeckDocument): string;
+/**
+ * Whether a value bound in scope is a read deck (so `extract … from` can take it).
+ *
+ * @param value - Anything.
+ * @returns Whether it is a {@link DeckDocument}.
+ */
+export declare function isDeckDocument(value: unknown): value is DeckDocument;
+//# sourceMappingURL=deck-document.model.d.ts.map

package/dist/src/deck-document/deck-table.algorithm.d.ts

@@ -0,0 +1,35 @@
+import type { TableAlign } from '../pdf-document/index.js';
+import type { GridTableQuery, WorkbookCell } from '../workbook-document/index.js';
+import type { DeckDocument } from './deck-document.model.js';
+/** What a table extract looks for in a deck. */
+export interface DeckTableQuery extends Omit<GridTableQuery, 'sheet'> {
+    /** Matches the titles of the slides to read; default every slide. */
+    slide?: RegExp;
+    /** Read text boxes laid out as a table instead of native tables. */
+    shapes?: boolean;
+    /** With `shapes`: how a row's values sit against a box wrapped over several lines. */
+    align?: TableAlign;
+}
+/** One table found in a deck. */
+export interface DeckTable {
+    /** The slide's number, from 1. */
+    slide: number;
+    slideTitle: string;
+    /** The first header cell. */
+    title: string;
+    header: string[];
+    rows: Record<string, WorkbookCell>[];
+}
+/**
+ * Finds tables in a deck: native tables through the workbook table reader
+ * (merged cells filled, a header over several rows joined), or, with
+ * `shapes`, text boxes laid out as a table through the PDF table reader (a box
+ * is a cell, boxes whose heights overlap a row, columns from where the body's
+ * boxes start). Hidden slides are skipped unless `includeHidden`.
+ *
+ * @param document - The deck.
+ * @param query - Which tables, on which slides, and how to name their columns.
+ * @returns The tables, slide by slide.
+ */
+export declare function findDeckTables(document: DeckDocument, query: DeckTableQuery): DeckTable[];
+//# sourceMappingURL=deck-table.algorithm.d.ts.map

package/dist/src/deck-document/index.d.ts

@@ -0,0 +1,6 @@
+export { deckText, isDeckDocument } from './deck-document.model.js';
+export type { DeckDocument, DeckSlide, DeckShape, DeckChart } from './deck-document.model.js';
+export { readPptxDeck } from './read-pptx.client.js';
+export { findDeckTables } from './deck-table.algorithm.js';
+export type { DeckTable, DeckTableQuery } from './deck-table.algorithm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/deck-document/read-pptx.client.d.ts

@@ -0,0 +1,16 @@
+import type { DeckDocument } from './deck-document.model.js';
+/**
+ * Reads a `.pptx` presentation into a deck document, through
+ * `@opencraw/office-reader`: every slide's text boxes with their positions,
+ * its tables with their merged cells, its charts' cached data and its notes.
+ * The reader is imported on first use, so recipes that never read a
+ * presentation never load it.
+ *
+ * @param bytes - The file.
+ * @param source - Where it came from, for messages.
+ * @returns The deck.
+ * @throws Error naming the source, and saying what to do, for a file that is
+ * not a readable presentation (a legacy `.ppt`, a password-protected file, an `.odp`…).
+ */
+export declare function readPptxDeck(bytes: Uint8Array, source: string): Promise<DeckDocument>;
+//# sourceMappingURL=read-pptx.client.d.ts.map

package/dist/src/extraction-scope/extraction-scope.model.d.ts

@@ -7,9 +7,11 @@
  * Page state (the current URL, page number and the document `extract` reads by
  * default) is scope state too, bound in the innermost scope that navigated.
  */
+import type { DeckDocument } from '../deck-document/index.js';
 import type { PdfDocument } from '../pdf-document/index.js';
+import type { WorkbookDocument } from '../workbook-document/index.js';
 /** A fetched or rendered document a later `extract` can read. */
-export type ScopeDocument = PdfDocument | {
+export type ScopeDocument = PdfDocument | WorkbookDocument | DeckDocument | {
     kind: 'json';
     data: unknown;
 } | {

package/dist/src/http-session/http-response.contract.d.ts

@@ -1,4 +1,6 @@
+import type { DeckDocument } from '../deck-document/index.js';
 import type { PdfDocument } from '../pdf-document/index.js';
+import type { WorkbookDocument } from '../workbook-document/index.js';
 import type { BodyKind, HttpMethod } from '../recipe-schema/index.js';
 /** One HTTP request as the api runner sends it, templates already rendered. */
 export interface HttpRequest {
@@ -9,10 +11,16 @@ export interface HttpRequest {
     body?: unknown;
     /** How to read the body; default: from the response content type. */
     as?: BodyKind;
+    /** The encoding of a text body (a WHATWG label); default: the BOM, the declared charset, UTF-8, else Windows-1252. */
+    encoding?: string;
+    /** A CSV body's delimiter (one character); default: detected. */
+    delimiter?: string;
+    /** A YAML body's scalars: `typed` (default) or `text`. */
+    scalars?: 'typed' | 'text';
     timeoutMs?: number;
 }
 /** A parsed response body. Structurally the same as a scope document, on purpose. */
-export type HttpBody = PdfDocument | {
+export type HttpBody = PdfDocument | WorkbookDocument | DeckDocument | {
     kind: 'json';
     data: unknown;
 } | {
@@ -28,6 +36,10 @@ export interface HttpResponse {
     url: string;
     headers: Record<string, string>;
     body: HttpBody;
+    /** What reading the body noticed but read anyway (an unknown YAML tag…). */
+    warnings?: string[];
+    /** The format the body was read as (`yaml` and `jsonl` both give JSON data). */
+    format?: BodyKind;
 }
 /** The part of the client the api runner needs; tests fake it. */
 export interface HttpSender {

package/dist/src/http-session/text-decoding.algorithm.d.ts

@@ -0,0 +1,35 @@
+/** Decoded text and the encoding it was read as. */
+export interface DecodedText {
+    text: string;
+    encoding: string;
+}
+/**
+ * Decodes a body, in this order: a byte-order mark (UTF-8, UTF-16 LE/BE; Excel's
+ * "Unicode text" export is UTF-16 LE), the encoding a recipe asks for, the
+ * charset the server declares, strict UTF-8, and Windows-1252 (a superset of
+ * Latin-1) for text that is not UTF-8.
+ *
+ * The Windows-1252 fallback is only taken when the text holds no valid UTF-8
+ * beyond ASCII: a UTF-8 page with one stray byte keeps its accents, with a
+ * replacement character for the stray byte, instead of turning every accent
+ * into mojibake.
+ *
+ * @param bytes - The body.
+ * @param options - `encoding`: the recipe's choice, a WHATWG label (wins over
+ * the charset, not over a BOM); `charset`: from the content type (ignored when
+ * not a known label).
+ * @returns The text, without its BOM, and the encoding used.
+ * @throws Error when `encoding` is not a known label.
+ */
+export declare function decodeText(bytes: Uint8Array, options?: {
+    encoding?: string;
+    charset?: string;
+}): DecodedText;
+/**
+ * The charset a content type declares (`text/csv; charset=ISO-8859-1`).
+ *
+ * @param contentType - The header value.
+ * @returns The charset, or `undefined`.
+ */
+export declare function charsetOf(contentType: string): string | undefined;
+//# sourceMappingURL=text-decoding.algorithm.d.ts.map