recker 1.0.2-0 → 1.0.3

package/dist/plugins/odata.js

@@ -0,0 +1,561 @@
+export class ODataException extends Error {
+    code;
+    target;
+    details;
+    innererror;
+    constructor(error) {
+        super(error.message);
+        this.name = 'ODataException';
+        this.code = error.code;
+        this.target = error.target;
+        this.details = error.details;
+        this.innererror = error.innererror;
+    }
+}
+export class ODataQueryBuilder {
+    client;
+    entitySet;
+    entityKey;
+    queryOptions = {};
+    requestOptions;
+    constructor(client, entitySet) {
+        this.client = client;
+        this.entitySet = entitySet;
+    }
+    key(key) {
+        this.entityKey = key;
+        return this;
+    }
+    select(...properties) {
+        this.queryOptions.$select = properties;
+        return this;
+    }
+    expand(...properties) {
+        const hasExpandOptions = properties.some((p) => typeof p !== 'string');
+        if (hasExpandOptions) {
+            this.queryOptions.$expand = properties;
+        }
+        else {
+            this.queryOptions.$expand = properties;
+        }
+        return this;
+    }
+    filter(filter) {
+        if (typeof filter === 'function') {
+            const builder = new FilterBuilder();
+            this.queryOptions.$filter = filter(builder).build();
+        }
+        else {
+            this.queryOptions.$filter = filter;
+        }
+        return this;
+    }
+    orderBy(property, direction = 'asc') {
+        const existing = this.queryOptions.$orderby;
+        const option = { property, direction };
+        if (Array.isArray(existing)) {
+            existing.push(option);
+        }
+        else if (existing) {
+            this.queryOptions.$orderby = [{ property: existing, direction: 'asc' }, option];
+        }
+        else {
+            this.queryOptions.$orderby = [option];
+        }
+        return this;
+    }
+    top(count) {
+        this.queryOptions.$top = count;
+        return this;
+    }
+    skip(count) {
+        this.queryOptions.$skip = count;
+        return this;
+    }
+    count(include = true) {
+        this.queryOptions.$count = include;
+        return this;
+    }
+    search(term) {
+        this.queryOptions.$search = term;
+        return this;
+    }
+    custom(key, value) {
+        this.queryOptions[key] = value;
+        return this;
+    }
+    options(options) {
+        this.requestOptions = options;
+        return this;
+    }
+    async get() {
+        return this.client.get(this.entitySet, this.entityKey, this.queryOptions, this.requestOptions);
+    }
+    async *getAll() {
+        let response = await this.get();
+        while (response.value) {
+            for (const item of response.value) {
+                yield item;
+            }
+            if (response['@odata.nextLink']) {
+                response = await this.client.getNextPage(response['@odata.nextLink']);
+            }
+            else {
+                break;
+            }
+        }
+    }
+    toUrl() {
+        return this.client.buildUrl(this.entitySet, this.entityKey, this.queryOptions);
+    }
+}
+export class FilterBuilder {
+    parts = [];
+    eq(property, value) {
+        this.parts.push(`${property} eq ${this.formatValue(value)}`);
+        return this;
+    }
+    ne(property, value) {
+        this.parts.push(`${property} ne ${this.formatValue(value)}`);
+        return this;
+    }
+    gt(property, value) {
+        this.parts.push(`${property} gt ${this.formatValue(value)}`);
+        return this;
+    }
+    ge(property, value) {
+        this.parts.push(`${property} ge ${this.formatValue(value)}`);
+        return this;
+    }
+    lt(property, value) {
+        this.parts.push(`${property} lt ${this.formatValue(value)}`);
+        return this;
+    }
+    le(property, value) {
+        this.parts.push(`${property} le ${this.formatValue(value)}`);
+        return this;
+    }
+    contains(property, value) {
+        this.parts.push(`contains(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    startswith(property, value) {
+        this.parts.push(`startswith(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    endswith(property, value) {
+        this.parts.push(`endswith(${property},'${this.escapeString(value)}')`);
+        return this;
+    }
+    isNull(property) {
+        this.parts.push(`${property} eq null`);
+        return this;
+    }
+    isNotNull(property) {
+        this.parts.push(`${property} ne null`);
+        return this;
+    }
+    in(property, values) {
+        const formatted = values.map((v) => this.formatValue(v)).join(',');
+        this.parts.push(`${property} in (${formatted})`);
+        return this;
+    }
+    and() {
+        if (this.parts.length > 0) {
+            this.parts.push('and');
+        }
+        return this;
+    }
+    or() {
+        if (this.parts.length > 0) {
+            this.parts.push('or');
+        }
+        return this;
+    }
+    not() {
+        this.parts.push('not');
+        return this;
+    }
+    group(builder) {
+        const inner = new FilterBuilder();
+        const result = builder(inner).build();
+        this.parts.push(`(${result})`);
+        return this;
+    }
+    raw(expression) {
+        this.parts.push(expression);
+        return this;
+    }
+    build() {
+        return this.parts.join(' ');
+    }
+    formatValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${this.escapeString(value)}'`;
+        if (typeof value === 'boolean')
+            return value.toString();
+        if (typeof value === 'number')
+            return value.toString();
+        if (value instanceof Date)
+            return value.toISOString();
+        if (typeof value === 'object')
+            return JSON.stringify(value);
+        return String(value);
+    }
+    escapeString(str) {
+        return str.replace(/'/g, "''");
+    }
+}
+export class ODataClient {
+    client;
+    options;
+    constructor(client, options) {
+        this.client = client;
+        this.options = {
+            serviceRoot: options.serviceRoot.replace(/\/$/, ''),
+            version: options.version ?? '4.0',
+            maxPageSize: options.maxPageSize ?? 100,
+            requestOptions: options.requestOptions ?? {},
+        };
+    }
+    query(entitySet) {
+        return new ODataQueryBuilder(this, entitySet);
+    }
+    async get(entitySet, key, queryOptions, requestOptions) {
+        const url = this.buildUrl(entitySet, key, queryOptions);
+        const response = await this.request('GET', url, undefined, requestOptions);
+        return response;
+    }
+    async getById(entitySet, key, queryOptions, requestOptions) {
+        const response = await this.get(entitySet, key, queryOptions, requestOptions);
+        return response;
+    }
+    async getNextPage(nextLink) {
+        const response = await this.client.get(nextLink, {
+            ...this.options.requestOptions,
+            headers: this.getHeaders(),
+        });
+        return this.handleResponse(response);
+    }
+    async create(entitySet, entity, requestOptions) {
+        const url = this.buildUrl(entitySet);
+        return this.request('POST', url, entity, requestOptions);
+    }
+    async update(entitySet, key, entity, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        return this.request('PATCH', url, entity, requestOptions);
+    }
+    async replace(entitySet, key, entity, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        return this.request('PUT', url, entity, requestOptions);
+    }
+    async delete(entitySet, key, requestOptions) {
+        const url = this.buildUrl(entitySet, key);
+        await this.request('DELETE', url, undefined, requestOptions);
+    }
+    async action(action, params, requestOptions) {
+        const url = `${this.options.serviceRoot}/${action}`;
+        return this.request('POST', url, params, requestOptions);
+    }
+    async function(func, params, requestOptions) {
+        let url = `${this.options.serviceRoot}/${func}`;
+        if (params && Object.keys(params).length > 0) {
+            const paramString = Object.entries(params)
+                .map(([k, v]) => `${k}=${this.formatKeyValue(v)}`)
+                .join(',');
+            url += `(${paramString})`;
+        }
+        return this.request('GET', url, undefined, requestOptions);
+    }
+    async batch(requests, requestOptions) {
+        const boundary = `batch_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+        const batchUrl = `${this.options.serviceRoot}/$batch`;
+        let body = '';
+        for (const req of requests) {
+            body += `--${boundary}\r\n`;
+            body += 'Content-Type: application/http\r\n';
+            body += 'Content-Transfer-Encoding: binary\r\n\r\n';
+            body += `${req.method} ${req.url} HTTP/1.1\r\n`;
+            if (req.headers) {
+                for (const [key, value] of Object.entries(req.headers)) {
+                    body += `${key}: ${value}\r\n`;
+                }
+            }
+            if (req.body) {
+                body += 'Content-Type: application/json\r\n\r\n';
+                body += JSON.stringify(req.body);
+            }
+            body += '\r\n';
+        }
+        body += `--${boundary}--\r\n`;
+        const response = await this.client.post(batchUrl, body, {
+            ...this.options.requestOptions,
+            ...requestOptions,
+            headers: {
+                ...this.getHeaders(),
+                'Content-Type': `multipart/mixed; boundary=${boundary}`,
+                ...requestOptions?.headers,
+            },
+        });
+        const responseText = await response.text();
+        return this.parseBatchResponse(responseText);
+    }
+    async getMetadata() {
+        const response = await this.client.get(`${this.options.serviceRoot}/$metadata`, {
+            ...this.options.requestOptions,
+            headers: {
+                Accept: 'application/xml',
+            },
+        });
+        return response.text();
+    }
+    buildUrl(entitySet, key, queryOptions) {
+        let url = `${this.options.serviceRoot}/${entitySet}`;
+        if (key !== undefined) {
+            url += `(${this.formatKey(key)})`;
+        }
+        if (queryOptions) {
+            const params = this.buildQueryString(queryOptions);
+            if (params) {
+                url += `?${params}`;
+            }
+        }
+        return url;
+    }
+    getHeaders() {
+        return {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'OData-Version': this.options.version,
+            'OData-MaxVersion': '4.01',
+        };
+    }
+    async request(method, url, body, requestOptions) {
+        const options = {
+            ...this.options.requestOptions,
+            ...requestOptions,
+            throwHttpErrors: false,
+            headers: {
+                ...this.getHeaders(),
+                ...requestOptions?.headers,
+            },
+        };
+        let response;
+        switch (method) {
+            case 'GET':
+                response = await this.client.get(url, options);
+                break;
+            case 'POST':
+                response = await this.client.post(url, body, options);
+                break;
+            case 'PUT':
+                response = await this.client.put(url, body, options);
+                break;
+            case 'PATCH':
+                response = await this.client.patch(url, body, options);
+                break;
+            case 'DELETE':
+                response = await this.client.delete(url, options);
+                break;
+            default:
+                throw new Error(`Unsupported method: ${method}`);
+        }
+        return this.handleResponse(response);
+    }
+    async handleResponse(response) {
+        if (response.status === 204) {
+            return undefined;
+        }
+        const data = await response.json();
+        if (!response.ok) {
+            const error = data;
+            if (error.error) {
+                throw new ODataException(error.error);
+            }
+            throw new Error(`OData request failed: ${response.status}`);
+        }
+        return data;
+    }
+    formatKey(key) {
+        if (typeof key === 'string') {
+            return `'${key.replace(/'/g, "''")}'`;
+        }
+        if (typeof key === 'number') {
+            return key.toString();
+        }
+        return Object.entries(key)
+            .map(([k, v]) => `${k}=${this.formatKeyValue(v)}`)
+            .join(',');
+    }
+    formatKeyValue(value) {
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "''")}'`;
+        if (value === null)
+            return 'null';
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    buildQueryString(options) {
+        const params = [];
+        if (options.$select) {
+            const select = Array.isArray(options.$select) ? options.$select.join(',') : options.$select;
+            params.push(`$select=${encodeURIComponent(select)}`);
+        }
+        if (options.$expand) {
+            const expand = this.formatExpand(options.$expand);
+            params.push(`$expand=${encodeURIComponent(expand)}`);
+        }
+        if (options.$filter) {
+            const filter = typeof options.$filter === 'string'
+                ? options.$filter
+                : this.formatFilterExpression(options.$filter);
+            params.push(`$filter=${encodeURIComponent(filter)}`);
+        }
+        if (options.$orderby) {
+            const orderby = this.formatOrderBy(options.$orderby);
+            params.push(`$orderby=${encodeURIComponent(orderby)}`);
+        }
+        if (options.$top !== undefined) {
+            params.push(`$top=${options.$top}`);
+        }
+        if (options.$skip !== undefined) {
+            params.push(`$skip=${options.$skip}`);
+        }
+        if (options.$count !== undefined) {
+            params.push(`$count=${options.$count}`);
+        }
+        if (options.$search) {
+            params.push(`$search=${encodeURIComponent(options.$search)}`);
+        }
+        if (options.$format) {
+            params.push(`$format=${options.$format}`);
+        }
+        for (const [key, value] of Object.entries(options)) {
+            if (!key.startsWith('$') && value !== undefined) {
+                params.push(`${key}=${encodeURIComponent(String(value))}`);
+            }
+        }
+        return params.join('&');
+    }
+    formatExpand(expand) {
+        if (typeof expand === 'string')
+            return expand;
+        if (Array.isArray(expand)) {
+            return expand.map((e) => {
+                if (typeof e === 'string')
+                    return e;
+                return this.formatExpandOption(e);
+            }).join(',');
+        }
+        return '';
+    }
+    formatExpandOption(option) {
+        let result = option.property;
+        const nested = [];
+        if (option.select)
+            nested.push(`$select=${option.select.join(',')}`);
+        if (option.filter) {
+            const filter = typeof option.filter === 'string'
+                ? option.filter
+                : this.formatFilterExpression(option.filter);
+            nested.push(`$filter=${filter}`);
+        }
+        if (option.orderby)
+            nested.push(`$orderby=${this.formatOrderBy(option.orderby)}`);
+        if (option.top !== undefined)
+            nested.push(`$top=${option.top}`);
+        if (option.skip !== undefined)
+            nested.push(`$skip=${option.skip}`);
+        if (option.count !== undefined)
+            nested.push(`$count=${option.count}`);
+        if (option.expand)
+            nested.push(`$expand=${this.formatExpand(option.expand)}`);
+        if (nested.length > 0) {
+            result += `(${nested.join(';')})`;
+        }
+        return result;
+    }
+    formatOrderBy(orderby) {
+        if (typeof orderby === 'string')
+            return orderby;
+        return orderby.map((o) => `${o.property} ${o.direction ?? 'asc'}`).join(',');
+    }
+    formatFilterExpression(filter) {
+        if (filter.raw)
+            return filter.raw;
+        const parts = [];
+        if (filter.eq)
+            parts.push(`${filter.eq[0]} eq ${this.formatFilterValue(filter.eq[1])}`);
+        if (filter.ne)
+            parts.push(`${filter.ne[0]} ne ${this.formatFilterValue(filter.ne[1])}`);
+        if (filter.gt)
+            parts.push(`${filter.gt[0]} gt ${this.formatFilterValue(filter.gt[1])}`);
+        if (filter.ge)
+            parts.push(`${filter.ge[0]} ge ${this.formatFilterValue(filter.ge[1])}`);
+        if (filter.lt)
+            parts.push(`${filter.lt[0]} lt ${this.formatFilterValue(filter.lt[1])}`);
+        if (filter.le)
+            parts.push(`${filter.le[0]} le ${this.formatFilterValue(filter.le[1])}`);
+        if (filter.contains)
+            parts.push(`contains(${filter.contains[0]},'${filter.contains[1]}')`);
+        if (filter.startswith)
+            parts.push(`startswith(${filter.startswith[0]},'${filter.startswith[1]}')`);
+        if (filter.endswith)
+            parts.push(`endswith(${filter.endswith[0]},'${filter.endswith[1]}')`);
+        if (filter.and) {
+            const andParts = filter.and.map((f) => this.formatFilterExpression(f));
+            parts.push(`(${andParts.join(' and ')})`);
+        }
+        if (filter.or) {
+            const orParts = filter.or.map((f) => this.formatFilterExpression(f));
+            parts.push(`(${orParts.join(' or ')})`);
+        }
+        if (filter.not) {
+            parts.push(`not (${this.formatFilterExpression(filter.not)})`);
+        }
+        return parts.join(' and ');
+    }
+    formatFilterValue(value) {
+        if (value === null)
+            return 'null';
+        if (typeof value === 'string')
+            return `'${value.replace(/'/g, "''")}'`;
+        if (typeof value === 'boolean')
+            return value.toString();
+        if (typeof value === 'number')
+            return value.toString();
+        if (value instanceof Date)
+            return value.toISOString();
+        return String(value);
+    }
+    parseBatchResponse(responseText) {
+        const results = [];
+        const boundaryMatch = responseText.match(/--batch[^\r\n]+/);
+        if (!boundaryMatch)
+            return results;
+        const boundary = boundaryMatch[0];
+        const parts = responseText.split(boundary).slice(1, -1);
+        for (const part of parts) {
+            const statusMatch = part.match(/HTTP\/\d\.\d\s+(\d+)/);
+            const bodyMatch = part.match(/\r\n\r\n({[\s\S]*})/);
+            results.push({
+                status: statusMatch ? parseInt(statusMatch[1], 10) : 0,
+                body: bodyMatch ? JSON.parse(bodyMatch[1]) : null,
+            });
+        }
+        return results;
+    }
+}
+export function createODataClient(client, options) {
+    return new ODataClient(client, options);
+}
+export function odata() {
+    return (client) => {
+        client.odata = (serviceRoot, options) => {
+            return createODataClient(client, { serviceRoot, ...options });
+        };
+    };
+}

package/dist/plugins/retry.d.ts

@@ -9,6 +9,7 @@ export interface RetryOptions {
     statusCodes?: number[];
     shouldRetry?: (error: unknown) => boolean;
     onRetry?: (attempt: number, error: unknown, delay: number) => void;
+    respectRetryAfter?: boolean;
 }
 export declare function retry(options?: RetryOptions): Plugin;
 //# sourceMappingURL=retry.d.ts.map

package/dist/plugins/retry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/plugins/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAC;AAExE,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpE;AAgDD,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CAgFxD"}
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/plugins/retry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAGvD,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,aAAa,GAAG,cAAc,CAAC;AAExE,MAAM,WAAW,YAAY;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;IAC1C,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAMnE,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AA4ED,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,MAAM,CA2FxD"}

package/dist/plugins/retry.js

@@ -23,14 +23,29 @@ function calculateDelay(attempt, baseDelay, maxDelay, strategy, useJitter) {
     }
     return Math.max(0, Math.floor(calculatedDelay));
 }
+function parseRetryAfter(headerValue) {
+    if (!headerValue)
+        return undefined;
+    const seconds = parseInt(headerValue, 10);
+    if (!isNaN(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const date = Date.parse(headerValue);
+    if (!isNaN(date)) {
+        const delay = date - Date.now();
+        return delay > 0 ? delay : undefined;
+    }
+    return undefined;
+}
 export function retry(options = {}) {
     const maxAttempts = options.maxAttempts || 3;
     const baseDelay = options.delay || 1000;
-    const maxDelay = options.maxDelay || 30_000;
+    const maxDelay = options.maxDelay || 30000;
     const backoffStrategy = options.backoff || 'exponential';
     const useJitter = options.jitter !== false;
     const statusCodes = options.statusCodes || [408, 429, 500, 502, 503, 504];
     const onRetry = options.onRetry;
+    const respectRetryAfter = options.respectRetryAfter !== false;
     const defaultShouldRetry = (error) => {
         if (error instanceof NetworkError)
             return true;
@@ -54,7 +69,16 @@ export function retry(options = {}) {
                     attempt++;
                     const res = await next(req);
                     if (attempt < maxAttempts && !res.ok && statusCodes.includes(res.status)) {
-                        const delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        let delayMs;
+                        if (respectRetryAfter) {
+                            const retryAfterDelay = parseRetryAfter(res.headers.get('Retry-After'));
+                            delayMs = retryAfterDelay !== undefined
+                                ? Math.min(retryAfterDelay, maxDelay)
+                                : calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        }
+                        else {
+                            delayMs = calculateDelay(attempt, baseDelay, maxDelay, backoffStrategy, useJitter);
+                        }
                         const err = new HttpError(res, req);
                         if (onRetry) {
                             onRetry(attempt, err, delayMs);

package/dist/plugins/scrape.d.ts

@@ -0,0 +1,22 @@
+import type { ReckerResponse } from '../types/index.js';
+import type { RequestPromise } from '../core/request-promise.js';
+import type { ScrapeOptions, ExtractionSchema, ExtractedLink, ExtractedImage, ExtractedMeta, OpenGraphData, TwitterCardData, JsonLdData, ExtractedForm, ExtractedTable, ExtractedScript, ExtractedStyle, LinkExtractionOptions, ImageExtractionOptions } from '../scrape/types.js';
+export interface ScrapePromise<T> extends Promise<T> {
+    scrape(options?: ScrapeOptions): Promise<import('../scrape/document.js').ScrapeDocument>;
+    links(options?: LinkExtractionOptions): Promise<ExtractedLink[]>;
+    images(options?: ImageExtractionOptions): Promise<ExtractedImage[]>;
+    meta(): Promise<ExtractedMeta>;
+    openGraph(): Promise<OpenGraphData>;
+    twitterCard(): Promise<TwitterCardData>;
+    jsonLd(): Promise<JsonLdData[]>;
+    forms(selector?: string): Promise<ExtractedForm[]>;
+    tables(selector?: string): Promise<ExtractedTable[]>;
+    scripts(): Promise<ExtractedScript[]>;
+    styles(): Promise<ExtractedStyle[]>;
+    extract<R extends Record<string, unknown>>(schema: ExtractionSchema): Promise<R>;
+}
+export declare function scrape<T extends ReckerResponse>(promise: RequestPromise<T> | Promise<T>): ScrapePromise<T>;
+export declare function parseHtml(html: string, options?: ScrapeOptions): Promise<import('../scrape/document.js').ScrapeDocument>;
+export declare function scrapeResponse(promise: Promise<ReckerResponse>, options?: ScrapeOptions): Promise<import('../scrape/document.js').ScrapeDocument>;
+export type { ScrapeOptions, ExtractionSchema, ExtractedLink, ExtractedImage, ExtractedMeta, OpenGraphData, TwitterCardData, JsonLdData, ExtractedForm, ExtractedFormField, ExtractedTable, ExtractedScript, ExtractedStyle, LinkExtractionOptions, ImageExtractionOptions, } from '../scrape/types.js';
+//# sourceMappingURL=scrape.d.ts.map

package/dist/plugins/scrape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrape.d.ts","sourceRoot":"","sources":["../../src/plugins/scrape.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,KAAK,EACV,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,eAAe,EACf,UAAU,EACV,aAAa,EACb,cAAc,EACd,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,sBAAsB,EACvB,MAAM,oBAAoB,CAAC;AAsB5B,MAAM,WAAW,aAAa,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IAIlD,MAAM,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,uBAAuB,EAAE,cAAc,CAAC,CAAC;IAKzF,KAAK,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAKjE,MAAM,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAKpE,IAAI,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAK/B,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IAKpC,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC,CAAC;IAKxC,MAAM,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;IAKhC,KAAK,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAAC;IAKnD,MAAM,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAKrD,OAAO,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;IAKtC,MAAM,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAKpC,OAAO,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAClF;AA2BD,wBAAgB,MAAM,CAAC,CAAC,SAAS,cAAc,EAC7C,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GACtC,aAAa,CAAC,CAAC,CAAC,CA8ElB;AAcD,wBAAsB,SAAS,CAC7B,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,uBAAuB,EAAE,cAAc,CAAC,CAGzD;AAaD,wBAAsB,cAAc,CAClC,OAAO,EAAE,OAAO,CAAC,cAAc,CAAC,EAChC,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,uBAAuB,EAAE,cAAc,CAAC,CAQzD;AAGD,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,eAAe,EACf,UAAU,EACV,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,eAAe,EACf,cAAc,EACd,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,oBAAoB,CAAC"}