@memorysmithapp/markdown-renderer 0.3.2 → 0.5.0

package/dist/edit/saves.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Where the save of the author's edits stands (#64, #86).
+ *
+ * The host saves each change it is handed. When `onChange` answers with a promise, the editor
+ * follows it: saving while it is pending, saved once it resolves, not saved when it rejects. Only
+ * the latest change counts: a save that settles after a later change was handed says nothing, so
+ * "Saved" always means the last text the author wrote. A host that answers with nothing has no
+ * status, and the editor shows none.
+ *
+ * A host may also say why (#86): a save that resolves with a `SaveOutcome` succeeded with
+ * something the author must decide, the alert; one rejected with a `SaveRefusal` was refused for
+ * a reason the host explains, the error. Either carries the actions the author chooses from, and
+ * an action the author runs is followed like a save.
+ */
+/** One choice the host offers the author: its word, and what choosing it does. */
+export interface SaveAction {
+    /** The button's word, in the reader's language: the host words it. */
+    readonly label: string;
+    /** Runs the choice; a promise answered is followed like a save, and may end in another notice. */
+    readonly run: () => Promise<void | SaveOutcome> | void;
+}
+/** What the host has to say about a save, and the choices it gives the author. */
+export interface SaveNotice {
+    /** The dialog's title, and the status button's tooltip. */
+    readonly title: string;
+    /** The explanation in the dialog. */
+    readonly message: string;
+    readonly actions: readonly SaveAction[];
+}
+/** A save that succeeded with something the author must decide: what `onChange`'s promise resolves with. */
+export type SaveOutcome = SaveNotice;
+/** A save the host refused, with its reason and its choices: what `onChange`'s promise rejects with. */
+export type SaveRefusal = SaveNotice;
+export type EditSave = 'idle' | 'saving' | 'saved' | 'alert' | 'failed';
+export interface EditSaves {
+    readonly state: EditSave;
+    /** What the host said of the save: present in `alert`, and in `failed` when it gave a reason. */
+    readonly notice: SaveNotice | null;
+    /** Hands a change to the host and follows its save. */
+    readonly hand: (markdown: string) => void;
+    /** Hands the latest change to the host again, after a save failed. */
+    readonly retry: () => void;
+    /** Runs one of the notice's actions and follows it like a save. */
+    readonly run: (action: SaveAction) => void;
+}
+/** Whether a value is a notice a host gave: a title, a message and its actions. */
+export declare function isSaveNotice(value: unknown): value is SaveNotice;
+export declare function useEditSaves(onChange: ((markdown: string) => unknown) | undefined): EditSaves;

package/dist/edit/saves.js

@@ -0,0 +1,73 @@
+/**
+ * Where the save of the author's edits stands (#64, #86).
+ *
+ * The host saves each change it is handed. When `onChange` answers with a promise, the editor
+ * follows it: saving while it is pending, saved once it resolves, not saved when it rejects. Only
+ * the latest change counts: a save that settles after a later change was handed says nothing, so
+ * "Saved" always means the last text the author wrote. A host that answers with nothing has no
+ * status, and the editor shows none.
+ *
+ * A host may also say why (#86): a save that resolves with a `SaveOutcome` succeeded with
+ * something the author must decide, the alert; one rejected with a `SaveRefusal` was refused for
+ * a reason the host explains, the error. Either carries the actions the author chooses from, and
+ * an action the author runs is followed like a save.
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { isThenable } from '../task-saves.js';
+/** Whether a value is a notice a host gave: a title, a message and its actions. */
+export function isSaveNotice(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const notice = value;
+    return (typeof notice.title === 'string' &&
+        typeof notice.message === 'string' &&
+        Array.isArray(notice.actions) &&
+        notice.actions.every((action) => typeof action === 'object' && action !== null && typeof action.label === 'string' && typeof action.run === 'function'));
+}
+export function useEditSaves(onChange) {
+    const [status, setStatus] = useState({ state: 'idle', notice: null });
+    const latest = useRef({ onChange, count: 0, text: null, alive: true });
+    latest.current.onChange = onChange;
+    useEffect(() => {
+        const self = latest.current;
+        self.alive = true;
+        return () => {
+            self.alive = false;
+        };
+    }, []);
+    /** Follows what the host answered, a change's save or an action; `done` is the state of an answer that is not a promise. */
+    const follow = useCallback((answer, done) => {
+        const self = latest.current;
+        const count = ++self.count;
+        const settle = (state, notice = null) => {
+            if (self.alive && count === self.count)
+                setStatus({ state, notice });
+        };
+        let result;
+        try {
+            result = answer();
+        }
+        catch (reason) {
+            settle('failed', isSaveNotice(reason) ? reason : null);
+            return;
+        }
+        if (!isThenable(result)) {
+            settle(done);
+            return;
+        }
+        settle('saving');
+        result.then((value) => (isSaveNotice(value) ? settle('alert', value) : settle('saved')), (reason) => settle('failed', isSaveNotice(reason) ? reason : null));
+    }, []);
+    const hand = useCallback((markdown) => {
+        latest.current.text = markdown;
+        follow(() => latest.current.onChange?.(markdown), 'idle');
+    }, [follow]);
+    const retry = useCallback(() => {
+        const text = latest.current.text;
+        if (text !== null)
+            hand(text);
+    }, [hand]);
+    // An action that answers nothing has done what it does: the author decided, and nothing is left to say.
+    const run = useCallback((action) => follow(() => action.run(), 'saved'), [follow]);
+    return { state: status.state, notice: status.notice, hand, retry, run };
+}

package/dist/edit/table.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A table of a note, read as ranges of its bytes, and the edits the editor makes to it (#56).
+ *
+ * Every edit is a list of changes to the note: a cell's content replaced, a row inserted or
+ * removed, a column inserted or removed in every row, the delimiter cell of one column rewritten.
+ * A row an edit does not reach keeps its spacing and its pipes as written.
+ */
+import type { Span } from './analyze.js';
+export type Alignment = 'left' | 'center' | 'right' | null;
+export interface TableCell extends Span {
+    /** The content as written, trimmed: the range is the content's, without the padding. */
+    readonly text: string;
+}
+export interface TableRow extends Span {
+    readonly cells: readonly TableCell[];
+}
+export interface Table extends Span {
+    /** The note's text the table was read from. */
+    readonly source: string;
+    /** The header row, the delimiter row and the body rows, in order. */
+    readonly rows: readonly TableRow[];
+    readonly align: readonly Alignment[];
+    /** Whether the header was written with a leading and a trailing pipe, which a new row copies. */
+    readonly leadingPipe: boolean;
+    readonly trailingPipe: boolean;
+    /** What precedes the first cell of a row: a quotation's markers, or the indent of a list. */
+    readonly prefix: string;
+}
+export interface TextChange {
+    readonly from: number;
+    readonly to: number;
+    readonly insert: string;
+}
+/** The table whose rows run from the line holding `from` to the line holding `to`. */
+export declare function readTable(source: string, from: number, to: number): Table;
+/** A cell's content as written in a row: a pipe escaped, a line break a space. */
+export declare function cellText(value: string): string;
+/** How many columns the table has: the header's. */
+export declare function columnCount(table: Table): number;
+/** The delimiter cell of an alignment. */
+export declare function delimiterOf(alignment: Alignment): string;
+/**
+ * Replaces the content of one cell of the header (row 0) or of the body (row 2 on). A row with
+ * fewer cells gains the ones it lacks at its end, and nothing else of the table moves.
+ */
+export declare function setCell(table: Table, row: number, column: number, value: string): TextChange[];
+/** Inserts an empty row after `row`; after the header, it goes after the delimiter row. */
+export declare function addRow(table: Table, row: number): TextChange[];
+/** Removes a body row, with the line break before it; the header and the delimiter stay. */
+export declare function removeRow(table: Table, row: number): TextChange[];
+/** Inserts an empty column after `column`, in every row that reaches it. */
+export declare function addColumn(table: Table, column: number): TextChange[];
+/** Removes a column from every row, with the pipe that opens it. */
+export declare function removeColumn(table: Table, column: number): TextChange[];
+/** Rewrites the delimiter cell of one column; every other byte of the table stays. */
+export declare function alignColumn(table: Table, column: number, alignment: Alignment): TextChange[];
+/** Applies changes that do not overlap to a text, for the tests and for a host without the editor. */
+export declare function applyChanges(text: string, changes: readonly TextChange[]): string;

package/dist/edit/table.js

@@ -0,0 +1,185 @@
+/**
+ * A table of a note, read as ranges of its bytes, and the edits the editor makes to it (#56).
+ *
+ * Every edit is a list of changes to the note: a cell's content replaced, a row inserted or
+ * removed, a column inserted or removed in every row, the delimiter cell of one column rewritten.
+ * A row an edit does not reach keeps its spacing and its pipes as written.
+ */
+const PREFIX = /^(?:[ \t]*>[ \t]?)*[ \t]*/;
+/** The offsets of the pipes of a line that separate cells: not escaped, not inside a code span. */
+function pipesOf(source, from, to) {
+    const pipes = [];
+    let code = 0;
+    for (let i = from; i < to; i++) {
+        const character = source[i];
+        if (character === '\\') {
+            i += 1;
+            continue;
+        }
+        if (character === '`') {
+            let run = 1;
+            while (source[i + run] === '`')
+                run += 1;
+            code = code === run ? 0 : code === 0 ? run : code;
+            i += run - 1;
+            continue;
+        }
+        if (character === '|' && code === 0)
+            pipes.push(i);
+    }
+    return pipes;
+}
+function rowOf(source, from, to) {
+    const start = from + (PREFIX.exec(source.slice(from, to))?.[0].length ?? 0);
+    const pipes = pipesOf(source, start, to);
+    const leading = pipes[0] === start;
+    const trailing = pipes.length > 0 && /^[ \t]*$/.test(source.slice(pipes[pipes.length - 1] + 1, to));
+    const bounds = [leading ? pipes[0] : start - 1, ...pipes.slice(leading ? 1 : 0)];
+    if (!trailing)
+        bounds.push(to);
+    const cells = [];
+    for (let i = 0; i + 1 < bounds.length; i++) {
+        const open = bounds[i] + 1;
+        const close = bounds[i + 1];
+        const raw = source.slice(open, close);
+        const text = raw.trim();
+        // An empty cell's range is one character in, where typing lands between its padding.
+        const at = text.length === 0 ? open + Math.min(1, raw.length) : open + (raw.length - raw.trimStart().length);
+        cells.push({ from: at, to: at + text.length, text });
+    }
+    return { from, to, cells, leading, trailing };
+}
+/** The table whose rows run from the line holding `from` to the line holding `to`. */
+export function readTable(source, from, to) {
+    const rows = [];
+    let leadingPipe = true;
+    let trailingPipe = true;
+    let at = source.lastIndexOf('\n', from - 1) + 1;
+    const prefix = PREFIX.exec(source.slice(at, to))?.[0] ?? '';
+    while (at <= to) {
+        const newline = source.indexOf('\n', at);
+        const end = newline === -1 ? source.length : newline;
+        const row = rowOf(source, at, end);
+        if (rows.length === 0) {
+            leadingPipe = row.leading;
+            trailingPipe = row.trailing;
+        }
+        rows.push({ from: row.from, to: row.to, cells: row.cells });
+        if (newline === -1 || end >= to)
+            break;
+        at = end + 1;
+    }
+    const align = (rows[1]?.cells ?? []).map((cell) => {
+        const left = cell.text.startsWith(':');
+        const right = cell.text.endsWith(':');
+        return left && right ? 'center' : right ? 'right' : left ? 'left' : null;
+    });
+    return { source, from: rows[0].from, to: rows[rows.length - 1].to, rows, align, leadingPipe, trailingPipe, prefix };
+}
+/** A cell's content as written in a row: a pipe escaped, a line break a space. */
+export function cellText(value) {
+    return value
+        .replace(/\r?\n/g, ' ')
+        .replace(/(?<!\\)\|/g, '\\|')
+        .trim();
+}
+/** How many columns the table has: the header's. */
+export function columnCount(table) {
+    return Math.max(table.rows[0]?.cells.length ?? 1, 1);
+}
+function rowText(table, cells) {
+    const inner = cells.map((cell) => ` ${cell} `).join('|');
+    return `${table.prefix}${table.leadingPipe ? '|' : ''}${inner}${table.trailingPipe ? '|' : ''}`;
+}
+/** The delimiter cell of an alignment. */
+export function delimiterOf(alignment) {
+    return alignment === 'center' ? ':---:' : alignment === 'right' ? '---:' : alignment === 'left' ? ':---' : '---';
+}
+/**
+ * Replaces the content of one cell of the header (row 0) or of the body (row 2 on). A row with
+ * fewer cells gains the ones it lacks at its end, and nothing else of the table moves.
+ */
+export function setCell(table, row, column, value) {
+    const target = table.rows[row];
+    if (!target || row === 1)
+        return [];
+    const insert = cellText(value);
+    const cell = target.cells[column];
+    if (cell)
+        return cell.text === insert ? [] : [{ from: cell.from, to: cell.to, insert }];
+    const missing = Array.from({ length: column - target.cells.length + 1 }, (_, index) => index === column - target.cells.length ? insert : '');
+    const written = table.source.slice(target.from, target.to);
+    const closed = /\|[ \t]*$/.test(written);
+    const text = missing.map((each) => ` ${each} |`).join('');
+    return [{ from: target.to, to: target.to, insert: closed ? text : `|${text.slice(0, -1)}` }];
+}
+/** Inserts an empty row after `row`; after the header, it goes after the delimiter row. */
+export function addRow(table, row) {
+    const after = table.rows[Math.max(row, 1)];
+    if (!after)
+        return [];
+    return [{ from: after.to, to: after.to, insert: `\n${rowText(table, Array.from({ length: columnCount(table) }, () => ''))}` }];
+}
+/** Removes a body row, with the line break before it; the header and the delimiter stay. */
+export function removeRow(table, row) {
+    const target = table.rows[row];
+    if (!target || row < 2)
+        return [];
+    return [{ from: table.rows[row - 1].to, to: target.to, insert: '' }];
+}
+function pipeAfter(table, row, at) {
+    return pipesOf(table.source, at, row.to)[0] ?? null;
+}
+function pipeBefore(table, row, at) {
+    const pipes = pipesOf(table.source, row.from, at);
+    return pipes.length > 0 ? pipes[pipes.length - 1] : null;
+}
+/** Inserts an empty column after `column`, in every row that reaches it. */
+export function addColumn(table, column) {
+    return table.rows.flatMap((row, index) => {
+        const cell = row.cells[Math.min(column, row.cells.length - 1)];
+        if (!cell)
+            return [];
+        const content = index === 1 ? ' --- ' : '  ';
+        const pipe = pipeAfter(table, row, cell.to);
+        if (pipe !== null)
+            return [{ from: pipe + 1, to: pipe + 1, insert: `${content}|` }];
+        // A row written with no closing pipe: a body row is short and draws the cell empty, but the
+        // header and the delimiter have to name it, so they gain one.
+        if (index > 1)
+            return [];
+        return [{ from: row.to, to: row.to, insert: ` |${content}|` }];
+    });
+}
+/** Removes a column from every row, with the pipe that opens it. */
+export function removeColumn(table, column) {
+    if (columnCount(table) < 2)
+        return [];
+    return table.rows.flatMap((row) => {
+        const cell = row.cells[column];
+        if (!cell)
+            return [];
+        const open = pipeBefore(table, row, cell.from);
+        const close = pipeAfter(table, row, cell.to);
+        const start = row.from + (PREFIX.exec(table.source.slice(row.from, row.to))?.[0].length ?? 0);
+        if (open === null || open < start) {
+            // The first cell of a row with no leading pipe: it goes with the pipe that closes it.
+            return close === null ? [] : [{ from: start, to: close + 1, insert: '' }];
+        }
+        return [{ from: open, to: close ?? row.to, insert: '' }];
+    });
+}
+/** Rewrites the delimiter cell of one column; every other byte of the table stays. */
+export function alignColumn(table, column, alignment) {
+    const cell = table.rows[1]?.cells[column];
+    if (!cell)
+        return [];
+    const insert = delimiterOf(alignment);
+    return cell.text === insert ? [] : [{ from: cell.from, to: cell.to, insert }];
+}
+/** Applies changes that do not overlap to a text, for the tests and for a host without the editor. */
+export function applyChanges(text, changes) {
+    return [...changes]
+        .sort((a, b) => b.from - a.from)
+        .reduce((out, change) => out.slice(0, change.from) + change.insert + out.slice(change.to), text);
+}

package/dist/file-types.d.ts

@@ -0,0 +1,30 @@
+/**
+ * How a file the notebook keeps is drawn, by its media type and never by its name (SPEC.md §5.8,
+ * #77). The list is MemorySmith's closed one — *observed* at `4b67c7e`, `FILE_TYPES` in its
+ * contracts — sixteen types, each with the shape a reading surface draws it in: what a browser
+ * draws without running anything is drawn, an image, an audio, a video, and everything else is a
+ * card, the PDF included. A type outside the list is a card too, named by its media type.
+ */
+export type FileShape = 'image' | 'audio' | 'video' | 'card';
+interface FileType {
+    readonly mimeType: string;
+    readonly renders: FileShape;
+    /** Whether a browser shows a card's file on its own, so the card may offer to open it: the PDF. */
+    readonly opens?: boolean;
+}
+export declare const FILE_TYPES: readonly FileType[];
+/** The shape a type is drawn in: `card` for anything this surface does not draw. */
+export declare function rendersAs(mimeType: string): FileShape;
+/** Whether a browser shows the file on its own: everything drawn, and a card's only when its type says so. */
+export declare function opensInBrowser(mimeType: string): boolean;
+/** What a type is called in the reader's words, or its media type when it is not on the list or has none. */
+export declare function fileKind(mimeType: string, words: Readonly<Record<string, string>>): string;
+/** A size as MemorySmith writes it, in the reader's locale: bytes, then kB, MB and GB in steps of 1024. */
+export declare function formatBytes(bytes: number, locale: string): string;
+/**
+ * The address of a file's bytes as it will be written, or the empty string when this surface will
+ * not follow it: a path, the web, a `blob:` the host made, or the bytes themselves as `data:` —
+ * never a scheme that runs something, nor `data:` of a type a browser runs as a page or a script.
+ */
+export declare function fileAddress(url: string): string;
+export {};

package/dist/file-types.js

@@ -0,0 +1,70 @@
+/**
+ * How a file the notebook keeps is drawn, by its media type and never by its name (SPEC.md §5.8,
+ * #77). The list is MemorySmith's closed one — *observed* at `4b67c7e`, `FILE_TYPES` in its
+ * contracts — sixteen types, each with the shape a reading surface draws it in: what a browser
+ * draws without running anything is drawn, an image, an audio, a video, and everything else is a
+ * card, the PDF included. A type outside the list is a card too, named by its media type.
+ */
+export const FILE_TYPES = [
+    { mimeType: 'image/png', renders: 'image' },
+    { mimeType: 'image/jpeg', renders: 'image' },
+    { mimeType: 'image/webp', renders: 'image' },
+    { mimeType: 'image/gif', renders: 'image' },
+    { mimeType: 'image/svg+xml', renders: 'image' },
+    { mimeType: 'application/pdf', renders: 'card', opens: true },
+    { mimeType: 'audio/mpeg', renders: 'audio' },
+    { mimeType: 'audio/wav', renders: 'audio' },
+    { mimeType: 'audio/ogg', renders: 'audio' },
+    { mimeType: 'audio/webm', renders: 'audio' },
+    { mimeType: 'video/mp4', renders: 'video' },
+    { mimeType: 'video/webm', renders: 'video' },
+    { mimeType: 'video/quicktime', renders: 'video' },
+    { mimeType: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', renders: 'card' },
+    { mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', renders: 'card' },
+    { mimeType: 'application/vnd.openxmlformats-officedocument.presentationml.presentation', renders: 'card' },
+];
+function typeOf(mimeType) {
+    return FILE_TYPES.find((each) => each.mimeType === mimeType.trim().toLowerCase()) ?? null;
+}
+/** The shape a type is drawn in: `card` for anything this surface does not draw. */
+export function rendersAs(mimeType) {
+    return typeOf(mimeType)?.renders ?? 'card';
+}
+/** Whether a browser shows the file on its own: everything drawn, and a card's only when its type says so. */
+export function opensInBrowser(mimeType) {
+    const type = typeOf(mimeType);
+    if (!type)
+        return false;
+    return type.renders === 'card' ? type.opens === true : true;
+}
+/** What a type is called in the reader's words, or its media type when it is not on the list or has none. */
+export function fileKind(mimeType, words) {
+    const type = typeOf(mimeType);
+    return type ? (words[type.mimeType] ?? mimeType) : mimeType;
+}
+/** A size as MemorySmith writes it, in the reader's locale: bytes, then kB, MB and GB in steps of 1024. */
+export function formatBytes(bytes, locale) {
+    const units = [
+        { limit: 1024, divisor: 1, unit: 'byte', digits: 0 },
+        { limit: 1024 ** 2, divisor: 1024, unit: 'kilobyte', digits: 0 },
+        { limit: 1024 ** 3, divisor: 1024 ** 2, unit: 'megabyte', digits: bytes >= 1024 ** 2 * 10 ? 0 : 1 },
+        { limit: Infinity, divisor: 1024 ** 3, unit: 'gigabyte', digits: 1 },
+    ];
+    const scale = units.find((each) => bytes < each.limit) ?? units[units.length - 1];
+    return new Intl.NumberFormat(locale, { style: 'unit', unit: scale.unit, unitDisplay: 'short', maximumFractionDigits: scale.digits }).format(bytes / scale.divisor);
+}
+/**
+ * The address of a file's bytes as it will be written, or the empty string when this surface will
+ * not follow it: a path, the web, a `blob:` the host made, or the bytes themselves as `data:` —
+ * never a scheme that runs something, nor `data:` of a type a browser runs as a page or a script.
+ */
+export function fileAddress(url) {
+    const trimmed = url.trim();
+    if (!/^[a-z][a-z0-9+.-]*:/i.test(trimmed))
+        return url;
+    if (/^(https?|blob):/i.test(trimmed))
+        return url;
+    if (/^data:/i.test(trimmed) && !/^data:\s*(text\/html|application\/xhtml\+xml|text\/xml|application\/xml|text\/javascript|application\/javascript)/i.test(trimmed))
+        return url;
+    return '';
+}

package/dist/highlight.d.ts

@@ -33,15 +33,29 @@
  * input. `refractor` produces a hast tree, which is converted to React
  * elements, so nothing is ever parsed as markup.
  *
- * **The languages are enumerated rather than bundled.** Prism carries close to
- * three hundred grammars and a knowledge notebook writes in a handful. The list
- * is what a notebook of MemorySmith plausibly holds — the languages of its own
- * repository, the two query languages, the three configuration formats and the
- * two shells — and adding one is a line, which is the point: a bundle nobody
- * chose is a bundle nobody can defend. It is MemorySmith's list, unchanged, so
- * a fence is highlighted here exactly when it is highlighted there.
+ * **Fifteen languages are there at once, and every other one when it is used.**
+ * The fifteen are what a notebook of MemorySmith plausibly holds — the languages
+ * of its own repository, the two query languages, the three configuration
+ * formats and the two shells — MemorySmith's own list, drawn highlighted on the
+ * first paint, a server's included. Every other grammar Prism carries is listed
+ * in `prism-grammars.ts` behind a dynamic import (#84): a fence that names one
+ * is plain code until its grammar arrives, then highlighted, and a page never
+ * downloads a grammar no note of it uses.
  */
 import type { Root } from 'hast';
+import { type Grammar } from './prism-grammars.js';
+/** The grammar a fence's info string names, by identifier or alias, or `null`: never `mermaid`'s. */
+export declare function grammarOf(name: string | null | undefined): Grammar | null;
+/**
+ * Registers the grammar a name points at, fetching it the first time; answers whether it is
+ * registered. The fifteen above are already, and answer at once.
+ */
+export declare function loadGrammar(name: string): Promise<boolean>;
+/**
+ * The language of a fence that a grammar answers but that is not registered yet, which
+ * `loadGrammar` fetches; `null` when there is none to fetch.
+ */
+export declare function languageToLoad(className: string | undefined): string | null;
 /**
  * The language of a fenced block, from the class react-markdown puts on it.
  *

package/dist/highlight.js

@@ -33,13 +33,14 @@
  * input. `refractor` produces a hast tree, which is converted to React
  * elements, so nothing is ever parsed as markup.
  *
- * **The languages are enumerated rather than bundled.** Prism carries close to
- * three hundred grammars and a knowledge notebook writes in a handful. The list
- * is what a notebook of MemorySmith plausibly holds — the languages of its own
- * repository, the two query languages, the three configuration formats and the
- * two shells — and adding one is a line, which is the point: a bundle nobody
- * chose is a bundle nobody can defend. It is MemorySmith's list, unchanged, so
- * a fence is highlighted here exactly when it is highlighted there.
+ * **Fifteen languages are there at once, and every other one when it is used.**
+ * The fifteen are what a notebook of MemorySmith plausibly holds — the languages
+ * of its own repository, the two query languages, the three configuration
+ * formats and the two shells — MemorySmith's own list, drawn highlighted on the
+ * first paint, a server's included. Every other grammar Prism carries is listed
+ * in `prism-grammars.ts` behind a dynamic import (#84): a fence that names one
+ * is plain code until its grammar arrives, then highlighted, and a page never
+ * downloads a grammar no note of it uses.
  */
 import { refractor } from 'refractor/core';
 import bash from 'refractor/bash';
@@ -57,6 +58,7 @@ import toml from 'refractor/toml';
 import tsx from 'refractor/tsx';
 import typescript from 'refractor/typescript';
 import yaml from 'refractor/yaml';
+import { GRAMMARS } from './prism-grammars.js';
 for (const language of [
     bash,
     css,
@@ -76,6 +78,53 @@ for (const language of [
 ]) {
     refractor.register(language);
 }
+// ── Every other grammar, loaded when a note names it (#84) ─────────────────────
+/** Each grammar by its identifier and by each alias, lower case. */
+const BY_NAME = new Map();
+for (const grammar of GRAMMARS) {
+    for (const name of [grammar.id, ...grammar.aliases])
+        BY_NAME.set(name.toLowerCase(), grammar);
+}
+/** The grammar a fence's info string names, by identifier or alias, or `null`: never `mermaid`'s. */
+export function grammarOf(name) {
+    const named = name?.trim().toLowerCase();
+    if (!named || named === 'mermaid')
+        return null;
+    return BY_NAME.get(named) ?? null;
+}
+const loading = new Map();
+/**
+ * Registers the grammar a name points at, fetching it the first time; answers whether it is
+ * registered. The fifteen above are already, and answer at once.
+ */
+export function loadGrammar(name) {
+    const grammar = grammarOf(name);
+    if (!grammar)
+        return Promise.resolve(false);
+    if (refractor.registered(grammar.id))
+        return Promise.resolve(true);
+    let pending = loading.get(grammar.id);
+    if (!pending) {
+        pending = grammar.load().then((module) => {
+            refractor.register(module.default);
+            return true;
+        }, () => {
+            loading.delete(grammar.id);
+            return false;
+        });
+        loading.set(grammar.id, pending);
+    }
+    return pending;
+}
+/**
+ * The language of a fence that a grammar answers but that is not registered yet, which
+ * `loadGrammar` fetches; `null` when there is none to fetch.
+ */
+export function languageToLoad(className) {
+    const match = /(?:^|\s)language-([A-Za-z0-9#+._-]+)/.exec(className ?? '');
+    const grammar = grammarOf(match?.[1]);
+    return grammar && !refractor.registered(grammar.id) ? grammar.id : null;
+}
 /**
  * The language of a fenced block, from the class react-markdown puts on it.
  *