@memorysmithapp/markdown-renderer 0.0.0-stage → 0.1.0

package/dist/markdown.js

@@ -0,0 +1,395 @@
+// The text helpers of the reading surface: what a note becomes before the parser reads it.
+// Nothing here rewrites the note a host keeps; each function returns a new string for display.
+import { readDimensions } from './image-dimensions.js';
+/**
+ * A note is bytes the notebook wrote, and a notebook written on Windows, or in a
+ * desktop editor, or pasted from anywhere, carries CRLF. Every reader in this
+ * module starts here, because a carriage return left at the end of a line is
+ * invisible in the source and fatal to a regex: `.` does not match one, so
+ * `(.*)$` fails on exactly the lines that have a value.
+ */
+export function toUnixNewlines(raw) {
+    return raw.replace(/\r\n?/g, '\n');
+}
+/**
+ * Where the body of a note starts: after its frontmatter, which a host shows as properties and
+ * not as prose. The cut is the one MemorySmith's reading page makes, so the ordinals of the task
+ * boxes below it are counted over the whole note, as the host stores it.
+ */
+export function bodyStart(text) {
+    return text.startsWith('---') ? text.indexOf('\n---', 3) + 4 : 0;
+}
+/**
+ * Strips one layer of matching quotes, as the facet projector does. The trim
+ * comes first: an item of an inline list arrives with the space that followed
+ * the comma, and a quote that is not at position zero is not stripped.
+ */
+function unquote(value) {
+    return value
+        .trim()
+        .replace(/^["']|["']$/g, '')
+        .trim();
+}
+/**
+ * The frontmatter block, read the way MemorySmith's reading page reads it to show a note's
+ * properties. The package does not draw it — `NoteBody` starts after it — and exports this so a
+ * host that draws the properties reads the same values MemorySmith does.
+ */
+export function splitFrontmatter(input) {
+    const raw = toUnixNewlines(input);
+    const bare = { frontmatter: {}, lists: new Set(), body: raw };
+    if (!raw.startsWith('---'))
+        return bare;
+    const end = raw.indexOf('\n---', 3);
+    if (end === -1)
+        return bare;
+    const head = raw.slice(raw.indexOf('\n') + 1, end);
+    const body = raw.slice(raw.indexOf('\n', end + 1) + 1);
+    const frontmatter = {};
+    const lists = new Set();
+    let lastKey = null;
+    for (const line of head.split('\n')) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line);
+        if (kv && kv[1]) {
+            lastKey = kv[1];
+            const value = (kv[2] ?? '').trim();
+            // An inline list becomes the same comma-separated string a dash list
+            // produces, so `tags: [a, b]` and a `tags:` block read alike from here.
+            const inlineList = value.startsWith('[') && value.endsWith(']');
+            if (inlineList)
+                lists.add(lastKey);
+            frontmatter[lastKey] = inlineList
+                ? value
+                    .slice(1, -1)
+                    .split(',')
+                    .map(unquote)
+                    .filter((item) => item.length > 0)
+                    .join(', ')
+                : unquote(value);
+        }
+        else if (lastKey && /^\s+-\s+/.test(line)) {
+            const item = unquote(line.replace(/^\s+-\s+/, ''));
+            lists.add(lastKey);
+            frontmatter[lastKey] = frontmatter[lastKey] ? `${frontmatter[lastKey]}, ${item}` : item;
+        }
+    }
+    return { frontmatter, lists, body };
+}
+/**
+ * A wikilink, with the `!` in front of it when it is an embed.
+ *
+ * The bang is captured and not assumed away, because it is what tells a
+ * **link** from an **embed**, and the two reach different things: a link
+ * addresses a note and nothing else (§5.2), while an embed may also name a
+ * file the notebook keeps (§5.8). By the time this pass runs, the bang of a
+ * note embed has been taken off by `demoteEmbeds` — an embed that could not be
+ * expanded is a reference — so what still carries one is an embed of a file.
+ */
+const WIKILINK = /(!)?\[\[([^\]|]+?)(?:\|([^\]]+?))?\]\]/g;
+/**
+ * Code, where notation is characters and nothing else.
+ *
+ * A fenced block parses nothing inside it and a code span is where an author
+ * writes notation without invoking it — both stated by the specification, in the
+ * `code-fenced` and `code-span` entries of `spec.json`. The rewrites below
+ * run over the raw text BEFORE the parser sees it, so they are the one place
+ * in the renderer that has to know that on its own: every other reading of
+ * the notation is a remark plugin, working on a tree where a code node is
+ * already a code node.
+ *
+ * Code is found by the rules the specification states and never by a pattern of
+ * backticks: a fence opens on a line whose first thing is a run of
+ * three or more backticks or tildes, closes on a line holding a run of the
+ * same character, at least as long, and nothing else, and otherwise runs to
+ * the end of the note; a code span closes on a run of exactly its own length.
+ * A pattern pairing any two runs of three backticks read a span SHOWING three
+ * backticks as an opening fence, and every block after it out of phase. The
+ * link extractor of MemorySmith reads code by the same rules, and both are held
+ * to the `link-in-code` cases of the conformance suite.
+ *
+ * The indented form is deliberately NOT here, and the reason is the cost of
+ * being wrong. Telling four spaces of code from four spaces of a nested list
+ * item needs the block context only a parser has; guessing it wrong turns a
+ * real link into text, and the same guess in the link extractor would drop a
+ * real edge. A wikilink written inside an indented code block is therefore
+ * still read, in both readers, and that is declared rather than discovered
+ * in MemorySmith's architecture. For the same reason a fence is accepted
+ * after whatever its list item or block quote puts in front of it, and a code
+ * span is not followed across a line break.
+ */
+const CONTAINER = String.raw `(?:[ \t]*(?:>[ \t]?|(?:[-*+]|\d{1,9}[.)])[ \t]+))*[ \t]*`;
+const OPENING_FENCE = new RegExp(`^(${CONTAINER})(\`{3,}|~{3,})(.*?)\r?$`);
+const CLOSING_FENCE = new RegExp(`^${CONTAINER}(\`{3,}|~{3,})[ \t]*\r?$`);
+/**
+ * The fenced blocks of `body`, as half-open ranges from the opening run to the
+ * end of the closing line, and the lines no fence holds, which are where code
+ * spans may be.
+ */
+function scanFences(body) {
+    const fences = [];
+    const prose = [];
+    let open = null;
+    let at = 0;
+    for (const line of body.split('\n')) {
+        const end = at + line.length;
+        if (open) {
+            const run = CLOSING_FENCE.exec(line)?.[1];
+            if (run && run[0] === open.char && run.length >= open.length) {
+                fences.push([open.start, end]);
+                open = null;
+            }
+        }
+        else {
+            const fence = OPENING_FENCE.exec(line);
+            const run = fence?.[2] ?? '';
+            // A backtick fence may not carry a backtick in its info string: such a
+            // line is a paragraph, and what looks like a fence in it is a span.
+            if (fence && !(run[0] === '`' && (fence[3] ?? '').includes('`'))) {
+                open = { char: run[0] ?? '`', length: run.length, start: at + (fence[1] ?? '').length };
+            }
+            else {
+                prose.push({ line, at });
+            }
+        }
+        at = end + 1;
+    }
+    if (open)
+        fences.push([open.start, body.length]);
+    return { fences, prose };
+}
+/**
+ * The code spans of one line: a run of backticks closes on the next run of
+ * exactly its length, a run with no partner is text, and a backtick escaped by
+ * a backslash opens nothing.
+ */
+function codeSpans(line, offset) {
+    const runs = [...line.matchAll(/`+/g)].map((match) => ({
+        index: match.index ?? 0,
+        length: match[0].length,
+    }));
+    const spans = [];
+    for (let i = 0; i < runs.length; i++) {
+        const run = runs[i];
+        if (!run)
+            continue;
+        const escaped = /(^|[^\\])(\\\\)*\\$/.test(line.slice(0, run.index));
+        const start = escaped ? run.index + 1 : run.index;
+        const length = escaped ? run.length - 1 : run.length;
+        if (length === 0)
+            continue;
+        const close = runs.findIndex((other, j) => j > i && other.length === length);
+        const closing = runs[close];
+        if (close === -1 || !closing)
+            continue;
+        spans.push([offset + start, offset + closing.index + closing.length]);
+        i = close;
+    }
+    return spans;
+}
+/** The half-open ranges of `body` that are fenced blocks. */
+export function fenceRegions(body) {
+    return scanFences(body).fences;
+}
+/** The half-open ranges of `body` that are code, fenced or inline, in order. */
+export function codeRegions(body) {
+    const { fences, prose } = scanFences(body);
+    const spans = prose.flatMap(({ line, at }) => codeSpans(line, at));
+    return [...fences, ...spans].sort((a, b) => a[0] - b[0]);
+}
+/** Whether an offset falls inside one of them. */
+export function insideCode(regions, at) {
+    return regions.some(([start, end]) => at >= start && at < end);
+}
+/**
+ * A GFM table, which is the third place an embed cannot expand (§7.3).
+ *
+ * A cell holds inlines and never blocks (§4.1), so an embed of a note in a
+ * cell is drawn as a link, the same answer the one-level rule and the embed
+ * ceiling already give. What made this its own case is that the expansion is
+ * decided on the raw string, by cutting the body into runs around each
+ * `![[…]]`, and a cut inside a table row does not merely fail to expand: it
+ * ends the run mid-row, so the parser that reads it has an unterminated table
+ * and the closing pipe becomes a paragraph of its own.
+ *
+ * Detected here rather than in a plugin for the reason the code regions
+ * already are: the split happens before anything is parsed, so this is the one
+ * place in the renderer that has to recognise the block on its own.
+ *
+ * A table is a line containing a pipe, followed by a delimiter row of dashes,
+ * and it runs to the first blank line. The outer pipes are optional, which is
+ * why the delimiter row is what identifies the block. A shape this misses
+ * costs nothing new — it is the behaviour of before — so the pattern is
+ * deliberately the conservative one.
+ */
+const DELIMITER_ROW = /^ {0,3}\|?[ \t]*:?-{1,}:?[ \t]*(\|[ \t]*:?-{1,}:?[ \t]*)*\|?[ \t]*$/;
+export function tableRegions(body) {
+    const regions = [];
+    const code = codeRegions(body);
+    const lines = body.split('\n');
+    const offsets = [];
+    let at = 0;
+    for (const line of lines) {
+        offsets.push(at);
+        at += line.length + 1;
+    }
+    for (let index = 0; index + 1 < lines.length; index++) {
+        const header = lines[index] ?? '';
+        const delimiter = lines[index + 1] ?? '';
+        if (!header.includes('|') || !delimiter.includes('|'))
+            continue;
+        if (!DELIMITER_ROW.test(delimiter))
+            continue;
+        if (insideCode(code, offsets[index] ?? 0))
+            continue;
+        let last = index + 1;
+        while (last + 1 < lines.length && (lines[last + 1] ?? '').trim().length > 0)
+            last++;
+        regions.push([offsets[index] ?? 0, (offsets[last] ?? 0) + (lines[last] ?? '').length]);
+        index = last;
+    }
+    return regions;
+}
+/** Whether an offset falls inside one of them. */
+export function insideTable(regions, at) {
+    return regions.some(([start, end]) => at >= start && at < end);
+}
+/** Runs a rewrite over everything except code, which is copied through. */
+export function outsideCode(body, rewrite) {
+    let out = '';
+    let cursor = 0;
+    for (const [start, end] of codeRegions(body)) {
+        out += rewrite(body.slice(cursor, start)) + body.slice(start, end);
+        cursor = end;
+    }
+    return out + rewrite(body.slice(cursor));
+}
+// Replaces [[wikilinks]] with markdown links. Resolved targets point at the
+// note route; unresolved ones become pending: links styled by the renderer.
+export function resolveWikilinks(body, resolve, 
+/**
+ * Whether the notebook keeps a FILE under that name. The extension of a
+ * name decides nothing, so what a target is cannot be read off it: it is
+ * read off what the notebook holds, which is the host's to answer.
+ */
+keeps = () => false) {
+    return outsideCode(body, (text) => resolveWikilinksIn(text, resolve, keeps));
+}
+/**
+ * The target of a wikilink is a NAME, and it is literal: nothing in it is
+ * decoded, no extension is removed and no path segment is discarded
+ * (§5.2). It used to be slugified here, which is what made a link differ
+ * from its note over an accent or a capital.
+ */
+function resolveWikilinksIn(body, resolve, keeps) {
+    return body.replace(WIKILINK, (_all, bang, target, label) => {
+        const clean = target.split('#')[0]?.trim().replace(/\\$/, '').trim() ?? '';
+        const embed = bang !== undefined;
+        const text = displayText(clean, label, target, (name) => embed && keeps(name));
+        if (!clean)
+            return `[${text}](pending:)`;
+        // The pipe is read by WHAT THE TARGET IS: a note takes the alias, an
+        // attachment takes the dimensions, and a target that resolves to neither
+        // takes the alias — because reading it as a dimension would discard text
+        // an author wrote.
+        //
+        // **Only an embed reaches a file**. A `[[name]]` is resolved against
+        // the notes of the notebook and their aliases, and against nothing else:
+        // §5.2 lists the whole of resolution and an attachment is in none of its
+        // steps, so a name only a file carries is a pending link like any other.
+        if (embed && keeps(clean)) {
+            // The dimension travels with the address, because the name is already
+            // percent-encoded and a bare `|` after it cannot be part of it.
+            // Dropping it here is what made `![[picture|120]]` render at full size:
+            // the notation was read and then thrown away one line before it was used.
+            const measured = label === undefined ? null : readDimensions(label);
+            const sized = measured
+                ? `|${measured.width}${measured.height === null ? '' : `x${measured.height}`}`
+                : '';
+            return `[${text}](attachment:${encodeURIComponent(clean)}${sized})`;
+        }
+        const url = resolve(clean.normalize('NFC'));
+        return url ? `[${text}](${url})` : `[${text}](pending:${encodeURIComponent(clean)})`;
+    });
+}
+/**
+ * What the link shows. The pipe of an attachment carries dimensions and is
+ * never rendered as text, so what is left to show is the name of the file.
+ */
+function displayText(clean, label, target, keeps) {
+    if (clean && keeps(clean))
+        return clean;
+    return (label ?? target).trim();
+}
+/** The longest a heading key may be, which is what an anchor is matched on. */
+const MAX_KEY_LENGTH = 80;
+/**
+ * The key a **heading** is matched by, which is how an anchor finds the
+ * section it names inside a note.
+ *
+ * **It is not the key of a note, and there is no longer one of those.** A link
+ * resolves against the name, literally and case-exact (§5.2), so the
+ * slug this file used to compute — the second implementation of a rule the
+ * kernel also implemented, and the one that drifted — is gone. What is
+ * left is this: an anchor and a heading are two spellings of the same phrase,
+ * written by the same person minutes apart, and folding case and punctuation
+ * between them is what makes `#Artigo 75` find `## Artigo 75`.
+ *
+ * Nothing outside this comparison reads it, and nothing else in the renderer
+ * computes a key from a name: the address of a note is the host's to give.
+ */
+export function headingKey(name) {
+    return name
+        .normalize('NFD')
+        .replace(/(\d)[.,](\d)/g, '$1$2')
+        .replace(/[̀-ͯ]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, MAX_KEY_LENGTH)
+        .replace(/-+$/g, '');
+}
+/**
+ * The hosts a note asks the reader's browser to talk to (§7.10).
+ *
+ * An image whose destination names a host is a **request to that host**, made
+ * when the note is opened, by whoever opens it — and the trigger was written
+ * by whoever wrote the note, which is the same sentence §7.9 uses about raw
+ * HTML. What travels with it is the reader's address, their user-agent and the
+ * moment they read it.
+ *
+ * The specification admits three answers and forbids only silence: never fetching,
+ * fetching on the reader's action, or fetching and saying so. MemorySmith,
+ * and this renderer with it, gives the third, so this is the half that says so. It is the image of §3.14
+ * and nothing else: a diagram and a formula render locally, and a link —
+ * bracketed, bare or autolinked — is a navigation the person initiates rather
+ * than a request the page makes.
+ *
+ * Code is excluded, because an image written inside a fence is an example of
+ * the notation and fetches nothing.
+ */
+const IMAGE_DESTINATION = /!\[[^\]]*\]\(\s*<?([^)\s>]+)>?(?:\s+"[^"]*")?\s*\)/g;
+export function remoteImageHosts(body) {
+    const regions = codeRegions(body);
+    const hosts = new Set();
+    for (const match of body.matchAll(IMAGE_DESTINATION)) {
+        if (insideCode(regions, match.index ?? 0))
+            continue;
+        const destination = (match[1] ?? '').trim();
+        // A path, a relative target or an anchor names no host and asks nobody
+        // for anything. Only a scheme or a leading `//` reaches outside.
+        const authority = /^[a-z][a-z0-9+.-]*:\/\//i.test(destination)
+            ? destination.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '')
+            : destination.startsWith('//')
+                ? destination.slice(2)
+                : '';
+        if (authority === '')
+            continue;
+        // The authority, minus any credentials, port and path: what a person needs
+        // in order to recognise who they just talked to.
+        const host = (authority.split('/')[0] ?? '').split('@').pop() ?? '';
+        const named = host.split(':')[0] ?? '';
+        if (named !== '')
+            hosts.add(named.toLowerCase());
+    }
+    return [...hosts];
+}

package/dist/remark-callouts.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Notebook callouts, rendered as callouts.
+ *
+ * A callout is a blockquote whose first line is a type marker:
+ *
+ *     > [!warning] O que pode dar errado
+ *     > O corpo do aviso.
+ *
+ * It is a notebook convention and not universal Markdown (§7.1). What
+ * MemorySmith's reading page once did was a pass over the
+ * string that swapped the marker for an emoji and left the blockquote behind,
+ * which reads as a quotation with a picture in front of it. This turns it into
+ * the element the vault editors draw, and the type travels to the DOM as an
+ * attribute so the stylesheet can colour and ice it without a class per type.
+ *
+ * It is a remark plugin rather than another pass over the string because the
+ * marker has to leave the tree the renderer walks, not the text the parser
+ * reads: a `[!note]` inside a code fence is not a callout, and only the parser
+ * can tell the difference.
+ */
+interface MdastNode {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: {
+        hName?: string;
+        hProperties?: Record<string, unknown>;
+    };
+}
+export interface CalloutOptions {
+    /**
+     * The title of a callout written without one, in the language of whoever
+     * reads it. It answers `undefined` for a type it has no word for,
+     * and that type titles itself, capitalised, as the editors do: the
+     * vocabulary is open (§7.1) and a word nobody translated is still a word.
+     */
+    readonly titleOf?: (kind: string) => string | undefined;
+}
+export declare function remarkCallouts(options?: CalloutOptions): (tree: MdastNode) => void;
+export {};

package/dist/remark-callouts.js

@@ -0,0 +1,108 @@
+/**
+ * Notebook callouts, rendered as callouts.
+ *
+ * A callout is a blockquote whose first line is a type marker:
+ *
+ *     > [!warning] O que pode dar errado
+ *     > O corpo do aviso.
+ *
+ * It is a notebook convention and not universal Markdown (§7.1). What
+ * MemorySmith's reading page once did was a pass over the
+ * string that swapped the marker for an emoji and left the blockquote behind,
+ * which reads as a quotation with a picture in front of it. This turns it into
+ * the element the vault editors draw, and the type travels to the DOM as an
+ * attribute so the stylesheet can colour and ice it without a class per type.
+ *
+ * It is a remark plugin rather than another pass over the string because the
+ * marker has to leave the tree the renderer walks, not the text the parser
+ * reads: a `[!note]` inside a code fence is not a callout, and only the parser
+ * can tell the difference.
+ */
+/** `[!type]`, an optional fold marker, and whatever titles it. */
+const MARKER = /^\[!([A-Za-z][\w-]*)\][+-]?[ \t]*(.*)$/;
+export function remarkCallouts(options = {}) {
+    return (tree) => descend(tree, options);
+}
+function descend(node, options) {
+    for (const child of node.children ?? []) {
+        if (child.type === 'blockquote')
+            rewrite(child, options);
+        descend(child, options);
+    }
+}
+function rewrite(quote, options) {
+    const [head, ...blocks] = quote.children ?? [];
+    if (head?.type !== 'paragraph')
+        return;
+    const [lead, ...inline] = head.children ?? [];
+    if (lead?.type !== 'text' || typeof lead.value !== 'string')
+        return;
+    const broke = lead.value.indexOf('\n');
+    const marker = MARKER.exec(broke === -1 ? lead.value : lead.value.slice(0, broke));
+    if (!marker)
+        return;
+    const kind = (marker[1] ?? '').toLowerCase();
+    const { title, body } = split(marker[2] ?? '', broke === -1 ? null : lead.value.slice(broke + 1), inline);
+    quote.data = {
+        hName: 'div',
+        hProperties: { className: ['callout'], 'data-callout': kind },
+    };
+    quote.children = [
+        {
+            type: 'paragraph',
+            data: { hName: 'div', hProperties: { className: ['callout-title'] } },
+            // An untitled callout is titled by its own type, as the editors do, and
+            // in the locale of the reader rather than always in English.
+            children: title.length > 0
+                ? title
+                : [{ type: 'text', value: options.titleOf?.(kind) ?? capitalize(kind) }],
+        },
+        ...(body.length > 0 ? [{ type: 'paragraph', children: body }] : []),
+        ...blocks,
+    ];
+}
+/**
+ * Cuts the first paragraph at its first line break: what comes before titles
+ * the callout, what comes after opens its body. The break can fall inside any
+ * of the inline nodes, because a title that carries emphasis makes the
+ * paragraph three children and not one, so the split walks them instead of
+ * assuming the title ends where the first text node does.
+ */
+function split(titled, after, inline) {
+    const title = [{ type: 'text', value: titled }];
+    const body = [];
+    // The lead text already broke, so everything after it belongs to the body.
+    let titling = after === null;
+    if (after !== null)
+        body.push({ type: 'text', value: after });
+    for (const node of inline) {
+        if (!titling) {
+            body.push(node);
+            continue;
+        }
+        const breakAt = node.type === 'text' ? (node.value ?? '').indexOf('\n') : -1;
+        if (breakAt === -1) {
+            title.push(node);
+            continue;
+        }
+        title.push({ type: 'text', value: (node.value ?? '').slice(0, breakAt) });
+        body.push({ type: 'text', value: (node.value ?? '').slice(breakAt + 1) });
+        titling = false;
+    }
+    return { title: trimEdges(title), body: trimEdges(body) };
+}
+/** Drops the empty text nodes the cut leaves at either end. */
+function trimEdges(nodes) {
+    const kept = [...nodes];
+    while (kept.length > 0 && isBlank(kept[0]))
+        kept.shift();
+    while (kept.length > 0 && isBlank(kept[kept.length - 1]))
+        kept.pop();
+    return kept;
+}
+function isBlank(node) {
+    return node?.type === 'text' && (node.value ?? '').trim().length === 0;
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}

package/dist/remark-ring.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The rest of the MemorySmith notation, on the reading surface: marked text,
+ * comments, block identifiers (§7.5, §7.6, §7.7) and the dollar rule of
+ * mathematics (§7.8).
+ *
+ * All three are remark plugins rather than passes over the string, for the
+ * reason `remark-callouts.ts` already gives: a `==` inside a code fence is not
+ * a highlight, and only the parser can tell the difference. Rewriting the text
+ * before it is parsed is how a notation starts firing inside examples.
+ *
+ * None of them touches the bytes. The reading surface is a rendering of the
+ * note and never a rewriting of it, so what a host stores and returns is
+ * unaffected by everything here — which is the whole of what makes
+ * `%%comment%%` an asymmetry that has to be declared rather than a deletion.
+ */
+interface MdastNode {
+    type: string;
+    value?: string;
+    children?: MdastNode[];
+    data?: {
+        hName?: string;
+        hProperties?: Record<string, unknown>;
+    };
+}
+export declare function remarkHighlight(): (tree: MdastNode) => void;
+export declare function remarkComments(): (tree: MdastNode) => void;
+export declare function remarkBlockIds(): (tree: MdastNode) => void;
+/**
+ * The `$` that is not math (§7.8).
+ *
+ * `remark-math` opens a formula at any `$` and closes it at the next one, so
+ * **two prices in one paragraph become a formula**: `costs $30 a month, and
+ * the plan $60` renders `30 a month, and the plan` as mathematics. That is not
+ * an exotic case, it is a sentence somebody writes on an ordinary day.
+ *
+ * The specification states four prohibitions, and **each one has an outside edge and
+ * an inside edge**. A `$` does not OPEN a formula when it is followed by
+ * whitespace, nor when it is immediately preceded by an alphanumeric; it does
+ * not CLOSE one when it is preceded by whitespace, nor when it is immediately
+ * followed by a digit.
+ *
+ * The inside edges arrived with specification v0.4.0, and they are what keeps a
+ * price whole. `R$ 100` is safe on the outside edge alone, because of the
+ * space. `R$100 e o frete R$200` is not: neither `$` sits next to a space, so
+ * with only the outside edge the sentence loses its middle — `100 e o frete R`
+ * typeset as mathematics, in italic serif, with the `R` and the `200` stranded
+ * either side of it. It is an ordinary sentence in pt-BR, where a price is
+ * written `R$`.
+ *
+ * **The cost is deliberate and the specification names it.** An inline formula
+ * written immediately after a word character no longer opens, so `2$x$` is
+ * text and `2 $x$` is the form that works. A `$` written for any other purpose
+ * belongs in a code span, which is opaque to everything — and for `$HOME` and
+ * `$PATH` in one sentence that is the only thing that protects them, because
+ * both delimiters look legal by every local rule.
+ *
+ * This runs after `remark-math` and gives back to the text any inline formula
+ * that breaks the rule, reading the source the parser read: the delimiters are
+ * gone from the node, and the position is what still knows where they were.
+ * The characters ON either side of the range are what the inside edges need,
+ * which is why the slice reaches one character past each end.
+ *
+ * Block math (`$$…$$`) is untouched: its delimiters are unambiguous.
+ */
+export declare function remarkMathDollarRule(): (tree: MdastNode, file: {
+    value?: unknown;
+}) => void;
+export {};