@stenographers/markdown 0.0.0-stage → 0.4.0

package/src/write.js

@@ -0,0 +1,251 @@
+// The stenographers' write (the studio's notes/markdown-plan.md, "Stenographers" and "Escalation"): a node's new bytes, written over its old transcript in the author's style. A stenographer reads a node as the HTML it means (the schema's document serializer's element), never by a ProseMirror type name, and its old slice re-parsed alone, with the file's definitions after it so a reference resolves as it did in the file. Every node that still means what its old bytes meant keeps them; only typed text is escaped, and only for what it could be misread as. A stenographer that cannot write its node answers null, and its parent writes it: the list for an item, the flow for a list; the last step is the lane change, the node written as raw HTML.
+import { parseMarkdown } from './parse.js';
+import { domOf, means } from './html.js';
+import { list, item } from './list.js';
+import { figure } from './figure.js';
+import { table } from './table.js';
+import { quote } from './quote.js';
+import { directive } from './directive.js';
+import { pairDialect, freshDialect } from './dialect.js';
+
+const BLOCKS = new Set(['address', 'article', 'aside', 'blockquote', 'details', 'div', 'dl', 'fieldset', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'hr', 'main', 'menu', 'nav', 'ol', 'p', 'pre', 'section', 'table', 'ul']);
+export const isBlock = (n) => n.nodeType === 1 && BLOCKS.has(n.localName);
+export const span = (ctx, from, to) => ctx.src.slice(from, to);
+export const start = (n) => n.position.start.offset;
+export const end = (n) => n.position.end.offset;
+export const sliceOf = (ctx, n) => span(ctx, start(n), end(n));
+
+/**
+ * A node's new bytes, written over its old slice.
+ * @param {Element} el the node as the HTML it means
+ * @param {{ text: string, column: number, defs?: string, markdown?: import('./parse.js').Markdown }} old its old slice, the column the slice's first byte stands at in the file (the lines after the first carry the parent's prefix up to it), the file's definitions and footnote definitions as source, the venue's Markdown options
+ * @param {{ force?: boolean }} [opts] `force`: no node keeps its bytes for meaning what they meant, every one is written from its style (the identity check's mode)
+ * @returns {string | null} null when the node refuses, for its parent to write
+ */
+export function writeNode(el, old, { force = false } = {}) {
+  const { body, prefixes } = dedent(old.text, old.column);
+  const tree = parseMarkdown(old.defs ? `${body}\n\n${old.defs}` : body, old.markdown);
+  let md = tree.children[0];
+  if (el.localName === 'li') md = md?.type === 'list' ? md.children[0] : null;
+  if (!md || start(md) !== 0) return null;
+  el = el.cloneNode(true);
+  el.normalize();
+  const out = block(el, md, { src: body, force, defs: old.defs, markdown: old.markdown });
+  return out == null ? null : reindent(out, prefixes, old.column);
+}
+
+// The parent's prefix on each line after the first (the indent of a list item's content), taken off so the node is written at column 0 and put back after. ponytail: spaces only; a tab or a `> ` prefix waits for round 3 (blockquote).
+function dedent(text, column) {
+  const lines = text.split('\n');
+  const prefixes = [''];
+  for (let i = 1; i < lines.length; i++) {
+    const k = Math.min(column, /^ */.exec(lines[i])[0].length);
+    prefixes.push(lines[i].slice(0, k));
+    lines[i] = lines[i].slice(k);
+  }
+  return { body: lines.join('\n'), prefixes };
+}
+// Each line takes back its old prefix while the node has as many lines as it had (a lazy line keeps its shorter one); once the count changed, the old prefixes no longer belong to the lines at their index, and every line that is not blank takes the column.
+const reindent = (text, prefixes, column) => {
+  const lines = text.split('\n');
+  const same = lines.length === prefixes.length;
+  return lines.map((line, i) => (i === 0 ? line : (same ? prefixes[i] : line ? ' '.repeat(column) : '') + line)).join('\n');
+};
+
+function block(el, md, ctx) {
+  const tag = el.localName;
+  if (!ctx.force && means(el, md)) return sliceOf(ctx, md);
+  if (tag === 'p' && md.type === 'paragraph') return paragraph(el, md, ctx);
+  if (/^h[1-6]$/.test(tag) && md.type === 'heading') return heading(el, md, ctx);
+  if ((tag === 'ul' || tag === 'ol') && md.type === 'list') return list(el, md, ctx);
+  if (tag === 'li' && md.type === 'listItem') return item(el, md, ctx);
+  if (tag === 'pre' && md.type === 'code') return code(el, md, ctx);
+  if (tag === 'figure' && md.type === 'paragraph') return figure(el, md, ctx);
+  // A container's writer that refuses leaves it to the rule below: its bytes kept while they mean it.
+  const container = tag === 'table' && md.type === 'table' ? table : tag === 'blockquote' && md.type === 'blockquote' ? quote : md.type === 'containerDirective' ? directive : null;
+  const written = container?.(el, md, ctx);
+  if (written != null) return written;
+  // A node no stenographer of this lane writes keeps its bytes while it means them, and refuses once it does not.
+  return means(el, md) ? sliceOf(ctx, md) : null;
+}
+
+// A textblock's bytes are read back before they are given. Bytes that do not mean the node are written once more with every colon of the touched text escaped (the plain parse reads `:name` as a directive unless a colon follows it, so escaping one colon can make the name before it one), and refused after that.
+export function checked(el, ctx, write) {
+  for (const strict of [false, true]) {
+    const out = write({ ...ctx, strict });
+    const md = parseMarkdown(ctx.defs ? `${out}\n\n${ctx.defs}` : out, ctx.markdown).children[0];
+    if (md && means(el, md)) return out;
+  }
+  return null;
+}
+
+function paragraph(el, md, ctx) {
+  const kids = md.children;
+  if (!kids.length) return null;
+  return checked(el, ctx, (c) => span(c, start(md), start(kids[0])) + edges(inline([...el.childNodes], kids, c)) + span(c, end(kids.at(-1)), end(md)));
+}
+
+// A space at a textblock's edge, which Markdown strips, written as its character reference so it stays (Enter just before a space leaves one at the new paragraph's start).
+export const edges = (s) => s.replace(/^ /, '&#32;').replace(/ $/, '&#32;');
+
+function heading(el, md, ctx) {
+  const level = Number(el.localName[1]);
+  const kids = md.children;
+  const atx = /^ {0,3}#/.test(sliceOf(ctx, md));
+  if (!kids.length) return atx ? sliceOf(ctx, md).replace(/#+/, '#'.repeat(level)) : null;
+  const head = span(ctx, start(md), start(kids[0]));
+  const tail = span(ctx, end(kids.at(-1)), end(md));
+  return checked(el, ctx, (c) => {
+    const content = edges(inline([...el.childNodes], kids, c));
+    if (atx) return head.replace(/#+/, '#'.repeat(level)) + content + tail;
+    if (level === md.depth) return head + content + tail;
+    // A setext heading keeps its underline's length; past level 2 it becomes ATX.
+    if (level <= 2) return head + content + tail.replace(/[=-]+/, (u) => (level === 1 ? '=' : '-').repeat(u.length));
+    return `${'#'.repeat(level)} ${content.replace(/\n/g, ' ')}`;
+  });
+}
+
+// A fenced code block keeps its fence lines and writes its new body; its language, when it changed, is the opening fence's first word. An indented block, or a body with a line that would close the fence, refuses.
+function code(el, md, ctx) {
+  const lines = sliceOf(ctx, md).split('\n');
+  const fence = /^( {0,3})(`{3,}|~{3,})(.*)$/.exec(lines[0]);
+  if (!fence) return null;
+  // A fenced body ends with a line end, which the read gives the code; without it (its last line end deleted) the block cannot be fenced.
+  if (el.textContent && !el.textContent.endsWith('\n')) return null;
+  const body = el.textContent.replace(/\n$/, '');
+  const closes = new RegExp(`^ {0,3}${fence[2][0] === '`' ? '`' : '~'}{${fence[2].length},}\\s*$`);
+  if (body.split('\n').some((line) => closes.test(line))) return null;
+  const was = /\blanguage-(\S+)/.exec(el.querySelector('code')?.className ?? '')?.[1] ?? '';
+  let open = lines[0];
+  if (was !== (md.lang ?? '')) open = `${fence[1]}${fence[2]}${was}${md.meta ? ` ${md.meta}` : ''}`;
+  const close = lines.length > 1 && closes.test(lines.at(-1)) ? `\n${lines.at(-1)}` : '';
+  return `${open}\n${body}${close}`;
+}
+
+// ---- inline content ----
+
+const same = (n, o, ctx) => !ctx.force && means(n, o);
+
+/** The bytes of new inline content over the old: the nodes that still mean what they meant keep their bytes, the rest are paired with the old in order and written in their style, or written fresh. */
+export function inline(nodes, kids, ctx) {
+  const n = nodes.length, m = kids.length;
+  let i = 0;
+  while (i < n && i < m && same(nodes[i], kids[i], ctx)) i++;
+  let j = 0;
+  while (j < n - i && j < m - i && same(nodes[n - 1 - j], kids[m - 1 - j], ctx)) j++;
+  const from = start(kids[0]), to = end(kids[m - 1]);
+  const midFrom = i < m ? start(kids[i]) : to;
+  const midTo = j ? start(kids[m - j]) : to;
+  const nMid = nodes.slice(i, n - j), oMid = kids.slice(i, m - j);
+  const mid = nMid.length === oMid.length ? nMid.map((x, k) => pair(x, oMid[k], ctx)).join('') : nMid.map((x) => fresh(x)).join('');
+  return span(ctx, from, midFrom) + mid + span(ctx, midTo, to);
+}
+
+const WRAPS = { em: 'emphasis', strong: 'strong', del: 'delete' };
+
+function pair(n, o, ctx) {
+  const notation = pairDialect(n, o, ctx);
+  if (notation !== undefined) return notation;
+  if (n.nodeType === 3) return o.type === 'text' ? text(n.data, o, ctx) : fresh(n);
+  if (n.nodeType !== 1) return fresh(n);
+  const tag = n.localName;
+  // A text directive keeps its name, label brackets and attributes; its label is inline content like any other.
+  if (tag === 'span' && o.type === 'textDirective') {
+    if (!o.children.length) return n.childNodes.length ? fresh(n) : sliceOf(ctx, o);
+    return span(ctx, start(o), start(o.children[0])) + inline([...n.childNodes], o.children, ctx) + span(ctx, end(o.children.at(-1)), end(o));
+  }
+  const wraps = (WRAPS[tag] === o.type || (tag === 'a' && (o.type === 'link' || o.type === 'linkReference'))) && o.children?.length;
+  if (wraps) {
+    const close = span(ctx, end(o.children.at(-1)), end(o));
+    if (tag === 'a' && !sameTarget(n, o)) {
+      if (o.type !== 'link' || sliceOf(ctx, o)[0] !== '[') return fresh(n);
+      return `${span(ctx, start(o), start(o.children[0]))}${inline([...n.childNodes], o.children, ctx)}](${target(n)})`;
+    }
+    return span(ctx, start(o), start(o.children[0])) + inline([...n.childNodes], o.children, ctx) + close;
+  }
+  if (tag === 'code' && o.type === 'inlineCode') return n.textContent === o.value ? sliceOf(ctx, o) : fresh(n);
+  if (tag === 'br' && o.type === 'break') return sliceOf(ctx, o);
+  // A footnote reference's text is its number, which the document counts: anything else typed into it is not Markdown's to say.
+  if (tag === 'sup' && o.type === 'footnoteReference') return sameTarget(n.querySelector('a') ?? n, o) && /^\d+$/.test(n.textContent) ? sliceOf(ctx, o) : fresh(n);
+  return means(n, o) ? sliceOf(ctx, o) : fresh(n);
+}
+
+// A link's (or a footnote reference's) target as the HTML says it, against what the old node meant: the reference resolved through the definitions.
+function sameTarget(a, o) {
+  const dom = domOf(o.children ? { ...o, children: [] } : o)[0];
+  const was = dom?.localName === 'a' ? dom : dom?.querySelector?.('a');
+  return !!was && a.getAttribute('href') === was.getAttribute('href') && a.getAttribute('title') === was.getAttribute('title');
+}
+const target = (a) => `${a.getAttribute('href') ?? ''}${a.hasAttribute('title') ? ` "${a.getAttribute('title').replace(/"/g, '\\"')}"` : ''}`;
+
+/** Typed text over an old text node: the common head and tail keep their bytes, the middle is escaped. */
+function text(now, o, ctx) {
+  const raw = sliceOf(ctx, o);
+  if (now === o.value) return raw;
+  if (ctx.strict) return escape(now, o.position.start.column === 1).replace(/(?<!\\):/g, '\\:');
+  // ponytail: a text run whose bytes are not its value (an escape, an entity, an indented continuation line) is written fresh once touched; mapping value to bytes would keep the author's escapes.
+  if (raw !== o.value) return escape(now, o.position.start.column === 1);
+  let p = 0;
+  while (p < now.length && p < raw.length && now[p] === raw[p]) p++;
+  let s = 0;
+  while (s < now.length - p && s < raw.length - p && now[now.length - 1 - s] === raw[raw.length - 1 - s]) s++;
+  const lineStart = p === 0 ? o.position.start.column === 1 : raw[p - 1] === '\n';
+  let head = raw.slice(0, p), mid = escape(now.slice(p, now.length - s), lineStart);
+  const tail = raw.slice(raw.length - s);
+  // A word typed against a colon would make the two a text directive (`:name`), so the colon is escaped, the old one included.
+  if (/^\w/.test(mid) && /(^|[^\\]):$/.test(head)) head = `${head.slice(0, -1)}\\:`;
+  if (/:$/.test(mid) && /^\w/.test(tail)) mid = `${mid.slice(0, -1)}\\:`;
+  return head + mid + tail;
+}
+
+/** Text as Markdown that reads back as the same text: CommonMark's inline punctuation, BelType's notations (`:name` directives, `==` marks, `^` and `~` super- and subscript, `{…}` attributes, `$` math), and at a line's start what would open a block. */
+export function escape(s, lineStart) {
+  let out = s.replace(/[\\`*_[\]<>{}$^~]/g, '\\$&').replace(/&(?=#?\w+;)/g, '\\&').replace(/:(?=\w)/g, '\\:').replace(/==/g, '\\=\\=');
+  out = out.replace(/\n(.*)/g, (_, line) => `\n${opener(line)}`);
+  return lineStart ? opener(out) : out;
+}
+// What would open a block at a line's start (a heading, a quote, a list item), escaped.
+const opener = (t) => t.replace(/^( {0,3})([#>+-])/, '$1\\$2').replace(/^( {0,3}\d+)([.)])/, '$1\\$2');
+
+/**
+ * A block written with no old bytes (a paragraph Enter made, a block inserted): a paragraph or a heading in Markdown's own syntax, read back before it is given; anything else, or what does not read back, as raw HTML (the lane change).
+ * @param {Element} el the block as the HTML it means
+ * @param {{ defs?: string, markdown?: import('./parse.js').Markdown }} [file] the file's definitions and Markdown options, for the read-back
+ */
+export function writeFresh(el, { defs, markdown } = {}) {
+  if (el.nodeType === 8) return `<!--${el.data}-->`;
+  const tag = el.localName;
+  const inner = () => edges(opener([...el.childNodes].map(fresh).join('')));
+  const out = tag === 'p' ? inner() : /^h[1-6]$/.test(tag) ? `${'#'.repeat(Number(tag[1]))} ${inner()}` : null;
+  if (out) {
+    const md = parseMarkdown(defs ? `${out}\n\n${defs}` : out, markdown).children[0];
+    if (md && means(el, md)) return out;
+  }
+  return el.outerHTML;
+}
+
+/** An inline node written with no old bytes to keep: Markdown's own syntax where it has one, raw HTML where it has none (the lane change). */
+export function fresh(n) {
+  // The line end mdast-util-to-hast puts after a `br` is the break's own, which `\` and a line end already write.
+  if (n.nodeType === 3) return escape(n.previousSibling?.localName === 'br' ? n.data.replace(/^\n/, '') : n.data, false);
+  if (n.nodeType !== 1) return '';
+  const notation = freshDialect(n);
+  if (notation !== undefined) return notation;
+  const inner = () => [...n.childNodes].map(fresh).join('');
+  switch (n.localName) {
+    case 'em': return `*${inner()}*`;
+    case 'strong': return `**${inner()}**`;
+    case 'del': return `~~${inner()}~~`;
+    case 'a': return n.hasAttribute('href') && n.attributes.length <= 2 ? `[${inner()}](${target(n)})` : n.outerHTML;
+    case 'br': return '\\\n';
+    case 'img': return n.attributes.length <= 3 ? `![${n.getAttribute('alt') ?? ''}](${target({ getAttribute: (k) => n.getAttribute(k === 'href' ? 'src' : k), hasAttribute: (k) => n.hasAttribute(k) })})` : n.outerHTML;
+    case 'code': {
+      const t = n.textContent;
+      const longest = Math.max(0, ...(t.match(/`+/g) ?? []).map((r) => r.length));
+      const fence = '`'.repeat(longest + 1);
+      const pad = /^`|`$/.test(t) ? ' ' : '';
+      return `${fence}${pad}${t}${pad}${fence}`;
+    }
+    default: return n.outerHTML;
+  }
+}

package/src/writer.js

@@ -0,0 +1,138 @@
+// Provenance's Markdown writer (the studio's notes/markdown-plan.md, "Saving through Provenance"): the editing half of a format plug-in, in Provenance's `Writer` shape and by shape only (nothing here imports Provenance). A path is a JSON Pointer over the heading outline: each step a heading's plain text, `~0` `~1` escaping `~` `/` as RFC 6901 does, a repeated sibling heading's step suffixed `@n`, and a heading whose own text ends in `@` and digits suffixed `@1` even when first, so a step's last `@n` is always its ordinal; the empty path is the preamble. A path addresses a section's own run: its heading line and the blocks after it, up to the next heading of any rank, so no two paths share a byte. The value is the run's blocks, each its HTML, the bytes it had at the base and whether it is unchanged (`writeRun`); the writer writes them with the stenographers over the run's bytes in the version it opened, a block finding its old self by those bytes. Only `set`: every edit is a new value for a run, structural ones included (a heading deleted is its run without it, a section deleted its run set to nothing). Bytes are counted here and nowhere else: the writer decodes UTF-8, works in string positions, and answers in byte positions.
+import { parseMarkdown } from './parse.js';
+import { writeFlow } from './flow.js';
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder('utf-8', { fatal: true });
+// The mdast nodes that are the gaps' bytes, not blocks: nothing in the value stands for them (a comment between blocks is the gap's, as it is the file's, the studio's src/markdown/file.js).
+const GAPS = new Set(['definition', 'footnoteDefinition', 'yaml']);
+const gap = (n) => GAPS.has(n.type) || (n.type === 'html' && /^\s*<!--[\s\S]*?-->\s*$/.test(n.value));
+
+const plain = (node) => ('value' in node && typeof node.value === 'string' ? node.value : (node.children ?? []).map(plain).join(''));
+/** A heading's step: its plain text, whitespace collapsed, escaped as RFC 6901 escapes a step. */
+export const step = (text) => text.replace(/\s+/g, ' ').trim().replace(/~/g, '~0').replace(/\//g, '~1');
+
+/**
+ * The runs of a Markdown text, by path, in order: the preamble (after any frontmatter) and each top-level heading's run. Nesting follows the ranks as BelType's sectioning reads them: a heading is the child of the nearest earlier heading of a lower rank.
+ * @returns {{ runs: Map<string, { from: number, to: number, blocks: object[] }>, siblings: Map<string, number> }} the runs, and how many siblings share each parent and text (for `shifted`)
+ */
+export function outline(tree, text) {
+  const top = tree.children;
+  const yaml = top[0]?.type === 'yaml' ? top[0] : null;
+  const headings = top.filter((n) => n.type === 'heading');
+  const runs = new Map(), siblings = new Map();
+  const blocksIn = (from, to) => top.filter((n) => !gap(n) && n.position.start.offset >= from && n.position.start.offset < to);
+  const first = headings[0]?.position.start.offset ?? text.length;
+  const preamble = yaml ? yaml.position.end.offset : 0;
+  runs.set('', { from: preamble, to: first, blocks: blocksIn(preamble, first) });
+  const stack = [];
+  headings.forEach((h, i) => {
+    while (stack.length && stack.at(-1).depth >= h.depth) stack.pop();
+    const parent = stack.map((s) => `/${s.step}`).join('');
+    const name = step(plain(h));
+    const key = `${parent}\0${name}`;
+    const n = (siblings.get(key) ?? 0) + 1;
+    siblings.set(key, n);
+    const own = n > 1 || /@\d+$/.test(name) ? `${name}@${n}` : name;
+    stack.push({ depth: h.depth, step: own });
+    const from = h.position.start.offset, to = headings[i + 1]?.position.start.offset ?? text.length;
+    runs.set(`${parent}/${own}`, { from, to, blocks: blocksIn(from, to), heading: true });
+  });
+  return { runs, siblings };
+}
+
+/**
+ * A run's new bytes over its old: the one function the file (the studio's src/markdown/file.js, against its base) and Provenance's writer (against whatever version it opened) both write with, so a preview is the file's working text. Each entry of the value is a block: its HTML, the bytes it had at the base the value was made against (null for a block that had none), whether it is that block unchanged, the bytes it had in the working text before this change (`prior`, null for none), and whether those stand as they are (`keep`: the block did not change since, or they are what the Markdown pane typed). A block finds its old block by its base bytes, in order; one whose bytes are not in this version of the run (the disk changed it) takes the next unpaired old block of its kind; a block with no bytes is new. A block that keeps its prior bytes is written as them; a changed one is written by its stenographer over its prior bytes, or over its old block's.
+ * @param {string} text the file's text
+ * @param {{ from: number, to: number, blocks: object[], heading?: boolean }} run the run in it, from `outline` (`heading`: a section's run, not the preamble)
+ * @param {[string, string | null, boolean, (string | null)?, boolean?][]} value
+ * @param {{ defs?: string, markdown?: import('./parse.js').Markdown }} file
+ * @returns {{ text: string, spans: [number, number][] }} the run's bytes, and each value block's span in them
+ */
+export function writeRun(text, run, value, file) {
+  if (!value.length) return { text: '', spans: [] };
+  const olds = run.blocks.map((b) => [b.position.start.offset, b.position.end.offset]);
+  const bytes = olds.map((span) => text.slice(...span));
+  const holder = globalThis.document.createElement('template');
+  const used = new Set();
+  let next = 0;
+  const blocks = value.map(([html, was, same, prior = null, keep = false]) => {
+    holder.innerHTML = html;
+    const el = holder.content.firstElementChild;
+    let j = -1;
+    if (was != null) {
+      j = bytes.findIndex((b, k) => k >= next && !used.has(k) && b === was);
+      if (j < 0) j = bytes.findIndex((b, k) => !used.has(k) && b === was);
+      if (j < 0) for (let k = next; k < olds.length; k++) if (!used.has(k) && sameKind(el, run.blocks[k])) { j = k; break; }
+    }
+    if (j >= 0) { used.add(j); next = j + 1; }
+    return { el, j, same: j >= 0 && same && bytes[j] === was, bytes: keep && prior != null ? prior : null, over: prior };
+  });
+  const out = writeFlow(blocks, { text, spans: olds, from: run.from, to: run.to }, file);
+  // A section's run that lost its heading and now begins with a list puts that list next to whatever ends the run before, which this run cannot see: the run before may be staged too, and Provenance writes the two independently. So it always opens with an empty comment, which keeps two lists apart as the flow does; at worst a comment where none was needed, never two lists read as one.
+  if (run.heading && /^[uo]l$/.test(blocks[0].el.localName)) {
+    const sep = '<!-- -->\n\n';
+    return { text: sep + out.text, spans: out.spans.map(([a, b]) => [a + sep.length, b + sep.length]) };
+  }
+  return out;
+}
+const KIND = { paragraph: 'p', code: 'pre', blockquote: 'blockquote', table: 'table', thematicBreak: 'hr' };
+const sameKind = (el, md) => {
+  if (md.type === 'heading') return /^h[1-6]$/.test(el.localName);
+  if (md.type === 'list') return el.localName === (md.ordered ? 'ol' : 'ul');
+  return KIND[md.type] === el.localName;
+};
+// Stenography's refusal rule: a wrong-typed path or value is the caller's bug and throws; a data problem is a refusal with its shared code.
+const isEditData = (v) => v === null || ['string', 'number', 'bigint', 'boolean'].includes(typeof v) || (Array.isArray(v) && v.every(isEditData)) || (v instanceof Map && [...v].every(([k, x]) => typeof k === 'string' && isEditData(x)));
+const pointer = (path) => {
+  if (typeof path !== 'string') throw new TypeError(`a path is a string, not ${typeof path}`);
+  return path === '' || (path.startsWith('/') && !/~(?![01])/.test(path));
+};
+const refuse = (code, reason) => ({ ok: false, code, reason });
+const wellFormed = (value) => Array.isArray(value) && value.every((b) => Array.isArray(b) && typeof b[0] === 'string' && (b[1] === null || typeof b[1] === 'string') && typeof b[2] === 'boolean' && (b[3] == null || typeof b[3] === 'string') && (b[4] == null || typeof b[4] === 'boolean'));
+
+/**
+ * @param {{ markdown?: import('./parse.js').Markdown, claims?: (location: string) => boolean }} [options]
+ */
+export function markdownWriter({ markdown, claims = (location) => /\.md$/i.test(location) } = {}) {
+  return {
+    claims,
+    open(bytes) {
+      let text;
+      try { text = decoder.decode(bytes); } catch { return refuse('open-unreadable', 'the file is not UTF-8'); }
+      const tree = parseMarkdown(text, markdown);
+      const { runs, siblings } = outline(tree, text);
+      const defs = tree.children.filter((n) => n.type === 'definition' || n.type === 'footnoteDefinition').map((n) => text.slice(n.position.start.offset, n.position.end.offset)).join('\n\n');
+      const byte = (i) => encoder.encode(text.slice(0, i)).length;
+      const opened = {
+        siblings,
+        locate(path) {
+          if (!pointer(path)) return refuse('path-malformed', `${JSON.stringify(path)} is not a JSON Pointer`);
+          const run = runs.get(path);
+          return run ? { ok: true, start: byte(run.from), end: byte(run.to) } : refuse('edit-target-absent', `no section at ${JSON.stringify(path)}`);
+        },
+        write(path, value) {
+          if (!pointer(path)) return refuse('path-malformed', `${JSON.stringify(path)} is not a JSON Pointer`);
+          if (!isEditData(value)) throw new TypeError('a value is EditData: a scalar, an array or a Map, never a plain object');
+          const run = runs.get(path);
+          if (!run) return refuse('edit-target-absent', `no section at ${JSON.stringify(path)}`);
+          if (!wellFormed(value)) return refuse('edit-unrepresentable', 'the value of a section is its blocks, each [html, its bytes at the base or null, unchanged, its prior bytes or null, whether they stand]');
+          const out = writeRun(text, run, value, { defs, markdown }).text;
+          return { ok: true, edit: { start: byte(run.from), end: byte(run.to), bytes: encoder.encode(out) } };
+        },
+        // A list along the path changed length when a step with an ordinal names siblings whose count changed.
+        shifted(path, newer) {
+          let parent = '';
+          for (const s of path.split('/').slice(1)) {
+            const name = s.replace(/@\d+$/, '');
+            const key = `${parent}\0${name}`;
+            if (s !== name && siblings.get(key) !== newer.siblings?.get(key)) return true;
+            parent += `/${s}`;
+          }
+          return false;
+        }
+      };
+      return { ok: true, document: opened };
+    }
+  };
+}