@opencraw/core 0.1.3 → 0.1.4

package/dist/crawl-execution/rotating-runner.use-case.d.ts

@@ -0,0 +1,66 @@
+import type { AccessLease } from '../access/index.js';
+import type { EventBus } from '../crawl-events/index.js';
+import type { ExtractionScope, LiveElement } from '../extraction-scope/index.js';
+import type { InputRecipe, PaginateNext, Step } from '../recipe-schema/index.js';
+import { BlockedError } from '../step-flow/index.js';
+import type { NextPageResult, StepRunner } from '../step-flow/index.js';
+/** A runner and the access lease it was opened with. */
+export interface LeasedRunner {
+    runner: StepRunner;
+    lease: AccessLease;
+}
+export interface RotatingRunnerOptions {
+    recipe: InputRecipe;
+    events: EventBus;
+    /** How many rotations the run may use; 0 disables rotation. */
+    maxRotations: number;
+    /** Opens a runner on a fresh lease: attempt 1 first, then 2, 3... */
+    open: (attempt: number) => Promise<LeasedRunner>;
+}
+/**
+ * The runner a recipe run uses. It delegates to a runner opened on an access
+ * lease, reports every block as an `access:blocked` event and, when the recipe
+ * allows it, rotates: takes a new lease, opens a new runner on it (re-running
+ * the bootstrap) and tells the step walk to retry the blocked step.
+ *
+ * Under concurrency several iterations can be blocked by the same lease at
+ * once. Each block remembers the generation of runner that produced it, so
+ * only the first one rotates; the rest just retry on the new runner. Replaced
+ * runners are kept until the run ends, because other iterations may still have
+ * requests in flight on them.
+ */
+export declare class RotatingRunner implements StepRunner {
+    private readonly options;
+    /**
+     * Opens the first runner.
+     *
+     * @param options - The recipe, events, rotation budget and how to open a runner.
+     * @returns The rotating runner.
+     */
+    static open(options: RotatingRunnerOptions): Promise<RotatingRunner>;
+    private current;
+    private readonly retired;
+    private readonly blockedAt;
+    private generation;
+    private rotations;
+    private rotating;
+    private constructor();
+    private get inner();
+    private swap;
+    private note;
+    runLeaf(step: Step, scope: ExtractionScope): Promise<void>;
+    nextPage(next: PaginateNext, scope: ExtractionScope): Promise<NextPageResult>;
+    /**
+     * A runner for one parallel iteration, forked from whichever runner is
+     * current when it runs a step: after a rotation it forks again from the new
+     * one, since the old context is gone (or going). Blocks are noted and
+     * rotated like the main runner's.
+     *
+     * @returns The iteration's runner.
+     */
+    fork(): Promise<StepRunner>;
+    elements(selector: string, scope: ExtractionScope): Promise<LiveElement[]>;
+    rotate(error: BlockedError): Promise<boolean>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=rotating-runner.use-case.d.ts.map

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

@@ -0,0 +1,17 @@
+import type { RecipeSet } from '../recipe-loading/index.js';
+import type { CrawlReport } from './crawl-report.model.js';
+import type { RecipeRunDependencies } from './run-input-recipe.use-case.js';
+/**
+ * Runs every input recipe of a set into one sink, `parallel` at a time
+ * (default one after another). Reports come back in the set's order whatever
+ * order the recipes finish in. Under `onRecipeError: 'stop'`, a failed recipe
+ * stops the ones not started yet; those already running finish.
+ *
+ * @param set - The bound recipes.
+ * @param deps - Shared browser, hooks, events, sink and de-duplication.
+ * @param onRecipeError - Whether a failed recipe stops the run.
+ * @param parallel - How many input recipes run at once.
+ * @returns The report.
+ */
+export declare function runCrawl(set: RecipeSet, deps: RecipeRunDependencies, onRecipeError: 'continue' | 'stop', parallel?: number): Promise<CrawlReport>;
+//# sourceMappingURL=run-crawl.use-case.d.ts.map

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

@@ -0,0 +1,51 @@
+import type { AccessBroker } from '../access/index.js';
+import { BrowserClient } from '../browser-session/index.js';
+import type { BrowserProfiles } 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, RetryRule } from '../recipe-schema/index.js';
+import type { DedupePolicy, RecordSink } from '../record-sink/index.js';
+import type { HostThrottle } from '../step-flow/index.js';
+import type { RecipeReport } from './crawl-report.model.js';
+export interface RecipeRunDependencies {
+    browser: () => Promise<BrowserClient>;
+    hooks: HookRegistry;
+    events: EventBus;
+    sink: RecordSink;
+    dedupe: DedupePolicy;
+    storageStateDir?: string;
+    /** Accept invalid TLS certificates in api mode too (sandbox proxies); mirrors `browser.ignoreHTTPSErrors`. */
+    ignoreHTTPSErrors?: boolean;
+    /** Skip records the sink already has (`sink.has`). */
+    resume?: boolean;
+    /** Attach the scope snapshot to record events. */
+    debug?: boolean;
+    /** Leases each recipe run its network access. */
+    access: AccessBroker;
+    /** The solvers recipes name; none when omitted. */
+    captchaSolvers?: CaptchaSolverRegistry;
+    /** The crawler's per-site throttle, shared by every recipe. */
+    hosts?: HostThrottle;
+    /** The runner's persistent browser profiles, for `session.browserProfile`. */
+    profiles?: BrowserProfiles;
+    /** The crawler's retry rule, under each recipe's `limits.retry`. */
+    retry?: RetryRule;
+}
+/**
+ * Runs one input recipe end to end: session, runner, the step walk, and for
+ * every emitted scope the mapping, de-duplication and the sink. A step or
+ * mapping failure under the `fail` policy ends the recipe and is reported,
+ * never thrown: the caller decides whether the run goes on.
+ *
+ * Emits are serialised through one promise chain whatever the concurrency, so
+ * the sink sees one record at a time and `maxRecords` is exact: once reached,
+ * every later emit returns `stop` before mapping.
+ *
+ * @param recipe - The input recipe.
+ * @param output - The output recipe it feeds.
+ * @param deps - Shared browser, hooks, events, sink and de-duplication.
+ * @returns What happened.
+ */
+export declare function runInputRecipe(recipe: InputRecipe, output: OutputRecipe, deps: RecipeRunDependencies): Promise<RecipeReport>;
+//# sourceMappingURL=run-input-recipe.use-case.d.ts.map

package/dist/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/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/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/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/docx-document/index.d.ts

@@ -0,0 +1,2 @@
+export { readDocxHtml } from './read-docx-html.client.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/docx-document/read-docx-html.client.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Reads a `.docx` Word document into HTML, through `@opencraw/office-reader`,
+ * so every selector that reads a page reads a Word document too:
+ *
+ * - headings become `<h1>`…`<h6>` inside `<section data-heading="…">`, as in
+ *   rendered Markdown;
+ * - list items become nested `<ul>` / `<ol>`;
+ * - tables become `<table>`s with their merged cells as `colspan` / `rowspan`,
+ *   so a `table` extract reads them like any HTML table;
+ * - a paragraph keeps its style as `data-style` and its links as `<a href>`;
+ * - headers, footers and notes follow the body, in `<header>`, `<footer>`
+ *   and `<aside data-part="notes">`; the title goes to `<title>`.
+ *
+ * The reader is imported on first use.
+ *
+ * @param bytes - The file.
+ * @param source - Where it came from, for messages.
+ * @returns The HTML document.
+ * @throws Error naming the source, and saying what to do, for a file that is
+ * not a readable Word document (a legacy `.doc`, a password-protected file, an `.odt`…).
+ */
+export declare function readDocxHtml(bytes: Uint8Array, source: string): Promise<string>;
+//# sourceMappingURL=read-docx-html.client.d.ts.map

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

@@ -0,0 +1,77 @@
+/**
+ * The values a recipe has extracted so far, by id, with the lexical nesting the
+ * steps create: `forEach` and `paginate` open a child scope per iteration or page
+ * and drop it afterwards, so nothing from one page leaks into the next. A read
+ * walks up the chain; a write lands in the scope it is made on.
+ *
+ * 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 { XmlDocument } from '../xml-document/index.js';
+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 | WorkbookDocument | DeckDocument | XmlDocument | {
+    kind: 'json';
+    data: unknown;
+} | {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'text';
+    text: string;
+};
+/** Where the crawl is: bound by whichever scope last navigated. */
+export interface PageState {
+    url: string;
+    number: number;
+    document?: ScopeDocument;
+}
+/** Paths a template can read besides ids: `page.url`, `page.number`, `start.url`, `vars.*`. */
+export declare const RESERVED_ROOTS: readonly ['page', 'start', 'vars'];
+export declare class ExtractionScope {
+    private readonly parent?;
+    private readonly values;
+    private page;
+    constructor(parent?: ExtractionScope | undefined);
+    /** Opens a nested scope; reads fall through to this one. */
+    child(): ExtractionScope;
+    /** Binds a value in this scope, shadowing any parent binding of the same id. */
+    set(id: string, value: unknown): void;
+    /**
+     * Appends to the list the id is bound to, in whichever scope binds it (this
+     * one or a parent), as a new list: a snapshot emitted earlier keeps what it saw.
+     *
+     * @param id - The id of a list bound in this scope or a parent.
+     * @param items - What to add, in order.
+     * @throws Error when no scope binds the id, or it holds something other than a list.
+     */
+    append(id: string, items: readonly unknown[]): void;
+    /** Whether the id is bound here or in a parent. */
+    has(id: string): boolean;
+    /** The nearest binding of the id; `undefined` when unbound. */
+    get(id: string): unknown;
+    /** Records a navigation in this scope. Missing fields inherit from the nearest page state. */
+    setPage(state: Partial<PageState>): void;
+    /** Replaces only the current document, keeping URL and number. */
+    setDocument(document: ScopeDocument): void;
+    /** The nearest page state up the chain, if any scope navigated. */
+    get pageState(): PageState | undefined;
+    /** The document `extract` reads when no `from` is given. */
+    get document(): ScopeDocument | undefined;
+    /**
+     * Every binding visible from here, child shadowing parent, plus `page` as
+     * `{ url, number }`. This is what `emit` hands to the mapping.
+     */
+    snapshot(): Record<string, unknown>;
+    /**
+     * Resolves a dotted path the way templates do: the first segment is an id (or
+     * `page`), the rest walks into the value.
+     *
+     * @param path - A dotted path such as `item.href` or `page.url`.
+     * @returns The value, or `undefined`.
+     */
+    lookup(path: string): unknown;
+}
+//# sourceMappingURL=extraction-scope.model.d.ts.map

package/dist/extraction-scope/index.d.ts

@@ -0,0 +1,5 @@
+export { ExtractionScope, RESERVED_ROOTS } from './extraction-scope.model.js';
+export type { PageState, ScopeDocument } from './extraction-scope.model.js';
+export { isLiveElement } from './live-element.model.js';
+export type { LiveElement } from './live-element.model.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction-scope/live-element.model.d.ts

@@ -0,0 +1,28 @@
+/**
+ * A snapshot of one element a `forEach` over `selector` iterates: what it held
+ * when the loop started, plus where to find it again. The engine never keeps a
+ * handle to the element itself: `selector` and `index` re-resolve it on every
+ * use, so a re-render between iterations does not break the loop.
+ */
+export interface LiveElement {
+    /** The selector the loop matched, already rendered. */
+    selector: string;
+    /** Position among the matches, from 0. */
+    index: number;
+    /** Text content, whitespace collapsed. */
+    text: string;
+    /** Inner HTML. */
+    html: string;
+    /** Every attribute, by name. */
+    attrs: Record<string, string>;
+    /** The `value` of an input, option or select; absent otherwise. */
+    value?: string;
+}
+/**
+ * Whether a value is a live element snapshot (a `target` template rendered to one).
+ *
+ * @param value - Anything a template rendered.
+ * @returns `true` for an object with a `selector` string and an `index` number.
+ */
+export declare function isLiveElement(value: unknown): value is LiveElement;
+//# sourceMappingURL=live-element.model.d.ts.map

package/dist/hooks/hook-registry.store.d.ts

@@ -0,0 +1,16 @@
+import type { Hook, HookMap } from './hook.contract.js';
+/** The hooks a crawler was created with, resolved by name at run time. */
+export declare class HookRegistry {
+    private readonly hooks;
+    constructor(hooks?: HookMap);
+    register(name: string, hook: Hook): void;
+    has(name: string): boolean;
+    names(): string[];
+    /**
+     * @param name - The name a recipe used.
+     * @returns The hook.
+     * @throws UnknownHookError when nothing was registered under that name.
+     */
+    resolve(name: string): Hook;
+}
+//# sourceMappingURL=hook-registry.store.d.ts.map

package/dist/hooks/hook.contract.d.ts

@@ -0,0 +1,17 @@
+/** Severity of a message a hook logs. Typed here so hooks stay a leaf slice. */
+export type HookLogLevel = 'debug' | 'info' | 'warn' | 'error';
+/** What a hook knows about where it runs. */
+export interface HookContext {
+    recipeId: string;
+    /** The extracted values visible at the call site, child scopes shadowing parents. */
+    scope: Record<string, unknown>;
+    log: (level: HookLogLevel, message: string, meta?: Record<string, unknown>) => void;
+}
+/**
+ * A programmatic handler a recipe references by name, from a `hook` step
+ * (`input` is `undefined`) or a `hook` transform (`input` is the value so far).
+ */
+export type Hook = (input: unknown, args: Record<string, unknown>, context: HookContext) => unknown;
+/** Hooks by the name recipes use. */
+export type HookMap = Record<string, Hook>;
+//# sourceMappingURL=hook.contract.d.ts.map

package/dist/hooks/hook.error.d.ts

@@ -0,0 +1,7 @@
+/** A recipe named a hook nothing registered. */
+export declare class UnknownHookError extends Error {
+    readonly hookName: string;
+    readonly name = "UnknownHookError";
+    constructor(hookName: string, known: readonly string[]);
+}
+//# sourceMappingURL=hook.error.d.ts.map

package/dist/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export type { Hook, HookMap, HookContext, HookLogLevel } from './hook.contract.js';
+export { HookRegistry } from './hook-registry.store.js';
+export { UnknownHookError } from './hook.error.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,58 @@
+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 { XmlDocument } from '../xml-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 {
+    method?: HttpMethod;
+    url: string;
+    query?: Record<string, string>;
+    headers?: Record<string, string>;
+    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 | WorkbookDocument | DeckDocument | XmlDocument | {
+    kind: 'json';
+    data: unknown;
+} | {
+    kind: 'html';
+    html: string;
+} | {
+    kind: 'text';
+    text: string;
+};
+export interface HttpResponse {
+    status: number;
+    /** The final URL after redirects. */
+    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 {
+    send: (request: HttpRequest) => Promise<HttpResponse>;
+}
+/** A response with a 4xx or 5xx status. */
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly url: string;
+    readonly body: HttpBody;
+    readonly headers: Record<string, string>;
+    readonly name = "HttpError";
+    constructor(status: number, url: string, body: HttpBody, headers?: Record<string, string>);
+}
+//# sourceMappingURL=http-response.contract.d.ts.map

package/dist/http-session/http.client.d.ts

@@ -0,0 +1,42 @@
+import type { APIRequestContext } from 'playwright';
+import type { HttpRequest, HttpResponse, HttpSender } from './http-response.contract.js';
+/** Playwright's storage state: cookies plus per-origin local storage. */
+export type StorageState = Awaited<ReturnType<APIRequestContext['storageState']>>;
+export interface HttpClientOptions {
+    /** Cookies and storage captured by a browser session, or loaded from a file. */
+    storageState?: StorageState;
+    headers?: Record<string, string>;
+    userAgent?: string;
+    timeoutMs?: number;
+    ignoreHTTPSErrors?: boolean;
+    /** Send every request through this proxy. */
+    proxy?: {
+        server: string;
+        username?: string;
+        password?: string;
+        bypass?: string;
+    };
+}
+/**
+ * HTTP through Playwright's request context: cookies, redirects and storage
+ * state behave exactly as they do in the browser, so a session captured by a
+ * browser bootstrap can be reused without translation. No browser is launched.
+ */
+export declare class HttpClient implements HttpSender {
+    private readonly context;
+    private readonly timeoutMs;
+    static open(options?: HttpClientOptions): Promise<HttpClient>;
+    private constructor();
+    /**
+     * Sends a request and parses the body.
+     *
+     * @param httpRequest - What to send.
+     * @returns The response.
+     * @throws HttpError for a 4xx or 5xx status.
+     */
+    send(httpRequest: HttpRequest): Promise<HttpResponse>;
+    /** The cookies and storage this context holds now. */
+    storageState(): Promise<StorageState>;
+    dispose(): Promise<void>;
+}
+//# sourceMappingURL=http.client.d.ts.map

package/dist/http-session/index.d.ts

@@ -0,0 +1,5 @@
+export { HttpClient } from './http.client.js';
+export type { HttpClientOptions, StorageState } from './http.client.js';
+export { HttpError } from './http-response.contract.js';
+export type { HttpRequest, HttpResponse, HttpBody, HttpSender } from './http-response.contract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/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