@react-x11/components 0.4.0 → 0.6.0

package/dist/maps/types.d.ts

@@ -0,0 +1,244 @@
+import type { Style } from 'react-x11/style';
+import type { ReactNode, Ref } from 'react';
+import type { LngLat, LngLatBounds, MapCamera, TileId } from './proj.js';
+import type { MapSource } from './sources.js';
+import type { MapStyle } from './style.js';
+import type { MapMarker, MapOverlay } from './overlay.js';
+export type { LngLat, LngLatBounds, MapCamera };
+export type { MapSource, TileData, TileRequest } from './sources.js';
+export type { MapMarker, MapOverlay, OverlayPalette } from './overlay.js';
+export type { MapStyle, MapStyleLayer, MapFilter, FillLayer, LineLayer, CircleLayer, SymbolLayer, Zoomed, } from './style.js';
+/** Where a pointer event happened, in every space that could be wanted. */
+export interface MapPointerEvent {
+    /** Geographic. */
+    lngLat: LngLat;
+    /** Pane-local logical pixels. */
+    x: number;
+    y: number;
+    /** The marker under the pointer, when there was one. */
+    marker: MapMarker | null;
+    /** Modifier state, as the synthetic event reported it. */
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    altKey: boolean;
+    metaKey: boolean;
+    /** `1` left, `2` middle, `3` right. */
+    button: number;
+}
+/** What one frame cost — for a performance HUD, and what
+ *  `scripts/bench/maps.ts` reads. */
+export interface MapFrameStats {
+    /** Milliseconds spent rasterizing tiles into their surfaces this frame.
+     *  Bounded by `rasterBudgetMs` except for the one run that crossed it. */
+    rasterMs: number;
+    /** …and compositing them, drawing the labels, overlays and markers. */
+    drawMs: number;
+    /** Tiles the cover asked for. */
+    tiles: number;
+    /** …of which were composited from their own finished surface. Under
+     *  `progressive` this also counts the half-drawn ones. */
+    ready: number;
+    /** …and how many were drawn from a coarser ancestor instead, scaled up.
+     *  What covers a hole while zooming *in*. */
+    fromAncestor: number;
+    /** …and how many from their finer descendants, scaled down. What covers
+     *  a hole while zooming *out*, where there is no ancestor to borrow. */
+    fromDescendant: number;
+    /** Tiles still to rasterize — non-zero means the map is still sharpening
+     *  and another frame is already scheduled. */
+    pending: number;
+    /** Labels placed, and labels drawn. */
+    labels: number;
+    /**
+     * Tiles in the cover whose load failed and are waiting on a retry.
+     *
+     * Here because a map whose tiles all fail looks exactly like a map that
+     * is still loading — an empty background and nothing else — and the
+     * difference is not something a user can see.
+     */
+    errors: number;
+    /** Bytes of rendered surfaces the cache is holding. */
+    surfaceBytes: number;
+    /**
+     * What this pass repainted, in device pixels, or `null` for a full one.
+     *
+     * The number to watch when a map looks busy: a frame that is only
+     * continuing a rasterization should claim almost nothing, because the
+     * tile being drawn is a second surface nobody is looking at. A run of
+     * full-pane damage while tiles are still landing means something is
+     * asking for repaints it does not need — which on a backend that paints
+     * many frames a second reads as flashing.
+     */
+    damage: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    /** What the rasterizer did, summed over the tiles drawn this frame. */
+    draw: {
+        features: number;
+        vertices: number;
+        decimated: number;
+        culled: number;
+        batches: number;
+    };
+}
+/** Options for framing a box. */
+export interface FitBoundsOptions {
+    /** Logical pixels kept clear on every side. 24 by default. */
+    padding?: number;
+    maxZoom?: number;
+}
+/** The imperative surface, through `ref`. */
+export interface MapHandle {
+    getCamera(): MapCamera;
+    setCamera(camera: Partial<MapCamera>): void;
+    panBy(dx: number, dy: number): void;
+    zoomIn(step?: number): void;
+    zoomOut(step?: number): void;
+    zoomTo(zoom: number): void;
+    /** Frame a box. */
+    fitBounds(bounds: LngLatBounds, options?: FitBoundsOptions): void;
+    /** Frame every marker, or the ones named. */
+    fitMarkers(ids?: readonly string[], options?: FitBoundsOptions): void;
+    /** What the pane can see. `west > east` across the antimeridian. */
+    getBounds(): LngLatBounds;
+    /** Geography to pane-local logical pixels, and back. */
+    project(position: LngLat): {
+        x: number;
+        y: number;
+    };
+    unproject(x: number, y: number): LngLat;
+    /** The marker at a pane-local point, or null. */
+    markerAt(x: number, y: number): MapMarker | null;
+    /** Throw away every rendered tile — after a style edit an application
+     *  made in place, which the map cannot see. */
+    refresh(): void;
+    /** What the last frame cost. */
+    stats(): MapFrameStats | null;
+}
+/** What the `<mapview>` element takes. `<Map>` adds the uncontrolled
+ *  camera and the box around it. */
+export interface MapViewProps {
+    /**
+     * Where tiles come from, drawn in order — a basemap, then an overlay
+     * pyramid over it. Empty draws the style's background and nothing else,
+     * which is what a map with only markers on it wants.
+     */
+    sources?: readonly MapSource[];
+    /** How to draw them. Defaults to {@link shortbreadStyle} in the theme's
+     *  light or dark palette. */
+    mapStyle?: MapStyle;
+    /**
+     * The camera, controlled. Leave it out and the **element** owns it —
+     * which is not just a convenience: an element-owned camera means a pan is
+     * a blit and a claim, with no React render in the loop at all.
+     */
+    camera?: MapCamera;
+    /** Where an element-owned camera starts. Read once, at construction. */
+    defaultCamera?: MapCamera;
+    onCameraChange?: (camera: MapCamera) => void;
+    /** Fired when a gesture ends and the camera has settled — the moment to
+     *  fetch what is now on screen. */
+    onMoveEnd?: (camera: MapCamera) => void;
+    minZoom?: number;
+    maxZoom?: number;
+    markers?: readonly MapMarker[];
+    overlays?: readonly MapOverlay[];
+    onMapClick?: (event: MapPointerEvent) => void;
+    onMarkerClick?: (marker: MapMarker, event: MapPointerEvent) => void;
+    /**
+     * The marker under the pointer, or null when it left every marker.
+     *
+     * `event` is null for the leave that comes from the pointer leaving the
+     * map altogether: there is no position on the map to report, and
+     * inventing one would be worse than saying so.
+     */
+    onMarkerHover?: (marker: MapMarker | null, event: MapPointerEvent | null) => void;
+    /** `false` freezes the camera: no drag, no wheel, no keys. The map still
+     *  draws and still reports clicks. */
+    interactive?: boolean;
+    /**
+     * Show a tile as it is drawn rather than when it is finished.
+     *
+     * `false` by default, which is what every other map client does: a tile
+     * appears whole, and until it does the coarser one already in the cache
+     * is scaled up in its place. `true` composites a tile's surface as soon
+     * as it exists — so a dense tile arrives as water, then landuse, then
+     * road casings, then roads, across a dozen frames — which is honest about
+     * what the renderer is doing and does not look like a map.
+     *
+     * The one thing the default costs is a transition that invalidates every
+     * surface at once: a `mapStyle` change, `refresh()`, or a display-scale
+     * change leaves no finished tile *and* no finished ancestor, so the map
+     * drops to its background colour until the new tiles land. `true` shows
+     * it repainting instead.
+     */
+    progressive?: boolean;
+    /**
+     * Milliseconds a frame may spend rasterizing tiles. 8 by default, which
+     * leaves the rest of a 60 Hz frame for everything else; a tile that takes
+     * longer than the budget is finished over the frames after it. `0`
+     * suspends rasterization, which is what a gesture does on its own.
+     */
+    rasterBudgetMs?: number;
+    /**
+     * Device pixels per logical pixel for the tile surfaces, if not the
+     * display's.
+     *
+     * Lowering it to 1 on a retina panel makes rasterization about 1.6×
+     * quicker and the basemap correspondingly softer; labels, markers and
+     * overlays are unaffected, since none of them goes through a tile
+     * surface. Worth having on a slow machine, and worth knowing about before
+     * reaching for it.
+     */
+    rasterScale?: number;
+    /** Bytes of rendered tile surfaces to keep. 128 MB by default. */
+    surfaceBudget?: number;
+    /**
+     * Vertices after which the rasterizer flushes its path. 12,000 by
+     * default.
+     *
+     * A real trade on X11, where a fill becomes one coverage-mask upload and
+     * a bigger path is fewer of them over the same pixels. It used to be a
+     * per-backend trade — `CGContextStrokePath` was quadratic in the number
+     * of subpaths, so the Cocoa backend wanted the opposite value and this
+     * element probed for it — and react-x11 2.6.1 chunks that stroke inside
+     * the backend instead (react-x11#457). Set it only with a profile in
+     * hand.
+     */
+    batchVertices?: number;
+    /** What the licence requires, drawn in the corner. Taken from the
+     *  sources when they carry one; `''` removes it, which is the
+     *  application saying it has put the attribution somewhere else. */
+    attribution?: string;
+    /** Called once per painted frame with what it cost. */
+    onFrame?: (stats: MapFrameStats) => void;
+    /**
+     * Called once per failed tile load, with whatever the source threw.
+     *
+     * Nothing is drawn for a failed tile, so without this a source that is
+     * misconfigured, rate-limited or down is indistinguishable from one that
+     * is slow. The tile is retried on a backoff (0.5 s doubling to 30 s), so
+     * this fires again for each retry rather than once and forever.
+     */
+    onTileError?: (error: unknown, tile: TileId & {
+        sourceId: string;
+    }) => void;
+    style?: Style;
+    role?: string;
+    'aria-label'?: string;
+    'data-testname'?: string;
+    ref?: Ref<unknown>;
+}
+/** What `<Map>` takes. */
+export interface MapProps extends Omit<MapViewProps, 'ref'> {
+    ref?: Ref<MapHandle>;
+    /** Anything absolutely positioned over the map — a legend, a control
+     *  panel. Laid out as siblings of the drawn pane rather than inside it,
+     *  because a registered element paints its children *before* its own
+     *  drawing and anything inside would be painted over. */
+    children?: ReactNode;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/maps/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/maps/types.ts"],"names":[],"mappings":"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"}

package/dist/maps/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/maps/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/maps/types.ts"],"names":[],"mappings":""}

package/dist/markdown/ast.d.ts

@@ -1,5 +1,15 @@
 /** Inline content, inside a paragraph, heading, list item or table cell. */
-export type InlineNode = TextInline | CodeInline | EmphasisInline | LinkInline | BreakInline | ComponentInline;
+export type InlineNode = TextInline | CodeInline | EmphasisInline | LinkInline | BreakInline | ComponentInline | ExpressionInline;
+/**
+ * `{count}` in the middle of a sentence: unevaluated source, which the
+ * renderer compiles against its `scope` and turns into text. Only emitted
+ * when `ParseOptions.expressions` says so, so `{braces}` in an ordinary
+ * document remain the characters they have always been.
+ */
+export interface ExpressionInline {
+    type: 'expression';
+    src: string;
+}
 /** A run of plain text. Softbreaks arrive collapsed to spaces. */
 export interface TextInline {
     type: 'text';
@@ -32,18 +42,61 @@ export interface BreakInline {
     type: 'break';
 }
 /**
- * Reserved for MDX: `<Chart data={…} />` would parse to one of these. The
- * current parser never emits it; the renderer maps unknown names to plain
- * text so a future parser upgrade cannot crash an older renderer.
+ * An attribute's value. `literal` is what an attribute string or a `{json}`
+ * attribute resolves to at parse time; `expression` holds unevaluated source
+ * for the rung that compiles it, so that parsing stays pure and one AST can
+ * be rendered against two scopes (docs/prd-mdx.md, M2). The parser emits
+ * only `literal` today.
+ */
+export type AttributeValue = {
+    kind: 'literal';
+    value: unknown;
+} | {
+    kind: 'expression';
+    src: string;
+};
+/**
+ * A spread (`{...props}`) is an attribute with no name, so it is keyed
+ * `...0`, `...1`, … in the order it appeared. An attribute name cannot start
+ * with `.`, so these cannot collide with one; a renderer walking
+ * `Object.entries` in insertion order applies each spread where it was
+ * written, which is what decides whether it overrides `height` or `height`
+ * overrides it.
+ */
+export declare const SPREAD_PREFIX = "...";
+/**
+ * **Still reserved.** `<Badge/>` in the middle of a sentence parses to one of
+ * these — except that nothing emits them yet, because nothing can render
+ * them: a paragraph is laid out as a single `<richtext>`, and a `TextRun`
+ * has no way to say "reserve this much advance width for an element someone
+ * else paints". Giving it one is the inline half of MDX and is its own piece
+ * of work (baseline alignment, wrapping around the element, and what a
+ * selection dragged across it should copy).
+ *
+ * Kept in the union so the shape stays stable, and so a renderer written
+ * against it today cannot be broken by the parser learning to emit them.
  */
 export interface ComponentInline {
     type: 'component';
     name: string;
-    attributes: Record<string, string>;
+    attributes: Record<string, AttributeValue>;
     children: InlineNode[];
 }
 /** Block-level content. */
-export type BlockNode = ParagraphBlock | HeadingBlock | CodeBlock | QuoteBlock | ListBlock | TableBlock | RuleBlock;
+export type BlockNode = ParagraphBlock | HeadingBlock | CodeBlock | QuoteBlock | ListBlock | TableBlock | RuleBlock | ComponentBlock;
+/**
+ * A component standing where a paragraph would: `<Chart data={…} />` on its
+ * own line, or `<Callout>` … `</Callout>` around blocks.
+ *
+ * Only emitted when `ParseOptions.isComponent` says the name is one — which
+ * is what keeps every document that renders today rendering the same way.
+ */
+export interface ComponentBlock {
+    type: 'component';
+    name: string;
+    attributes: Record<string, AttributeValue>;
+    children: BlockNode[];
+}
 export interface ParagraphBlock {
     type: 'paragraph';
     children: InlineNode[];
@@ -122,5 +175,26 @@ export interface ParseOptions {
      * underline or a rule) is held back. Pass false for text that is final.
      */
     partial?: boolean;
+    /**
+     * Whether `name` is a component this document may use. Absent — the
+     * default — means no tag is a component and `<Chart/>` stays the literal
+     * text it has always been, so turning MDX on is opt-in and turning it off
+     * is byte-for-byte the old behaviour.
+     *
+     * `<Markdown>` supplies one from its `components` prop. A dotted name
+     * (`Card.Header`) is passed through whole; resolving it is the caller's.
+     */
+    isComponent?: (name: string) => boolean;
+    /**
+     * Whether `{…}` may hold a JavaScript expression — in an attribute, as a
+     * `{...spread}`, or bare in the prose. Off by default, and off is the
+     * whole of rung 1: a `{…}` attribute must be JSON, and a brace in a
+     * paragraph is a brace.
+     *
+     * `<Markdown>` turns this on when it is given a `scope`, which is the prop
+     * that says the application accepts a document running code. Parsing still
+     * evaluates nothing — an expression is kept as source.
+     */
+    expressions?: boolean;
 }
 //# sourceMappingURL=ast.d.ts.map

package/dist/markdown/ast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/markdown/ast.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ast.d.ts","sourceRoot":"","sources":["../../src/markdown/ast.ts"],"names":[],"mappings":"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"}

package/dist/markdown/ast.js

@@ -1,8 +1,17 @@
 // The markdown AST `parse.ts` produces and `index.ts` renders. Deliberately
 // small: it is the GFM constructs this component draws, not a general
 // mdast — but it is shaped so that growing it stays additive. In particular
-// `component` is reserved for the MDX direction: a parser extension can emit
-// one without the renderer, the selection model or the caches changing shape
-// (see "MDX" in index.ts).
-export {};
+// `component` is the MDX direction: `ComponentBlock` is parsed and rendered
+// (docs/prd-mdx.md, M1), and `ComponentInline` is still reserved — see the
+// note on it for why the inline half needs machinery `<richtext>` does not
+// have yet.
+/**
+ * A spread (`{...props}`) is an attribute with no name, so it is keyed
+ * `...0`, `...1`, … in the order it appeared. An attribute name cannot start
+ * with `.`, so these cannot collide with one; a renderer walking
+ * `Object.entries` in insertion order applies each spread where it was
+ * written, which is what decides whether it overrides `height` or `height`
+ * overrides it.
+ */
+export const SPREAD_PREFIX = '...';
 //# sourceMappingURL=ast.js.map

package/dist/markdown/ast.js.map

@@ -1 +1 @@
-{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../src/markdown/ast.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,sEAAsE;AACtE,4EAA4E;AAC5E,6EAA6E;AAC7E,6EAA6E;AAC7E,2BAA2B"}
+{"version":3,"file":"ast.js","sourceRoot":"","sources":["../../src/markdown/ast.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,sEAAsE;AACtE,4EAA4E;AAC5E,4EAA4E;AAC5E,2EAA2E;AAC3E,2EAA2E;AAC3E,YAAY;AAqEZ;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,KAAK,CAAC"}

package/dist/markdown/expressions.d.ts

@@ -0,0 +1,27 @@
+import type { Document } from './ast.js';
+/**
+ * What a renderer calls: source in, value out, `undefined` if it did not
+ * work. Never throws — a document being edited is full of expressions that
+ * do not work yet.
+ */
+export type Evaluate = (src: string) => unknown;
+/**
+ * An evaluator over `scope`. The keys are read once, so a scope mutated in
+ * place after this is called keeps its old shape — the same contract every
+ * other seam here has, and the reason the prop doc asks for a stable object.
+ */
+export declare function evaluator(scope: Record<string, unknown>): Evaluate;
+/**
+ * Only the tests need to reach in: a compile cache that survived between
+ * them would make one test's expression another's, and the warn-once flag
+ * would hide the second failure anyone asserted on.
+ */
+export declare function clearExpressionCache(): void;
+/**
+ * The document with its expressions evaluated. `raws` is carried over
+ * untouched: it is the block cache's key, and what changed is the values an
+ * expression produced, not the text that produced them — a change of `scope`
+ * invalidates that cache through its own identity instead.
+ */
+export declare function resolveExpressions(doc: Document, evaluate: Evaluate): Document;
+//# sourceMappingURL=expressions.d.ts.map

package/dist/markdown/expressions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/markdown/expressions.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAa,QAAQ,EAAc,MAAM,UAAU,CAAC;AA8DhE;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAEhD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAalE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAG3C;AAgGD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,QAAQ,EACb,QAAQ,EAAE,QAAQ,GACjB,QAAQ,CAGV"}

package/dist/markdown/expressions.js

@@ -0,0 +1,203 @@
+// Compiling `{…}` — the rung where a document runs code (docs/prd-mdx.md,
+// M2), and the one place in this component that calls `new Function`.
+//
+// It is a small file on purpose. Everything hard about MDX expressions was
+// decided elsewhere: the parser holds an expression as *source* rather than
+// a value, so a parse is pure and one AST can be rendered against two
+// scopes; and `<Markdown>` only turns any of this on when the application
+// passes a `scope`, which is the prop that means "I accept that this
+// document may compute". What is left here is compiling the source once, and
+// not letting a half-typed expression take down a document that is still
+// being typed.
+//
+// **There is no sandbox.** `new Function` runs in this process with this
+// process's authority. That is why the gate is a prop, and why the docs say
+// in as few words as they can: do not pass `scope` alongside a document you
+// did not write.
+/**
+ * Keyed on the scope's shape *and* the source, because a compiled function
+ * closes over its parameter names. Bounded the way `richtext/node.ts` bounds
+ * its layout cache: a streaming document recompiles its tail on every chunk,
+ * and an unbounded map would hold every intermediate spelling of an
+ * expression that was being typed.
+ */
+const CACHE = new Map();
+const LIMIT = 256;
+let warned = false;
+/**
+ * Say so, once, when an expression does not work out. A document that
+ * silently loses a value should not be a mystery — and saying it on every
+ * frame of a streaming render would be worse than saying nothing.
+ *
+ * `process` and `console` come off `globalThis` because `src/` compiles with
+ * `types: []` — a Node global that wandered in would fail the build rather
+ * than become an implicit `@types/node` dependency.
+ */
+function warnFailed(src, error) {
+    if (warned)
+        return;
+    warned = true;
+    const g = globalThis;
+    if (g.process?.env?.NODE_ENV === 'production')
+        return;
+    g.console?.warn('@react-x11/components: a markdown expression did not evaluate, so it ' +
+        `rendered as nothing: {${src}}`, error);
+}
+function compile(src, keys) {
+    const key = `${keys.join(',')} ${src}`;
+    const hit = CACHE.get(key);
+    if (hit !== undefined)
+        return hit;
+    let compiled = null;
+    try {
+        // `return (…)` rather than a bare body: an expression is what the braces
+        // promised, and the parentheses keep an object literal an object literal
+        // rather than a block.
+        compiled = new Function(...keys, `"use strict"; return (${src});`);
+    }
+    catch (error) {
+        // A syntax error is the ordinary state of an expression being typed.
+        warnFailed(src, error);
+    }
+    if (CACHE.size >= LIMIT)
+        CACHE.clear();
+    CACHE.set(key, compiled);
+    return compiled;
+}
+/**
+ * An evaluator over `scope`. The keys are read once, so a scope mutated in
+ * place after this is called keeps its old shape — the same contract every
+ * other seam here has, and the reason the prop doc asks for a stable object.
+ */
+export function evaluator(scope) {
+    const keys = Object.keys(scope);
+    const values = keys.map((k) => scope[k]);
+    return (src) => {
+        const fn = compile(src, keys);
+        if (!fn)
+            return undefined;
+        try {
+            return fn(...values);
+        }
+        catch (error) {
+            warnFailed(src, error);
+            return undefined;
+        }
+    };
+}
+/**
+ * Only the tests need to reach in: a compile cache that survived between
+ * them would make one test's expression another's, and the warn-once flag
+ * would hide the second failure anyone asserted on.
+ */
+export function clearExpressionCache() {
+    CACHE.clear();
+    warned = false;
+}
+// --- resolving a parsed document ------------------------------------------
+/**
+ * A copy of `nodes` with every `expression` replaced by the text it
+ * evaluates to. Primitives stringify; anything else — an object, an array, a
+ * React element — renders as nothing, because a paragraph is text and there
+ * is nowhere in a text run to put an element (see "The inline half" in
+ * docs/prd-mdx.md). `null` and `undefined` are nothing on purpose, so
+ * `{maybe}` reads as absent rather than as the word "undefined".
+ */
+function resolveInline(nodes, evaluate) {
+    let changed = false;
+    const out = [];
+    for (const node of nodes) {
+        if (node.type === 'expression') {
+            changed = true;
+            const value = evaluate(node.src);
+            const text = value == null ||
+                typeof value === 'object' ||
+                typeof value === 'function'
+                ? ''
+                : String(value);
+            if (text)
+                out.push({ type: 'text', text });
+            continue;
+        }
+        if ('children' in node) {
+            const children = resolveInline(node.children, evaluate);
+            if (children !== node.children) {
+                changed = true;
+                out.push({ ...node, children });
+                continue;
+            }
+        }
+        out.push(node);
+    }
+    return changed ? out : nodes;
+}
+function resolveBlocks(blocks, evaluate) {
+    let changed = false;
+    const out = blocks.map((block) => {
+        switch (block.type) {
+            case 'paragraph':
+            case 'heading': {
+                const children = resolveInline(block.children, evaluate);
+                if (children === block.children)
+                    return block;
+                changed = true;
+                return { ...block, children };
+            }
+            case 'quote':
+            case 'component': {
+                const children = resolveBlocks(block.children, evaluate);
+                if (children === block.children)
+                    return block;
+                changed = true;
+                return { ...block, children };
+            }
+            case 'list': {
+                let itemsChanged = false;
+                const items = block.items.map((item) => {
+                    const children = resolveBlocks(item.children, evaluate);
+                    if (children === item.children)
+                        return item;
+                    itemsChanged = true;
+                    return { ...item, children };
+                });
+                if (!itemsChanged)
+                    return block;
+                changed = true;
+                return { ...block, items };
+            }
+            case 'table': {
+                let rowsChanged = false;
+                const rows = block.rows.map((row) => row.map((cell) => {
+                    const next = resolveInline(cell, evaluate);
+                    if (next !== cell)
+                        rowsChanged = true;
+                    return next;
+                }));
+                const header = block.header.map((cell) => {
+                    const next = resolveInline(cell, evaluate);
+                    if (next !== cell)
+                        rowsChanged = true;
+                    return next;
+                });
+                if (!rowsChanged)
+                    return block;
+                changed = true;
+                return { ...block, header, rows };
+            }
+            default:
+                return block;
+        }
+    });
+    return changed ? out : blocks;
+}
+/**
+ * The document with its expressions evaluated. `raws` is carried over
+ * untouched: it is the block cache's key, and what changed is the values an
+ * expression produced, not the text that produced them — a change of `scope`
+ * invalidates that cache through its own identity instead.
+ */
+export function resolveExpressions(doc, evaluate) {
+    const blocks = resolveBlocks(doc.blocks, evaluate);
+    return blocks === doc.blocks ? doc : { blocks, raws: doc.raws };
+}
+//# sourceMappingURL=expressions.js.map

package/dist/markdown/expressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.js","sourceRoot":"","sources":["../../src/markdown/expressions.ts"],"names":[],"mappings":"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"}