contour-deck 0.0.0-stage → 0.2.0

package/dist/core/labels.js

@@ -0,0 +1,20 @@
+export const defaultLabels = {
+    overview: "輪廓",
+    notes: "講稿",
+    script: "提詞",
+    threeD: "3D",
+    prev: "上一步",
+    next: "下一步",
+    exit: "離開簡報",
+    remote: "遙控",
+    here: "目前位置",
+    appendix: "書面",
+    rail: "整份簡報的位置",
+    noNotes: "（這一頁沒有講稿）",
+    slides: count => `${count} 張`,
+    pages: count => `${count} 頁`,
+    minutes: count => `約 ${count} 分`,
+    page: (index, count) => `頁 ${index}/${count}`,
+    steps: (shown, count) => `要點 ${shown}/${count}`,
+    thumb: (block, slide, title, pages) => `${block}，第 ${slide} 張：${title}${pages > 1 ? `，${pages} 頁` : ""}`,
+};

package/dist/core/model.d.ts

@@ -0,0 +1,37 @@
+/** The outline tree, read once from the contract HTML (docs/CONTRACT.md). */
+export interface PageNode {
+    el: HTMLElement;
+    steps: HTMLElement[];
+    notes: HTMLElement[];
+}
+export interface SlideNode {
+    el: HTMLElement;
+    title: string;
+    pages: PageNode[];
+}
+export interface BlockNode {
+    el: HTMLElement;
+    title: string;
+    short: string;
+    kind: string;
+    minutes: number;
+    slides: SlideNode[];
+}
+/** A position with 0-based indexes. The public API and the URL use 1-based ordinals. */
+export interface Pos {
+    b: number;
+    s: number;
+    p: number;
+}
+export declare function readModel(root: HTMLElement, deckTitle: string): BlockNode[];
+/** `"4"`, `"4.4"`, or `"4.4.2"` (1-based) to a position; `null` when the text is not numeric. */
+export declare function parseAt(at: string): Pos | null;
+export declare const formatAt: ({ b, s, p }: Pos) => string;
+/** A position that exists in `blocks`, or `null`: the block and slide must exist, the page is clamped. */
+export declare function fitPos(blocks: {
+    slides: {
+        pages: unknown[];
+    }[];
+}[], pos: Pos): Pos | null;
+/** The position of the block, slide, or page that is, or contains, `target`. */
+export declare function posOf(blocks: BlockNode[], target: Element): Pos | null;

package/dist/core/model.js

@@ -0,0 +1,51 @@
+/** The outline tree, read once from the contract HTML (docs/CONTRACT.md). */
+const childrenWith = (el, attribute) => Array.from(el.children).filter((child) => child.hasAttribute(attribute));
+function need(list, what) {
+    if (!list.length)
+        throw new Error(`contour-deck: ${what} (see docs/CONTRACT.md)`);
+    return list;
+}
+export function readModel(root, deckTitle) {
+    return need(childrenWith(root, "data-ct-block"), "the deck has no [data-ct-block] child").map((el, b) => ({
+        el,
+        title: el.dataset.title || deckTitle,
+        short: el.dataset.short || String(b + 1),
+        kind: el.dataset.kind || "",
+        minutes: Number(el.dataset.minutes) || 0,
+        slides: need(childrenWith(el, "data-ct-slide"), `block ${b + 1} has no [data-ct-slide] child`).map((slide, s) => ({
+            el: slide,
+            title: slide.dataset.title || "",
+            pages: need(childrenWith(slide, "data-ct-page"), `slide ${b + 1}.${s + 1} has no [data-ct-page] child`).map(page => ({
+                el: page,
+                steps: Array.from(page.querySelectorAll("[data-ct-step]")),
+                notes: childrenWith(page, "data-ct-notes"),
+            })),
+        })),
+    }));
+}
+/** `"4"`, `"4.4"`, or `"4.4.2"` (1-based) to a position; `null` when the text is not numeric. */
+export function parseAt(at) {
+    const match = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?$/.exec(at);
+    if (!match)
+        return null;
+    return { b: Number(match[1]) - 1, s: Number(match[2] ?? 1) - 1, p: Number(match[3] ?? 1) - 1 };
+}
+export const formatAt = ({ b, s, p }) => `${b + 1}.${s + 1}.${p + 1}`;
+/** A position that exists in `blocks`, or `null`: the block and slide must exist, the page is clamped. */
+export function fitPos(blocks, pos) {
+    const slide = blocks[pos.b]?.slides[pos.s];
+    if (!slide || pos.p < 0)
+        return null;
+    return { b: pos.b, s: pos.s, p: Math.min(pos.p, slide.pages.length - 1) };
+}
+/** The position of the block, slide, or page that is, or contains, `target`. */
+export function posOf(blocks, target) {
+    for (const [b, block] of blocks.entries()) {
+        if (!block.el.contains(target))
+            continue;
+        const s = Math.max(0, block.slides.findIndex(slide => slide.el.contains(target)));
+        const p = Math.max(0, block.slides[s].pages.findIndex(page => page.el.contains(target)));
+        return { b, s, p };
+    }
+    return null;
+}

package/dist/core/navigator.d.ts

@@ -0,0 +1,6 @@
+/** Which block a move across the block boundary lands in. */
+/**
+ * The nearest block in `direction` whose kind is not skipped, or -1.
+ * With `skip = ["appendix"]` the main part ends at its last block, and an appendix is left backwards only.
+ */
+export declare function neighbourBlock(kinds: string[], from: number, direction: 1 | -1, skip: string[]): number;

package/dist/core/navigator.js

@@ -0,0 +1,12 @@
+/** Which block a move across the block boundary lands in. */
+/**
+ * The nearest block in `direction` whose kind is not skipped, or -1.
+ * With `skip = ["appendix"]` the main part ends at its last block, and an appendix is left backwards only.
+ */
+export function neighbourBlock(kinds, from, direction, skip) {
+    for (let b = from + direction; b >= 0 && b < kinds.length; b += direction) {
+        if (!skip.includes(kinds[b]))
+            return b;
+    }
+    return -1;
+}

package/dist/core/notes.d.ts

@@ -0,0 +1,11 @@
+import type { BlockNode, PageNode, Pos } from "./model.js";
+import type { Labels } from "./types.js";
+export declare const notesHtml: (page: PageNode) => string;
+export declare function pageTitle(page: PageNode): string;
+export interface Script {
+    el: HTMLElement;
+    /** Scrolls the entry of a position to the top. */
+    show(pos: Pos): void;
+}
+/** Every page in order with its notes; the heading of an entry opens that page on the stage. */
+export declare function buildScript(blocks: BlockNode[], labels: Labels): Script;

package/dist/core/notes.js

@@ -0,0 +1,34 @@
+/** Speaker notes: the panel beside the stage, and the notes view (a scrolling script for a phone). */
+import { h } from "./dom.js";
+export const notesHtml = (page) => page.notes.map(note => note.innerHTML).join("");
+export function pageTitle(page) {
+    return page.el.querySelector("h1,h2,h3")?.textContent?.trim() ?? "";
+}
+/** Every page in order with its notes; the heading of an entry opens that page on the stage. */
+export function buildScript(blocks, labels) {
+    const el = h("div", "ct-script", "", { tabindex: -1 });
+    const entries = new Map();
+    blocks.forEach((block, b) => {
+        const section = el.appendChild(h("section", "ct-sb"));
+        const head = section.appendChild(h("h2", "ct-sbh", block.title));
+        if (block.kind === "appendix")
+            head.append(h("span", "ct-badge", labels.appendix));
+        if (block.minutes)
+            head.append(h("span", "ct-meta", labels.minutes(block.minutes)));
+        block.slides.forEach((slide, s) => {
+            slide.pages.forEach((page, p) => {
+                const entry = section.appendChild(h("article", "ct-se"));
+                const count = slide.pages.length;
+                const open = entry.appendChild(h("button", "ct-sh", "", { "data-ct-go": `${b},${s},${p}` }));
+                open.append(h("span", "ct-meta", `${block.short}.${s + 1}${count > 1 ? ` · ${labels.page(p + 1, count)}` : ""}`), h("b", "", pageTitle(page) || slide.title));
+                const body = entry.appendChild(h("div", "ct-sn"));
+                body.innerHTML = notesHtml(page);
+                entries.set(`${b},${s},${p}`, entry);
+            });
+        });
+    });
+    return {
+        el,
+        show: ({ b, s, p }) => entries.get(`${b},${s},${p}`)?.scrollIntoView(),
+    };
+}

package/dist/core/overview.d.ts

@@ -0,0 +1,11 @@
+import type { BlockNode } from "./model.js";
+import type { Labels } from "./types.js";
+export interface Overview {
+    el: HTMLElement;
+    /** `faces[b][s]` is the front sheet of a thumbnail, the rectangle the stage zooms from. */
+    faces: HTMLElement[][];
+    thumbs: HTMLButtonElement[][];
+    /** Moves the "you are here" ring onto a thumbnail. */
+    ring(b: number, s: number, instant?: boolean): void;
+}
+export declare function buildOverview(blocks: BlockNode[], labels: Labels): Overview;

package/dist/core/overview.js

@@ -0,0 +1,104 @@
+/** The outline: one panel per block, one schematic thumbnail per slide. */
+import { h, offsetIn } from "./dom.js";
+const FIGURE = "figure,img,picture,svg,canvas,video,iframe";
+function sketchType(el) {
+    if (el.dataset.ctSk)
+        return el.dataset.ctSk;
+    if (el.matches("ul,ol"))
+        return "list";
+    if (el.matches("table") || (el.children.length === 1 && el.children[0].matches("table")))
+        return "table";
+    if (el.matches("blockquote"))
+        return "quote";
+    if (el.matches(FIGURE))
+        return "figure";
+    return el.tagName === "DIV" && el.children.length > 1 ? "grid" : "text";
+}
+/** Up to two marks that hint at what the page holds. */
+function sketch(page) {
+    const box = h("span", "ct-sk");
+    for (const el of page.children) {
+        if (!(el instanceof HTMLElement) || el.matches("[data-ct-notes],h1,h2,h3,h4,h5,h6"))
+            continue;
+        const type = sketchType(el);
+        const mark = h("i", `ct-g ct-g-${type}`);
+        const cells = type === "nums" ? 2 : Math.min(el.children.length, 4);
+        if (type === "list")
+            mark.style.setProperty("--c", String(cells));
+        if (type === "grid" || type === "flow" || type === "nums")
+            for (let i = 0; i < cells; i++)
+                mark.append(h("b"));
+        box.append(mark);
+        if (box.children.length === 2)
+            break;
+    }
+    return box;
+}
+export function buildOverview(blocks, labels) {
+    const el = h("div", "ct-ov");
+    const plane = el.appendChild(h("div", "ct-plane"));
+    const faces = [];
+    const thumbs = [];
+    blocks.forEach((block, b) => {
+        const tile = plane.appendChild(h("section", "ct-tile"));
+        if (block.kind)
+            tile.dataset.kind = block.kind;
+        if (block.slides.length > 3)
+            tile.dataset.wide = "";
+        const pages = block.slides.reduce((sum, slide) => sum + slide.pages.length, 0);
+        const meta = [labels.slides(block.slides.length)];
+        if (pages > block.slides.length)
+            meta.push(labels.pages(pages));
+        if (block.minutes)
+            meta.push(labels.minutes(block.minutes));
+        const open = tile.appendChild(h("button", "ct-open", "", { "data-ct-go": `${b},0,0` }));
+        open.append(h("span", "ct-tt", block.title));
+        if (block.kind === "appendix")
+            open.append(h("span", "ct-badge", labels.appendix));
+        open.append(h("span", "ct-meta", meta.join(" · ")));
+        const strip = tile.appendChild(h("ol", "ct-strip"));
+        faces[b] = [];
+        thumbs[b] = block.slides.map((slide, s) => {
+            const count = slide.pages.length;
+            const thumb = h("button", "ct-thumb", "", {
+                "data-ct-go": `${b},${s},0`,
+                "aria-label": labels.thumb(block.title, s + 1, slide.title, count),
+            });
+            thumb.style.setProperty("--n", String(count));
+            // A slide with several pages is a stack of sheets, one per page.
+            for (let k = count - 1; k > 0; k--)
+                thumb.appendChild(h("span", "ct-layer")).style.setProperty("--k", String(k));
+            const face = thumb.appendChild(h("span", "ct-face"));
+            const number = face.appendChild(h("span", "ct-num"));
+            number.append(h("span", "", `${block.short}.${s + 1}`));
+            if (count > 1)
+                number.append(h("span", "", labels.pages(count)));
+            face.append(h("span", "ct-t", slide.title), sketch(slide.pages[0].el));
+            strip.appendChild(h("li")).append(thumb);
+            faces[b][s] = face;
+            return thumb;
+        });
+    });
+    const ringEl = plane.appendChild(h("div", "ct-ring", "", { "data-label": labels.here }));
+    return {
+        el,
+        faces,
+        thumbs,
+        ring(b, s, instant) {
+            const face = faces[b][s];
+            const { x, y } = offsetIn(face, plane);
+            const style = ringEl.style;
+            if (instant)
+                style.transition = "none";
+            style.left = `${x}px`;
+            style.top = `${y}px`;
+            style.width = `${face.offsetWidth}px`;
+            style.height = `${face.offsetHeight}px`;
+            style.setProperty("--n", String(blocks[b].slides[s].pages.length));
+            if (instant) {
+                void ringEl.offsetWidth;
+                style.transition = "";
+            }
+        },
+    };
+}

package/dist/core/rail.d.ts

@@ -0,0 +1,8 @@
+import type { BlockNode, Pos } from "./model.js";
+import type { Labels } from "./types.js";
+export interface Rail {
+    el: HTMLElement;
+    /** Slides the marker onto the pip of a position. */
+    mark(pos: Pos): void;
+}
+export declare function buildRail(blocks: BlockNode[], labels: Labels): Rail;

package/dist/core/rail.js

@@ -0,0 +1,26 @@
+/** The locator rail: the whole deck as a mini-map, one column per slide, one pip per page. */
+import { h, offsetIn } from "./dom.js";
+export function buildRail(blocks, labels) {
+    const el = h("nav", "ct-rail", "", { "aria-label": labels.rail });
+    const groups = [];
+    const pips = blocks.map((block, b) => {
+        const group = el.appendChild(h("div", "ct-rg"));
+        if (block.kind)
+            group.dataset.kind = block.kind;
+        groups.push(group);
+        group.append(h("button", "ct-rl", block.short, { "data-ct-go": `${b},0,0`, title: block.title }));
+        return block.slides.map((slide, s) => {
+            const column = group.appendChild(h("button", "ct-rc", "", { "data-ct-go": `${b},${s},0`, title: slide.title, "aria-label": `${block.title}：${slide.title}` }));
+            return slide.pages.map((_, p) => column.appendChild(h("i", "", "", { "data-ct-go": `${b},${s},${p}` })));
+        });
+    });
+    const marker = el.appendChild(h("span", "ct-rm"));
+    return {
+        el,
+        mark({ b, s, p }) {
+            groups.forEach((group, i) => group.toggleAttribute("data-cur", i === b));
+            const { x, y } = offsetIn(pips[b][s][p], el);
+            marker.style.transform = `translate(${x}px,${y}px)`;
+        },
+    };
+}

package/dist/core/stops.d.ts

@@ -0,0 +1,17 @@
+/** Where a vertical step may stop inside one slide. Pure geometry, no DOM. */
+export interface Box {
+    top: number;
+    height: number;
+}
+/**
+ * Every page top is a stop. A page taller than the viewport adds stops inside it and one flush with its bottom,
+ * so a step first walks down the page and only then reaches the next one.
+ */
+export declare function pageStops(pages: Box[], viewport: number): number[];
+/** The first stop past `y` in the direction of travel, or `undefined` at the end. */
+export declare function nextStop(stops: number[], y: number, direction: 1 | -1): number | undefined;
+/** The page under the reading line, 35% down the viewport. */
+export declare function pageIndexAt(pages: Box[], y: number, viewport: number): number;
+/** How much of a tall page has been read, 0 to 1; 1 for a page that fits. */
+export declare function pageProgress(page: Box, y: number, viewport: number): number;
+export declare const isTall: (page: Box, viewport: number) => boolean;

package/dist/core/stops.js

@@ -0,0 +1,40 @@
+/** Where a vertical step may stop inside one slide. Pure geometry, no DOM. */
+/** A page counts as taller than the viewport only past this slack, in pixels. */
+const SLACK = 8;
+/** A tall page is walked in steps of this share of the viewport, so the last lines of one screen open the next. */
+const STEP = 0.85;
+/** An inner stop closer than this share of the viewport to the page's end is dropped. */
+const MIN_LAST = 0.2;
+/**
+ * Every page top is a stop. A page taller than the viewport adds stops inside it and one flush with its bottom,
+ * so a step first walks down the page and only then reaches the next one.
+ */
+export function pageStops(pages, viewport) {
+    const stops = [];
+    for (const page of pages) {
+        stops.push(page.top);
+        if (!isTall(page, viewport))
+            continue;
+        const end = page.top + page.height - viewport;
+        for (let y = page.top + viewport * STEP; y < end - viewport * MIN_LAST; y += viewport * STEP)
+            stops.push(Math.round(y));
+        stops.push(end);
+    }
+    return stops;
+}
+/** The first stop past `y` in the direction of travel, or `undefined` at the end. */
+export function nextStop(stops, y, direction) {
+    return direction > 0 ? stops.find(stop => stop > y + SLACK) : stops.findLast(stop => stop < y - SLACK);
+}
+/** The page under the reading line, 35% down the viewport. */
+export function pageIndexAt(pages, y, viewport) {
+    const line = y + viewport * 0.35;
+    return Math.max(0, pages.findLastIndex(page => page.top <= line));
+}
+/** How much of a tall page has been read, 0 to 1; 1 for a page that fits. */
+export function pageProgress(page, y, viewport) {
+    if (page.height - viewport <= SLACK)
+        return 1;
+    return Math.min(1, Math.max(0, (y - page.top + viewport) / page.height));
+}
+export const isTall = (page, viewport) => page.height > viewport + SLACK;

package/dist/core/transitions.d.ts

@@ -0,0 +1,9 @@
+/** Zoom between a thumbnail and the stage (FLIP), with the outline pulling back around the same thumbnail. */
+type Direction = "in" | "out";
+/** The stage grows out of the rectangle `thumb` (`in`) or shrinks into it (`out`); `content` fades with it. */
+export declare function zoomStage(stage: HTMLElement, content: HTMLElement, thumb: DOMRect, direction: Direction, ms: number, reduced: boolean): Animation[];
+/** The outline scales up and fades around `thumb` as the stage opens (`out`), and settles back as it closes (`in`). */
+export declare function zoomOverview(overview: HTMLElement, thumb: DOMRect, direction: Direction, ms: number, reduced: boolean): Animation;
+/** Resolves when every animation has finished; a cancelled one counts as finished. */
+export declare const finished: (animations: Animation[]) => Promise<(void | Animation)[]>;
+export {};

package/dist/core/transitions.js

@@ -0,0 +1,37 @@
+/** Zoom between a thumbnail and the stage (FLIP), with the outline pulling back around the same thumbnail. */
+const EASE_OUT = "cubic-bezier(.22,1,.36,1)";
+const EASE_IN_OUT = "cubic-bezier(.6,0,.35,1)";
+const FADE_MS = 140;
+const fade = (el, direction) => el.animate(direction === "in" ? [{ opacity: 0 }, { opacity: 1 }] : [{ opacity: 1 }, { opacity: 0 }], { duration: FADE_MS, fill: "both" });
+/** The stage grows out of the rectangle `thumb` (`in`) or shrinks into it (`out`); `content` fades with it. */
+export function zoomStage(stage, content, thumb, direction, ms, reduced) {
+    if (reduced)
+        return [fade(stage, direction)];
+    const full = stage.getBoundingClientRect();
+    const small = {
+        transform: `translate(${thumb.left - full.left}px,${thumb.top - full.top}px) scale(${thumb.width / full.width},${thumb.height / full.height})`,
+        opacity: 0,
+    };
+    const big = { transform: "none", opacity: 1 };
+    const isIn = direction === "in";
+    return [
+        stage.animate(isIn ? [small, { opacity: 1, offset: 0.3 }, big] : [big, { opacity: 1, offset: 0.7 }, small], {
+            duration: ms,
+            easing: isIn ? EASE_OUT : EASE_IN_OUT,
+            fill: "both",
+        }),
+        content.animate(isIn ? [{ opacity: 0 }, { opacity: 0, offset: 0.35 }, { opacity: 1 }] : [{ opacity: 1 }, { opacity: 0, offset: 0.6 }, { opacity: 0 }], { duration: ms, fill: "both" }),
+    ];
+}
+/** The outline scales up and fades around `thumb` as the stage opens (`out`), and settles back as it closes (`in`). */
+export function zoomOverview(overview, thumb, direction, ms, reduced) {
+    if (reduced)
+        return fade(overview, direction);
+    const box = overview.getBoundingClientRect();
+    overview.style.transformOrigin = `${thumb.left + thumb.width / 2 - box.left}px ${thumb.top + thumb.height / 2 - box.top}px`;
+    const far = { transform: "scale(1.45)", opacity: 0 };
+    const near = { transform: "none", opacity: 1 };
+    return overview.animate(direction === "in" ? [far, near] : [near, far], { duration: ms, easing: EASE_OUT, fill: "both" });
+}
+/** Resolves when every animation has finished; a cancelled one counts as finished. */
+export const finished = (animations) => Promise.all(animations.map(animation => animation.finished.catch(() => { })));

package/dist/core/types.d.ts

@@ -0,0 +1,82 @@
+/** Which layer is in front: the outline, one block on the stage, or the notes script. */
+export type Mode = "overview" | "stage" | "notes";
+/** Where the deck is. `block`, `slide`, and `page` are 1-based ordinals, as in `?at=4.4.2`. */
+export interface DeckState {
+    mode: Mode;
+    block: number;
+    slide: number;
+    page: number;
+    /** Steps revealed on the current page, from 0. */
+    step: number;
+}
+export interface DeckChange extends DeckState {
+    /** The position as written in the URL, for example `4.4.2`. */
+    at: string;
+}
+/** Interface text. The defaults are Traditional Chinese. */
+export interface Labels {
+    overview: string;
+    notes: string;
+    script: string;
+    threeD: string;
+    prev: string;
+    next: string;
+    exit: string;
+    remote: string;
+    here: string;
+    appendix: string;
+    rail: string;
+    noNotes: string;
+    slides(count: number): string;
+    pages(count: number): string;
+    minutes(count: number): string;
+    page(index: number, count: number): string;
+    steps(shown: number, count: number): string;
+    thumb(block: string, slide: number, title: string, pages: number): string;
+}
+export interface DeckOptions {
+    /** `snap` moves one stop per wheel gesture; `free` leaves scrolling native with proximity snap. Default `snap`. */
+    paging?: "snap" | "free";
+    /** How the outline looks on entry. Default `flat`. */
+    overview?: "flat" | "3d";
+    /** Block kinds the linear advance and the arrow keys never enter. Default `["appendix"]`. */
+    linear?: {
+        skip?: string[];
+    };
+    /** Entry view. Default: `?view=notes` selects `notes`, anything else `deck`. */
+    view?: "deck" | "notes";
+    /** Entry position, in the `?at=` format. Default: the `at` query parameter. */
+    at?: string;
+    /** Read and write `?view=` and `?at=`. Default `true`. */
+    url?: boolean;
+    labels?: Partial<Labels>;
+    /**
+     * The remote: with this option the bar has a remote button, and the button and the `R` key call it.
+     * It usually loads `contour-deck/remote` on first use. Without it the deck has neither.
+     */
+    remote?: (deck: Deck) => void;
+}
+export interface Deck {
+    /** Back to the outline. */
+    overview(): Promise<void>;
+    /** Put a block on the stage: `"4"` or `"4.2"`. */
+    open(at: string): Promise<void>;
+    /** Linear advance: next step, down within the page, next page, next slide, next block. */
+    next(): void;
+    /** The linear advance in reverse. */
+    prev(): void;
+    /** Go to a position (`"4.4.2"` or an element id), with the transition that fits the distance. */
+    go(at: string): Promise<void>;
+    /** The slide before or after, as the left and right arrow keys: it leaves the block at its ends. */
+    slideBy(direction: 1 | -1): void;
+    /** One stop up or down inside the slide, as the up and down arrow keys. */
+    pageBy(direction: 1 | -1): void;
+    on(type: "change", listener: (change: DeckChange) => void): () => void;
+    /** `exit` fires when the reader leaves: Esc on the outline, or the close button of the bar. The host usually calls `destroy()`. */
+    on(type: "exit", listener: () => void): () => void;
+    /** `destroy` fires once, at the start of `destroy()`, while the shell is still in the document. */
+    on(type: "destroy", listener: () => void): () => void;
+    readonly state: DeckState;
+    /** Puts the deck element back where it was and removes everything the core added. */
+    destroy(): void;
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/rehype/hast.d.ts

@@ -0,0 +1,26 @@
+export interface HastNode {
+    type: string;
+    value?: string;
+    tagName?: string;
+    properties?: Record<string, unknown>;
+    children?: HastNode[];
+}
+export interface Element extends HastNode {
+    type: "element";
+    tagName: string;
+    properties: Record<string, unknown>;
+    children: HastNode[];
+}
+export declare function isElement(node: HastNode): node is Element;
+export declare function element(tagName: string, properties: Record<string, unknown>, children: HastNode[]): Element;
+export declare function classesOf(node: Element): string[];
+export declare function hasClass(node: HastNode, name: string): boolean;
+export declare function isBlank(node: HastNode): boolean;
+/** The marker the remark plugin put on `node`, if any. */
+export declare function markOf(node: HastNode): string | undefined;
+/** Plain text of `node`; subtrees for which `skip` is true count as empty. */
+export declare function textOf(node: HastNode, skip?: (node: HastNode) => boolean): string;
+/** Text as a title: whitespace collapsed and trimmed. */
+export declare function plainText(node: HastNode): string;
+/** Calls `visit` for every element under `nodes`, in document order. */
+export declare function walkElements(nodes: HastNode[], visit: (node: Element) => void): void;

package/dist/rehype/hast.js

@@ -0,0 +1,48 @@
+/** The few hast shapes the plugin touches; hast itself is not a dependency. */
+import { MARK } from "../shared/markers.js";
+export function isElement(node) {
+    return node.type === "element";
+}
+export function element(tagName, properties, children) {
+    return { type: "element", tagName, properties, children };
+}
+export function classesOf(node) {
+    const value = node.properties.className;
+    if (Array.isArray(value))
+        return value.map(String);
+    return typeof value === "string" ? value.split(/\s+/) : [];
+}
+export function hasClass(node, name) {
+    return isElement(node) && classesOf(node).includes(name);
+}
+export function isBlank(node) {
+    return node.type === "text" && !(node.value ?? "").trim();
+}
+/** The marker the remark plugin put on `node`, if any. */
+export function markOf(node) {
+    if (!isElement(node))
+        return undefined;
+    const mark = node.properties[MARK];
+    return typeof mark === "string" ? mark : undefined;
+}
+/** Plain text of `node`; subtrees for which `skip` is true count as empty. */
+export function textOf(node, skip) {
+    if (node.type === "text")
+        return node.value ?? "";
+    if (skip?.(node))
+        return "";
+    return (node.children ?? []).map(child => textOf(child, skip)).join("");
+}
+/** Text as a title: whitespace collapsed and trimmed. */
+export function plainText(node) {
+    return textOf(node).replace(/\s+/g, " ").trim();
+}
+/** Calls `visit` for every element under `nodes`, in document order. */
+export function walkElements(nodes, visit) {
+    for (const node of nodes) {
+        if (!isElement(node))
+            continue;
+        visit(node);
+        walkElements(node.children, visit);
+    }
+}

package/dist/rehype/index.d.ts

@@ -0,0 +1,12 @@
+import { type HastNode } from "./hast.js";
+export interface DeckOptions {
+    /** Deck title for `data-title`. Default: the `title` frontmatter field under Astro, else none. */
+    title?: string;
+    /** Whether to build a deck for this file. Default: every file. */
+    match?: (file: DeckFile) => boolean;
+}
+export interface DeckFile {
+    data: object;
+    fail(reason: string, place?: unknown, origin?: string): never;
+}
+export declare function rehypeDeck(options?: DeckOptions): (tree: HastNode, file: DeckFile) => void;