@opencraw/core 0.1.0

package/dist/src/recipe-schema/transform-rule.contract.d.ts

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import type { MissingPolicy } from './recipe-kind.enum.js';
+/** One operation in a mapping chain. The set is closed: extension happens through `hook`. */
+export type TransformRule = {
+    op: 'trim';
+} | {
+    op: 'lowercase';
+} | {
+    op: 'uppercase';
+} | {
+    op: 'replace';
+    pattern: string;
+    replacement: string;
+    flags?: string;
+} | {
+    op: 'regex';
+    pattern: string;
+    group?: number;
+    flags?: string;
+} | {
+    op: 'split';
+    separator: string;
+} | {
+    op: 'join';
+    separator: string;
+} | {
+    op: 'first';
+} | {
+    op: 'last';
+} | {
+    op: 'nth';
+    index: number;
+} | {
+    op: 'slice';
+    start: number;
+    end?: number;
+} | {
+    op: 'concat';
+    separator?: string;
+} | {
+    op: 'coalesce';
+} | {
+    op: 'default';
+    value: unknown;
+} | {
+    op: 'number';
+    locale?: string;
+} | {
+    op: 'integer';
+} | {
+    op: 'boolean';
+    truthy?: string[];
+} | {
+    op: 'currency';
+    locale?: string;
+    currency?: string;
+} | {
+    op: 'date';
+    format?: string;
+    timezone?: string;
+} | {
+    op: 'absoluteUrl';
+    base?: string;
+} | 
+/** Percent-encodes text for one URL component (`encodeURIComponent`). */
+{
+    op: 'urlEncode';
+} | {
+    op: 'flatten';
+} | {
+    op: 'unique';
+} | {
+    op: 'sum';
+} | {
+    op: 'count';
+} | {
+    op: 'template';
+    value: string;
+} | {
+    op: 'jsonpath';
+    path: string;
+} | 
+/** Finds the item of a table (an id or path in scope) whose `key` path equals the input; yields `pick` from it, or the item. */
+{
+    op: 'lookup';
+    in: string;
+    key: string;
+    pick?: string;
+} | 
+/** Groups a list by a path into `[{ key, items }]`, first-seen order. */
+{
+    op: 'group';
+    by: string;
+} | {
+    op: 'hook';
+    name: string;
+    args?: Record<string, unknown>;
+};
+export type TransformOp = TransformRule['op'];
+/** Binds one output field to extracted values. */
+export type MappingRule = {
+    from: string | string[];
+    transform?: TransformRule[];
+    onMissing?: MissingPolicy;
+} | 
+/** Builds an array of objects from a list: `fields` paths are relative to each list item. */
+{
+    each: string;
+    fields: Record<string, MappingRule>;
+    onMissing?: MissingPolicy;
+};
+export type FromRule = Extract<MappingRule, {
+    from: unknown;
+}>;
+export type EachRule = Extract<MappingRule, {
+    each: unknown;
+}>;
+export declare const transformRuleSchema: z.ZodType<TransformRule>;
+export declare const mappingRuleSchema: z.ZodType<MappingRule>;
+//# sourceMappingURL=transform-rule.contract.d.ts.map

package/dist/src/record-sink/dedupe.policy.d.ts

@@ -0,0 +1,17 @@
+import type { OutputRecord } from '../output-mapping/index.js';
+/** How far de-duplication reaches: the whole run, one input recipe, or not at all. */
+export type DedupeScope = 'run' | 'recipe' | 'off';
+/** Drops records whose key was already seen. First record wins; keyless records always pass. */
+export declare class DedupePolicy {
+    readonly scope: DedupeScope;
+    private seen;
+    constructor(scope?: DedupeScope);
+    /** Called when an input recipe starts; forgets keys under `recipe` scope. */
+    startRecipe(): void;
+    /**
+     * @param record - A validated record.
+     * @returns `true` when the record repeats an earlier key and must be dropped.
+     */
+    isDuplicate(record: OutputRecord): boolean;
+}
+//# sourceMappingURL=dedupe.policy.d.ts.map

package/dist/src/record-sink/index.d.ts

@@ -0,0 +1,8 @@
+export type { RecordSink, SinkSummary } from './record-sink.contract.js';
+export { memorySink } from './memory-sink.repository.js';
+export type { MemorySink } from './memory-sink.repository.js';
+export { jsonLinesSink } from './json-lines-sink.repository.js';
+export type { JsonLinesSinkOptions } from './json-lines-sink.repository.js';
+export { DedupePolicy } from './dedupe.policy.js';
+export type { DedupeScope } from './dedupe.policy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/record-sink/json-lines-sink.repository.d.ts

@@ -0,0 +1,19 @@
+import type { RecordSink } from './record-sink.contract.js';
+export interface JsonLinesSinkOptions {
+    /**
+     * Keep what the file holds and add to it. Each line then carries the record
+     * key as `_key`, and `open` reads the keys already there so a resumed run
+     * (`CrawlOptions.resume`) can skip them.
+     */
+    append?: boolean;
+}
+/**
+ * A sink that writes one JSON object per line to a file (JSON Lines). Each line
+ * is the record's `data` plus a `_source` member (and `_key` in append mode).
+ *
+ * @param path - The file to write; created with its directories, truncated on open unless `append`.
+ * @param options - Append mode.
+ * @returns The sink.
+ */
+export declare function jsonLinesSink(path: string, options?: JsonLinesSinkOptions): RecordSink;
+//# sourceMappingURL=json-lines-sink.repository.d.ts.map

package/dist/src/record-sink/memory-sink.repository.d.ts

@@ -0,0 +1,9 @@
+import type { OutputRecord } from '../output-mapping/index.js';
+import type { RecordSink } from './record-sink.contract.js';
+/** A sink that keeps records in memory; `records` is readable at any time. */
+export interface MemorySink extends RecordSink {
+    readonly records: OutputRecord[];
+}
+/** @returns A new in-memory sink. */
+export declare function memorySink(): MemorySink;
+//# sourceMappingURL=memory-sink.repository.d.ts.map

package/dist/src/record-sink/record-sink.contract.d.ts

@@ -0,0 +1,17 @@
+import type { OutputRecord } from '../output-mapping/index.js';
+import type { OutputRecipe } from '../recipe-schema/index.js';
+/** What a sink reports when closed. */
+export interface SinkSummary {
+    written: number;
+    /** Where the records went, when the sink has a location. */
+    location?: string;
+}
+/** Where validated records go. Opened once per run, written per record, closed once. */
+export interface RecordSink {
+    open: (output: OutputRecipe) => Promise<void>;
+    write: (record: OutputRecord) => Promise<void>;
+    close: () => Promise<SinkSummary>;
+    /** Whether a record with this key is already there; what a resumed run asks before writing. */
+    has?: (key: string) => Promise<boolean>;
+}
+//# sourceMappingURL=record-sink.contract.d.ts.map

package/dist/src/selection/html-selector.algorithm.d.ts

@@ -0,0 +1,18 @@
+import type { Cheerio, CheerioAPI } from 'cheerio';
+import type { AnyNode } from 'domhandler';
+/** A matched HTML element together with the document it belongs to. */
+export interface HtmlMatch {
+    api: CheerioAPI;
+    element: Cheerio<AnyNode>;
+}
+/**
+ * Runs a CSS selector on static HTML. A whole document is parsed as one; anything
+ * else (a table row, a list item taken with `take: "html"`) is parsed as a
+ * fragment, so cells and rows outside a table survive instead of being dropped.
+ *
+ * @param html - The markup (a whole document or a fragment).
+ * @param selector - A CSS selector.
+ * @returns Every match, in document order.
+ */
+export declare function selectHtml(html: string, selector: string): HtmlMatch[];
+//# sourceMappingURL=html-selector.algorithm.d.ts.map

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

@@ -0,0 +1,8 @@
+export { selectJson } from './json-path.algorithm.js';
+export { selectRegex } from './regex.algorithm.js';
+export { selectHtml } from './html-selector.algorithm.js';
+export type { HtmlMatch } from './html-selector.algorithm.js';
+export { takeFromHtml, takeFromJson, collapse } from './take-value.mapper.js';
+export type { Take } from './take-value.mapper.js';
+export { tryParseJson, parseJsonText, dataItemsOf } from './json-text.algorithm.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/selection/json-path.algorithm.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Evaluates a JSONPath expression on a decoded JSON document.
+ *
+ * @param document - The JSON value.
+ * @param path - A JSONPath such as `$.items[*].url`.
+ * @returns Every match, in document order.
+ */
+export declare function selectJson(document: unknown, path: string): unknown[];
+//# sourceMappingURL=json-path.algorithm.d.ts.map

package/dist/src/selection/json-text.algorithm.d.ts

@@ -0,0 +1,31 @@
+/**
+ * JSON that arrives as text: a `<script type="application/ld+json">` body, a
+ * `data-*` attribute, a fetched document read as text. Sites wrap inline JSON
+ * in comment guards, which are stripped before parsing.
+ */
+/**
+ * Parses text as JSON, guards stripped.
+ *
+ * @param text - The text.
+ * @returns The value, or `undefined` when it is not JSON.
+ */
+export declare function tryParseJson(text: string): unknown;
+/**
+ * Parses text that must be JSON.
+ *
+ * @param text - The text.
+ * @param id - What the text is, for the error.
+ * @returns The value.
+ * @throws Error when it is not JSON.
+ */
+export declare function parseJsonText(text: string, id: string): unknown;
+/**
+ * The data a value holds, whatever shape it arrived in: JSON text is parsed, a
+ * list of texts becomes the list of its parsable entries, and an entry that
+ * parses to a list is spliced in. Data that is not text is kept as is.
+ *
+ * @param value - A bound value: data, text, or a list of either.
+ * @returns A list of items.
+ */
+export declare function dataItemsOf(value: unknown): unknown[];
+//# sourceMappingURL=json-text.algorithm.d.ts.map

package/dist/src/selection/regex.algorithm.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Evaluates a regular expression on text: the extract kind for values that
+ * live in inline scripts, attributes or prose rather than in elements or JSON.
+ *
+ * @param text - The document text.
+ * @param pattern - A regular expression source; group 1 is returned when the
+ * pattern has a capturing group, else the whole match.
+ * @returns Every match, in document order.
+ * @throws When the pattern is not a valid regular expression.
+ */
+export declare function selectRegex(text: string, pattern: string): string[];
+//# sourceMappingURL=regex.algorithm.d.ts.map

package/dist/src/selection/take-value.mapper.d.ts

@@ -0,0 +1,27 @@
+import type { HtmlMatch } from './html-selector.algorithm.js';
+/** What `extract` takes from a match: text, inner HTML, an attribute, an input's value, or the node as data. */
+export type Take = 'text' | 'html' | 'value' | 'json' | `attr:${string}`;
+/**
+ * The value of an HTML match.
+ *
+ * @param match - A selected element.
+ * @param take - What to take; `text` collapses whitespace.
+ * @returns The value; `undefined` for a missing attribute.
+ */
+export declare function takeFromHtml(match: HtmlMatch, take: Take): unknown;
+/**
+ * The value of a JSON match.
+ *
+ * @param node - A JSONPath result.
+ * @param take - `json` keeps the node; `text` stringifies scalars.
+ * @returns The value.
+ */
+export declare function takeFromJson(node: unknown, take: Take): unknown;
+/**
+ * Text as a human reads it: runs of whitespace collapsed, ends trimmed.
+ *
+ * @param text - Raw text content.
+ * @returns The collapsed text.
+ */
+export declare function collapse(text: string): string;
+//# sourceMappingURL=take-value.mapper.d.ts.map

package/dist/src/step-flow/block-rule.policy.d.ts

@@ -0,0 +1,21 @@
+import type { BlockRule } from '../recipe-schema/index.js';
+import { BlockedError } from './blocked.error.js';
+/** A block unless a recipe says otherwise: forbidden, rate limited, or an AWS WAF challenge (IMDb answers 202 with it). */
+export declare const DEFAULT_BLOCK_RULE: BlockRule;
+/** The parts of a response a block rule reads. The body is read only when the rule has a `text` condition. */
+export interface ObservedResponse {
+    url: string;
+    status: number;
+    /** Header names in lower case, as Playwright reports them. */
+    headers: Record<string, string>;
+    text?: () => Promise<string>;
+}
+/**
+ * Whether a response is a block.
+ *
+ * @param response - What came back.
+ * @param rule - The recipe's `session.blockedWhen`; `DEFAULT_BLOCK_RULE` when omitted.
+ * @returns The error to throw, or `undefined` when the response is not a block.
+ */
+export declare function detectBlock(response: ObservedResponse, rule?: BlockRule): Promise<BlockedError | undefined>;
+//# sourceMappingURL=block-rule.policy.d.ts.map

package/dist/src/step-flow/blocked.error.d.ts

@@ -0,0 +1,9 @@
+/** A response the recipe's `session.blockedWhen` rule (or the default one) says is the site refusing the crawl. */
+export declare class BlockedError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly reason: string;
+    readonly name = "BlockedError";
+    constructor(url: string, status: number, reason: string);
+}
+//# sourceMappingURL=blocked.error.d.ts.map

package/dist/src/step-flow/for-each.use-case.d.ts

@@ -0,0 +1,18 @@
+import type { ExtractionScope } from '../extraction-scope/index.js';
+import type { ForEachStep } from '../recipe-schema/index.js';
+import type { EmitOutcome, StepWalk } from './run-steps.use-case.js';
+/**
+ * Runs a body once per item of a list (`over`), or once per live element
+ * matching `selector`, each in a fresh child scope with the item bound under
+ * `as`; emits a record per iteration when asked.
+ *
+ * With a concurrent gate, iterations run as permits allow and records come
+ * out in completion order; without one, in list order.
+ *
+ * @param step - The forEach step.
+ * @param scope - The scope the list lives in.
+ * @param walk - Runs a step list; also carries the emit callback.
+ * @returns `stop` when the crawl reached its record limit.
+ */
+export declare function runForEach(step: ForEachStep, scope: ExtractionScope, walk: StepWalk): Promise<EmitOutcome>;
+//# sourceMappingURL=for-each.use-case.d.ts.map

package/dist/src/step-flow/index.d.ts

@@ -0,0 +1,10 @@
+export { runSteps } from './run-steps.use-case.js';
+export type { StepWalkOptions, EmitOutcome } from './run-steps.use-case.js';
+export type { StepRunner, NextPageResult } from './step-runner.contract.js';
+export { StepFailure, NoMatchError } from './step-failure.error.js';
+export { resolveErrorPolicy, backoffFor, sleep } from './retry.policy.js';
+export { RunGate } from './run-gate.policy.js';
+export { BlockedError } from './blocked.error.js';
+export { detectBlock, DEFAULT_BLOCK_RULE } from './block-rule.policy.js';
+export type { ObservedResponse } from './block-rule.policy.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/step-flow/paginate.use-case.d.ts

@@ -0,0 +1,17 @@
+import type { ExtractionScope } from '../extraction-scope/index.js';
+import type { PaginateStep } from '../recipe-schema/index.js';
+import type { EmitOutcome, StepWalk } from './run-steps.use-case.js';
+/**
+ * Runs a body once per page, each in a fresh child scope, then asks the runner
+ * for the next page until there is none, `until` renders truthy, or `maxPages`
+ * is reached.
+ *
+ * The runner reports the visit of each new page; this only steers.
+ *
+ * @param step - The paginate step.
+ * @param scope - The scope to page in; its page URL advances with each page.
+ * @param walk - Runs a step list; carries the runner and the emit callback.
+ * @returns `stop` when the crawl reached its record limit.
+ */
+export declare function runPaginate(step: PaginateStep, scope: ExtractionScope, walk: StepWalk): Promise<EmitOutcome>;
+//# sourceMappingURL=paginate.use-case.d.ts.map

package/dist/src/step-flow/retry.policy.d.ts

@@ -0,0 +1,21 @@
+import type { ErrorPolicy, InputRecipe, Step } from '../recipe-schema/index.js';
+/**
+ * The policy for a failing step: the step's own, else the recipe's, else `fail`.
+ *
+ * @param step - The step that failed.
+ * @param recipe - Its recipe.
+ * @returns The policy to apply.
+ */
+export declare function resolveErrorPolicy(step: Step, recipe: Pick<InputRecipe, 'onError'>): ErrorPolicy;
+/**
+ * How long to wait before a retry: linear backoff.
+ *
+ * @param policy - A retry policy.
+ * @param attempt - The attempt about to be made, starting at 2.
+ * @returns Milliseconds.
+ */
+export declare function backoffFor(policy: Extract<ErrorPolicy, {
+    policy: 'retry';
+}>, attempt: number): number;
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=retry.policy.d.ts.map

package/dist/src/step-flow/run-gate.policy.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What bounds a recipe run: how many `forEach` iterations may be in flight and
+ * how close together requests may start. One gate per recipe run, shared by
+ * every loop in it, so nested loops never multiply the limit.
+ *
+ * Permits go to the outermost concurrent loop: a loop that runs inside an
+ * iteration already holding a permit runs its body sequentially (see `nested`),
+ * which keeps the total at `permits` and cannot deadlock.
+ */
+export declare class RunGate {
+    readonly permits: number;
+    readonly minIntervalMs: number;
+    private readonly shared?;
+    private inFlight;
+    private readonly waiting;
+    private lastStart;
+    /**
+     * @param permits - Iterations allowed in flight; 1 is sequential.
+     * @param minIntervalMs - Minimum time between two request starts across the run.
+     * @param shared - The throttle state to share (internal: `nested` gates keep their parent's).
+     */
+    constructor(permits: number, minIntervalMs: number, shared?: RunGate | undefined);
+    /** Whether this gate lets more than one iteration run at once. */
+    get concurrent(): boolean;
+    /**
+     * Takes a permit, waiting for one when all are in flight.
+     *
+     * @returns The release; call it exactly once, when the iteration ends.
+     */
+    acquire(): Promise<() => void>;
+    /**
+     * Waits until a request may start: `minIntervalMs` after the previous start,
+     * whichever loop started it. Returns at once when the interval has passed.
+     */
+    throttle(): Promise<void>;
+    /** The gate for a body running inside an iteration that holds a permit: sequential, same throttle. */
+    nested(): RunGate;
+}
+//# sourceMappingURL=run-gate.policy.d.ts.map

package/dist/src/step-flow/run-steps.use-case.d.ts

@@ -0,0 +1,39 @@
+import type { EventBus } from '../crawl-events/index.js';
+import type { ExtractionScope } from '../extraction-scope/index.js';
+import type { HookRegistry } from '../hooks/index.js';
+import type { InputRecipe, Step } from '../recipe-schema/index.js';
+import type { RunGate } from './run-gate.policy.js';
+import type { StepRunner } from './step-runner.contract.js';
+/** Whether the walk goes on after a record was emitted. */
+export type EmitOutcome = 'continue' | 'stop';
+/** Everything a step walk needs. */
+export interface StepWalkOptions {
+    recipe: InputRecipe;
+    runner: StepRunner;
+    hooks: HookRegistry;
+    events: EventBus;
+    /** Called with the scope to snapshot for each record; `stop` ends the walk. */
+    onEmit: (scope: ExtractionScope, output?: string) => Promise<EmitOutcome>;
+    /** Bounds concurrency and request rate; absent means sequential and unthrottled. */
+    gate?: RunGate;
+}
+/** The walk as the control-flow steps see it: options plus the current path. */
+export interface StepWalk extends StepWalkOptions {
+    path: string;
+    /** Runs a nested step list; `overrides` replace walk options for that list (a sequential gate inside a concurrent iteration). */
+    runSteps: (steps: readonly Step[], scope: ExtractionScope, path: string, overrides?: Partial<StepWalkOptions>) => Promise<EmitOutcome>;
+}
+/**
+ * Walks a step list in order. Control flow (`forEach`, `if`, `paginate`, `emit`,
+ * `set`, `hook`, `when`, error policies) is handled here; leaf steps go to the
+ * runner. Mode-agnostic: the same walk drives a browser page or an HTTP context.
+ *
+ * @param steps - The steps.
+ * @param scope - The scope to run in.
+ * @param options - Recipe, runner, hooks, events and the emit callback.
+ * @param path - Where these steps are, for messages and events.
+ * @returns `stop` when the emit callback asked to stop.
+ * @throws StepFailure when a step fails under the `fail` policy.
+ */
+export declare function runSteps(steps: readonly Step[], scope: ExtractionScope, options: StepWalkOptions, path?: string): Promise<EmitOutcome>;
+//# sourceMappingURL=run-steps.use-case.d.ts.map

package/dist/src/step-flow/step-failure.error.d.ts

@@ -0,0 +1,14 @@
+/** A step that failed under the `fail` policy: the recipe stops here. */
+export declare class StepFailure extends Error {
+    readonly stepPath: string;
+    readonly stepType: string;
+    readonly name = "StepFailure";
+    constructor(stepPath: string, stepType: string, cause: unknown);
+}
+/** A single `extract` that matched nothing. */
+export declare class NoMatchError extends Error {
+    readonly selector: string;
+    readonly name = "NoMatchError";
+    constructor(selector: string);
+}
+//# sourceMappingURL=step-failure.error.d.ts.map

package/dist/src/step-flow/step-runner.contract.d.ts

@@ -0,0 +1,39 @@
+import type { ExtractionScope, LiveElement } from '../extraction-scope/index.js';
+import type { PaginateNext, Step } from '../recipe-schema/index.js';
+import type { BlockedError } from './blocked.error.js';
+/** What `paginate` learns from the runner after a page body ran. */
+export type NextPageResult = 
+/** The next page is at this URL (the runner already navigated in web mode). */
+{
+    kind: 'url';
+    url: string;
+} | 
+/** A value to bind in the next page's scope under `name` (a cursor, a token). */
+{
+    kind: 'value';
+    name: string;
+    value: unknown;
+} | 
+/** There is no next page. */
+null;
+/**
+ * The mode-specific half of step execution. `step-flow` walks the tree and
+ * owns control flow; a runner executes leaf steps against a page or a request
+ * context. Runners never mutate scope bindings other than through this contract.
+ */
+export interface StepRunner {
+    /** Runs one leaf step (not forEach, paginate, emit, set or hook). */
+    runLeaf: (step: Step, scope: ExtractionScope) => Promise<void>;
+    /** Finds (and in web mode reaches) the next page. */
+    nextPage: (next: PaginateNext, scope: ExtractionScope) => Promise<NextPageResult>;
+    /** Snapshots every element matching a rendered selector, for `forEach` over `selector`. Web mode only. */
+    elements?: (selector: string, scope: ExtractionScope) => Promise<LiveElement[]>;
+    /**
+     * Called when a step is blocked. `true` means the runner now reaches the
+     * network another way (a new access lease) and the step should run again;
+     * `false` means it cannot, and the block fails the step like any error.
+     */
+    rotate?: (error: BlockedError) => Promise<boolean>;
+    dispose: () => Promise<void>;
+}
+//# sourceMappingURL=step-runner.contract.d.ts.map

package/dist/src/template/expression.algorithm.d.ts

@@ -0,0 +1,53 @@
+/**
+ * A small expression language for `{{ }}` placeholders: literals, paths,
+ * arithmetic, comparison, logic, `??`, `a ? b : c` and a fixed set of
+ * functions. It is parsed into a tree and walked; nothing is ever compiled or
+ * evaluated as JavaScript, and a path can only read own properties of plain
+ * data, so `constructor`, `__proto__` and friends resolve to nothing.
+ */
+import type { Lookup } from './value-text.algorithm.js';
+export type Expression = {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'path';
+    path: string;
+} | {
+    kind: 'unary';
+    op: '-' | '!';
+    operand: Expression;
+} | {
+    kind: 'binary';
+    op: string;
+    left: Expression;
+    right: Expression;
+} | {
+    kind: 'ternary';
+    test: Expression;
+    consequent: Expression;
+    alternate: Expression;
+} | {
+    kind: 'call';
+    name: string;
+    args: Expression[];
+};
+/** The names an expression may call. */
+export declare const EXPRESSION_FUNCTIONS: readonly string[];
+/**
+ * Parses an expression, with a small cache since templates render per iteration.
+ *
+ * @param source - The text inside the placeholder.
+ * @returns The tree.
+ * @throws Error naming the position of the first problem.
+ */
+export declare function parseExpression(source: string): Expression;
+/**
+ * Evaluates a tree against a lookup. A function found where data is expected
+ * counts as `undefined`, so nothing callable ever leaks out of the scope.
+ *
+ * @param expression - The tree.
+ * @param lookup - Resolves a path.
+ * @returns The value.
+ */
+export declare function evaluateExpression(expression: Expression, lookup: Lookup): unknown;
+//# sourceMappingURL=expression.algorithm.d.ts.map

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

@@ -0,0 +1,7 @@
+export { getPath, setPath, segmentsOf } from './value-path.algorithm.js';
+export { render, renderDeep, renderText, resolve, hasPlaceholder } from './template.algorithm.js';
+export { isTruthy, stringify } from './value-text.algorithm.js';
+export { parseExpression, evaluateExpression, EXPRESSION_FUNCTIONS } from './expression.algorithm.js';
+export type { Expression } from './expression.algorithm.js';
+export type { Lookup } from './value-text.algorithm.js';
+//# sourceMappingURL=index.d.ts.map