forgebook 0.1.8 → 0.2.0

package/dist/src/vite/closeWatch.d.ts

@@ -0,0 +1,96 @@
+import type { ViteDevServer, WatchOptions } from "vite";
+/** How many files are followed at most: each holds a file descriptor while it is followed. */
+export declare const CLOSE_WATCH_LIMIT = 64;
+/** A file's watch, as `watchFile` opens it. */
+export type FileWatch = {
+    /** Stops watching. */
+    readonly close: () => void;
+};
+/**
+ * Opens a file's watch: Node's `fs.watch`, unless a test hands its own.
+ *
+ * @param file - the file.
+ * @param onEvent - called with `"change"` when the file's content changed, `"rename"` when the file was replaced or
+ * removed (an editor that saves through a new file), `"error"` when the watch failed.
+ * @throws when the file cannot be watched (gone, or no file descriptor left).
+ */
+export type WatchFile = (file: string, onEvent: (kind: "change" | "rename" | "error") => void) => FileWatch;
+/** The files followed, and what the dev server took of each. */
+export type CloseWatch = {
+    /**
+     * Follows a file, or keeps following it as the most recent; a file that cannot be watched is left to Vite's watcher.
+     *
+     * @param file - the file, in Node's or Vite's form.
+     */
+    readonly follow: (file: string) => void;
+    /**
+     * Whether an update of a followed file is the late report of an edit the environment took already: one the close
+     * watch did not hand on since the environment's last update of the file, whose text is the one it took then. Each
+     * update the close watch handed on is taken, the same text or not; the text is kept for the next. Always false for
+     * a file not followed.
+     *
+     * @param environment - the environment's name.
+     * @param file - the file, in Node's or Vite's form.
+     */
+    readonly isLateReport: (environment: string, file: string) => boolean;
+    /** Stops following every file. */
+    readonly close: () => void;
+};
+/** What `closeWatch` is made with. */
+export type CloseWatchOptions = {
+    /**
+     * Hands a followed file's change to the dev server's watcher.
+     *
+     * @param file - the file, in Vite's form.
+     */
+    readonly onChange: (file: string) => void;
+    /** How many files are followed at most; `CLOSE_WATCH_LIMIT` by default. */
+    readonly limit?: number;
+    /** Opens a file's watch; Node's `fs.watch` by default. */
+    readonly watchFile?: WatchFile;
+    /**
+     * A file's text now, or none when it cannot be read; read from the disk by default.
+     *
+     * @param file - the file.
+     */
+    readonly readText?: (file: string) => string | undefined;
+};
+/**
+ * Whether a dev server's watcher hears of changes through FSEvents, which deliver them late: Vite's on macOS, unless
+ * it polls, was told not to use them, or waits for writes to finish; none when the dev server watches nothing.
+ *
+ * @param options - the dev server's `server.watch`.
+ * @param platform - the system, `process.platform` by default.
+ */
+export declare const isWatchingByFileEvents: (options: WatchOptions | null | undefined, platform?: NodeJS.Platform) => boolean;
+/**
+ * Follows the files a person is working on, each on its own.
+ *
+ * @param options - where a change goes, how many files at most, and how a file is watched and read.
+ */
+export declare const closeWatch: (options: CloseWatchOptions) => CloseWatch;
+/**
+ * A dev server's close watch, where its watcher reads FSEvents and it sends updates: changes go to its watcher, and a
+ * file a page loaded that the person edits is followed from then on, since it is likely edited again. Closed with the
+ * server's HTTP server; the plugin closes it with the server too, which may have none.
+ *
+ * @param server - the dev server.
+ * @param platform - the system, `process.platform` by default.
+ * @returns the close watch; none where the watcher hears of changes at once, or polls.
+ */
+export declare const serverCloseWatch: (server: ViteDevServer, platform?: NodeJS.Platform) => CloseWatch | undefined;
+/** The close watch of the dev server that runs now, as the plugin holds it across restarts. */
+export type CurrentCloseWatch = Pick<CloseWatch, "follow" | "isLateReport" | "close"> & {
+    /**
+     * Ends the watch of the server before, if any, and starts this server's: a restart configures the new server before
+     * it closes the old one.
+     *
+     * @param server - the dev server; none in a run where no person waits for a page (a test run).
+     * @param platform - the system, `process.platform` by default.
+     */
+    readonly serve: (server: ViteDevServer | undefined, platform?: NodeJS.Platform) => void;
+};
+/**
+ * The close watch of the dev server that runs now; none follows a file until a server is served.
+ */
+export declare const currentCloseWatch: () => CurrentCloseWatch;

package/dist/src/vite/closeWatch.js

@@ -0,0 +1,219 @@
+/**
+ * The files a person is working on, each watched on its own, so the dev server hears of an edit at once: the story
+ * files the open frames loaded, and each file a page loaded that was edited since the server started.
+ *
+ * @remarks
+ * On macOS, Vite's watcher hears of a change through FSEvents, by streams that deliver it a tenth of a second late by
+ * design, and later still while the system's file-event service is busy: on a large library that wait is most of the
+ * time an edit takes to reach the page, and most of its spread. A file watched on its own (`fs.watch` on the file,
+ * a kernel event) is told at once, so each followed file's change is handed to Vite's watcher as its own. Its
+ * FSEvents event still comes, a little later: the dev server drops an update the close watch did not hand on when it
+ * finds the text the environment took last (`isLateReport`), so an edit is drawn once, while a save that changes
+ * nothing still draws anew when the close watch reports it (a story retried after an error). Vite still marks the
+ * file's modules stale for a dropped report, and no later plugin's `hotUpdate` sees it. A watch holds a file
+ * descriptor, so only a bounded few files are followed, the least recently followed dropped first; never a
+ * dependency's file, which Vite's watcher ignores, nor a page (`.html`), for which Vite answers an update it drops
+ * with a reload of the pages.
+ *
+ * Only where Vite's watcher reads FSEvents and the dev server sends updates: elsewhere its events already come at
+ * once, polling (`--poll`) is the choice where no event can be trusted, and a watcher told to wait for writes to
+ * finish (`awaitWriteFinish`) is left to wait.
+ *
+ * @module
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, watch } from "node:fs";
+import { VITE_PATHS } from "./vitePaths.js";
+/** Where a project's dependencies are installed, whose files Vite's watcher ignores and none is followed in. */
+const DEPENDENCIES = "/node_modules/";
+/** A page, whose update Vite answers with a reload when it is dropped: never followed. */
+const PAGE_FILE = /\.html?$/;
+/** How many files are followed at most: each holds a file descriptor while it is followed. */
+export const CLOSE_WATCH_LIMIT = 64;
+/**
+ * Node's watch of one file: a kernel event per change (kqueue on macOS). Not persistent, so it never keeps a process
+ * that is ending alive.
+ *
+ * @param file - the file.
+ * @param onEvent - the watch's events.
+ */
+const nodeWatchFile = (file, onEvent) => {
+    const watcher = watch(file, { persistent: false }, (kind) => onEvent(kind === "rename" ? "rename" : "change"));
+    watcher.on("error", () => onEvent("error"));
+    return { close: () => watcher.close() };
+};
+/**
+ * A file's text, or none when it cannot be read.
+ *
+ * @param file - the file.
+ */
+const diskText = (file) => {
+    try {
+        return readFileSync(file, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * A text's digest: what is kept of a file's last update, so a long file is not held twice.
+ *
+ * @param text - the text.
+ */
+const digestOf = (text) => createHash("sha256").update(text).digest("hex");
+/**
+ * Whether a dev server's watcher hears of changes through FSEvents, which deliver them late: Vite's on macOS, unless
+ * it polls, was told not to use them, or waits for writes to finish; none when the dev server watches nothing.
+ *
+ * @param options - the dev server's `server.watch`.
+ * @param platform - the system, `process.platform` by default.
+ */
+export const isWatchingByFileEvents = (options, platform = process.platform) => platform === "darwin" &&
+    options !== null &&
+    options?.usePolling !== true &&
+    options?.useFsEvents !== false &&
+    (options?.awaitWriteFinish === undefined || options.awaitWriteFinish === false);
+/**
+ * Follows the files a person is working on, each on its own.
+ *
+ * @param options - where a change goes, how many files at most, and how a file is watched and read.
+ */
+export const closeWatch = (options) => {
+    const limit = options.limit ?? CLOSE_WATCH_LIMIT;
+    const watchFile = options.watchFile ?? nodeWatchFile;
+    const readText = options.readText ?? diskText;
+    // by file in Vite's form, the least recently followed first
+    const followed = new Map();
+    // how many changes of each followed file the close watch handed on
+    const handed = new Map();
+    // what each environment last took of a followed file, by environment and file: the handed count it had reached and
+    // the text's digest
+    const taken = new Map();
+    // the files whose change is handed on at the end of this turn: a save is often two events (emptied, then written)
+    const handing = new Set();
+    const handOn = (file) => {
+        if (handing.has(file))
+            return;
+        handing.add(file);
+        setImmediate(() => {
+            handing.delete(file);
+            if (!followed.has(file))
+                return;
+            handed.set(file, (handed.get(file) ?? 0) + 1);
+            options.onChange(file);
+        });
+    };
+    const stop = (file) => {
+        followed.get(file)?.close();
+        followed.delete(file);
+    };
+    const forget = (file) => {
+        stop(file);
+        handed.delete(file);
+        for (const key of [...taken.keys()]) {
+            if (key.endsWith(`\0${file}`))
+                taken.delete(key);
+        }
+    };
+    const open = (file) => {
+        try {
+            followed.set(file, watchFile(file, (kind) => {
+                if (kind === "change") {
+                    handOn(file);
+                    return;
+                }
+                // a file saved through a new one is another file now: the old watch hears nothing more of it, and what
+                // was taken of it still tells the late event of this save from a new edit
+                if (kind === "rename" && existsSync(file)) {
+                    stop(file);
+                    open(file);
+                    handOn(file);
+                    return;
+                }
+                // removed, or the watch failed: Vite's own watcher reports what follows
+                forget(file);
+            }));
+        }
+        catch {
+            // gone already, or no file descriptor left: Vite's own watcher still reports it
+        }
+        while (followed.size > limit) {
+            const oldest = followed.keys().next().value;
+            if (oldest === undefined)
+                break;
+            forget(oldest);
+        }
+    };
+    return {
+        follow: (file) => {
+            const key = VITE_PATHS.normalize(file);
+            if (key.includes(DEPENDENCIES) || PAGE_FILE.test(key))
+                return;
+            const kept = followed.get(key);
+            if (kept === undefined) {
+                open(key);
+                return;
+            }
+            followed.delete(key);
+            followed.set(key, kept);
+        },
+        isLateReport: (environment, file) => {
+            const key = VITE_PATHS.normalize(file);
+            if (!followed.has(key))
+                return false;
+            const text = readText(key);
+            if (text === undefined)
+                return false;
+            const digest = digestOf(text);
+            const takenKey = `${environment}\0${key}`;
+            const last = taken.get(takenKey);
+            const count = handed.get(key) ?? 0;
+            const isHandedOn = last === undefined || count > last.handed;
+            if (!isHandedOn && last.digest === digest)
+                return true;
+            taken.set(takenKey, { handed: count, digest });
+            return false;
+        },
+        close: () => {
+            for (const file of [...followed.keys()])
+                forget(file);
+        }
+    };
+};
+/**
+ * A dev server's close watch, where its watcher reads FSEvents and it sends updates: changes go to its watcher, and a
+ * file a page loaded that the person edits is followed from then on, since it is likely edited again. Closed with the
+ * server's HTTP server; the plugin closes it with the server too, which may have none.
+ *
+ * @param server - the dev server.
+ * @param platform - the system, `process.platform` by default.
+ * @returns the close watch; none where the watcher hears of changes at once, or polls.
+ */
+export const serverCloseWatch = (server, platform = process.platform) => {
+    const { watch, hmr } = server.config.server;
+    if (!isWatchingByFileEvents(watch, platform) || hmr === false)
+        return undefined;
+    const watching = closeWatch({ onChange: (file) => void server.watcher.emit("change", file) });
+    server.watcher.on("change", (file) => {
+        const loaded = server.environments.client.moduleGraph.getModulesByFile(VITE_PATHS.normalize(file));
+        if (loaded !== undefined && loaded.size > 0)
+            watching.follow(file);
+    });
+    server.httpServer?.on("close", () => watching.close());
+    return watching;
+};
+/**
+ * The close watch of the dev server that runs now; none follows a file until a server is served.
+ */
+export const currentCloseWatch = () => {
+    let current;
+    return {
+        serve: (server, platform = process.platform) => {
+            current?.close();
+            current = server === undefined ? undefined : serverCloseWatch(server, platform);
+        },
+        follow: (file) => current?.follow(file),
+        isLateReport: (environment, file) => current?.isLateReport(environment, file) === true,
+        close: () => current?.close()
+    };
+};

package/dist/src/vite/codeFence.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A code fence's whole line read, and its code drawn by it: a title, marked lines, inserted and deleted lines, a diff
+ * coloured in its own language, and long lines wrapped.
+ *
+ * @remarks
+ * The line after the backticks is written as Expressive Code and VitePress write it, so an author knows it: the
+ * language, then `title="Button.tsx"`, the marked lines in braces (`1,4-6`), `ins=` and `del=` with lines in braces,
+ * and `wrap`; a `diff` fence takes `lang="tsx"`, so its `+` and `-` lines keep the colours of their language. Everything is done here, at build time: the page gets HTML
+ * whose lines are elements (`<mark>`, `<ins>`, `<del>`), so a screen reader hears what changed and the shell needs no
+ * script for it. The copied text is the code as it reads after the change: its diff signs taken off and its deleted
+ * lines left out, so what is pasted runs. Pure.
+ *
+ * @module
+ */
+import type { PageNote, SourcePosition } from "./docDirectives.ts";
+/** What a code fence's line says. */
+export type FenceInfo = {
+    /** The language the code is coloured in; none leaves it plain. */
+    readonly language: string | undefined;
+    /** Its title, a file's name most often; none when it has none. */
+    readonly title: string | undefined;
+    /** The lines marked, from 1. */
+    readonly marked: ReadonlySet<number>;
+    /** The lines inserted, from 1. */
+    readonly inserted: ReadonlySet<number>;
+    /** The lines deleted, from 1. */
+    readonly deleted: ReadonlySet<number>;
+    /** Whether it is a diff, whose lines start with `+`, `-` or a space. */
+    readonly isDiff: boolean;
+    /** Whether long lines wrap instead of scrolling. */
+    readonly isWrapped: boolean;
+};
+/** A code block as the page draws it. */
+export type FencedCode = {
+    /** The code as the copy button copies it. */
+    readonly text: string;
+    /** The code as HTML, coloured, its lines elements when some are marked. */
+    readonly html: string;
+    /** Its language, when it has one. */
+    readonly language: string | undefined;
+    /** Its title, when it has one. */
+    readonly title: string | undefined;
+    /** Whether long lines wrap. */
+    readonly isWrapped: boolean;
+};
+/**
+ * What a code fence's line says, every word it does not read reported where it is.
+ *
+ * @param info - the line after the backticks.
+ * @param start - where the line starts in the file, for the notes.
+ * @param notes - receives what cannot be read.
+ */
+export declare const fenceInfo: (info: string, start: SourcePosition, notes: PageNote[]) => FenceInfo;
+/**
+ * Coloured HTML split at its lines, every span closed at a line's end and opened again on the next, so each line can
+ * be an element of its own.
+ *
+ * @param html - the coloured code.
+ */
+export declare const htmlLines: (html: string) => string[];
+/**
+ * The first line a fence names that its code does not have; none when every line it names is there.
+ *
+ * @param code - the code as the fence holds it.
+ * @param info - what its fence's line says.
+ * @returns the line, and how many the code has.
+ */
+export declare const missingLine: (code: string, info: FenceInfo) => {
+    readonly line: number;
+    readonly count: number;
+} | undefined;
+/**
+ * A fenced block's code as the page draws it.
+ *
+ * @param code - the code as the fence holds it.
+ * @param info - what its fence's line says.
+ */
+export declare const fencedCode: (code: string, info: FenceInfo) => FencedCode;

package/dist/src/vite/codeFence.js

@@ -0,0 +1,267 @@
+import { highlightCode } from "./highlightCode.js";
+/** The class of every line of a block whose lines are elements. */
+const LINE_CLASS = "forgebook-code-line";
+/** A fence's line split into words: a quoted value or braces stay whole. */
+const fenceWords = (info) => {
+    const words = [];
+    const pattern = /(?:[^\s"'{=]+(?:=(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\{[^}]*\}|[^\s]*))?|\{[^}]*\}|"[^"]*"|\S+)/g;
+    for (const match of info.matchAll(pattern))
+        words.push({ text: match[0], offset: match.index });
+    return words;
+};
+/** The highest line a fence may name. */
+const MAX_LINE = 100_000;
+/**
+ * The lines a range list names: `1,4-6` is 1, 4, 5 and 6.
+ *
+ * @param text - the list, without its braces.
+ * @returns the lines, or none when the list cannot be read.
+ */
+const rangeLines = (text) => {
+    const lines = new Set();
+    for (const part of text.split(",")) {
+        const range = /^\s*(\d+)\s*(?:-\s*(\d+)\s*)?$/.exec(part);
+        if (range?.[1] === undefined)
+            return undefined;
+        const from = Number(range[1]);
+        const to = range[2] === undefined ? from : Number(range[2]);
+        // a range no code can hold is a mistake, and would fill the set with millions of lines
+        if (from < 1 || to < from || to > MAX_LINE)
+            return undefined;
+        for (let line = from; line <= to; line += 1)
+            lines.add(line);
+    }
+    return lines;
+};
+/** A value without its quotes or braces, its escapes read. */
+const bareValue = (value) => {
+    const first = value.charAt(0);
+    if ((first === '"' || first === "'") && value.endsWith(first) && value.length > 1)
+        return value.slice(1, -1).replace(/\\(.)/g, "$1");
+    return value;
+};
+/** The words that name lines, and the set each fills. */
+const RANGE_KEYS = {
+    mark: "marked",
+    ins: "inserted",
+    del: "deleted"
+};
+/**
+ * Adds the lines a `{1,4-6}` list names to a set, or notes that it is no list.
+ *
+ * @param target - the set.
+ * @param value - the list, with its braces.
+ * @param position - where it starts, for the note.
+ * @param notes - receives what cannot be read.
+ */
+const addRanges = (target, value, position, notes) => {
+    const lines = value.startsWith("{") && value.endsWith("}") ? rangeLines(value.slice(1, -1)) : undefined;
+    if (lines === undefined) {
+        notes.push({ position, message: `"${value}" is not a list of lines: write {1,4-6}` });
+        return;
+    }
+    for (const line of lines)
+        target.add(line);
+};
+/**
+ * Reads one word of a fence's line into what it says.
+ *
+ * @param word - the word.
+ * @param isDiff - whether the fence is a diff, the one that takes `lang`.
+ * @param reading - what the line says so far.
+ * @param at - the position of a place of the line.
+ * @param notes - receives what cannot be read.
+ */
+const readFenceWord = ({ text, offset }, isDiff, reading, at, notes) => {
+    if (text.startsWith("{")) {
+        addRanges(reading.marked, text, at(offset), notes);
+        return;
+    }
+    if (text === "wrap") {
+        reading.isWrapped = true;
+        return;
+    }
+    const equals = text.indexOf("=");
+    const key = equals === -1 ? text : text.slice(0, equals);
+    const value = equals === -1 ? "" : text.slice(equals + 1);
+    const range = RANGE_KEYS[key];
+    if (range !== undefined) {
+        addRanges(reading[range], value, at(offset + equals + 1), notes);
+        return;
+    }
+    if (key === "title" && value !== "") {
+        reading.title = bareValue(value);
+        return;
+    }
+    if (key === "lang" && isDiff && value !== "") {
+        reading.language = bareValue(value);
+        return;
+    }
+    const hint = key === "lang"
+        ? '`lang` goes with a diff (```diff lang="tsx")'
+        : 'it reads title="…", {1,4-6}, ins={…}, del={…} and wrap';
+    notes.push({ position: at(offset), message: `the code fence's "${text}" is not read: ${hint}` });
+};
+/**
+ * What a code fence's line says, every word it does not read reported where it is.
+ *
+ * @param info - the line after the backticks.
+ * @param start - where the line starts in the file, for the notes.
+ * @param notes - receives what cannot be read.
+ */
+export const fenceInfo = (info, start, notes) => {
+    const at = (offset) => ({ line: start.line, column: start.column + offset });
+    const words = fenceWords(info);
+    const first = words[0];
+    const named = first !== undefined && first.text !== "wrap" && !first.text.includes("=") && !/^[{"]/.test(first.text)
+        ? first.text
+        : undefined;
+    const isDiff = named === "diff";
+    const reading = {
+        language: isDiff ? undefined : named,
+        title: undefined,
+        isWrapped: false,
+        marked: new Set(),
+        inserted: new Set(),
+        deleted: new Set()
+    };
+    for (const word of named === undefined ? words : words.slice(1))
+        readFenceWord(word, isDiff, reading, at, notes);
+    return { ...reading, isDiff };
+};
+/**
+ * Coloured HTML split at its lines, every span closed at a line's end and opened again on the next, so each line can
+ * be an element of its own.
+ *
+ * @param html - the coloured code.
+ */
+export const htmlLines = (html) => {
+    const lines = [];
+    const open = [];
+    let current = "";
+    for (const part of html.split(/(<span[^>]*>|<\/span>|\n)/)) {
+        if (part === "\n") {
+            lines.push(current + "</span>".repeat(open.length));
+            current = open.join("");
+        }
+        else if (part.startsWith("<span")) {
+            open.push(part);
+            current += part;
+        }
+        else if (part === "</span>") {
+            open.pop();
+            current += part;
+        }
+        else
+            current += part;
+    }
+    lines.push(current);
+    return lines;
+};
+/** The kind of line each sign of a diff starts. */
+const DIFF_SIGNS = { "+": "ins", "-": "del" };
+/** A patch's file headers (`--- a/x`, `+++ b/x`): plain lines, never a deletion or an insertion. */
+const PATCH_HEADER = /^(---|\+\+\+)( |$)/;
+/**
+ * A diff's lines and the kind of each. A diff in a language (`lang="tsx"`) is code whose signs come off, so it is
+ * coloured and copied as code; one without is a patch, kept as written, so what is copied still applies.
+ *
+ * @param code - the diff.
+ * @param isCode - whether its signs come off.
+ */
+const diffLines = (code, isCode) => {
+    const kinds = [];
+    const lines = code.split("\n").map((line) => {
+        const sign = line.charAt(0);
+        kinds.push(PATCH_HEADER.test(line) ? "plain" : (DIFF_SIGNS[sign] ?? "plain"));
+        return isCode && (sign === "+" || sign === "-" || sign === " ") ? line.slice(1) : line;
+    });
+    return { code: lines.join("\n"), kinds };
+};
+/** Whether a fence is a diff of code in a language, whose signs come off: a diff without one is a patch. */
+const isCodeDiff = (info) => info.isDiff && info.language !== undefined;
+/** A line as an element of its kind. */
+const lineElement = (html, kind) => {
+    const element = kind === "plain" ? "span" : kind;
+    return `<${element} class="${LINE_CLASS}">${html}</${element}>`;
+};
+/**
+ * Each line coloured, the code before the change and after it apart: a deleted line that leaves a string or a comment
+ * open would otherwise colour the inserted line after it as part of it.
+ *
+ * @param code - the code, its diff signs taken off.
+ * @param kinds - each line's kind.
+ * @param language - the language it is coloured in.
+ */
+const coloredLines = (code, kinds, language) => {
+    const lines = code.split("\n");
+    if (!kinds.includes("del"))
+        return htmlLines(highlightCode(code, language));
+    const version = (left) => {
+        const places = lines.flatMap((_line, index) => (kinds[index] === left ? [] : [index]));
+        const html = htmlLines(highlightCode(places.map((index) => lines[index] ?? "").join("\n"), language));
+        return { places, html };
+    };
+    const coloured = [];
+    for (const { places, html } of [version("ins"), version("del")]) {
+        places.forEach((index, at) => {
+            coloured[index] ??= html[at] ?? "";
+        });
+    }
+    return lines.map((_line, index) => coloured[index] ?? "");
+};
+/**
+ * A diff's code without its signs, or the code itself.
+ *
+ * @param code - the code as the fence holds it.
+ * @param info - what its fence's line says.
+ */
+const shownCode = (code, info) => info.isDiff ? diffLines(code, isCodeDiff(info)).code : code;
+/**
+ * The first line a fence names that its code does not have; none when every line it names is there.
+ *
+ * @param code - the code as the fence holds it.
+ * @param info - what its fence's line says.
+ * @returns the line, and how many the code has.
+ */
+export const missingLine = (code, info) => {
+    const count = shownCode(code, info).split("\n").length;
+    const beyond = [...info.marked, ...info.inserted, ...info.deleted].filter((line) => line > count);
+    return beyond.length === 0 ? undefined : { line: Math.min(...beyond), count };
+};
+/**
+ * A fenced block's code as the page draws it.
+ *
+ * @param code - the code as the fence holds it.
+ * @param info - what its fence's line says.
+ */
+export const fencedCode = (code, info) => {
+    const diff = info.isDiff ? diffLines(code, isCodeDiff(info)) : undefined;
+    const plain = shownCode(code, info);
+    const base = { language: info.language, title: info.title, isWrapped: info.isWrapped };
+    if (diff === undefined && info.marked.size + info.inserted.size + info.deleted.size === 0) {
+        return { ...base, text: code, html: highlightCode(code, info.language) };
+    }
+    const kinds = plain.split("\n").map((_line, index) => {
+        const line = index + 1;
+        if (info.deleted.has(line))
+            return "del";
+        if (info.inserted.has(line))
+            return "ins";
+        if (info.marked.has(line))
+            return "mark";
+        return diff?.kinds[index] ?? "plain";
+    });
+    const html = coloredLines(plain, kinds, info.language)
+        .map((line, index) => lineElement(line, kinds[index] ?? "plain"))
+        .join("\n");
+    // a patch is copied whole, to apply; code is copied as it reads after the change
+    const isPatch = info.isDiff && !isCodeDiff(info);
+    const text = isPatch
+        ? plain
+        : plain
+            .split("\n")
+            .filter((_line, index) => kinds[index] !== "del")
+            .join("\n");
+    return { ...base, text, html };
+};

package/dist/src/vite/componentImport.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The module a story file imports its meta's component from (`./Button`).
+ *
+ * @param storyFile - the story file's path, for the parser (its extension decides TypeScript and JSX).
+ * @param text - the story file's text.
+ * @returns the import's module specifier, or none when the meta names no imported component.
+ */
+export declare const componentImport: (storyFile: string, text: string) => string | undefined;