reladraw 0.3.0 → 0.5.0

package/dist/parser.js

@@ -1,6 +1,7 @@
-import { COLOR_KEYS, DIAGRAM_KEYS, DIRECTIONS, describePlacement, SIDE_AXIS, SIDES, PASSAGE_AXES, TEXT_KEYS, CONTENTS_KEYS, PLACEMENT_KEYS, BOUNDARY_PARTS, INWARD, OPPOSITE, isDirection, isPart, isPosition, listTargets, nameTarget, } from './ast.js';
+import { COLOR_KEYS, DEFAULT_KEYS, DEFAULT_TARGETS, DIAGRAM_KEYS, DIRECTIONS, describePlacement, SIDE_AXIS, SIDES, PASSAGE_AXES, TEXT_KEYS, CONTENTS_KEYS, PLACEMENT_KEYS, BOUNDARY_PARTS, INWARD, OPPOSITE, isDirection, isPart, isPosition, listTargets, nameTarget, } from './ast.js';
 import { SourceError } from './errors.js';
 import { isAttrKey, tokenizeLine } from './lexer.js';
+import { THEME_NAMES, THEMES } from './themes.js';
 /** Parse a whole source file. One statement per line; blanks and comments drop out. */
 export function parse(source) {
     const statements = [];
@@ -23,12 +24,12 @@ function parseStatement(tokens, line) {
             return parseNode(tokens, line);
         case 'edge':
             return parseEdge(tokens, line);
-        case 'deck':
-            return parseDeck(tokens, line);
         case 'style':
             return parseStyle(tokens, line);
         case 'diagram':
             return parseDiagram(tokens, line);
+        case 'default':
+            return parseDefault(tokens, line);
         default:
             throw new SourceError(substitution(keyword.text, tokens), line);
     }
@@ -66,6 +67,14 @@ function substitution(word, head) {
         return `reladraw has no \`note\` statement — a note is a node with no body, so try ` +
             `\`node ${rewrite(head)} shape: none\``;
     }
+    // A statement until 0.4.0. It created nothing, only said more about a node
+    // declared elsewhere, which is what an attribute on that node is for.
+    if (word === 'deck') {
+        const name = head[1] && !head[1].quoted ? head[1].text : '<name>';
+        const texts = head.slice(2).map((token) => (token.quoted ? quoteOf(token.text) : token.text));
+        return `reladraw has no \`deck\` statement — a deck is an attribute of the node, so write ` +
+            `\`deck: ${texts.length > 0 ? texts.join(' ') : '"…"'}\` on \`node ${name}\``;
+    }
     const replacement = SUBSTITUTIONS[word];
     if (replacement === undefined)
         return `unknown statement "${word}"`;
@@ -142,6 +151,19 @@ const BRACKET_ABOUT = {
  * `fill:` as though the two were the same sort of statement.
  */
 const MOVED_INTO_BRACKET = ['size', 'wrap', 'align'];
+/**
+ * Store one attribute, refusing a key the line has already set. Two words on
+ * one line are equally explicit, so nothing says which was meant — and keeping
+ * either drops the other in silence. It is almost always an edit that forgot to
+ * delete the old value, so the error shows both and asks for one.
+ */
+function setOnce(attrs, key, value, subject, line, shown = { key, value: (v) => v }) {
+    const had = attrs[key];
+    if (had !== undefined) {
+        throw new SourceError(`${subject}: "${shown.key}" is written twice (${shown.value(had)}, ${shown.value(value)}) — keep one`, line);
+    }
+    attrs[key] = value;
+}
 /** Read one `key: value` pair, and refuse the words that used to be keys. */
 function readAttr(tokens, at, attrs, line, subject) {
     const keyToken = tokens[at];
@@ -161,8 +183,11 @@ function readAttr(tokens, at, attrs, line, subject) {
         if (Object.keys(read.values).length === 0) {
             throw new SourceError(`${subject}: \`${key}:\` opens empty brackets`, line);
         }
-        for (const [inner, value] of Object.entries(read.values))
-            attrs[`${key}.${inner}`] = value;
+        // Two brackets for one part are fine as long as they say different things;
+        // the same property in both is the same defect as `fill:` written twice.
+        for (const [inner, value] of Object.entries(read.values)) {
+            setOnce(attrs, `${key}.${inner}`, value, subject, line, { key: `${key}: (${inner}: …)`, value: (v) => v });
+        }
         return read.next;
     }
     if (key === 'url') {
@@ -175,9 +200,57 @@ function readAttr(tokens, at, attrs, line, subject) {
             throw new SourceError(`${subject}: a url is written in quotes — \`url: "https://example.com"\`. Without them ` +
                 'everything from the `//` onwards is read as a comment', line);
         }
-        attrs[key] = value.text;
+        setOnce(attrs, key, value.text, subject, line, { key, value: quoteOf });
         return at + 2;
     }
+    if (key === 'style') {
+        // `style: base, critical and alarm` — several bundles, applied in the order
+        // written, a later one winning where two set the same key. The list reads
+        // the way a placement's targets do: commas and `and` both separate. Stored
+        // joined on a space, which no style name can hold.
+        const names = [];
+        let next = at + 1;
+        for (;;) {
+            const token = tokens[next];
+            if (!token || token.quoted || isAttrKey(token) || token.text === '(' || token.text === ')') {
+                throw new SourceError(names.length === 0 ? `attribute "style" has no value` : `${subject}: "style:" ends its list with a comma`, line);
+            }
+            const listed = token.text.endsWith(',') && token.text.length > 1;
+            const name = listed ? token.text.slice(0, -1) : token.text;
+            if (names.includes(name)) {
+                throw new SourceError(`${subject}: style "${name}" is named twice in one \`style:\` — keep one`, line);
+            }
+            names.push(name);
+            next += 1;
+            if (follows(tokens, next, 'and')) {
+                next += 1;
+                continue;
+            }
+            if (listed)
+                continue;
+            break;
+        }
+        setOnce(attrs, key, names.join(' '), subject, line, { key, value: (v) => v.split(' ').join(', ') });
+        return next;
+    }
+    if (key === 'deck') {
+        // One quoted text per copy behind the node, back to front, as many as are
+        // written. Stored joined on a line break, which no source line can hold.
+        const texts = [];
+        let next = at + 1;
+        while (tokens[next]?.quoted)
+            texts.push(tokens[next++].text);
+        if (texts.length === 0) {
+            const given = tokens[next];
+            throw new SourceError(`${subject}: \`deck:\` takes one quoted text per copy behind the node, as in \`deck: "Drive 2" "Drive 3"\`` +
+                (given && !isAttrKey(given) ? `, not \`deck: ${given.text}\`` : ''), line);
+        }
+        setOnce(attrs, key, texts.join('\n'), subject, line, {
+            key,
+            value: (v) => v.split('\n').map(quoteOf).join(' '),
+        });
+        return next;
+    }
     if (bracketKeys !== undefined && key !== 'text') {
         // `contents: match` names the part and then says one of its two properties
         // without saying which. The brackets are what make the level shift visible,
@@ -243,7 +316,7 @@ function readAttr(tokens, at, attrs, line, subject) {
         }
         throw new SourceError(`"${key}" takes a color and a quoted value is text — drop the quotes if ${valueToken.text} is a color`, line);
     }
-    attrs[key] = valueToken.text;
+    setOnce(attrs, key, valueToken.text, subject, line);
     return at + 2;
 }
 /** Attributes only, for the statements that take no placements. */
@@ -405,27 +478,6 @@ function parseEdge(head, line) {
         line,
     };
 }
-/** `deck <name> "<text>" ["<text>" ...]` */
-function parseDeck(head, line) {
-    const name = requireName(head[1], 'deck', line);
-    const texts = [];
-    for (const token of head.slice(2)) {
-        if (!token.quoted) {
-            // Until 0.3.0 the head/attributes split cut these off and threw them
-            // away, so `deck d "one" fill: red` drew an uncolored deck in silence.
-            if (isAttrKey(token)) {
-                throw new SourceError(`deck "${name}" has ${token.text} — a deck says how many copies a node has and what ` +
-                    `each one reads, so write attributes on \`node ${name}\` itself`, line);
-            }
-            throw new SourceError(`deck "${name}" takes quoted texts only`, line);
-        }
-        texts.push(token.text);
-    }
-    if (texts.length === 0) {
-        throw new SourceError(`deck "${name}" needs at least one text`, line);
-    }
-    return { kind: 'deck', name, texts, line };
-}
 /** `style <name> <attributes>` */
 function parseStyle(head, line) {
     const name = requireName(head[1], 'style', line);
@@ -453,12 +505,80 @@ function parseDiagram(head, line) {
         throw new SourceError('diagram sets nothing', line);
     }
     for (const key of Object.keys(attrs)) {
+        if (key.startsWith('text.')) {
+            // The theme has one text color, shared by everything, and that is all
+            // the diagram's text sets. A size or a wrap is about one kind of text.
+            if (key !== 'text.color') {
+                const inner = key.slice('text.'.length);
+                throw new SourceError(`diagram text: sets only a color — \`${inner}\` is about one kind of text, so write ` +
+                    `\`text: (${inner}: ${attrs[key]})\` on a \`default node\` or \`default edge\``, line);
+            }
+            continue;
+        }
         if (!DIAGRAM_KEYS.includes(key)) {
             throw new SourceError(`diagram has no "${key}" — it takes ${DIAGRAM_KEYS.join(', ')}`, line);
         }
     }
+    if (attrs['text'] !== undefined) {
+        throw new SourceError('diagram text: takes a bracket — `text: (color: #e0e0e0)`', line);
+    }
+    const theme = attrs['theme'];
+    if (theme !== undefined && THEMES[theme] === undefined) {
+        throw new SourceError(`there is no theme called "${theme}" — the themes are ${THEME_NAMES.join(', ')}`, line);
+    }
     return { kind: 'diagram', attrs, line };
 }
+/**
+ * `default <node | leaf | container | edge> <attributes>` — a style every thing
+ * of that kind wears without naming it. It is strict about kind where a style
+ * is permissive, because it names the kind it is for: a word that kind has no
+ * use for can only be a mistake.
+ */
+function parseDefault(head, line) {
+    const target = head[1];
+    if (!target || target.quoted || !DEFAULT_TARGETS.includes(target.text)) {
+        throw new SourceError(`default needs the kind it is for — ${DEFAULT_TARGETS.join(', ')}` +
+            (target && !isAttrKey(target) ? `, not "${target.text}"` : ''), line);
+    }
+    const kind = target.text;
+    const subject = `default ${kind}`;
+    // `default leaf node` reads naturally and says nothing `default leaf` does not.
+    const extra = head[2];
+    if (extra && !extra.quoted && !isAttrKey(extra) && extra.text === 'node' && kind !== 'node') {
+        throw new SourceError(`write \`default ${kind}\` — a ${kind} is already a node`, line);
+    }
+    const attrs = attrsOnly(head, 2, line, subject);
+    if (Object.keys(attrs).length === 0) {
+        throw new SourceError(`${subject} sets nothing`, line);
+    }
+    const allowed = DEFAULT_KEYS[kind];
+    for (const key of new Set(Object.keys(attrs).map((k) => k.split('.')[0]))) {
+        if (allowed.includes(key))
+            continue;
+        throw new SourceError(`${subject} has ${key}:, ${defaultRefusal(kind, key)}`, line);
+    }
+    return { kind: 'default', target: kind, attrs, line };
+}
+/** Why a default cannot carry a word, and what to write instead. */
+function defaultRefusal(kind, key) {
+    const takes = `it takes ${DEFAULT_KEYS[kind].map((k) => `${k}:`).join(', ')}`;
+    if (key === 'url')
+        return `and a destination belongs to one thing rather than to every one of a kind`;
+    if (key === 'badge') {
+        return 'and a badge is a child, so every leaf given one would become a container. ' +
+            'Put the badge in a style, or write `default container  badge:`';
+    }
+    if (key === 'icon') {
+        return 'and a picture cannot hold children, so an icon is a leaf\'s word — write `default leaf  icon:`';
+    }
+    if (kind === 'edge' && (key === 'fill' || key === 'border')) {
+        return `which an edge does not have — an edge is colored by line: and text: (color: …)`;
+    }
+    if (kind !== 'edge' && key === 'line') {
+        return `which is an edge's — a node is colored by fill:, border: and text: (color: …)`;
+    }
+    return `which a default does not set — ${takes}`;
+}
 function requireName(token, keyword, line) {
     if (!token || token.quoted) {
         throw new SourceError(`${keyword} needs a name`, line);
@@ -497,7 +617,7 @@ function readPlacement(tokens, at, line, subject) {
             throw new SourceError(`${subject}: an alignment reads "${written} <node>"`, line);
         }
         const read = readTargets(tokens, from + 2, subject, written, line);
-        const modifiers = readModifiers(tokens, read.next, subject, written, line);
+        const modifiers = readModifiers(tokens, read.next, subject, `${written} ${listTargets(read.targets)}`, line);
         // An alignment shares a line outright, so there is no distance in it for
         // a gap to set. Refusing rather than dropping it, for the reason unknown
         // modifier names are refused: a word that quietly does nothing reads as a
@@ -529,10 +649,11 @@ function readPlacement(tokens, at, line, subject) {
         throw new SourceError(`${subject}: "${word.text}" is not a direction`, line);
     }
     let next = at + 1;
-    if (follows(tokens, next, 'of'))
+    const of = follows(tokens, next, 'of');
+    if (of)
         next += 1;
     const read = readTargets(tokens, next, subject, word.text, line);
-    const modifiers = readModifiers(tokens, read.next, subject, word.text, line);
+    const modifiers = readModifiers(tokens, read.next, subject, `${word.text}${of ? ' of' : ''} ${listTargets(read.targets)}`, line);
     return {
         placement: {
             kind: 'offset',
@@ -673,7 +794,12 @@ function readBracket(tokens, start, keys, about) {
         // targets of a placement. `(at: bottom, align: center)` and the same without
         // the comma are the same statement.
         const value = valueToken.text;
-        values[key] = value.endsWith(',') && value.length > 1 ? value.slice(0, -1) : value;
+        const clean = value.endsWith(',') && value.length > 1 ? value.slice(0, -1) : value;
+        const had = values[key];
+        if (had !== undefined) {
+            throw new SourceError(`${about.subject}: "${key}" is written twice in the brackets after ${about.what} (${had}, ${clean}) — keep one`, about.line);
+        }
+        values[key] = clean;
         i += 2;
     }
     return { values, next: i + 1 };

package/dist/render.d.ts

@@ -1,31 +1,10 @@
 import { type Measurer } from './measure.js';
 import type { Layout } from './model.js';
+import { type Theme } from './themes.js';
 export interface RenderOptions {
     measurer?: Measurer;
     fontSize?: number;
     theme?: Theme;
 }
-export interface Theme {
-    background: string;
-    boxFill: string;
-    boxStroke: string;
-    containerFill: string;
-    /** A container is a region rather than a thing, so its outline is quieter. */
-    containerStroke: string;
-    text: string;
-    mutedText: string;
-    edge: string;
-    /** An icon's drawn line. */
-    iconInk: string;
-    /** The body an icon's lines enclose. */
-    iconShade: string;
-}
-/**
- * Sampled out of `examples/reference/arch.png` rather than invented,
- * so the benchmark render and the drawing it is measured against differ by
- * geometry and typography alone. A container is a shade off the page and barely
- * outlined; a leaf is the navy that carries the diagram's weight.
- */
-export declare const DARK_THEME: Theme;
 /** Turn solved geometry into a standalone SVG document. */
 export declare function render(layout: Layout, options?: RenderOptions): string;

package/dist/render.js

@@ -3,40 +3,25 @@ import { describeAxis } from './ast.js';
 import { SourceError } from './errors.js';
 import { ICON_STROKE } from './icons.js';
 import { monospaceMeasurer } from './measure.js';
+import { DARK_THEME, THEMES } from './themes.js';
 import { plain } from './text.js';
-/**
- * Sampled out of `examples/reference/arch.png` rather than invented,
- * so the benchmark render and the drawing it is measured against differ by
- * geometry and typography alone. A container is a shade off the page and barely
- * outlined; a leaf is the navy that carries the diagram's weight.
- */
-export const DARK_THEME = {
-    background: '#111111',
-    boxFill: '#191728',
-    boxStroke: '#4f5367',
-    containerFill: '#191920',
-    containerStroke: '#25242f',
-    text: '#d9d9d9',
-    mutedText: '#8b8b8b',
-    edge: '#5c5c7c',
-    // Both sampled off the reference's machine glyphs. Note that the reference
-    // gives each icon its own hue — the drive is gray, the laptop periwinkle, the
-    // workstation violet — which is a drawing tool's per-shape default and not a
-    // system. One pair for the whole set is the deliberate difference: an icon
-    // should read as part of the diagram's palette, not as clip art dropped in.
-    iconInk: '#8d8d8e',
-    iconShade: '#3e3d58',
-};
 const CORNER = 8;
 /** Turn solved geometry into a standalone SVG document. */
 export function render(layout, options = {}) {
     const measurer = options.measurer ?? monospaceMeasurer();
     const fontSize = options.fontSize ?? DEFAULT_FONT_SIZE;
-    // `diagram background:` is the author overruling the theme for this one
-    // drawing, so it is folded in here and everything downstream sees one theme.
-    const base = options.theme ?? DARK_THEME;
-    const stated = layout.diagram['background'];
-    const theme = stated === undefined ? base : { ...base, background: stated };
+    // A theme passed in — the command line's `--theme` — beats the one the file
+    // names, so one source renders in either. `diagram background:` and `text:`
+    // are the author overruling a color of whichever theme that is, and a color
+    // written by hand wins over any theme, so they are folded in afterwards and
+    // everything downstream sees one theme.
+    const named = layout.diagram['theme'];
+    const base = options.theme ?? (named === undefined ? undefined : THEMES[named]) ?? DARK_THEME;
+    const theme = {
+        ...base,
+        ...(layout.diagram['background'] !== undefined && { background: layout.diagram['background'] }),
+        ...(layout.diagram['text.color'] !== undefined && { text: layout.diagram['text.color'] }),
+    };
     const body = [];
     for (const root of layout.roots) {
         body.push(drawNode(root, theme, measurer, fontSize, layout.markup));
@@ -162,10 +147,10 @@ function nodeSvg(node, theme, measurer, fontSize, markup, url) {
     const parts = [];
     const kids = [];
     const face = faceOf(node);
-    // A container *looks* like one because things stack beside its text, not
-    // because it has children: a node whose only child sits beside its text is
-    // drawn as the leaf it reads as.
-    const container = node.banded;
+    // A node with children is colored as a backdrop however they are placed,
+    // including a lone badge beside its text. Every rule that tried to tell a
+    // badge from contents was a guess; this one is visible in the source.
+    const container = node.children.length > 0;
     const border = borderOf(node.appearance, container ? theme.containerStroke : theme.boxStroke);
     const fill = fillOf(node.appearance, container ? theme.containerFill : theme.boxFill);
     // A box is the one kind with two inkable parts, which is why its text needs
@@ -188,8 +173,9 @@ function nodeSvg(node, theme, measurer, fontSize, markup, url) {
     // A leaf's text defaults to the middle of its box, a container's to the top
     // left of the band; both then read `at` for where it really goes. Where the
     // text sits is the resolver's answer, in `textBox`; only the alignment of
-    // its lines against each other is read here.
-    const textStyle = textStyleFor(node.textAttrs, node.line, container ? 'start' : 'middle', container ? 'top-left' : 'center');
+    // its lines against each other is read here. This follows the band, not the
+    // colors: a badged leaf is a backdrop but its text still centers.
+    const textStyle = textStyleFor(node.textAttrs, node.line, node.banded ? 'start' : 'middle', node.banded ? 'top-left' : 'center');
     parts.push(sized(textBlock(node.lines, node.x, node.y, textHeight, size, node.textBox, {
         color: text,
         align: textStyle.align,

package/dist/resolve.js

@@ -23,12 +23,12 @@ export function resolve(doc, options = {}) {
     const margin = options.margin ?? DEFAULT_MARGIN;
     const styles = collectStyles(doc.statements);
     checkStyleKeys(doc.statements);
-    const { nodes, byName, roots } = buildTree(doc.statements, styles);
-    applyDecks(doc.statements, byName);
+    const defaults = collectDefaults(doc.statements, styles);
+    const { nodes, byName, roots } = buildTree(doc.statements, styles, defaults);
     // Edges are resolved to nodes before anything is sized, because a labeled
     // edge claims room in the gap it crosses and so has to be in hand while the
     // gaps are being worked out. Nothing here reads geometry.
-    const edges = buildEdges(doc.statements, byName, styles);
+    const edges = buildEdges(doc.statements, byName, styles, defaults);
     const local = new Map();
     for (const root of roots)
         sizeNode(root, edges, measurer, fontSize, local);
@@ -59,6 +59,40 @@ function collectStyles(statements) {
     }
     return styles;
 }
+/**
+ * Each kind's default, with any style it names already folded in beneath its
+ * own words, so a default arrives at a node as one flat bundle. The same kind
+ * written twice is refused, as a second `diagram` is: nothing says which was
+ * meant.
+ */
+function collectDefaults(statements, styles) {
+    const defaults = new Map();
+    const seen = new Map();
+    for (const stmt of statements) {
+        if (stmt.kind !== 'default')
+            continue;
+        const earlier = seen.get(stmt.target);
+        if (earlier !== undefined) {
+            throw new SourceError(`default ${stmt.target} is written twice, here and on line ${earlier} — keep one`, stmt.line);
+        }
+        seen.set(stmt.target, stmt.line);
+        const { style: _named, ...flat } = appearanceOf(stmt.attrs, styles, stmt.line);
+        defaults.set(stmt.target, flat);
+    }
+    return defaults;
+}
+/**
+ * One bundle laid over a weaker one, key by key — except the body, which is
+ * one thing said by either of two words. A default's `shape: cylinder` under
+ * a style's `icon: disk` is not a node with two bodies; the style said what
+ * this node is drawn as, and that settles it.
+ */
+function over(base, top) {
+    if (top['shape'] === undefined && top['icon'] === undefined)
+        return { ...base, ...top };
+    const { shape: _shape, icon: _icon, ...rest } = base;
+    return { ...rest, ...top };
+}
 /** A file holds one diagram, so a second `diagram` statement is a mistake. */
 function collectDiagram(statements) {
     let found;
@@ -71,12 +105,27 @@ function collectDiagram(statements) {
     }
     return found ?? {};
 }
-function buildTree(statements, styles) {
+function buildTree(statements, styles, defaults) {
     const nodes = [];
     const byName = new Map();
     const roots = [];
     /** Each badge child's name, and the node whose `badge:` it was written out from. */
     const badges = new Map();
+    // Which nodes will hold children has to be known before any node is built,
+    // because it decides which default a node wears, and its children are
+    // declared after it. A child is a dotted name, or a badge the node's own
+    // line or styles give it; a default cannot give a leaf a badge, so what
+    // the defaults say cannot change the answer.
+    const parents = new Set();
+    for (const stmt of statements) {
+        if (stmt.kind !== 'node')
+            continue;
+        const cut = stmt.name.lastIndexOf('.');
+        if (cut !== -1)
+            parents.add(stmt.name.slice(0, cut));
+        if (appearanceOf(stmt.attrs, styles, stmt.line)['badge'] !== undefined)
+            parents.add(stmt.name);
+    }
     for (const stmt of statements) {
         if (stmt.kind !== 'node')
             continue;
@@ -88,7 +137,9 @@ function buildTree(statements, styles) {
             }
             throw new SourceError(`"${stmt.name}" is declared twice`, stmt.line);
         }
-        const appearance = appearanceOf(stmt.attrs, styles, stmt.line);
+        // Weakest first: every node's default, then the leaf's or the container's,
+        // then the node's own styles and words over both.
+        const appearance = over(over(defaults.get('node') ?? {}, defaults.get(parents.has(stmt.name) ? 'container' : 'leaf') ?? {}), appearanceOf(stmt.attrs, styles, stmt.line));
         const body = bodyFor(stmt.attrs, appearance, stmt.line);
         const kind = KIND_OF_BODY[body.kind];
         // A node with no text of its own is labelled with its name, because the
@@ -129,6 +180,11 @@ function buildTree(statements, styles) {
         };
         checkAttrs(kind, node.name, stmt.attrs, stmt.line);
         checkStyleUse(kind, node.name, stmt.attrs, styles, stmt.line);
+        // `deck:` holds one text per copy, joined on a line break the source cannot
+        // contain. Like a badge, only a box has an outline to repeat.
+        const deck = appearance['deck'];
+        if (deck !== undefined && body.kind === 'shape')
+            node.deckTexts = deck.split('\n');
         const cut = stmt.name.lastIndexOf('.');
         if (cut === -1) {
             roots.push(node);
@@ -254,7 +310,9 @@ function checkAttrs(kind, name, attrs, line) {
             continue;
         // Quoted back the way it was written. A bracketed value arrives one dotted
         // key at a time, and `contents: match` is not a line anybody could look for.
-        const wrote = written === key ? `${key}: ${value}` : `${key}: (${written.slice(key.length + 1)}: ${value})`;
+        // A deck's texts are stored joined on a line break; quote them back as written.
+        const shown = key === 'deck' ? value.split('\n').map((text) => `"${text}"`).join(' ') : value;
+        const wrote = written === key ? `${key}: ${shown}` : `${key}: (${written.slice(key.length + 1)}: ${shown})`;
         if (!ALL_ATTR_KEYS.includes(key)) {
             // Nothing anywhere in the language answers to this word, so the only
             // remedy is the vocabulary itself.
@@ -269,6 +327,11 @@ function checkAttrs(kind, name, attrs, line) {
             const parts = COLOR_PARTS[kind].map((part) => `\`${part}\``).join(', ');
             throw new SourceError(`"${name}" is ${article(KIND_WORD[kind])} and has ${wrote}. ${capital(article(KIND_WORD[kind]))} is ${KIND_PARTS[kind]}, so it has no ${key} — it takes ${parts}`, line);
         }
+        // A word only the whole drawing takes, such as a theme.
+        if (belongTo(key).length === 0) {
+            throw new SourceError(`"${name}" is ${article(KIND_WORD[kind])} and has ${wrote}. \`${key}:\` is said about the ` +
+                `whole drawing — write \`diagram ${key}: ${shown}\``, line);
+        }
         // Anything else names no part, so what the kind is made of explains
         // nothing. What does explain it is where the word *does* belong, which is
         // also the more useful thing to be told: the author has usually written a
@@ -288,23 +351,25 @@ function checkAttrs(kind, name, attrs, line) {
  * construction — that hole is left open, because nobody writes one by accident.
  */
 function checkStyleUse(kind, name, attrs, styles, line) {
-    const named = attrs['style'];
-    if (named === undefined)
-        return;
-    const base = styles.get(named);
-    if (base === undefined)
-        return; // `appearanceOf` reports the missing style.
-    // A style naming another style is the one way to carry nothing at all: the
-    // parser already refuses one with no attributes, and `appearanceOf` does not
-    // recurse, so the name would sit there doing nothing.
-    const carried = [...new Set(Object.keys(base).map(topKey))].filter((key) => key !== 'style');
-    if (carried.length === 0) {
-        throw new SourceError(`style "${named}" carries nothing but a style name`, line);
+    // Each style in a list is checked on its own: one that gives this thing
+    // nothing is a name written on the wrong sort of thing, whatever its
+    // neighbours in the list carry.
+    for (const named of styleNames(attrs)) {
+        const base = styles.get(named);
+        if (base === undefined)
+            continue; // `appearanceOf` reports the missing style.
+        // A style naming another style is the one way to carry nothing at all: the
+        // parser already refuses one with no attributes, and `appearanceOf` does not
+        // recurse, so the name would sit there doing nothing.
+        const carried = [...new Set(Object.keys(base).map(topKey))].filter((key) => key !== 'style');
+        if (carried.length === 0) {
+            throw new SourceError(`style "${named}" carries nothing but a style name`, line);
+        }
+        if (carried.some((key) => ATTR_KEYS[kind].includes(key)))
+            continue;
+        throw new SourceError(`style "${named}" gives "${name}" nothing. It carries ${carried.join(' and ')}; ` +
+            `${article(KIND_WORD[kind])} is ${KIND_PARTS[kind]}`, line);
     }
-    if (carried.some((key) => ATTR_KEYS[kind].includes(key)))
-        return;
-    throw new SourceError(`style "${named}" gives "${name}" nothing. It carries ${carried.join(' and ')}; ` +
-        `${article(KIND_WORD[kind])} is ${KIND_PARTS[kind]}`, line);
 }
 /**
  * A style is a bundle spanning kinds, so its keys cannot be checked against any
@@ -345,26 +410,27 @@ function listKinds(kinds) {
         return words[0] ?? 'nothing';
     return `${words.slice(0, -1).join(', ')} or ${words[words.length - 1]}`;
 }
-function appearanceOf(attrs, styles, line) {
+/** The styles a `style:` names, in the order written. The parser joins them on a space. */
+function styleNames(attrs) {
     const named = attrs['style'];
-    if (named === undefined)
-        return { ...attrs };
-    const base = styles.get(named);
-    if (!base)
-        throw new SourceError(`no style named "${named}"`, line);
-    return { ...base, ...attrs };
+    return named === undefined ? [] : named.split(' ');
 }
-function applyDecks(statements, byName) {
-    for (const stmt of statements) {
-        if (stmt.kind !== 'deck')
-            continue;
-        const node = byName.get(stmt.name);
-        if (!node)
-            throw new SourceError(`deck names "${stmt.name}", which does not exist`, stmt.line);
-        node.deckTexts = stmt.texts;
+/**
+ * The styles in the order written, a later one winning where two set the same
+ * key, and then the statement's own words over all of them — a word written on
+ * the line was meant for this thing, wherever `style:` sits.
+ */
+function appearanceOf(attrs, styles, line) {
+    const merged = {};
+    for (const named of styleNames(attrs)) {
+        const base = styles.get(named);
+        if (!base)
+            throw new SourceError(`no style named "${named}"`, line);
+        Object.assign(merged, base);
     }
+    return { ...merged, ...attrs };
 }
-function buildEdges(statements, byName, styles) {
+function buildEdges(statements, byName, styles, defaults) {
     const edges = [];
     for (const stmt of statements) {
         if (stmt.kind !== 'edge')
@@ -391,7 +457,7 @@ function buildEdges(statements, byName, styles) {
             }),
             ...(stmt.between.axis !== undefined ? { axis: stmt.between.axis } : {}),
         };
-        const appearance = appearanceOf(stmt.attrs, styles, stmt.line);
+        const appearance = { ...defaults.get('edge'), ...appearanceOf(stmt.attrs, styles, stmt.line) };
         const what = `${stmt.from} -> ${stmt.to}`;
         checkAttrs('edge', what, stmt.attrs, stmt.line);
         checkStyleUse('edge', what, stmt.attrs, styles, stmt.line);