/**
 * `scrape` — zero-dependency string/JSON extraction primitives for
 * server-rendered pages.
 *
 * Consolidates the SSR JSON-store extraction stack the fleet re-implemented at
 * least five times: musescore's `store.ts` (entity recovery + string-aware
 * bracket matching), tock's `redux-state.ts` (top-level slice extraction +
 * JS-literal repair) and `parse.ts` (cycle-guarded deep walkers), zillow's
 * `page-props.ts` (`findArrayByShape`), etix's `parse.ts` (JSON-LD / OpenGraph
 * / dataLayer readers), plus the entity-decode/strip-tags helpers duplicated in
 * alltrails / musescore / signupgenius and the anti-XSSI guard strippers in
 * workday / canvas / redfin.
 *
 * Everything here is pure string/JSON work — NO `node-html-parser`. DOM-level
 * scraping (tables, link lists) lives in `@chrischall/mcp-utils/html`, which
 * carries that optional peer dep; this module is safe for the core barrel.
 */
/**
 * Decode HTML character references: decimal (`A`) and hex (`A`)
 * numerics plus the common named entities. `&` is decoded **last** so a
 * double-escaped entity survives exactly one level (`<` → `<`, not
 * `<`) — the ordering both alltrails' `stripHtml` and musescore's `decodeText`
 * depend on when recovering attribute-escaped JSON. Unknown entities pass
 * through untouched.
 */
export declare function decodeHtmlEntities(text: string): string;
/**
 * Strip an HTML **fragment** to readable text: tags → spaces, entities decoded
 * (via {@link decodeHtmlEntities}), whitespace collapsed and trimmed.
 *
 * For a full document where inline `<script>`/`<style>` *content* must not leak
 * into the output, use `extractPlainTextFromHtml` from
 * `@chrischall/mcp-utils/html` — this fragment-level helper does not remove
 * element content, only markup.
 */
export declare function stripHtml(html: string): string;
/**
 * Replace bare JS `undefined` literals with `null` so a scraped JS object
 * literal becomes parseable JSON. String-aware: occurrences inside single- or
 * double-quoted strings are left alone, as are identifiers that merely contain
 * the word. Consolidates tock's `sanitizeJsLiterals`.
 */
export declare function sanitizeJsLiterals(text: string): string;
/**
 * Given `text[start]` on a `{` or `[`, walk the balanced structure — tracking
 * double- AND single-quoted strings and backslash escapes so brackets inside
 * string literals don't terminate it early — and return the **exclusive** end
 * index. Returns `-1` when `start` isn't on an opener or the structure never
 * closes. Consolidates musescore's `matchBracket` and the brace-walk inside
 * tock's `extractReduxSlice` (regex can't do this: the stores nest and escape).
 */
export declare function matchBalanced(text: string, start: number): number;
/** Options for {@link extractJsonAfterMarker}. */
export interface ExtractJsonOptions {
    /** Run {@link sanitizeJsLiterals} before parsing (JS object literals). */
    sanitize?: boolean;
}
/**
 * Find the first of `markers` in `text`, skip to the next `{` or `[`, walk the
 * balanced structure ({@link matchBalanced}), and `JSON.parse` it. Returns
 * `null` on any failure — marker absent, no opener, unbalanced, or invalid
 * JSON — so callers can branch without a try/catch.
 *
 * The array-capable, multi-marker, JS-literal-tolerant generalization of the
 * `/html` subpath's `extractJsonFromHtml` (which is object-only and marker-form
 * fixed). Use this for `window.$REDUX_STATE` slices (tock), `__NEXT_DATA__`
 * analogues, and attribute-escaped stores (run the text through
 * {@link decodeHtmlEntities} first when the blob is entity-escaped).
 */
export declare function extractJsonAfterMarker(text: string, markers: string | string[], opts?: ExtractJsonOptions): unknown;
/**
 * Parse every `<script type="application/ld+json">` block in the page,
 * skipping malformed ones. Returns the parsed values in document order.
 * Consolidates etix's / tripadvisor's ld+json block iteration.
 *
 * Linear-time by construction: `indexOf`-driven tag scanning (find `<script`,
 * find its `>`, find `</script>`), never a `[^>]*>` regex — the previous
 * single mega-regex was O(n³) and its `[^>]*>`-per-opener replacement is still
 * O(n²); string `indexOf` doesn't backtrack, so an unterminated
 * `<script type="application/ld+json"` flood can't pin the event loop.
 */
export declare function extractJsonLdBlocks(html: string): unknown[];
/**
 * Find the first schema.org entity of `@type === type` across the page's
 * JSON-LD blocks — checking each block itself, its array items, its `@graph`
 * items, and each candidate's `mainEntity` (the etix pattern: the Event often
 * hides inside a `WebPage.mainEntity`). Returns the matching node, or `null`.
 */
export declare function findJsonLdEntity(html: string, type: string): Record<string, unknown> | null;
/**
 * Read a `<meta property="og:…" content="…">` value, tolerant of either
 * attribute order (both occur in the wild — etix's `ogContent`) and of
 * `name=`-keyed OpenGraph. The content is entity-decoded. Returns `undefined`
 * when the property is absent.
 *
 * Linear-time by construction: `indexOf`-driven `<meta …>` scanning, reading
 * the `property`/`content` attributes WITHIN each single (bounded) tag — never
 * a `<meta\s[^>]*PROP[^>]*content…` regex, which backtracked quadratically on a
 * flood of unterminated `<meta property=…` (a ReDoS on hostile scraped HTML).
 */
export declare function ogContent(html: string, property: string): string | undefined;
/**
 * Locate an array inside a drifting JSON container (a `pageProps` /
 * `__NEXT_DATA__` blob): try `directKeys` first, then scan the container's
 * top-level array values and return the first whose FIRST element passes
 * `looksRight`. An empty array at a direct key is trusted (there is no first
 * element to test). Returns `[]` on a miss — never `undefined` — so projections
 * degrade to "no rows" instead of crashing when the upstream renames a key.
 * Consolidates zillow's `page-props.ts#findArrayByShape`.
 */
export declare function findArrayByShape<T = unknown>(container: Record<string, unknown>, directKeys: string[], looksRight: (first: unknown) => boolean): T[];
/**
 * Depth-first, cycle-guarded walk collecting every array whose FIRST element
 * passes `pred`. Recurses into matched arrays too (nested hits are collected).
 * Consolidates tock's `collectArrays` — the "walk for the shape, don't
 * hard-code the path" discipline for SSR stores.
 */
export declare function deepCollectArrays(root: unknown, pred: (first: unknown) => boolean): unknown[][];
/**
 * Depth-first, cycle-guarded search for the first non-array object passing
 * `pred`. Returns `null` when nothing matches. Consolidates tock's
 * `findObject`.
 */
export declare function deepFindObject(root: unknown, pred: (obj: Record<string, unknown>) => boolean): Record<string, unknown> | null;
/**
 * Detect a Cloudflare challenge interstitial by its DEFINITIVE markers only:
 * the `_cf_chl_opt` bootstrap object or a `<title>Just a moment` page title.
 * Deliberately does NOT match `cdn-cgi/challenge-platform` or
 * `challenges.cloudflare.com` references — Cloudflare inlines those on CLEARED
 * pages too, and matching them false-positives on legit pages (the musescore
 * "search works but detail pages fail" bug). Consolidates the byte-identical
 * predicates in musescore and tock.
 */
export declare function isCloudflareChallenge(html: string): boolean;
/**
 * Strip anti-XSSI / anti-JSON-hijacking guard prefixes from a response body so
 * it parses as JSON: `)]}'`, `while(1);`, `for(;;);`, and `{}&&` (redfin's
 * stingray envelope), plus surrounding whitespace, applied repeatedly until no
 * guard remains. Unguarded input passes through unchanged. Consolidates
 * workday's `stripJsonGuard`, canvas-parent's `while(1);` strip, and redfin's
 * `stripStingrayPrefix`.
 */
export declare function stripJsonGuard(text: string): string;
//# sourceMappingURL=index.d.ts.map