@elicdavis/node-flow 0.1.15 → 0.1.17

package/src/port.ts

@@ -1,5 +1,6 @@
 import { Camera } from "./camera";
 import { Connection } from './connection';
+import { requestRender } from "./render_scheduler";
 import { RenderElementBase } from "./elements/base";
 import { ContainerRenderElement, AlignItems } from './elements/container';
 import { TextAlign, TextElement } from "./elements/text";
@@ -31,12 +32,62 @@ export interface PortConfig {
     type?: string;
     description?: string;
     array?: boolean;
+
+    /**
+     * Lets this port connect to a port of any type, instead of only to one
+     * declaring the same `type` string. For a port whose type is decided by
+     * whatever gets wired into it, where `type` is a placeholder shown to
+     * the user rather than a promise about the values passing through.
+     */
+    anyType?: boolean;
+
+    /**
+     * Every type this port takes, when it takes more than one. For a port
+     * that works on a single value or an array of them, where `type` is
+     * only the one it happens to be showing.
+     *
+     * An empty or absent list means the port takes exactly its `type`,
+     * unless `anyType` says otherwise.
+     */
+    acceptedTypes?: Array<string>;
+
     emptyStyle?: PortStyle;
     filledStyle?: PortStyle;
     onConnectionAdded?: ConnectionChangeCallback;
     onConnectionRemoved?: ConnectionChangeCallback;
 };
 
+/**
+ * Whether two ports may be connected, going by their types alone. Each port
+ * offers the set of types it takes - one entry for an ordinary port, several
+ * for a port that takes more than one, and none at all for a port that takes
+ * anything. They connect when those sets overlap.
+ */
+export function portsCompatible(a: Port | undefined | null, b: Port | undefined | null): boolean {
+    if (!a || !b) {
+        return false;
+    }
+
+    return typeSetsCompatible(a.acceptedTypes(), b.acceptedTypes());
+}
+
+export function typeSetsCompatible(a: Array<string>, b: Array<string>): boolean {
+    if (a.length === 0 || b.length === 0) {
+        return true;
+    }
+    return a.some((type) => b.includes(type));
+}
+
+export function portConfigTypes(config: PortConfig): Array<string> {
+    if (config.anyType === true) {
+        return [];
+    }
+    if (config.acceptedTypes !== undefined && config.acceptedTypes.length > 0) {
+        return config.acceptedTypes;
+    }
+    return [config.type === undefined ? "" : config.type];
+}
+
 // Calculate a color hash for an arbirary type
 function fallbackColor(type: string, s: number): string {
     let value = 0;
@@ -69,6 +120,18 @@ export class Port {
 
     #dataType: string;
 
+    #anyType: boolean;
+
+    #acceptedTypes: Array<string>;
+
+    #description: string;
+
+    #array: boolean;
+
+    #configuredEmptyFill: string | undefined;
+
+    #configuredFilledFill: string | undefined;
+
     #dataTypePopupElement: RenderElementBase;
 
     #onConnectionAdded: Array<ConnectionChangeCallback>;
@@ -81,17 +144,23 @@ export class Port {
         this.#portType = portType;
         this.#displayName = config?.name === undefined ? "Port" : config?.name;
         this.#dataType = config?.type === undefined ? "" : config?.type;
+        this.#anyType = config?.anyType === true;
+        this.#acceptedTypes = config?.acceptedTypes === undefined ? [] : config.acceptedTypes;
+        this.#description = config?.description === undefined ? "" : config.description;
+        this.#array = config?.array === true;
+        this.#configuredEmptyFill = config?.emptyStyle?.fillColor;
+        this.#configuredFilledFill = config?.filledStyle?.fillColor;
 
         this.#emptyStyle = {
             borderColor: config?.emptyStyle?.borderColor === undefined ? "#1c1c1c" : config.emptyStyle?.borderColor,
-            fillColor: config?.emptyStyle?.fillColor === undefined ? fallbackColor(this.#dataType, 0.3) : config.emptyStyle?.fillColor,
+            fillColor: this.#configuredEmptyFill === undefined ? fallbackColor(this.#dataType, 0.3) : this.#configuredEmptyFill,
             borderSize: config?.emptyStyle?.borderSize === undefined ? 1 : config.emptyStyle?.borderSize,
             size: config?.emptyStyle?.size === undefined ? 4 : config.emptyStyle?.size
         }
 
         this.#filledStyle = {
             borderColor: config?.filledStyle?.borderColor === undefined ? "#1c1c1c" : config.filledStyle?.borderColor,
-            fillColor: config?.filledStyle?.fillColor === undefined ? fallbackColor(this.#dataType, 1) : config.filledStyle?.fillColor,
+            fillColor: this.#configuredFilledFill === undefined ? fallbackColor(this.#dataType, 1) : this.#configuredFilledFill,
             borderSize: config?.filledStyle?.borderSize === undefined ? 1 : config.filledStyle?.borderSize,
             size: config?.filledStyle?.size === undefined ? 5 : config.filledStyle?.size
         }
@@ -106,9 +175,20 @@ export class Port {
             this.#onConnectionRemoved.push(config?.onConnectionRemoved);
         }
 
+        this.#dataTypePopupElement = this.#buildTooltip();
+    }
+
+    #buildTooltip(): RenderElementBase {
         const containerElements = new Array<RenderElementBase>();
+
         let dataTypeDisplay = this.#dataType;
-        if (config?.array === true) {
+        if (this.#acceptedTypes.length > 1) {
+            dataTypeDisplay = this.#acceptedTypes.join(" or ");
+        }
+        if (dataTypeDisplay === "" && this.#anyType) {
+            dataTypeDisplay = "any";
+        }
+        if (this.#array) {
             dataTypeDisplay = "Array<" + dataTypeDisplay + ">"
         }
         containerElements.push(new TextElement(
@@ -120,10 +200,9 @@ export class Port {
             }
         ));
 
-        const description = config?.description;
-        if (description && description !== "") {
+        if (this.#description !== "") {
             containerElements.push(new TextElement(
-                new Text(description, { color: "white", style: FontStyle.Italic }),
+                new Text(this.#description, { color: "white", style: FontStyle.Italic }),
                 {
                     Align: TextAlign.Center,
                     Padding: { Top: 16 },
@@ -133,7 +212,7 @@ export class Port {
             ));
         }
 
-        this.#dataTypePopupElement = new ContainerRenderElement(
+        return new ContainerRenderElement(
             containerElements,
             {
                 BackgroundColor: "rgba(0, 0, 0, 0.85)",
@@ -145,6 +224,42 @@ export class Port {
         );
     }
 
+    #refreshDataType(): void {
+        if (this.#configuredEmptyFill === undefined) {
+            this.#emptyStyle.fillColor = fallbackColor(this.#dataType, 0.3);
+        }
+        if (this.#configuredFilledFill === undefined) {
+            this.#filledStyle.fillColor = fallbackColor(this.#dataType, 1);
+        }
+        this.#dataTypePopupElement = this.#buildTooltip();
+        requestRender();
+    }
+
+    setDataType(type: string): void {
+        if (this.#dataType === type) {
+            return;
+        }
+        this.#dataType = type;
+        this.#refreshDataType();
+    }
+
+    setAnyType(anyType: boolean): void {
+        if (this.#anyType === anyType) {
+            return;
+        }
+        this.#anyType = anyType;
+        this.#refreshDataType();
+    }
+
+    /**
+     * Scope accepted types to singular type
+     */
+    settleOn(type: string): void {
+        this.#acceptedTypes = [type];
+        this.setDataType(type);
+        this.#refreshDataType();
+    }
+
     addConnection(connection: Connection): void {
         const c = this.#connections.length;
         this.#connections.push(connection);
@@ -195,6 +310,27 @@ export class Port {
         return this.#dataType;
     }
 
+    acceptsAnyType(): boolean {
+        return this.#anyType;
+    }
+
+    /**
+     * Every type this port takes. Empty means it takes anything.
+     */
+    acceptedTypes(): Array<string> {
+        if (this.#anyType) {
+            return [];
+        }
+        if (this.#acceptedTypes.length > 0) {
+            return this.#acceptedTypes;
+        }
+        return [this.#dataType];
+    }
+
+    setAcceptedTypes(types: Array<string>): void {
+        this.#acceptedTypes = types;
+    }
+
     getPortType(): PortType {
         return this.#portType;
     }

package/src/render_scheduler.ts

@@ -0,0 +1,49 @@
+type Redraw = () => void;
+
+const subscribers = new Set<Redraw>();
+let frameQueued = false;
+let continuous = 0;
+
+const canSchedule = (): boolean =>
+    typeof requestAnimationFrame === "function";
+
+export function onRenderRequested(redraw: Redraw): () => void {
+    subscribers.add(redraw);
+    return () => {
+        subscribers.delete(redraw);
+    };
+}
+
+
+export function requestRender(): void {
+    if (frameQueued || !canSchedule()) {
+        return;
+    }
+
+    frameQueued = true;
+    requestAnimationFrame(() => {
+        frameQueued = false;
+        subscribers.forEach((redraw) => redraw());
+
+        // Something asked to be redrawn every frame, so keep the loop
+        // alive by asking again on its behalf.
+        if (continuous > 0) {
+            requestRender();
+        }
+    });
+}
+
+
+export function renderContinuously(): () => void {
+    continuous++;
+    requestRender();
+
+    let released = false;
+    return () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        continuous--;
+    };
+}

package/src/styles/text.ts

@@ -65,6 +65,14 @@ export class TextStyle {
         return this.#font;
     }
 
+    getWeight(): FontWeight {
+        return this.#weight;
+    }
+
+    getStyle(): FontStyle {
+        return this.#fontStyle;
+    }
+
     measure(ctx: CanvasRenderingContext2D, scale: number, text: string, out: Vector2): void {
         this.setupStyle(ctx, scale);
         const measurements = ctx.measureText(text)

package/src/theme.ts

@@ -59,6 +59,14 @@ export const Theme = {
         FontColor: "#afb9bb",
         DisabledFontColor: "#4a585c",
     },
+    Minimap: {
+        BackgroundColor: "rgba(7, 33, 42, 0.85)",
+        BorderColor: "#1c1c1c",
+        BorderRadius: 4,
+        Padding: 6,
+        NodeColor: "#6b7f85",
+        ViewportColor: "rgba(175, 185, 187, 0.25)",
+    },
     Note: {
         FontColor: "#afb9bb",
         FontSize: 16,

package/src/types/text.ts

@@ -1,3 +1,4 @@
+import { requestRender } from "../render_scheduler";
 import { FontWeight, TextStyle, TextStyleConfig } from "../styles/text";
 import { splitString, splitStringIntoLines } from "../utils/string";
 import { CopyVector2, ScaleVector, Vector2, Zero } from "./vector2";
@@ -32,10 +33,13 @@ export class Text {
         this.#lineSpacing = config?.LineSpacing ? config?.LineSpacing : 5;
         this.#textToRender = [value];
 
-        if (!document.fonts.check(`16px "${this.#style.getFont()}"`)) {
-            document.fonts.addEventListener("loadingdone", (event) => {
-                this.#measured = false;
-            });
+        if (typeof document !== "undefined" && document.fonts !== undefined) {
+            if (!document.fonts.check(`16px "${this.#style.getFont()}"`)) {
+                document.fonts.addEventListener("loadingdone", () => {
+                    this.#measured = false;
+                    requestRender();
+                });
+            }
         }
     }
 

package/src/utils/string.ts

@@ -1,4 +1,10 @@
-const binarySearch = ({ max, getValue, match }) => {
+interface BinarySearch {
+    max: number;
+    getValue: (guess: number) => number;
+    match: number;
+}
+
+const binarySearch = ({ max, getValue, match }: BinarySearch): number => {
     let min = 0;
 
     while (min <= max) {

package/src/widgets/color.ts

@@ -2,7 +2,7 @@ import { HexToColor } from "../utils/color";
 import { TextStyleConfig } from "../styles/text";
 import { Box } from "../types/box";
 import { CopyVector2, Vector2 } from "../types/vector2";
-import { height, width } from "./widget";
+import { height, startingWidgetValue, width } from "./widget";
 import { Popup } from "../popup";
 import { TextBoxStyle } from '../styles/textBox';
 import { Theme } from "../theme";
@@ -46,12 +46,12 @@ export class ColorWidget {
     #callback?: (newColor: string) => void;
 
     constructor(node: FlowNode, config?: ColorWidgetConfig) {
-        this.#value = "#000000"
-        this.#contrast = contrastColor(this.#value);
-        this.Set(config?.value === undefined ? "#000000" : config?.value);
-        
         this.#node = node;
         this.#nodeProperty = config?.property;
+        this.#callback = config?.callback;
+
+        this.#value = startingWidgetValue(node, this.#nodeProperty, config?.value, "#000000");
+        this.#contrast = contrastColor(this.#value);
         this.#textBoxStyle = new TextBoxStyle({
             box: {
                 color: this.#value,
@@ -62,7 +62,6 @@ export class ColorWidget {
             },
             text: config?.textStyle
         });
-        this.#callback = config?.callback;
 
         if (this.#nodeProperty !== undefined) {
             this.#node.addPropertyChangeListener(this.#nodeProperty, (oldVal, newVal) => {

package/src/widgets/factory.ts

@@ -11,7 +11,7 @@ import { TextWidget, TextWidgetConfig } from "./text";
 
 export type WidgetBuilder = (node: FlowNode, confg?: any) => Widget;
 
-class WidgetFactory {
+export class WidgetFactory {
 
     #registeredWidgets: Map<string, WidgetBuilder>
 

package/src/widgets/image.ts

@@ -1,3 +1,4 @@
+import { requestRender } from "../render_scheduler";
 import { Box } from "../types/box";
 import { CopyVector2, Vector2 } from "../types/vector2";
 
@@ -101,6 +102,7 @@ export class ImageWidget {
         img.src = url;
         img.onload = () => {
             this.#image = img;
+            requestRender();
         };
         img.onerror = (event) => {
             console.log("error loading image:", url, event);

package/src/widgets/number.ts

@@ -3,7 +3,7 @@ import { Popup } from "../popup";
 import { TextBoxStyle, TextBoxStyleConfig, TextBoxStyleWithFallback } from "../styles/textBox";
 import { Box, InBox } from '../types/box';
 import { CopyVector2, Vector2 } from "../types/vector2";
-import { height, width } from "./widget";
+import { height, startingWidgetValue, width } from "./widget";
 import { FlowNode } from "../node";
 
 export interface NumberWidgetConfig {
@@ -62,8 +62,8 @@ export class NumberWidget {
             },
             text: { color: Theme.Widget.FontColor },
         }));
-        this.Set(config?.value === undefined ? 0 : config?.value);
         this.#callback = config?.callback;
+        this.Set(startingWidgetValue(node, this.#nodeProperty, config?.value, 0));
 
         if (this.#nodeProperty !== undefined) {
             this.#node.addPropertyChangeListener(this.#nodeProperty, (oldVal, newVal) => {

package/src/widgets/slider.ts

@@ -4,7 +4,7 @@ import { TextStyle, TextStyleConfig, TextStyleFallback } from "../styles/text";
 import { Box } from '../types/box';
 import { CopyVector2, Vector2, Zero } from "../types/vector2";
 import { Clamp, Clamp01 } from "../utils/math";
-import { height, width } from "./widget";
+import { height, startingWidgetValue, width } from "./widget";
 import { TextBaseline } from "../styles/canvasTextBaseline";
 import { FlowNode } from "../node";
 
@@ -104,7 +104,7 @@ export class SliderWidget {
             });
         }
 
-        this.SetValue(config?.value === undefined ? 0 : config?.value);
+        this.SetValue(startingWidgetValue(node, this.#nodeProperty, config?.value, 0));
 
         // Setup change callback after we set the initial value to prevent the callback from being 
         this.#change = config?.change;

package/src/widgets/string.ts

@@ -3,7 +3,7 @@ import { TextBoxStyle, TextBoxStyleConfig, TextBoxStyleWithFallback } from "../s
 import { Box, InBox } from "../types/box";
 import { CopyVector2, Vector2 } from "../types/vector2";
 import { fitString } from "../utils/string";
-import { height, width } from "./widget";
+import { height, startingWidgetValue, width } from "./widget";
 import { FlowNode } from '../node';
 import { SetStringPopup } from "../popups/string";
 
@@ -60,8 +60,8 @@ export class StringWidget {
             text: { color: Theme.Widget.FontColor },
         }));
 
-        this.Set(config?.value === undefined ? "" : config?.value);
         this.#callback = config?.callback;
+        this.Set(startingWidgetValue(node, this.#nodeProperty, config?.value, ""));
         if (this.#nodeProperty !== undefined) {
             this.#node.addPropertyChangeListener(this.#nodeProperty, (oldVal, newVal) => {
                 this.Set(newVal);

package/src/widgets/toggle.ts

@@ -1,7 +1,7 @@
 import { Theme } from "../theme";
 import { Box, InBox } from "../types/box";
 import { CopyVector2, Vector2 } from "../types/vector2";
-import { height, width } from "./widget";
+import { height, startingWidgetValue, width } from "./widget";
 import { TextBoxStyle, TextBoxStyleConfig, TextBoxStyleWithFallback } from "../styles/textBox";
 import { FlowNode } from "../node";
 
@@ -159,8 +159,8 @@ export class ToggleWidget {
             lightColor: config?.disabledStyle?.lightColor === undefined ? "#004400" : config?.enabledStyle?.lightColor,
         });
 
-        this.Set(config?.value === undefined ? false : config?.value);
         this.#callback = config?.callback;
+        this.Set(startingWidgetValue(node, this.#nodeProperty, config?.value, false));
         if (this.#nodeProperty !== undefined) {
             this.#node.addPropertyChangeListener(this.#nodeProperty, (oldVal, newVal) => {
                 this.Set(newVal);

package/src/widgets/widget.ts

@@ -9,4 +9,26 @@ export interface Widget {
     Draw(ctx: CanvasRenderingContext2D, position: Vector2, scale: number, mousePosition: Vector2 | undefined): Box
     ClickStart(): void
     ClickEnd(): void
+}
+
+interface PropertyReader {
+    getProperty(name: string): any;
+}
+
+export function startingWidgetValue<T>(
+    node: PropertyReader,
+    property: string | undefined,
+    configured: T | undefined,
+    fallback: T,
+): T {
+    if (configured !== undefined) {
+        return configured;
+    }
+    if (property !== undefined && property !== null) {
+        const existing = node.getProperty(property);
+        if (existing !== undefined && existing !== null) {
+            return existing as T;
+        }
+    }
+    return fallback;
 }

package/test/markdown.test.ts

@@ -0,0 +1,165 @@
+import * as assert from 'assert';
+import { BuildMarkdown } from '../src/markdown/markdown';
+import { BasicMarkdownEntry, CodeBlockEntry, UnorderedListMarkdownEntry } from '../src/markdown/entry';
+import { FontStyle, FontWeight } from '../src/styles/text';
+import { Text } from '../src/types/text';
+
+/** The runs of text in an entry, as [content, weight, style] triples. */
+function runs(entry: any): Array<[string, FontWeight, FontStyle]> {
+    let lines: ReadonlyArray<Text>;
+    if (entry.entries) {
+        lines = entry.entries().flatMap((item: any) => item.lines());
+    } else if (entry.lines) {
+        lines = entry.lines();
+    } else {
+        lines = [entry.text()];
+    }
+    return lines.map(line => [
+        line.get(),
+        line.style().getWeight(),
+        line.style().getStyle(),
+    ] as [string, FontWeight, FontStyle]);
+}
+
+function contentOf(entry: any): string {
+    return runs(entry).map(r => r[0]).join('');
+}
+
+describe('markdown: paragraphs and headers', () => {
+    it('reads a plain line', () => {
+        const entries = BuildMarkdown('hello world');
+        assert.strictEqual(entries.length, 1);
+        assert.strictEqual(contentOf(entries[0]), 'hello world');
+    });
+
+    it('reads each header level', () => {
+        const entries = BuildMarkdown('# one\n## two\n### three');
+        assert.strictEqual(entries.length, 3);
+        assert.strictEqual(contentOf(entries[0]), 'one');
+        assert.strictEqual(contentOf(entries[1]), 'two');
+        assert.strictEqual(contentOf(entries[2]), 'three');
+    });
+
+    it('keeps a # that is not at the start of a line as text', () => {
+        const entries = BuildMarkdown('issue #42 filed');
+        assert.strictEqual(contentOf(entries[0]), 'issue #42 filed');
+    });
+});
+
+describe('markdown: emphasis', () => {
+    it('italicises a single-starred run', () => {
+        const entries = BuildMarkdown('*hello*');
+        assert.deepStrictEqual(runs(entries[0]), [['hello', FontWeight.Normal, FontStyle.Italic]]);
+    });
+
+    it('bolds a double-starred run', () => {
+        const entries = BuildMarkdown('**hello**');
+        assert.deepStrictEqual(runs(entries[0]), [['hello', FontWeight.Bold, FontStyle.Normal]]);
+    });
+
+    it('emphasises a run in the middle of a line', () => {
+        const entries = BuildMarkdown('a *b* c');
+        assert.deepStrictEqual(runs(entries[0]), [
+            ['a ', FontWeight.Normal, FontStyle.Normal],
+            ['b', FontWeight.Normal, FontStyle.Italic],
+            [' c', FontWeight.Normal, FontStyle.Normal],
+        ]);
+    });
+
+    it('leaves a star surrounded by spaces alone', () => {
+        const entries = BuildMarkdown('2 * 3 * 4');
+        assert.strictEqual(contentOf(entries[0]), '2 * 3 * 4');
+    });
+
+    it('keeps stars that never matched as text', () => {
+        assert.strictEqual(contentOf(BuildMarkdown('*unclosed')[0]), '*unclosed');
+        assert.strictEqual(contentOf(BuildMarkdown('a * b')[0]), 'a * b');
+    });
+
+    it('keeps the stars left over when the runs are uneven', () => {
+        // Two opened, one closed: the extra opener is just a character.
+        assert.deepStrictEqual(runs(BuildMarkdown('**a*')[0]), [
+            ['*', FontWeight.Normal, FontStyle.Normal],
+            ['a', FontWeight.Normal, FontStyle.Italic],
+        ]);
+        assert.deepStrictEqual(runs(BuildMarkdown('*a**')[0]), [
+            ['a', FontWeight.Normal, FontStyle.Italic],
+            ['*', FontWeight.Normal, FontStyle.Normal],
+        ]);
+    });
+
+    it('does not emphasise across a space held against the stars', () => {
+        assert.strictEqual(contentOf(BuildMarkdown('** a **')[0]), '** a **');
+        assert.strictEqual(contentOf(BuildMarkdown('**a **')[0]), '**a **');
+    });
+
+    it('emphasises a run holding a space in the middle', () => {
+        assert.deepStrictEqual(runs(BuildMarkdown('**a f**')[0]), [
+            ['a f', FontWeight.Bold, FontStyle.Normal],
+        ]);
+    });
+
+    it('never produces an empty run', () => {
+        for (const source of ['*a*', '**a**', '*a**', '**a*', '* a *', 'a `b` c']) {
+            for (const [content] of runs(BuildMarkdown(source)[0])) {
+                assert.notStrictEqual(content, '', `${source} produced an empty run`);
+            }
+        }
+    });
+
+    it('emphasises more than one run on a line', () => {
+        const entries = BuildMarkdown('*a* and *b*');
+        assert.deepStrictEqual(runs(entries[0]), [
+            ['a', FontWeight.Normal, FontStyle.Italic],
+            [' and ', FontWeight.Normal, FontStyle.Normal],
+            ['b', FontWeight.Normal, FontStyle.Italic],
+        ]);
+    });
+});
+
+describe('markdown: lists', () => {
+    it('collects consecutive star lines into one list', () => {
+        const entries = BuildMarkdown('* one\n* two\n* three');
+        assert.strictEqual(entries.length, 1);
+        assert.ok(entries[0] instanceof UnorderedListMarkdownEntry);
+        assert.strictEqual((entries[0] as any).entries().length, 3);
+    });
+
+    it('ends the list at the first line that is not one', () => {
+        const entries = BuildMarkdown('* one\n* two\nafter');
+        assert.strictEqual(entries.length, 2);
+        assert.ok(entries[0] instanceof UnorderedListMarkdownEntry);
+        assert.strictEqual(contentOf(entries[1]), 'after');
+    });
+});
+
+describe('markdown: code', () => {
+    it('sets inline code apart without keeping the backticks', () => {
+        const entry = BuildMarkdown('a `b` c')[0] as any;
+        assert.deepStrictEqual(runs(entry).map(r => r[0]), ['a ', 'b', ' c']);
+        assert.strictEqual(entry.lines()[1].style().getFont(), 'monospace');
+        assert.notStrictEqual(entry.lines()[0].style().getFont(), 'monospace');
+    });
+
+    it('keeps a lone backtick as text', () => {
+        assert.strictEqual(contentOf(BuildMarkdown('a ` b')[0]), 'a ` b');
+    });
+
+    it('keeps a fenced block verbatim', () => {
+        const entries = BuildMarkdown('```\nlet a = *b*;\n```');
+        assert.strictEqual(entries.length, 1);
+        assert.ok(entries[0] instanceof CodeBlockEntry, `got ${entries[0].constructor.name}`);
+        assert.strictEqual(contentOf(entries[0]), 'let a = *b*;\n');
+    });
+
+    it('keeps more than one line of a fenced block', () => {
+        const entries = BuildMarkdown('```\none\ntwo\n```');
+        assert.strictEqual(contentOf(entries[0]), 'one\ntwo\n');
+    });
+
+    it('carries on after a fenced block', () => {
+        const entries = BuildMarkdown('```\ncode\n```\nafter');
+        assert.strictEqual(entries.length, 2);
+        assert.strictEqual(contentOf(entries[1]), 'after');
+    });
+});