Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

git clone https://repo.autonoma.ca/repo/keenwrite.git

M build.gradle

 test {
   useJUnitPlatform()
   testLogging {
     exceptionFormat = 'full'
+  }
+}

M docs/diagram.yaml

   classes:
     processors:
       markdown: "MarkdownProcessor"
       markdown: MarkdownProcessor
       variable:
         definition: "DefinitionProcessor"
       preview: "PreviewProcessor"
         definition: DefinitionProcessor
       preview: PreviewProcessor
   palette:
     primary:
       light: "#51a9cf"
       dark: "#126d95"
       light: '#51a9cf'
       dark: '#126d95'
     secondary:
       light: "#ec706a"
       dark: "#7e252f"
       light: '#ec706a'
       dark: '#7e252f'
     accent:
       light: "#76A786"
       dark: "#385742"
       light: '#76A786'
       dark: '#385742'
     grayscale:
       light: "#bac2c5"
       dark: "#394343"
       light: '#bac2c5'
       dark: '#394343'
   graph:
     label:
       chain:
         next: "successor"
         next: successor

M src/main/java/com/keenwrite/Bootstrap.java

  * </p>
  */
 public class Bootstrap {
 public final class Bootstrap {
   private static final Properties BOOTSTRAP = new Properties();

M src/main/java/com/keenwrite/Caret.java

    * within the text. Typically this will include the current line number,
    * the number of lines, and the character offset into the text.
    * <p>
    * If the {@link Caret} has not been properly built, this will return a
    * string for the status bar having all values set to zero. This can happen
    * during unit testing, but should not happen any other time.
    * </p>
+   *
    * @return A string to present to an end user.
    */
   @Override
   public String toString() {
     return get( STATUS_BAR_LINE,
                 getParagraph() + 1,
                 getParagraphCount(),
                 getTextOffset() + 1 );
     try {
       return get( STATUS_BAR_LINE,
                   getParagraph() + 1,
                   getParagraphCount(),
                   getTextOffset() + 1 );
     } catch( final NullPointerException ex ) {
       return get( STATUS_BAR_LINE, 0, 0, 0 );
+    }
+  }
+}

M src/main/java/com/keenwrite/Constants.java

  * Defines application-wide default values.
  */
 public class Constants {
 public final class Constants {
   /**

M src/main/java/com/keenwrite/DefinitionNameInjector.java

+          }
           else {
             editor.replaceText( indexes, operator.entoken( leaf.toPath() ) );
             final var entokened = operator.entoken( leaf.toPath() );
             editor.replaceText( indexes, operator.apply( entokened ) );
             definitions.expand( leaf );
+          }
    * @param word Match the word by: exact, beginning, containment, or other.
    */
   @SuppressWarnings("ConstantConditions")
   @SuppressWarnings( "ConstantConditions" )
   private static DefinitionTreeItem<String> findLeaf(
     final TextDefinition definition, final String word ) {

M src/main/java/com/keenwrite/ExportFormat.java

   /**
    * For HTML exports, encode TeX as SVG.
    * For HTML exports, encode TeX as SVG. Treat image links relatively.
    */
   HTML_TEX_SVG( ".html" ),
   /**
    * For HTML exports, encode TeX using {@code $} delimiters, suitable for
    * rendering by an external TeX typesetting engine (or online with KaTeX).
    * Treat image links relatively.
    */
   HTML_TEX_DELIMITED( ".html" ),
   /**
    * Indicates that the processors should export to a Markdown format.
    * Treat image links relatively.
    */
   MARKDOWN_PLAIN( ".out.md" ),
   /**
    * Indicates no special export format is to be created. No extension is
    * applicable.
    * applicable. Image links must use absolute directories.
    */
   NONE( "" );

M src/main/java/com/keenwrite/Launcher.java

  * </p>
  */
 public class Launcher {
 public final class Launcher {
   /**
    * Delegates to the application entry point.

M src/main/java/com/keenwrite/MainPane.java

   public ProcessorContext createProcessorContext() {
     return createProcessorContext( NONE );
+  }
   public ProcessorContext createProcessorContext( final ExportFormat format ) {
     final var editor = getActiveTextEditor();
     return createProcessorContext( editor.getPath(), editor.getCaret() );
     return createProcessorContext(
       editor.getPath(), editor.getCaret(), format );
+  }
    */
   private ProcessorContext createProcessorContext(
     final Path path, final Caret caret ) {
     final Path path, final Caret caret, final ExportFormat format ) {
     return new ProcessorContext(
       mHtmlPreview, mResolvedMap, path, caret, NONE, mWorkspace
       mHtmlPreview, mResolvedMap, path, caret, format, mWorkspace
     );
+  }
     final var editor = new MarkdownEditor( file, getWorkspace() );
     final var caret = editor.getCaret();
     final var context = createProcessorContext( path, caret );
     final var context = createProcessorContext( path, caret, NONE );
     mProcessors.computeIfAbsent( editor, p -> createProcessors( context ) );

M src/main/java/com/keenwrite/MainScene.java

  * Responsible for creating the bar scene: menu bar, tool bar, and status bar.
  */
 public class MainScene {
 public final class MainScene {
   private final Scene mScene;
   private final Node mMenuBar;

M src/main/java/com/keenwrite/Messages.java

  * properties using a <code>${var}</code> syntax.
  */
 public class Messages {
 public final class Messages {
   private static final ResourceBundle RESOURCE_BUNDLE =

M src/main/java/com/keenwrite/StatusNotifier.java

  * class can go away.
  */
 public class StatusNotifier {
 public final class StatusNotifier {
   private static final String OK = get( STATUS_BAR_OK, "OK" );

M src/main/java/com/keenwrite/editors/definition/DefinitionEditor.java

    * Constructs a definition pane with a given tree view root.
+   *
    * @param file The file to
    * @param file The file of definitions to maintain through the UI.
    */
   public DefinitionEditor(

M src/main/java/com/keenwrite/editors/definition/DefinitionTabSceneFactory.java

  * @author White Magic Software, Ltd.
  */
 public class DefinitionTabSceneFactory {
 public final class DefinitionTabSceneFactory {
   private final Consumer<Tab> mTabSelectionConsumer;

M src/main/java/com/keenwrite/editors/definition/TreeCellFactory.java

  * and respond to drag and drop functionality.
  */
 public class TreeCellFactory
 public final class TreeCellFactory
     implements Callback<TreeView<String>, TreeCell<String>> {
   private static final String STYLE_CLASS_DROP_TARGET = "drop-target";

M src/main/java/com/keenwrite/editors/definition/TreeItemMapper.java

  * </p>
  */
 public class TreeItemMapper {
 public final class TreeItemMapper {
   /**
    * Separates definition keys (e.g., the dots in {@code $root.node.var$}).

M src/main/java/com/keenwrite/editors/definition/TreeTransformer.java

 import javafx.scene.control.TreeItem;
 import java.util.function.Consumer;
 import java.util.function.Function;
 /**
  * Responsible for converting an object hierarchy into a {@link TreeItem}

D src/main/java/com/keenwrite/editors/definition/yaml/YamlParser.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.editors.definition.yaml;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
 import java.util.function.Function;
 /**
  * Responsible for reading a YAML document into an object hierarchy.
  */
 class YamlParser implements Function<String, JsonNode> {
   /**
    * Creates a new instance that can parse the contents of a YAML
    * document.
    */
   YamlParser() {
+  }
   @Override
   public JsonNode apply( final String yaml ) {
     try {
       return new ObjectMapper( new YAMLFactory() ).readTree( yaml );
     } catch( final Exception ex ) {
       // Ensure that a document root node exists.
       return new ObjectMapper().createObjectNode();
+    }
+  }
+}

M src/main/java/com/keenwrite/editors/definition/yaml/YamlTreeTransformer.java

 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ObjectNode;
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;
 import com.fasterxml.jackson.dataformat.yaml.YAMLMapper;
 import com.keenwrite.editors.definition.DefinitionTreeItem;
 import com.keenwrite.editors.definition.TreeTransformer;
 import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeView;
 import java.util.Map.Entry;
 import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.MINIMIZE_QUOTES;
 import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.SPLIT_LINES;
 /**
  * Transforms a JsonNode hierarchy into a tree that can be displayed in a user
  * interface and vice-versa.
  */
 public final class YamlTreeTransformer implements TreeTransformer {
   private static final YAMLFactory sFactory;
   private static final YAMLMapper sMapper;
   static {
     sFactory = new YAMLFactory();
     sFactory.configure( MINIMIZE_QUOTES, true );
     sFactory.configure( SPLIT_LINES, false );
     sMapper = new YAMLMapper( sFactory );
+  }
   /**
   public String transform( final TreeItem<String> treeItem ) {
     try {
       final YAMLMapper mapper = new YAMLMapper();
       final ObjectNode root = mapper.createObjectNode();
       final var root = sMapper.createObjectNode();
       // Iterate over the root item's children. The root item is used by the
       // application to ensure definitions can always be added to a tree, as
       // such it is not meant to be exported, only its children.
       for( final TreeItem<String> child : treeItem.getChildren() ) {
       for( final var child : treeItem.getChildren() ) {
         transform( child, root );
+      }
       return mapper.writeValueAsString( root );
       return sMapper.writeValueAsString( root );
     } catch( final Exception ex ) {
       throw new RuntimeException( ex );
+    }
+  }
   /**
    * Converts a YAML document to a {@link TreeItem} based on the document
    * keys.
+   *
    * @param document The YAML document to convert to a hierarchy of
    *                 {@link TreeItem} instances.
    * @throws StackOverflowError If infinite recursion is encountered.
    */
   @Override
   public TreeItem<String> transform( final String document ) {
     final var jsonNode = toJson( document );
     final var rootItem = createTreeItem( "root" );
     transform( jsonNode, rootItem );
     return rootItem;
+  }
   private JsonNode toJson( final String yaml ) {
     try {
       return new ObjectMapper( sFactory ).readTree( yaml );
     } catch( final Exception ex ) {
       // Ensure that a document root node exists.
       return new ObjectMapper().createObjectNode();
+    }
+  }
+      }
+    }
+  }
   /**
    * Converts a YAML document to a {@link TreeItem} based on the document
    * keys.
+   *
    * @param document The YAML document to convert to a hierarchy of
    *                 {@link TreeItem} instances.
    * @throws StackOverflowError If infinite recursion is encountered.
    */
   @Override
   public TreeItem<String> transform( final String document ) {
     final var parser = new YamlParser();
     final var jsonNode = parser.apply( document );
     final var rootItem = createTreeItem( "root" );
     transform( jsonNode, rootItem );
     return rootItem;
+  }
    */
   private void transform(
       final Entry<String, JsonNode> node, final TreeItem<String> item ) {
     final Entry<String, JsonNode> node, final TreeItem<String> item ) {
     final var leafNode = node.getValue();
     final var key = node.getKey();

M src/main/java/com/keenwrite/editors/markdown/HyperlinkModel.java

  * Represents the model for a hyperlink: text, url, and title.
  */
 public class HyperlinkModel {
 public final class HyperlinkModel {
   private String text;

M src/main/java/com/keenwrite/editors/markdown/LinkVisitor.java

  * can edit the link within a dialog.
  */
 public class LinkVisitor {
 public final class LinkVisitor {
   private NodeVisitor mVisitor;

M src/main/java/com/keenwrite/editors/markdown/MarkdownEditor.java

  * Responsible for editing Markdown documents.
  */
 public class MarkdownEditor extends BorderPane implements TextEditor {
 public final class MarkdownEditor extends BorderPane implements TextEditor {
   /**
    * Regular expression that matches the type of markup block. This is used

M src/main/java/com/keenwrite/exceptions/MissingFileException.java

  * This avoids duplicating the error message prefix.
  */
 public class MissingFileException extends FileNotFoundException {
 public final class MissingFileException extends FileNotFoundException {
   /**
    * Constructs a new {@link MissingFileException} using the given path.

M src/main/java/com/keenwrite/io/HttpMediaType.java

  * an HTTP request.
  */
 public class HttpMediaType {
 public final class HttpMediaType {
   private final static HttpClient HTTP_CLIENT = HttpClient

M src/main/java/com/keenwrite/predicates/PredicateFactory.java

  * of string comparisons, including basic strings and file name strings.
  */
 public class PredicateFactory {
 public final class PredicateFactory {
   /**
    * Creates an instance of {@link Predicate} that matches a globbed file

M src/main/java/com/keenwrite/preferences/FileProperty.java

 import java.io.File;
 public class FileProperty extends SimpleObjectProperty<File> {
 public final class FileProperty extends SimpleObjectProperty<File> {
   public FileProperty( final File file ) {
     super( file );

M src/main/java/com/keenwrite/preferences/LocaleProperty.java

 import static java.util.Locale.forLanguageTag;
 public class LocaleProperty extends SimpleObjectProperty<String> {
 public final class LocaleProperty extends SimpleObjectProperty<String> {
   /**

M src/main/java/com/keenwrite/preferences/LocaleScripts.java

  * using the same format.
  */
 public class LocaleScripts {
 public final class LocaleScripts {
   /**
    * ISO 15924 alpha-4 script code to represent Latin scripts.

M src/main/java/com/keenwrite/preferences/PreferencesController.java

  */
 @SuppressWarnings( "SameParameterValue" )
 public class PreferencesController {
 public final class PreferencesController {
   private final Workspace mWorkspace;

M src/main/java/com/keenwrite/preferences/Workspace.java

  * </dl>
  */
 public class Workspace {
   private static final Key KEY_ROOT = key( "workspace" );
   public static final Key KEY_META = key( KEY_ROOT, "meta" );
   public static final Key KEY_META_NAME = key( KEY_META, "name" );
   public static final Key KEY_META_VERSION = key( KEY_META, "version" );
   public static final Key KEY_R = key( KEY_ROOT, "r" );
   public static final Key KEY_R_SCRIPT = key( KEY_R, "script" );
   public static final Key KEY_R_DIR = key( KEY_R, "dir" );
   public static final Key KEY_R_DELIM = key( KEY_R, "delimiter" );
   public static final Key KEY_R_DELIM_BEGAN = key( KEY_R_DELIM, "began" );
   public static final Key KEY_R_DELIM_ENDED = key( KEY_R_DELIM, "ended" );
   public static final Key KEY_IMAGES = key( KEY_ROOT, "images" );
   public static final Key KEY_IMAGES_DIR = key( KEY_IMAGES, "dir" );
   public static final Key KEY_IMAGES_ORDER = key( KEY_IMAGES, "order" );
   public static final Key KEY_DEF = key( KEY_ROOT, "definition" );
   public static final Key KEY_DEF_PATH = key( KEY_DEF, "path" );
   public static final Key KEY_DEF_DELIM = key( KEY_DEF, "delimiter" );
   public static final Key KEY_DEF_DELIM_BEGAN = key( KEY_DEF_DELIM, "began" );
   public static final Key KEY_DEF_DELIM_ENDED = key( KEY_DEF_DELIM, "ended" );
   //@formatter:off
   public static final Key KEY_UI = key( KEY_ROOT, "ui" );
   public static final Key KEY_UI_RECENT = key( KEY_UI, "recent" );
   public static final Key KEY_UI_RECENT_DIR = key( KEY_UI_RECENT, "dir" );
   public static final Key KEY_UI_RECENT_DOCUMENT = key( KEY_UI_RECENT,"document" );
   public static final Key KEY_UI_RECENT_DEFINITION = key( KEY_UI_RECENT, "definition" );
   public static final Key KEY_UI_FILES = key( KEY_UI, "files" );
   public static final Key KEY_UI_FILES_PATH = key( KEY_UI_FILES, "path" );
   public static final Key KEY_UI_FONT = key( KEY_UI, "font" );
   public static final Key KEY_UI_FONT_EDITOR = key( KEY_UI_FONT, "editor" );
   public static final Key KEY_UI_FONT_EDITOR_NAME = key( KEY_UI_FONT_EDITOR, "name" );
   public static final Key KEY_UI_FONT_EDITOR_SIZE = key( KEY_UI_FONT_EDITOR, "size" );
   public static final Key KEY_UI_FONT_PREVIEW = key( KEY_UI_FONT, "preview" );
   public static final Key KEY_UI_FONT_PREVIEW_NAME = key( KEY_UI_FONT_PREVIEW, "name" );
   public static final Key KEY_UI_FONT_PREVIEW_SIZE = key( KEY_UI_FONT_PREVIEW, "size" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO = key( KEY_UI_FONT_PREVIEW, "mono" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO_NAME = key( KEY_UI_FONT_PREVIEW_MONO, "name" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO_SIZE = key( KEY_UI_FONT_PREVIEW_MONO, "size" );
   public static final Key KEY_LANGUAGE = key( KEY_ROOT, "language" );
   public static final Key KEY_LANG_LOCALE = key( KEY_LANGUAGE, "locale" );
   public static final Key KEY_UI_WINDOW = key( KEY_UI, "window" );
   public static final Key KEY_UI_WINDOW_X = key( KEY_UI_WINDOW, "x" );
   public static final Key KEY_UI_WINDOW_Y = key( KEY_UI_WINDOW, "y" );
   public static final Key KEY_UI_WINDOW_W = key( KEY_UI_WINDOW, "width" );
   public static final Key KEY_UI_WINDOW_H = key( KEY_UI_WINDOW, "height" );
   public static final Key KEY_UI_WINDOW_MAX = key( KEY_UI_WINDOW, "maximized" );
   public static final Key KEY_UI_WINDOW_FULL = key( KEY_UI_WINDOW, "full" );
   private final Map<Key, Property<?>> VALUES = Map.ofEntries(
     entry( KEY_META_VERSION, asStringProperty( getVersion() ) ),
     entry( KEY_META_NAME, asStringProperty( "default" ) ),
     entry( KEY_R_SCRIPT, asStringProperty( "" ) ),
     entry( KEY_R_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_R_DELIM_BEGAN, asStringProperty( R_DELIM_BEGAN_DEFAULT ) ),
     entry( KEY_R_DELIM_ENDED, asStringProperty( R_DELIM_ENDED_DEFAULT ) ),
     entry( KEY_IMAGES_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_IMAGES_ORDER, asStringProperty( PERSIST_IMAGES_DEFAULT ) ),
     entry( KEY_DEF_PATH, asFileProperty( DEFINITION_DEFAULT ) ),
     entry( KEY_DEF_DELIM_BEGAN, asStringProperty( DEF_DELIM_BEGAN_DEFAULT ) ),
     entry( KEY_DEF_DELIM_ENDED, asStringProperty( DEF_DELIM_ENDED_DEFAULT ) ),
     entry( KEY_UI_RECENT_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_UI_RECENT_DOCUMENT, asFileProperty( DOCUMENT_DEFAULT ) ),
     entry( KEY_UI_RECENT_DEFINITION, asFileProperty( DEFINITION_DEFAULT ) ),
     entry( KEY_LANG_LOCALE, asLocaleProperty( LOCALE_DEFAULT ) ),
     entry( KEY_UI_FONT_EDITOR_NAME, asStringProperty( FONT_NAME_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_EDITOR_SIZE, asDoubleProperty( FONT_SIZE_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_NAME, asStringProperty( FONT_NAME_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_NAME, asStringProperty( FONT_NAME_PREVIEW_MONO_NAME_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_MONO_SIZE_DEFAULT ) ),
     entry( KEY_UI_WINDOW_X, asDoubleProperty( WINDOW_X_DEFAULT ) ),
     entry( KEY_UI_WINDOW_Y, asDoubleProperty( WINDOW_Y_DEFAULT ) ),
     entry( KEY_UI_WINDOW_W, asDoubleProperty( WINDOW_W_DEFAULT ) ),
     entry( KEY_UI_WINDOW_H, asDoubleProperty( WINDOW_H_DEFAULT ) ),
     entry( KEY_UI_WINDOW_MAX, asBooleanProperty() ),
     entry( KEY_UI_WINDOW_FULL, asBooleanProperty() )
   );
   //@formatter:on
   private StringProperty asStringProperty( final String defaultValue ) {
     return new SimpleStringProperty( defaultValue );
+  }
   private DoubleProperty asDoubleProperty( final double defaultValue ) {
     return new SimpleDoubleProperty( defaultValue );
+  }
   private BooleanProperty asBooleanProperty() {
     return new SimpleBooleanProperty();
+  }
   private FileProperty asFileProperty( final File defaultValue ) {
     return new FileProperty( defaultValue );
+  }
   @SuppressWarnings( "SameParameterValue" )
   private LocaleProperty asLocaleProperty( final Locale defaultValue ) {
     return new LocaleProperty( defaultValue );
+  }
   /**
    * Helps instantiate {@link Property} instances for XML configuration items.
    */
   private static final Map<Class<?>, Function<String, Object>> UNMARSHALL =
     Map.of(
       LocaleProperty.class, LocaleProperty::parseLocale,
       SimpleBooleanProperty.class, Boolean::parseBoolean,
       SimpleDoubleProperty.class, Double::parseDouble,
       SimpleFloatProperty.class, Float::parseFloat,
       FileProperty.class, File::new
     );
   private static final Map<Class<?>, Function<String, Object>> MARSHALL =
     Map.of(
       LocaleProperty.class, LocaleProperty::toLanguageTag
     );
   private final Map<Key, SetProperty<?>> SETS = Map.ofEntries(
     entry(
       KEY_UI_FILES_PATH,
       new SimpleSetProperty<>( observableSet( new HashSet<>() ) )
+    )
   );
   /**
    * Creates a new {@link Workspace} that will attempt to load a configuration
    * file. If the configuration file cannot be loaded, the workspace settings
    * will return default values. This allows unit tests to provide an instance
    * of {@link Workspace} when necessary without encountering failures.
    */
   public Workspace() {
     load();
+  }
   /**
    * Creates an instance of {@link ObservableList} that is based on a
    * modifiable observable array list for the given items.
+   *
    * @param items The items to wrap in an observable list.
    * @param <E>   The type of items to add to the list.
    * @return An observable property that can have its contents modified.
    */
   public static <E> ObservableList<E> listProperty( final Set<E> items ) {
     return new SimpleListProperty<>( observableArrayList( items ) );
+  }
   /**
    * Returns a value that represents a setting in the application that the user
    * may configure, either directly or indirectly.
+   *
    * @param key The reference to the users' preference stored in deference
    *            of app reëntrance.
    * @return An observable property to be persisted.
    */
   @SuppressWarnings( "unchecked" )
   public <T, U extends Property<T>> U valuesProperty( final Key key ) {
     // The type that goes into the map must come out.
     return (U) VALUES.get( key );
+  }
   /**
    * Returns a list of values that represent a setting in the application that
    * the user may configure, either directly or indirectly. The property
    * returned is backed by a mutable {@link Set}.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return An observable property to be persisted.
    */
   @SuppressWarnings( "unchecked" )
   public <T> SetProperty<T> setsProperty( final Key key ) {
     // The type that goes into the map must come out.
     return (SetProperty<T>) SETS.get( key );
+  }
   /**
    * Returns the {@link Boolean} preference value associated with the given
    * {@link Key}. The caller must be sure that the given {@link Key} is
    * associated with a value that matches the return type.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public boolean toBoolean( final Key key ) {
     return (Boolean) valuesProperty( key ).getValue();
+  }
   /**
    * Returns the {@link Double} preference value associated with the given
    * {@link Key}. The caller must be sure that the given {@link Key} is
    * associated with a value that matches the return type.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public double toDouble( final Key key ) {
     return (Double) valuesProperty( key ).getValue();
+  }
   public File toFile( final Key key ) {
     return fileProperty( key ).get();
+  }
   public String toString( final Key key ) {
     return stringProperty( key ).get();
+  }
   public Tokens toTokens( final Key began, final Key ended ) {
     return new Tokens( stringProperty( began ), stringProperty( ended ) );
+  }
   @SuppressWarnings( "SameParameterValue" )
   public DoubleProperty doubleProperty( final Key key ) {
     return valuesProperty( key );
+  }
   /**
    * Returns the {@link File} {@link Property} associated with the given
    * {@link Key} from the internal list of preference values. The caller
    * must be sure that the given {@link Key} is associated with a {@link File}
    * {@link Property}.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public ObjectProperty<File> fileProperty( final Key key ) {
     return valuesProperty( key );
+  }
   public LocaleProperty localeProperty( final Key key ) {
     return valuesProperty( key );
+  }
   /**
    * Returns the language locale setting for the {@link #KEY_LANG_LOCALE} key.
+   *
    * @return The user's current locale setting.
    */
   public Locale getLocale() {
     return localeProperty( KEY_LANG_LOCALE ).toLocale();
+  }
   public StringProperty stringProperty( final Key key ) {
     return valuesProperty( key );
+  }
   public void loadValueKeys( final Consumer<Key> consumer ) {
     VALUES.keySet().forEach( consumer );
+  }
   public void loadSetKeys( final Consumer<Key> consumer ) {
     SETS.keySet().forEach( consumer );
+  }
   /**
    * Calls the given consumer for all single-value keys. For lists, see
    * {@link #saveSets(BiConsumer)}.
+   *
    * @param consumer Called to accept each preference key value.
    */
   public void saveValues( final BiConsumer<Key, Property<?>> consumer ) {
     VALUES.forEach( consumer );
+  }
   /**
    * Calls the given consumer for all multi-value keys. For single items, see
    * {@link #saveValues(BiConsumer)}. Callers are responsible for iterating
    * over the list of items retrieved through this method.
+   *
    * @param consumer Called to accept each preference key list.
    */
   public void saveSets( final BiConsumer<Key, SetProperty<?>> consumer ) {
     SETS.forEach( consumer );
+  }
   /**
    * Delegates to {@link #listen(Key, ReadOnlyProperty, BooleanSupplier)},
    * providing a value of {@code true} for the {@link BooleanSupplier} to
    * indicate the property changes always take effect.
+   *
    * @param key      The value to bind to the internal key property.
    * @param property The external property value that sets the internal value.
    */
   public <T> void listen( final Key key, final ReadOnlyProperty<T> property ) {
     listen( key, property, () -> true );
+  }
   /**
    * Binds a read-only property to a value in the preferences. This allows
    * user interface properties to change and the preferences will be
    * synchronized automatically.
    * <p>
    * This calls {@link Platform#runLater(Runnable)} to ensure that all pending
    * application window states are finished before assessing whether property
    * changes should be applied. Without this, exiting the application while the
    * window is maximized would persist the window's maximum dimensions,
    * preventing restoration to its prior, non-maximum size.
    * </p>
+   *
    * @param key      The value to bind to the internal key property.
    * @param property The external property value that sets the internal value.
    * @param enabled  Indicates whether property changes should be applied.
    */
   public <T> void listen(
     final Key key,
     final ReadOnlyProperty<T> property,
     final BooleanSupplier enabled ) {
     property.addListener(
       ( c, o, n ) -> runLater( () -> {
         if( enabled.getAsBoolean() ) {
           valuesProperty( key ).setValue( n );
+        }
       } )
     );
+  }
   /**
    * Saves the current workspace.
    */
   public void save() {
     try {
       final var config = new XMLConfiguration();
       // The root config key can only be set for an empty configuration file.
       config.setRootElementName( APP_TITLE_LOWERCASE );
       valuesProperty( KEY_META_VERSION ).setValue( getVersion() );
       saveValues( ( key, property ) ->
                     config.setProperty( key.toString(), marshall( property ) )
       );
       saveSets( ( key, set ) -> {
         final var keyName = key.toString();
         set.forEach( ( value ) -> config.addProperty( keyName, value ) );
       } );
       new FileHandler( config ).save( FILE_PREFERENCES );
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   /**
    * Attempts to load the {@link Constants#FILE_PREFERENCES} configuration file.
    * If not found, this will fall back to an empty configuration file, leaving
    * the application to fill in default values.
    */
   private void load() {
     try {
       final var config = new Configurations().xml( FILE_PREFERENCES );
 public final class Workspace {
   private static final Key KEY_ROOT = key( "workspace" );
   public static final Key KEY_META = key( KEY_ROOT, "meta" );
   public static final Key KEY_META_NAME = key( KEY_META, "name" );
   public static final Key KEY_META_VERSION = key( KEY_META, "version" );
   public static final Key KEY_R = key( KEY_ROOT, "r" );
   public static final Key KEY_R_SCRIPT = key( KEY_R, "script" );
   public static final Key KEY_R_DIR = key( KEY_R, "dir" );
   public static final Key KEY_R_DELIM = key( KEY_R, "delimiter" );
   public static final Key KEY_R_DELIM_BEGAN = key( KEY_R_DELIM, "began" );
   public static final Key KEY_R_DELIM_ENDED = key( KEY_R_DELIM, "ended" );
   public static final Key KEY_IMAGES = key( KEY_ROOT, "images" );
   public static final Key KEY_IMAGES_DIR = key( KEY_IMAGES, "dir" );
   public static final Key KEY_IMAGES_ORDER = key( KEY_IMAGES, "order" );
   public static final Key KEY_DEF = key( KEY_ROOT, "definition" );
   public static final Key KEY_DEF_PATH = key( KEY_DEF, "path" );
   public static final Key KEY_DEF_DELIM = key( KEY_DEF, "delimiter" );
   public static final Key KEY_DEF_DELIM_BEGAN = key( KEY_DEF_DELIM, "began" );
   public static final Key KEY_DEF_DELIM_ENDED = key( KEY_DEF_DELIM, "ended" );
   //@formatter:off
   public static final Key KEY_UI = key( KEY_ROOT, "ui" );
   public static final Key KEY_UI_RECENT = key( KEY_UI, "recent" );
   public static final Key KEY_UI_RECENT_DIR = key( KEY_UI_RECENT, "dir" );
   public static final Key KEY_UI_RECENT_DOCUMENT = key( KEY_UI_RECENT,"document" );
   public static final Key KEY_UI_RECENT_DEFINITION = key( KEY_UI_RECENT, "definition" );
   public static final Key KEY_UI_FILES = key( KEY_UI, "files" );
   public static final Key KEY_UI_FILES_PATH = key( KEY_UI_FILES, "path" );
   public static final Key KEY_UI_FONT = key( KEY_UI, "font" );
   public static final Key KEY_UI_FONT_EDITOR = key( KEY_UI_FONT, "editor" );
   public static final Key KEY_UI_FONT_EDITOR_NAME = key( KEY_UI_FONT_EDITOR, "name" );
   public static final Key KEY_UI_FONT_EDITOR_SIZE = key( KEY_UI_FONT_EDITOR, "size" );
   public static final Key KEY_UI_FONT_PREVIEW = key( KEY_UI_FONT, "preview" );
   public static final Key KEY_UI_FONT_PREVIEW_NAME = key( KEY_UI_FONT_PREVIEW, "name" );
   public static final Key KEY_UI_FONT_PREVIEW_SIZE = key( KEY_UI_FONT_PREVIEW, "size" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO = key( KEY_UI_FONT_PREVIEW, "mono" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO_NAME = key( KEY_UI_FONT_PREVIEW_MONO, "name" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO_SIZE = key( KEY_UI_FONT_PREVIEW_MONO, "size" );
   public static final Key KEY_LANGUAGE = key( KEY_ROOT, "language" );
   public static final Key KEY_LANG_LOCALE = key( KEY_LANGUAGE, "locale" );
   public static final Key KEY_UI_WINDOW = key( KEY_UI, "window" );
   public static final Key KEY_UI_WINDOW_X = key( KEY_UI_WINDOW, "x" );
   public static final Key KEY_UI_WINDOW_Y = key( KEY_UI_WINDOW, "y" );
   public static final Key KEY_UI_WINDOW_W = key( KEY_UI_WINDOW, "width" );
   public static final Key KEY_UI_WINDOW_H = key( KEY_UI_WINDOW, "height" );
   public static final Key KEY_UI_WINDOW_MAX = key( KEY_UI_WINDOW, "maximized" );
   public static final Key KEY_UI_WINDOW_FULL = key( KEY_UI_WINDOW, "full" );
   private final Map<Key, Property<?>> VALUES = Map.ofEntries(
     entry( KEY_META_VERSION, asStringProperty( getVersion() ) ),
     entry( KEY_META_NAME, asStringProperty( "default" ) ),
     entry( KEY_R_SCRIPT, asStringProperty( "" ) ),
     entry( KEY_R_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_R_DELIM_BEGAN, asStringProperty( R_DELIM_BEGAN_DEFAULT ) ),
     entry( KEY_R_DELIM_ENDED, asStringProperty( R_DELIM_ENDED_DEFAULT ) ),
     entry( KEY_IMAGES_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_IMAGES_ORDER, asStringProperty( PERSIST_IMAGES_DEFAULT ) ),
     entry( KEY_DEF_PATH, asFileProperty( DEFINITION_DEFAULT ) ),
     entry( KEY_DEF_DELIM_BEGAN, asStringProperty( DEF_DELIM_BEGAN_DEFAULT ) ),
     entry( KEY_DEF_DELIM_ENDED, asStringProperty( DEF_DELIM_ENDED_DEFAULT ) ),
     entry( KEY_UI_RECENT_DIR, asFileProperty( USER_DIRECTORY ) ),
     entry( KEY_UI_RECENT_DOCUMENT, asFileProperty( DOCUMENT_DEFAULT ) ),
     entry( KEY_UI_RECENT_DEFINITION, asFileProperty( DEFINITION_DEFAULT ) ),
     entry( KEY_LANG_LOCALE, asLocaleProperty( LOCALE_DEFAULT ) ),
     entry( KEY_UI_FONT_EDITOR_NAME, asStringProperty( FONT_NAME_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_EDITOR_SIZE, asDoubleProperty( FONT_SIZE_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_NAME, asStringProperty( FONT_NAME_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_NAME, asStringProperty( FONT_NAME_PREVIEW_MONO_NAME_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_MONO_SIZE_DEFAULT ) ),
     entry( KEY_UI_WINDOW_X, asDoubleProperty( WINDOW_X_DEFAULT ) ),
     entry( KEY_UI_WINDOW_Y, asDoubleProperty( WINDOW_Y_DEFAULT ) ),
     entry( KEY_UI_WINDOW_W, asDoubleProperty( WINDOW_W_DEFAULT ) ),
     entry( KEY_UI_WINDOW_H, asDoubleProperty( WINDOW_H_DEFAULT ) ),
     entry( KEY_UI_WINDOW_MAX, asBooleanProperty() ),
     entry( KEY_UI_WINDOW_FULL, asBooleanProperty() )
   );
   //@formatter:on
   private StringProperty asStringProperty( final String defaultValue ) {
     return new SimpleStringProperty( defaultValue );
+  }
   private DoubleProperty asDoubleProperty( final double defaultValue ) {
     return new SimpleDoubleProperty( defaultValue );
+  }
   private BooleanProperty asBooleanProperty() {
     return new SimpleBooleanProperty();
+  }
   private FileProperty asFileProperty( final File defaultValue ) {
     return new FileProperty( defaultValue );
+  }
   @SuppressWarnings( "SameParameterValue" )
   private LocaleProperty asLocaleProperty( final Locale defaultValue ) {
     return new LocaleProperty( defaultValue );
+  }
   /**
    * Helps instantiate {@link Property} instances for XML configuration items.
    */
   private static final Map<Class<?>, Function<String, Object>> UNMARSHALL =
     Map.of(
       LocaleProperty.class, LocaleProperty::parseLocale,
       SimpleBooleanProperty.class, Boolean::parseBoolean,
       SimpleDoubleProperty.class, Double::parseDouble,
       SimpleFloatProperty.class, Float::parseFloat,
       FileProperty.class, File::new
     );
   private static final Map<Class<?>, Function<String, Object>> MARSHALL =
     Map.of(
       LocaleProperty.class, LocaleProperty::toLanguageTag
     );
   private final Map<Key, SetProperty<?>> SETS = Map.ofEntries(
     entry(
       KEY_UI_FILES_PATH,
       new SimpleSetProperty<>( observableSet( new HashSet<>() ) )
+    )
   );
   /**
    * Creates a new {@link Workspace} that will attempt to load a configuration
    * file. If the configuration file cannot be loaded, the workspace settings
    * will return default values. This allows unit tests to provide an instance
    * of {@link Workspace} when necessary without encountering failures.
    */
   public Workspace() {
     load( FILE_PREFERENCES );
+  }
   /**
    * Creates a new {@link Workspace} that will attempt to load the given
    * configuration file.
+   *
    * @param filename The file to load.
    */
   public Workspace( final String filename ) {
     load( filename );
+  }
   /**
    * Creates an instance of {@link ObservableList} that is based on a
    * modifiable observable array list for the given items.
+   *
    * @param items The items to wrap in an observable list.
    * @param <E>   The type of items to add to the list.
    * @return An observable property that can have its contents modified.
    */
   public static <E> ObservableList<E> listProperty( final Set<E> items ) {
     return new SimpleListProperty<>( observableArrayList( items ) );
+  }
   /**
    * Returns a value that represents a setting in the application that the user
    * may configure, either directly or indirectly.
+   *
    * @param key The reference to the users' preference stored in deference
    *            of app reëntrance.
    * @return An observable property to be persisted.
    */
   @SuppressWarnings( "unchecked" )
   public <T, U extends Property<T>> U valuesProperty( final Key key ) {
     // The type that goes into the map must come out.
     return (U) VALUES.get( key );
+  }
   /**
    * Returns a list of values that represent a setting in the application that
    * the user may configure, either directly or indirectly. The property
    * returned is backed by a mutable {@link Set}.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return An observable property to be persisted.
    */
   @SuppressWarnings( "unchecked" )
   public <T> SetProperty<T> setsProperty( final Key key ) {
     // The type that goes into the map must come out.
     return (SetProperty<T>) SETS.get( key );
+  }
   /**
    * Returns the {@link Boolean} preference value associated with the given
    * {@link Key}. The caller must be sure that the given {@link Key} is
    * associated with a value that matches the return type.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public boolean toBoolean( final Key key ) {
     return (Boolean) valuesProperty( key ).getValue();
+  }
   /**
    * Returns the {@link Double} preference value associated with the given
    * {@link Key}. The caller must be sure that the given {@link Key} is
    * associated with a value that matches the return type.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public double toDouble( final Key key ) {
     return (Double) valuesProperty( key ).getValue();
+  }
   public File toFile( final Key key ) {
     return fileProperty( key ).get();
+  }
   public String toString( final Key key ) {
     return stringProperty( key ).get();
+  }
   public Tokens toTokens( final Key began, final Key ended ) {
     return new Tokens( stringProperty( began ), stringProperty( ended ) );
+  }
   @SuppressWarnings( "SameParameterValue" )
   public DoubleProperty doubleProperty( final Key key ) {
     return valuesProperty( key );
+  }
   /**
    * Returns the {@link File} {@link Property} associated with the given
    * {@link Key} from the internal list of preference values. The caller
    * must be sure that the given {@link Key} is associated with a {@link File}
    * {@link Property}.
+   *
    * @param key The {@link Key} associated with a preference value.
    * @return The value associated with the given {@link Key}.
    */
   public ObjectProperty<File> fileProperty( final Key key ) {
     return valuesProperty( key );
+  }
   public LocaleProperty localeProperty( final Key key ) {
     return valuesProperty( key );
+  }
   /**
    * Returns the language locale setting for the {@link #KEY_LANG_LOCALE} key.
+   *
    * @return The user's current locale setting.
    */
   public Locale getLocale() {
     return localeProperty( KEY_LANG_LOCALE ).toLocale();
+  }
   public StringProperty stringProperty( final Key key ) {
     return valuesProperty( key );
+  }
   public void loadValueKeys( final Consumer<Key> consumer ) {
     VALUES.keySet().forEach( consumer );
+  }
   public void loadSetKeys( final Consumer<Key> consumer ) {
     SETS.keySet().forEach( consumer );
+  }
   /**
    * Calls the given consumer for all single-value keys. For lists, see
    * {@link #saveSets(BiConsumer)}.
+   *
    * @param consumer Called to accept each preference key value.
    */
   public void saveValues( final BiConsumer<Key, Property<?>> consumer ) {
     VALUES.forEach( consumer );
+  }
   /**
    * Calls the given consumer for all multi-value keys. For single items, see
    * {@link #saveValues(BiConsumer)}. Callers are responsible for iterating
    * over the list of items retrieved through this method.
+   *
    * @param consumer Called to accept each preference key list.
    */
   public void saveSets( final BiConsumer<Key, SetProperty<?>> consumer ) {
     SETS.forEach( consumer );
+  }
   /**
    * Delegates to {@link #listen(Key, ReadOnlyProperty, BooleanSupplier)},
    * providing a value of {@code true} for the {@link BooleanSupplier} to
    * indicate the property changes always take effect.
+   *
    * @param key      The value to bind to the internal key property.
    * @param property The external property value that sets the internal value.
    */
   public <T> void listen( final Key key, final ReadOnlyProperty<T> property ) {
     listen( key, property, () -> true );
+  }
   /**
    * Binds a read-only property to a value in the preferences. This allows
    * user interface properties to change and the preferences will be
    * synchronized automatically.
    * <p>
    * This calls {@link Platform#runLater(Runnable)} to ensure that all pending
    * application window states are finished before assessing whether property
    * changes should be applied. Without this, exiting the application while the
    * window is maximized would persist the window's maximum dimensions,
    * preventing restoration to its prior, non-maximum size.
    * </p>
+   *
    * @param key      The value to bind to the internal key property.
    * @param property The external property value that sets the internal value.
    * @param enabled  Indicates whether property changes should be applied.
    */
   public <T> void listen(
     final Key key,
     final ReadOnlyProperty<T> property,
     final BooleanSupplier enabled ) {
     property.addListener(
       ( c, o, n ) -> runLater( () -> {
         if( enabled.getAsBoolean() ) {
           valuesProperty( key ).setValue( n );
+        }
       } )
     );
+  }
   /**
    * Saves the current workspace.
    */
   public void save() {
     try {
       final var config = new XMLConfiguration();
       // The root config key can only be set for an empty configuration file.
       config.setRootElementName( APP_TITLE_LOWERCASE );
       valuesProperty( KEY_META_VERSION ).setValue( getVersion() );
       saveValues( ( key, property ) ->
                     config.setProperty( key.toString(), marshall( property ) )
       );
       saveSets( ( key, set ) -> {
         final var keyName = key.toString();
         set.forEach( ( value ) -> config.addProperty( keyName, value ) );
       } );
       new FileHandler( config ).save( FILE_PREFERENCES );
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   /**
    * Attempts to load the {@link Constants#FILE_PREFERENCES} configuration file.
    * If not found, this will fall back to an empty configuration file, leaving
    * the application to fill in default values.
+   *
    * @param filename The file containing user preferences to load.
    */
   private void load( final String filename ) {
     try {
       final var config = new Configurations().xml( filename );
       loadValueKeys( ( key ) -> {

M src/main/java/com/keenwrite/preferences/XmlStorageHandler.java

  * </p>
  */
 public class XmlStorageHandler implements StorageHandler {
 public final class XmlStorageHandler implements StorageHandler {
   @Override
   public void saveSelectedCategory( final String breadcrumb ) { }

M src/main/java/com/keenwrite/preview/ChainedReplacedElementFactory.java

  * the HTML document prior to displaying it.
  */
 public class ChainedReplacedElementFactory extends ReplacedElementAdapter {
 public final class ChainedReplacedElementFactory extends ReplacedElementAdapter {
   /**
    * Retain insertion order so that client classes can control the order that

M src/main/java/com/keenwrite/preview/DomConverter.java

  * builders, and implementations.
  */
 class DomConverter extends W3CDom {
 final class DomConverter extends W3CDom {
   /**
    * Retain insertion order using an instance of {@link LinkedHashMap} so

M src/main/java/com/keenwrite/preview/HtmlPanel.java

  * Responsible for configuring FlyingSaucer's {@link XHTMLPanel}.
  */
 public class HtmlPanel extends XHTMLPanel {
 public final class HtmlPanel extends XHTMLPanel {
   /**

M src/main/java/com/keenwrite/preview/MathRenderer.java

  * Responsible for rendering formulas as scalable vector graphics (SVG).
  */
 public class MathRenderer {
 public final class MathRenderer {
   /**

M src/main/java/com/keenwrite/preview/RenderingSettings.java

  */
 @SuppressWarnings("rawtypes")
 public class RenderingSettings {
 public final class RenderingSettings {
   /**

M src/main/java/com/keenwrite/preview/SvgRasterizer.java

  * Responsible for converting SVG images into rasterized PNG images.
  */
 public class SvgRasterizer {
 public final class SvgRasterizer {
   private static final SAXSVGDocumentFactory FACTORY_DOM =
       new SAXSVGDocumentFactory( getXMLParserClassName() );

M src/main/java/com/keenwrite/preview/SvgReplacedElementFactory.java

 import java.awt.image.BufferedImage;
 import java.net.URI;
 import java.nio.file.Paths;
 import java.nio.file.Path;
 import static com.keenwrite.StatusNotifier.clue;
  * a document to transform them into rasterized versions.
  */
 public class SvgReplacedElementFactory extends ReplacedElementAdapter {
 public final class SvgReplacedElementFactory extends ReplacedElementAdapter {
   public static final String HTML_IMAGE = "img";
           else if( isSvg( MediaType.valueFrom( source ) ) ) {
             // Attempt to rasterize based on file name.
             final var base = new URI( getBaseUri( e ) ).getPath();
             uri = Paths.get( base, source ).toUri();
             final var path = Path.of( new URI( source ).getPath() );
             if( path.isAbsolute() ) {
               uri = path.toUri();
+            }
             else {
               final var base = new URI( getBaseUri( e ) ).getPath();
               uri = Path.of( base, source ).toUri();
+            }
+          }

M src/main/java/com/keenwrite/processors/HtmlPreviewProcessor.java

  * chain.
  */
 public class HtmlPreviewProcessor extends ExecutorProcessor<String> {
 public final class HtmlPreviewProcessor extends ExecutorProcessor<String> {
   /**

M src/main/java/com/keenwrite/processors/IdentityProcessor.java

  * end of a processing chain when no more processing is required.
  */
 public class IdentityProcessor extends ExecutorProcessor<String> {
 public final class IdentityProcessor extends ExecutorProcessor<String> {
   public static final IdentityProcessor IDENTITY = new IdentityProcessor();

D src/main/java/com/keenwrite/processors/InlineRProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.processors.markdown.extensions.r.ROutputProcessor;
 import com.keenwrite.util.BoundedCache;
 import javafx.beans.property.Property;
 import javax.script.ScriptEngine;
 import javax.script.ScriptEngineManager;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import static com.keenwrite.Constants.STATUS_PARSE_ERROR;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.StatusNotifier.clue;
 import static com.keenwrite.preferences.Workspace.*;
 import static com.keenwrite.processors.text.TextReplacementFactory.replace;
 import static com.keenwrite.sigils.RSigilOperator.PREFIX;
 import static com.keenwrite.sigils.RSigilOperator.SUFFIX;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
 /**
  * Transforms a document containing R statements into Markdown.
  */
 public final class InlineRProcessor extends DefinitionProcessor {
   private final Processor<String> mPostProcessor = new ROutputProcessor();
   /**
    * Where to put document inline evaluated R expressions, constrained to
    * avoid running out of memory.
    */
   private final Map<String, String> mEvalCache =
     new BoundedCache<>( 512 );
   private static final ScriptEngine ENGINE =
     (new ScriptEngineManager()).getEngineByName( "Renjin" );
   private static final int PREFIX_LENGTH = PREFIX.length();
   private final AtomicBoolean mDirty = new AtomicBoolean( false );
   private final Workspace mWorkspace;
   /**
    * Constructs a processor capable of evaluating R statements.
+   *
    * @param successor Subsequent link in the processing chain.
    * @param context   Contains resolved definitions map.
    */
   public InlineRProcessor(
     final Processor<String> successor,
     final ProcessorContext context ) {
     super( successor, context );
     mWorkspace = context.getWorkspace();
     bootstrapScriptProperty().addListener(
       ( __, oldScript, newScript ) -> setDirty( true ) );
     workingDirectoryProperty().addListener(
       ( __, oldScript, newScript ) -> setDirty( true ) );
     // TODO: Watch the "R" property keys in the workspace, directly.
     // If the user saves the preferences, make sure that any R-related settings
     // changes are applied.
 //    getWorkspace().addSaveEventHandler( ( handler ) -> {
 //      if( isDirty() ) {
 //        init();
 //        setDirty( false );
 //      }
 //    } );
     init();
+  }
   /**
    * Initialises the R code so that R can find imported libraries. Note that
    * any existing R functionality will not be overwritten if this method is
    * called multiple times.
+   *
    * @return {@code true} if initialization completed and all variables were
    * replaced; {@code false} if any variables remain.
    */
   public boolean init() {
     final var bootstrap = getBootstrapScript();
     if( !bootstrap.isBlank() ) {
       final var wd = getWorkingDirectory();
       final var dir = wd.toString().replace( '\\', '/' );
       final var map = getDefinitions();
       final var defBegan = mWorkspace.toString( KEY_DEF_DELIM_BEGAN );
       final var defEnded = mWorkspace.toString( KEY_DEF_DELIM_ENDED );
       map.put( defBegan + "application.r.working.directory" + defEnded, dir );
       final var replaced = replace( bootstrap, map );
       final var bIndex = replaced.indexOf( defBegan );
       //
       if( bIndex >= 0 ) {
         var eIndex = replaced.indexOf( defEnded );
         eIndex = (eIndex == -1) ? replaced.length() - 1 : max( bIndex, eIndex );
         final var def = replaced.substring( bIndex, eIndex );
         clue( "Main.status.error.bootstrap.eval", def );
         return false;
+      }
       else {
         eval( replaced );
+      }
+    }
     return true;
+  }
   /**
    * Empties the cache.
    */
   public void clear() {
     mEvalCache.clear();
+  }
   /**
    * Sets the dirty flag to indicate that the bootstrap script or working
    * directory has been modified. Upon saving the preferences, if this flag
    * is true, then {@link #init()} will be called to reload the R environment.
+   *
    * @param dirty Set to true to reload changes upon closing preferences.
    */
   private void setDirty( final boolean dirty ) {
     mDirty.set( dirty );
+  }
   /**
    * Answers whether R-related settings have been modified.
+   *
    * @return {@code true} when the settings have changed.
    */
   private boolean isDirty() {
     return mDirty.get();
+  }
   /**
    * Evaluates all R statements in the source document and inserts the
    * calculated value into the generated document.
+   *
    * @param text The document text that includes variables that should be
    *             replaced with values when rendered as HTML.
    * @return The generated document with output from all R statements
    * substituted with value returned from their execution.
    */
   @Override
   public String apply( final String text ) {
     final int length = text.length();
     // The * 2 is a wild guess at the ratio of R statements to the length
     // of text produced by those statements.
     final StringBuilder sb = new StringBuilder( length * 2 );
     int prevIndex = 0;
     int currIndex = text.indexOf( PREFIX );
     while( currIndex >= 0 ) {
       // Copy everything up to, but not including, the opening token.
       sb.append( text, prevIndex, currIndex );
       // Jump to the start of the R statement.
       prevIndex = currIndex + PREFIX_LENGTH;
       // Find the closing token, without indexing past the text boundary.
       currIndex = text.indexOf( SUFFIX, min( currIndex + 1, length ) );
       // Only evaluate inline R statements that have end delimiters.
       if( currIndex > 1 ) {
         // Extract the inline R statement to be evaluated.
         final var r = text.substring( prevIndex, currIndex );
         // Pass the R statement into the R engine for evaluation.
         try {
           // Append the string representation of the result into the text.
           sb.append( evalCached( r ) );
         } catch( final Exception ex ) {
           // Inform the user that there was a problem.
           clue( STATUS_PARSE_ERROR, ex.getMessage(), currIndex );
           // If the string couldn't be parsed using R, append the statement
           // that failed to parse, instead of its evaluated value.
           sb.append( PREFIX ).append( r ).append( SUFFIX );
+        }
         // Retain the R statement's ending position in the text.
         prevIndex = currIndex + 1;
+      }
       // Find the start of the next inline R statement.
       currIndex = text.indexOf( PREFIX, min( currIndex + 1, length ) );
+    }
     // Copy from the previous index to the end of the string.
     return sb.append( text.substring( min( prevIndex, length ) ) ).toString();
+  }
   /**
    * Look up an R expression from the cache then return the resulting object.
    * If the R expression hasn't been cached, it'll first be evaluated.
+   *
    * @param r The expression to evaluate.
    * @return The object resulting from the evaluation.
    */
   private String evalCached( final String r ) {
     return mEvalCache.computeIfAbsent( r, __ -> evalHtml( r ) );
+  }
   /**
    * Converts the given string to HTML, trimming new lines, and inlining
    * the text if it is a paragraph. Otherwise, the resulting HTML is most likely
    * complex (e.g., a Markdown table) and should be rendered as its HTML
    * equivalent.
+   *
    * @param r The R expression to evaluate then convert to HTML.
    * @return The result from the R expression as an HTML element.
    */
   private String evalHtml( final String r ) {
     return mPostProcessor.apply( eval( r ) );
+  }
   /**
    * Evaluate an R expression and return the resulting object.
+   *
    * @param r The expression to evaluate.
    * @return The object resulting from the evaluation.
    */
   private String eval( final String r ) {
     try {
       return ENGINE.eval( r ).toString();
     } catch( final Exception ex ) {
       final var expr = r.substring( 0, min( r.length(), 50 ) );
       clue( get( "Main.status.error.r", expr, ex.getMessage() ), ex );
       return "";
+    }
+  }
   /**
    * Return the given path if not {@code null}, otherwise return the path to
    * the user's directory.
+   *
    * @return A non-null path.
    */
   private Path getWorkingDirectory() {
     return workingDirectoryProperty().getValue().toPath();
+  }
   private Property<File> workingDirectoryProperty() {
     return getWorkspace().fileProperty( KEY_R_DIR );
+  }
   /**
    * Loads the R init script from the application's persisted preferences.
+   *
    * @return A non-null string, possibly empty.
    */
   private String getBootstrapScript() {
     return bootstrapScriptProperty().getValue();
+  }
   private Property<String> bootstrapScriptProperty() {
     return getWorkspace().valuesProperty( KEY_R_SCRIPT );
+  }
   private Workspace getWorkspace() {
     return mWorkspace;
+  }
+}

M src/main/java/com/keenwrite/processors/PreformattedProcessor.java

  * element.
  */
 public class PreformattedProcessor extends ExecutorProcessor<String> {
 public final class PreformattedProcessor extends ExecutorProcessor<String> {
   /**

M src/main/java/com/keenwrite/processors/ProcessorContext.java

  * Provides a context for configuring a chain of {@link Processor} instances.
  */
 public class ProcessorContext {
 public final class ProcessorContext {
   private final HtmlPreview mHtmlPreview;
   private final Map<String, String> mResolvedMap;
   private final Path mPath;
   private final Path mDocumentPath;
   private final Caret mCaret;
   private final ExportFormat mExportFormat;
    * @param htmlPreview  Where to display the final (HTML) output.
    * @param resolvedMap  Fully expanded interpolated strings.
    * @param path         Path to the document to process.
    * @param documentPath         Path to the document to process.
    * @param caret        Location of the caret in the edited document, which is
    *                     used to synchronize the scrollbars.
    * @param exportFormat Indicate configuration options for export format.
    */
   public ProcessorContext(
     final HtmlPreview htmlPreview,
     final Map<String, String> resolvedMap,
     final Path path,
     final Path documentPath,
     final Caret caret,
     final ExportFormat exportFormat,
     final Workspace workspace ) {
     assert htmlPreview != null;
     assert resolvedMap != null;
     assert path != null;
     assert documentPath != null;
     assert caret != null;
     assert exportFormat != null;
     assert workspace != null;
     mHtmlPreview = htmlPreview;
     mResolvedMap = resolvedMap;
     mPath = path;
     mDocumentPath = documentPath;
     mCaret = caret;
     mExportFormat = exportFormat;
    */
   public Path getBaseDir() {
     final var path = getPath().toAbsolutePath().getParent();
     final var path = getDocumentPath().toAbsolutePath().getParent();
     return path == null ? DEFAULT_DIRECTORY : path;
+  }
   public Path getPath() {
     return mPath;
   public Path getDocumentPath() {
     return mDocumentPath;
+  }
   FileType getFileType() {
     return lookup( getPath() );
     return lookup( getDocumentPath() );
+  }

M src/main/java/com/keenwrite/processors/ProcessorFactory.java

  * interpolating, and rendering known file types.
  */
 public class ProcessorFactory extends AbstractFileFactory {
 public final class ProcessorFactory extends AbstractFileFactory {
   private final ProcessorContext mContext;
   private Processor<String> createRProcessor(
     final Processor<String> successor ) {
     final var irp = new InlineRProcessor( successor, getProcessorContext() );
     final var rvp = new RVariableProcessor( irp, getProcessorContext() );
     return MarkdownProcessor.create( rvp, getProcessorContext() );
     return MarkdownProcessor.create( successor, getProcessorContext() );
+  }

D src/main/java/com/keenwrite/processors/RVariableProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.sigils.RSigilOperator;
 import com.keenwrite.sigils.SigilOperator;
 import com.keenwrite.sigils.YamlSigilOperator;
 import java.util.HashMap;
 import java.util.Map;
 import static com.keenwrite.preferences.Workspace.*;
 /**
  * Converts the keys of the resolved map from default form to R form, then
  * performs a substitution on the text. The default R variable syntax is
  * {@code v$tree$leaf}.
  */
 public class RVariableProcessor extends DefinitionProcessor {
   private final SigilOperator mSigilOperator;
   public RVariableProcessor(
     final InlineRProcessor irp, final ProcessorContext context ) {
     super( irp, context );
     mSigilOperator = createSigilOperator( context.getWorkspace() );
+  }
   /**
    * Returns the R-based version of the interpolated variable definitions.
+   *
    * @return Variable names transmogrified from the default syntax to R syntax.
    */
   @Override
   protected Map<String, String> getDefinitions() {
     return entoken( super.getDefinitions() );
+  }
   /**
    * Converts the given map from regular variables to R variables.
+   *
    * @param map Map of variable names to values.
    * @return Map of R variables.
    */
   private Map<String, String> entoken( final Map<String, String> map ) {
     final var rMap = new HashMap<String, String>( map.size() );
     for( final var entry : map.entrySet() ) {
       final var key = entry.getKey();
       rMap.put( mSigilOperator.entoken( key ), escape( map.get( key ) ) );
+    }
     return rMap;
+  }
   private String escape( final String value ) {
     return '\'' + escape( value, '\'', "\\'" ) + '\'';
+  }
   /**
    * TODO: Make generic method for replacing text.
+   *
    * @param haystack Search this string for the needle, must not be null.
    * @param needle   The character to find in the haystack.
    * @param thread   Replace the needle with this text, if the needle is found.
    * @return The haystack with the all instances of needle replaced with thread.
    */
   @SuppressWarnings("SameParameterValue")
   private String escape(
     final String haystack, final char needle, final String thread ) {
     int end = haystack.indexOf( needle );
     if( end < 0 ) {
       return haystack;
+    }
     final int length = haystack.length();
     int start = 0;
     // Replace up to 32 occurrences before the string reallocates its buffer.
     final var sb = new StringBuilder( length + 32 );
     while( end >= 0 ) {
       sb.append( haystack, start, end ).append( thread );
       start = end + 1;
       end = haystack.indexOf( needle, start );
+    }
     return sb.append( haystack.substring( start ) ).toString();
+  }
   private SigilOperator createSigilOperator( final Workspace workspace ) {
     final var tokens = workspace.toTokens(
       KEY_R_DELIM_BEGAN, KEY_R_DELIM_ENDED );
     final var antecedent = createDefinitionOperator( workspace );
     return new RSigilOperator( tokens, antecedent );
+  }
   private SigilOperator createDefinitionOperator(
     final Workspace workspace ) {
     final var tokens = workspace.toTokens(
       KEY_DEF_DELIM_BEGAN, KEY_DEF_DELIM_ENDED );
     return new YamlSigilOperator( tokens );
+  }
+}

M src/main/java/com/keenwrite/processors/XmlProcessor.java

  * </p>
  */
 public class XmlProcessor extends ExecutorProcessor<String>
 public final class XmlProcessor extends ExecutorProcessor<String>
     implements ErrorListener {
       final ProcessorContext context ) {
     super( successor );
     mPath = context.getPath();
     mPath = context.getDocumentPath();
     // Bubble problems up to the user interface, rather than standard error.

A src/main/java/com/keenwrite/processors/markdown/BaseMarkdownProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors.markdown;
 import com.keenwrite.processors.ExecutorProcessor;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.markdown.extensions.r.RExtension;
 import com.vladsch.flexmark.ext.definition.DefinitionExtension;
 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughSubscriptExtension;
 import com.vladsch.flexmark.ext.superscript.SuperscriptExtension;
 import com.vladsch.flexmark.ext.tables.TablesExtension;
 import com.vladsch.flexmark.ext.typographic.TypographicExtension;
 import com.vladsch.flexmark.html.HtmlRenderer;
 import com.vladsch.flexmark.parser.Parser;
 import com.vladsch.flexmark.util.ast.IParse;
 import com.vladsch.flexmark.util.ast.IRender;
 import com.vladsch.flexmark.util.ast.Node;
 import com.vladsch.flexmark.util.misc.Extension;
 import java.util.ArrayList;
 import java.util.List;
 /**
  * Responsible for parsing and rendering Markdown into HTML. This is required
  * to break a circular dependency between the {@link MarkdownProcessor} and
  * {@link RExtension}.
  */
 public class BaseMarkdownProcessor extends ExecutorProcessor<String> {
   private final IParse mParser;
   private final IRender mRenderer;
   public BaseMarkdownProcessor(
     final Processor<String> successor, final ProcessorContext context ) {
     super( successor );
     final var extensions = new ArrayList<Extension>();
     init( extensions, context );
     mParser = Parser.builder().extensions( extensions ).build();
     mRenderer = HtmlRenderer.builder().extensions( extensions ).build();
+  }
   /**
    * Instantiates a number of extensions to be applied when parsing. These
    * are typically typographic extensions that convert characters into
    * HTML entities.
+   *
    * @param extensions A {@link List} of {@link Extension} instances that
    *                   change the {@link Parser}'s behaviour.
    * @param context    The context that subclasses use to configure custom
    *                   extension behaviour.
    */
   void init(
     final List<Extension> extensions, final ProcessorContext context ) {
     extensions.add( DefinitionExtension.create() );
     extensions.add( StrikethroughSubscriptExtension.create() );
     extensions.add( SuperscriptExtension.create() );
     extensions.add( TablesExtension.create() );
     extensions.add( TypographicExtension.create() );
+  }
   /**
    * Converts the given Markdown string into HTML, without the doctype, html,
    * head, and body tags.
+   *
    * @param markdown The string to convert from Markdown to HTML.
    * @return The HTML representation of the Markdown document.
    */
   @Override
   public String apply( final String markdown ) {
     return toHtml( parse( markdown ) );
+  }
   /**
    * Returns the AST in the form of a node for the given Markdown document. This
    * can be used, for example, to determine if a hyperlink exists inside of a
    * paragraph.
+   *
    * @param markdown The Markdown to convert into an AST.
    * @return The Markdown AST for the given text (usually a paragraph).
    */
   public Node toNode( final String markdown ) {
     return parse( markdown );
+  }
   /**
    * Returns the result of converting the given AST into an HTML string.
+   *
    * @param node The AST {@link Node} to convert to an HTML string.
    * @return The given {@link Node} as an HTML string.
    */
   public String toHtml( final Node node ) {
     return getRenderer().render( node );
+  }
   /**
    * Helper method to create an AST given some Markdown.
+   *
    * @param markdown The Markdown to parse.
    * @return The root node of the Markdown tree.
    */
   private Node parse( final String markdown ) {
     return getParser().parse( markdown );
+  }
   /**
    * Creates the Markdown document processor.
+   *
    * @return An instance of {@link IParse} for building abstract syntax trees.
    */
   private IParse getParser() {
     return mParser;
+  }
   private IRender getRenderer() {
     return mRenderer;
+  }
+}

M src/main/java/com/keenwrite/processors/markdown/MarkdownProcessor.java

 import com.keenwrite.io.MediaType;
 import com.keenwrite.processors.ExecutorProcessor;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.markdown.extensions.FencedBlockExtension;
 import com.keenwrite.processors.markdown.extensions.ImageLinkExtension;
 import com.keenwrite.processors.markdown.extensions.caret.CaretExtension;
 import com.keenwrite.processors.markdown.extensions.r.RExtension;
 import com.keenwrite.processors.markdown.extensions.tex.TeXExtension;
 import com.vladsch.flexmark.ext.definition.DefinitionExtension;
 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughSubscriptExtension;
 import com.vladsch.flexmark.ext.superscript.SuperscriptExtension;
 import com.vladsch.flexmark.ext.tables.TablesExtension;
 import com.vladsch.flexmark.ext.typographic.TypographicExtension;
 import com.vladsch.flexmark.html.HtmlRenderer;
 import com.vladsch.flexmark.parser.Parser;
 import com.vladsch.flexmark.util.ast.IParse;
 import com.vladsch.flexmark.util.ast.IRender;
 import com.vladsch.flexmark.util.ast.Node;
 import com.keenwrite.processors.r.RProcessor;
 import com.vladsch.flexmark.util.misc.Extension;
 import java.util.ArrayList;
 import java.util.List;
 import static com.keenwrite.io.MediaType.TEXT_R_MARKDOWN;
 import static com.keenwrite.io.MediaType.TEXT_R_XML;
 import static com.keenwrite.processors.IdentityProcessor.IDENTITY;
 /**
  * Responsible for parsing a Markdown document and rendering it as HTML.
  */
 public class MarkdownProcessor extends ExecutorProcessor<String> {
   private static final List<Extension> DEFAULT_EXTENSIONS =
     createDefaultExtensions();
   private final IParse mParser;
   private final IRender mRenderer;
 public final class MarkdownProcessor extends BaseMarkdownProcessor {
   private MarkdownProcessor(
     final Processor<String> successor,
     final List<Extension> extensions ) {
     super( successor );
     mParser = Parser.builder().extensions( extensions ).build();
     mRenderer = HtmlRenderer.builder().extensions( extensions ).build();
     final Processor<String> successor, final ProcessorContext context ) {
     super( successor, context );
+  }
   public static MarkdownProcessor create( final ProcessorContext context ) {
     return create( IDENTITY, context );
+  }
   public static MarkdownProcessor create(
     final Processor<String> successor, final ProcessorContext context ) {
     final var extensions = createExtensions( context );
     return new MarkdownProcessor( successor, extensions );
+  }
   private static List<Extension> createEmptyExtensions() {
     return new ArrayList<>();
+  }
   /**
    * Instantiates a number of extensions to be applied when parsing. These
    * are typically typographic extensions that convert characters into
    * HTML entities.
+   *
    * @return A {@link List} of {@link Extension} instances that
    * change the {@link Parser}'s behaviour.
    */
   private static List<Extension> createDefaultExtensions() {
     final List<Extension> extensions = new ArrayList<>();
     extensions.add( DefinitionExtension.create() );
     extensions.add( StrikethroughSubscriptExtension.create() );
     extensions.add( SuperscriptExtension.create() );
     extensions.add( TablesExtension.create() );
     extensions.add( TypographicExtension.create() );
     return extensions;
     return new MarkdownProcessor( successor, context );
+  }
    * formats can be edited.
+   *
    * @param context Contains necessary information needed to create extensions
    *                used by the Markdown parser.
    * @return {@link List} of extensions invoked when parsing Markdown.
    * @param extensions {@link List} of extensions invoked when parsing Markdown.
    * @param context    Contains necessary information needed to create
    *                   extensions used by the Markdown parser.
    */
   private static List<Extension> createExtensions(
     final ProcessorContext context ) {
     final var extensions = createEmptyExtensions();
     final var editorFile = context.getPath();
   void init(
     final List<Extension> extensions, final ProcessorContext context ) {
     final var editorFile = context.getDocumentPath();
     final var mediaType = MediaType.valueFrom( editorFile );
     final Processor<String> processor;
     if( mediaType == TEXT_R_MARKDOWN || mediaType == TEXT_R_XML ) {
       extensions.add( RExtension.create( context ) );
       final var rProcessor = new RProcessor( context );
       extensions.add( RExtension.create( rProcessor ) );
       processor = rProcessor;
+    }
     else {
       processor = IDENTITY;
+    }
     extensions.addAll( DEFAULT_EXTENSIONS );
     // Add typographic, table, strikethrough, and similar extensions.
     super.init( extensions, context );
     extensions.add( ImageLinkExtension.create( context ) );
     extensions.add( TeXExtension.create( context ) );
     extensions.add( TeXExtension.create( context, processor ) );
     extensions.add( FencedBlockExtension.create( context ) );
     extensions.add( CaretExtension.create( context ) );
     return extensions;
+  }
   /**
    * Converts the given Markdown string into HTML, without the doctype, html,
    * head, and body tags.
+   *
    * @param markdown The string to convert from Markdown to HTML.
    * @return The HTML representation of the Markdown document.
    */
   @Override
   public String apply( final String markdown ) {
     return toHtml( parse( markdown ) );
+  }
   /**
    * Returns the AST in the form of a node for the given Markdown document. This
    * can be used, for example, to determine if a hyperlink exists inside of a
    * paragraph.
+   *
    * @param markdown The Markdown to convert into an AST.
    * @return The Markdown AST for the given text (usually a paragraph).
    */
   public Node toNode( final String markdown ) {
     return parse( markdown );
+  }
   /**
    * Returns the result of converting the given AST into an HTML string.
+   *
    * @param node The AST {@link Node} to convert to an HTML string.
    * @return The given {@link Node} as an HTML string.
    */
   public String toHtml( final Node node ) {
     return getRenderer().render( node );
+  }
   /**
    * Helper method to create an AST given some Markdown.
+   *
    * @param markdown The Markdown to parse.
    * @return The root node of the Markdown tree.
    */
   private Node parse( final String markdown ) {
     return getParser().parse( markdown );
+  }
   /**
    * Creates the Markdown document processor.
+   *
    * @return An instance of {@link IParse} for building abstract syntax trees.
    */
   private IParse getParser() {
     return mParser;
+  }
   private IRender getRenderer() {
     return mRenderer;
+  }
+}

M src/main/java/com/keenwrite/processors/markdown/extensions/ImageLinkExtension.java

 package com.keenwrite.processors.markdown.extensions;
 import com.keenwrite.ExportFormat;
 import com.keenwrite.exceptions.MissingFileException;
 import com.keenwrite.preferences.Workspace;
 import com.vladsch.flexmark.util.ast.Node;
 import org.jetbrains.annotations.NotNull;
 import org.renjin.repackaged.guava.base.Splitter;
 import java.io.File;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import static com.keenwrite.ExportFormat.NONE;
 import static com.keenwrite.StatusNotifier.clue;
 import static com.keenwrite.preferences.Workspace.KEY_IMAGES_DIR;
 import static com.keenwrite.preferences.Workspace.KEY_IMAGES_ORDER;
 import static com.keenwrite.util.ProtocolScheme.getProtocol;
 import static com.vladsch.flexmark.html.HtmlRenderer.Builder;
 import static com.vladsch.flexmark.html.renderer.LinkStatus.VALID;
 import static java.lang.String.format;
 import static org.renjin.repackaged.guava.base.Splitter.on;
 /**
  * Responsible for ensuring that images can be rendered relative to a path.
  * This allows images to be located virtually anywhere.
  */
 public class ImageLinkExtension extends HtmlRendererAdapter {
   private final Path mBaseDir;
   private final Workspace mWorkspace;
   private final ExportFormat mExportFormat;
   private ImageLinkExtension( @NotNull final ProcessorContext context ) {
     mBaseDir = context.getBaseDir();
     mWorkspace = context.getWorkspace();
     mExportFormat = context.getExportFormat();
+  }
+    }
     /**
      * Algorithm:
      * <ol>
      *   <li>Accept remote URLs as valid links.</li>
      *   <li>Accept existing readable files as valid links.</li>
      *   <li>Accept non-{@link ExportFormat#NONE} exports as valid links.</li>
      *   <li>Append the images dir to the edited file's dir (baseDir).</li>
      *   <li>Search for images by extension.</li>
      * </ol>
+     *
      * @param link The link URL to resolve.
      * @return The {@link ResolvedLink} instance used to render the link.
      */
     private ResolvedLink resolve( final ResolvedLink link ) {
       var uri = link.getUrl();
       final var protocol = getProtocol( uri );
       if( protocol.isHttp() ) {
       if( protocol.isRemote() ) {
         return valid( link, uri );
+      }
       final var baseDir = getBaseDir();
       // Determine the fully-qualified file name (fqfn).
       final var fqfn = Paths.get( getBaseDir().toString(), uri ).toFile();
       final var fqfn = Path.of( baseDir.toString(), uri ).toFile();
       if( fqfn.isFile() ) {
       if( fqfn.isFile() && fqfn.canRead() ) {
         return valid( link, uri );
+      }
       // At this point either the image directory is qualified or needs to be
       // qualified using the image prefix, as set in the user preferences.
       try {
         final var imagePrefix = getImagePrefix();
         final var baseDir = getBaseDir().resolve( imagePrefix );
       if( mExportFormat != NONE ) {
         return valid( link, uri );
+      }
         final var imagePrefixDir = Path.of( baseDir.toString(), uri );
         final var suffixes = getImageExtensions();
         boolean missing = true;
       try {
         // Compute the path to the image file. The base directory should
         // be an absolute path to the file being edited, without an extension.
         final var imagesDir = getUserImagesDir();
         final var relativeDir = imagesDir.toString().isEmpty()
           ? imagesDir : baseDir.relativize( imagesDir );
         final var imageFile = Path.of(
           baseDir.toString(), relativeDir.toString(), uri );
         // Iterate over the user's preferred image file type extensions.
         for( final var ext : Splitter.on( ' ' ).split( suffixes ) ) {
           final var imagePath = format( "%s.%s", imagePrefixDir, ext );
           final var file = new File( imagePath );
         for( final var ext : getImageExtensions() ) {
           var file = new File( imageFile.toString() + '.' + ext );
           if( file.exists() ) {
             uri += '.' + ext;
             final var path = Path.of( imagePrefix.toString(), uri );
             uri = path.normalize().toString();
             missing = false;
             break;
           if( file.exists() && file.canRead() ) {
             uri = file.toURI().toString();
             return valid( link, uri );
+          }
+        }
         if( missing ) {
           throw new MissingFileException( imagePrefixDir + ".*" );
+        }
         return valid( link, uri );
         throw new MissingFileException( imageFile + ".*" );
       } catch( final Exception ex ) {
         clue( ex );
+    }
     private Path getImagePrefix() {
     private Path getUserImagesDir() {
       return mWorkspace.toFile( KEY_IMAGES_DIR ).toPath();
+    }
     private String getImageExtensions() {
       return mWorkspace.toString( KEY_IMAGES_ORDER );
     private Iterable<String> getImageExtensions() {
       return on( ' ' ).split( mWorkspace.toString( KEY_IMAGES_ORDER ) );
+    }

M src/main/java/com/keenwrite/processors/markdown/extensions/r/RExtension.java

 package com.keenwrite.processors.markdown.extensions.r;
 import com.keenwrite.processors.*;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.r.InlineRProcessor;
 import com.keenwrite.processors.r.RProcessor;
 import com.keenwrite.sigils.RSigilOperator;
 import com.vladsch.flexmark.ast.Text;
 import java.util.Map;
 import static com.keenwrite.processors.IdentityProcessor.IDENTITY;
 import static com.vladsch.flexmark.parser.Parser.Builder;
 import static com.vladsch.flexmark.parser.Parser.ParserExtension;
 public final class RExtension implements ParserExtension {
   private final InlineParserFactory FACTORY = CustomParser::new;
   private final Processor<String> mProcessor;
   private final InlineRProcessor mInlineRProcessor;
   private boolean mReady;
   private final RProcessor mProcessor;
   private RExtension( final ProcessorContext context ) {
     final var irp = new InlineRProcessor( IDENTITY, context );
     final var rvp = new RVariableProcessor( irp, context );
     mProcessor = new ExecutorProcessor<>( rvp );
     mInlineRProcessor = irp;
   private RExtension( final RProcessor processor ) {
     mProcessor = processor;
+  }
   /**
    * Creates an extension capable of intercepting R code blocks and preventing
    * them from being converted into HTML {@code <code>} elements.
    */
   public static RExtension create( final ProcessorContext context ) {
     return new RExtension( context );
   public static RExtension create( final RProcessor processor ) {
     return new RExtension( processor );
+  }
              referenceLinkProcessors,
              inlineParserExtensions );
       mReady = mInlineRProcessor.init();
       mProcessor.init();
+    }
       final var foundTicks = super.parseBackticks();
       if( foundTicks && mReady ) {
       if( foundTicks && mProcessor.isReady() ) {
         final var blockNode = getBlock();
         final var codeNode = blockNode.getLastChild();

M src/main/java/com/keenwrite/processors/markdown/extensions/r/ROutputProcessor.java

 import com.keenwrite.processors.ExecutorProcessor;
 import com.keenwrite.processors.InlineRProcessor;
 import com.keenwrite.processors.r.InlineRProcessor;
 import com.keenwrite.processors.markdown.MarkdownProcessor;
 import com.keenwrite.processors.markdown.extensions.tex.TeXExtension;

M src/main/java/com/keenwrite/processors/markdown/extensions/tex/TeXExtension.java

 import com.keenwrite.ExportFormat;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.markdown.extensions.HtmlRendererAdapter;
   private final ExportFormat mExportFormat;
   private TeXExtension( final ProcessorContext context ) {
   private final Processor<String> mProcessor;
   private TeXExtension(
     final ProcessorContext context, final Processor<String> processor ) {
     mExportFormat = context.getExportFormat();
     mProcessor = processor;
+  }
   /**
    * Creates an extension capable of handling delimited TeX code in Markdown.
+   *
    * @return The new {@link TeXExtension}, never {@code null}.
    */
   public static TeXExtension create( final ProcessorContext context ) {
     return new TeXExtension( context );
   public static TeXExtension create(
     final ProcessorContext context, final Processor<String> processor ) {
     return new TeXExtension( context, processor );
+  }
                       @NotNull final String rendererType ) {
     if( "HTML".equalsIgnoreCase( rendererType ) ) {
       builder.nodeRendererFactory( new Factory( mExportFormat ) );
       builder.nodeRendererFactory( new Factory( mExportFormat, mProcessor ) );
+    }
+  }

M src/main/java/com/keenwrite/processors/markdown/extensions/tex/TexNodeRenderer.java

 import com.keenwrite.ExportFormat;
 import com.keenwrite.preview.SvgRasterizer;
 import com.keenwrite.processors.Processor;
 import com.vladsch.flexmark.html.HtmlWriter;
 import com.vladsch.flexmark.html.renderer.NodeRenderer;
 import org.jetbrains.annotations.Nullable;
 import java.util.Map;
 import java.util.Set;
 import static com.keenwrite.ExportFormat.*;
 import static com.keenwrite.preview.MathRenderer.MATH_RENDERER;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.*;
 public class TexNodeRenderer {
   private static final Map<ExportFormat, RendererFacade> EXPORT_RENDERERS =
     Map.of(
       HTML_TEX_SVG, new TexSvgNodeRenderer(),
       HTML_TEX_DELIMITED, new TexDelimNodeRenderer(),
       MARKDOWN_PLAIN, new TexDelimNodeRenderer(),
       NONE, new TexElementNodeRenderer()
     );
   public static class Factory implements NodeRendererFactory {
     private final ExportFormat mExportFormat;
     private final RendererFacade mNodeRenderer;
     public Factory( final ExportFormat exportFormat ) {
       mExportFormat = exportFormat;
     public Factory(
       final ExportFormat exportFormat, final Processor<String> processor ) {
       mNodeRenderer = EXPORT_RENDERERS.get( exportFormat );
       mNodeRenderer.setProcessor( processor );
+    }
     @NotNull
     @Override
     public NodeRenderer apply( @NotNull DataHolder options ) {
       return switch( mExportFormat ) {
         case HTML_TEX_SVG -> new TexSvgNodeRenderer();
         case HTML_TEX_DELIMITED, MARKDOWN_PLAIN -> new TexDelimNodeRenderer();
         case NONE -> new TexElementNodeRenderer();
       };
       return mNodeRenderer;
+    }
+  }
   private static abstract class AbstractTexNodeRenderer
       implements NodeRenderer {
   private static abstract class RendererFacade
     implements NodeRenderer {
     private Processor<String> mProcessor;
     @Override
                           final NodeRendererContext context,
                           final HtmlWriter html );
     private void setProcessor( final Processor<String> processor ) {
       mProcessor = processor;
+    }
     Processor<String> getProcessor() {
       return mProcessor;
+    }
+  }
   /**
    * Responsible for rendering a TeX node as an HTML {@code <tex>}
    * element. This is the default behaviour.
    */
   private static class TexElementNodeRenderer extends AbstractTexNodeRenderer {
   private static class TexElementNodeRenderer extends RendererFacade {
     void render( final TexNode node,
                  final NodeRendererContext context,
                  final HtmlWriter html ) {
       html.tag( HTML_TEX );
       html.raw( node.getText() );
       html.raw( getProcessor().apply( node.getText().toString() ) );
       html.closeTag( HTML_TEX );
+    }
+  }
   /**
    * Responsible for rendering a TeX node as an HTML {@code <svg>}
    * element.
    */
   private static class TexSvgNodeRenderer extends AbstractTexNodeRenderer {
   private static class TexSvgNodeRenderer extends RendererFacade {
     void render( final TexNode node,
                  final NodeRendererContext context,
                  final HtmlWriter html ) {
       final var tex = node.getText().toStringOrNull();
       final var doc = MATH_RENDERER.render( tex == null ? "" : tex );
       final var doc = MATH_RENDERER.render(
         tex == null ? "" : getProcessor().apply( tex ) );
       final var svg = SvgRasterizer.toSvg( doc.getDocumentElement() );
       html.raw( svg );
+    }
+  }
   /**
    * Responsible for rendering a TeX node as text bracketed by $ tokens.
    */
   private static class TexDelimNodeRenderer extends AbstractTexNodeRenderer {
   private static class TexDelimNodeRenderer extends RendererFacade {
     void render( final TexNode node,
                  final NodeRendererContext context,
                  final HtmlWriter html ) {
       html.raw( TOKEN_OPEN );
       html.raw( node.getText() );
       html.raw( getProcessor().apply( node.getText().toString() ) );
       html.raw( TOKEN_CLOSE );
+    }

A src/main/java/com/keenwrite/processors/r/InlineRProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors.r;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.processors.DefinitionProcessor;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.markdown.extensions.r.ROutputProcessor;
 import com.keenwrite.util.BoundedCache;
 import javafx.beans.property.Property;
 import javax.script.ScriptEngine;
 import javax.script.ScriptEngineManager;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicBoolean;
 import static com.keenwrite.Constants.STATUS_PARSE_ERROR;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.StatusNotifier.clue;
 import static com.keenwrite.preferences.Workspace.*;
 import static com.keenwrite.processors.text.TextReplacementFactory.replace;
 import static com.keenwrite.sigils.RSigilOperator.PREFIX;
 import static com.keenwrite.sigils.RSigilOperator.SUFFIX;
 import static java.lang.Math.max;
 import static java.lang.Math.min;
 import static java.lang.String.format;
 /**
  * Transforms a document containing R statements into Markdown.
  */
 public final class InlineRProcessor extends DefinitionProcessor {
   private final Processor<String> mPostProcessor = new ROutputProcessor();
   /**
    * Where to put document inline evaluated R expressions, constrained to
    * avoid running out of memory.
    */
   private final Map<String, String> mEvalCache =
     new BoundedCache<>( 512 );
   private static final ScriptEngine ENGINE =
     (new ScriptEngineManager()).getEngineByName( "Renjin" );
   private static final int PREFIX_LENGTH = PREFIX.length();
   private final AtomicBoolean mDirty = new AtomicBoolean( false );
   private final Workspace mWorkspace;
   /**
    * Constructs a processor capable of evaluating R statements.
+   *
    * @param successor Subsequent link in the processing chain.
    * @param context   Contains resolved definitions map.
    */
   public InlineRProcessor(
     final Processor<String> successor,
     final ProcessorContext context ) {
     super( successor, context );
     mWorkspace = context.getWorkspace();
     bootstrapScriptProperty().addListener(
       ( __, oldScript, newScript ) -> setDirty( true ) );
     workingDirectoryProperty().addListener(
       ( __, oldScript, newScript ) -> setDirty( true ) );
     // TODO: Watch the "R" property keys in the workspace, directly.
     // If the user saves the preferences, make sure that any R-related settings
     // changes are applied.
 //    getWorkspace().addSaveEventHandler( ( handler ) -> {
 //      if( isDirty() ) {
 //        init();
 //        setDirty( false );
 //      }
 //    } );
     init();
+  }
   /**
    * Initialises the R code so that R can find imported libraries. Note that
    * any existing R functionality will not be overwritten if this method is
    * called multiple times.
+   *
    * @return {@code true} if initialization completed and all variables were
    * replaced; {@code false} if any variables remain.
    */
   public boolean init() {
     final var bootstrap = getBootstrapScript();
     if( !bootstrap.isBlank() ) {
       final var wd = getWorkingDirectory();
       final var dir = wd.toString().replace( '\\', '/' );
       final var map = getDefinitions();
       final var defBegan = mWorkspace.toString( KEY_DEF_DELIM_BEGAN );
       final var defEnded = mWorkspace.toString( KEY_DEF_DELIM_ENDED );
       map.put( defBegan + "application.r.working.directory" + defEnded, dir );
       final var replaced = replace( bootstrap, map );
       final var bIndex = replaced.indexOf( defBegan );
       // If there's a delimiter in the replaced text it means not all variables
       // are bound, which is an error.
       if( bIndex >= 0 ) {
         var eIndex = replaced.indexOf( defEnded );
         eIndex = (eIndex == -1) ? replaced.length() - 1 : max( bIndex, eIndex );
         final var def = replaced.substring(
           bIndex + defBegan.length(), eIndex );
         clue( "Main.status.error.bootstrap.eval",
               format( "%s%s%s", defBegan, def, defEnded ) );
         return false;
+      }
       else {
         eval( replaced );
+      }
+    }
     return true;
+  }
   /**
    * Empties the cache.
    */
   public void clear() {
     mEvalCache.clear();
+  }
   /**
    * Sets the dirty flag to indicate that the bootstrap script or working
    * directory has been modified. Upon saving the preferences, if this flag
    * is true, then {@link #init()} will be called to reload the R environment.
+   *
    * @param dirty Set to true to reload changes upon closing preferences.
    */
   private void setDirty( final boolean dirty ) {
     mDirty.set( dirty );
+  }
   /**
    * Answers whether R-related settings have been modified.
+   *
    * @return {@code true} when the settings have changed.
    */
   private boolean isDirty() {
     return mDirty.get();
+  }
   /**
    * Evaluates all R statements in the source document and inserts the
    * calculated value into the generated document.
+   *
    * @param text The document text that includes variables that should be
    *             replaced with values when rendered as HTML.
    * @return The generated document with output from all R statements
    * substituted with value returned from their execution.
    */
   @Override
   public String apply( final String text ) {
     final int length = text.length();
     // The * 2 is a wild guess at the ratio of R statements to the length
     // of text produced by those statements.
     final StringBuilder sb = new StringBuilder( length * 2 );
     int prevIndex = 0;
     int currIndex = text.indexOf( PREFIX );
     while( currIndex >= 0 ) {
       // Copy everything up to, but not including, the opening token.
       sb.append( text, prevIndex, currIndex );
       // Jump to the start of the R statement.
       prevIndex = currIndex + PREFIX_LENGTH;
       // Find the closing token, without indexing past the text boundary.
       currIndex = text.indexOf( SUFFIX, min( currIndex + 1, length ) );
       // Only evaluate inline R statements that have end delimiters.
       if( currIndex > 1 ) {
         // Extract the inline R statement to be evaluated.
         final var r = text.substring( prevIndex, currIndex );
         // Pass the R statement into the R engine for evaluation.
         try {
           // Append the string representation of the result into the text.
           sb.append( evalCached( r ) );
         } catch( final Exception ex ) {
           // Inform the user that there was a problem.
           clue( STATUS_PARSE_ERROR, ex.getMessage(), currIndex );
           // If the string couldn't be parsed using R, append the statement
           // that failed to parse, instead of its evaluated value.
           sb.append( PREFIX ).append( r ).append( SUFFIX );
+        }
         // Retain the R statement's ending position in the text.
         prevIndex = currIndex + 1;
+      }
       // Find the start of the next inline R statement.
       currIndex = text.indexOf( PREFIX, min( currIndex + 1, length ) );
+    }
     // Copy from the previous index to the end of the string.
     return sb.append( text.substring( min( prevIndex, length ) ) ).toString();
+  }
   /**
    * Look up an R expression from the cache then return the resulting object.
    * If the R expression hasn't been cached, it'll first be evaluated.
+   *
    * @param r The expression to evaluate.
    * @return The object resulting from the evaluation.
    */
   private String evalCached( final String r ) {
     return mEvalCache.computeIfAbsent( r, __ -> evalHtml( r ) );
+  }
   /**
    * Converts the given string to HTML, trimming new lines, and inlining
    * the text if it is a paragraph. Otherwise, the resulting HTML is most likely
    * complex (e.g., a Markdown table) and should be rendered as its HTML
    * equivalent.
+   *
    * @param r The R expression to evaluate then convert to HTML.
    * @return The result from the R expression as an HTML element.
    */
   private String evalHtml( final String r ) {
     return mPostProcessor.apply( eval( r ) );
+  }
   /**
    * Evaluate an R expression and return the resulting object.
+   *
    * @param r The expression to evaluate.
    * @return The object resulting from the evaluation.
    */
   private String eval( final String r ) {
     try {
       return ENGINE.eval( r ).toString();
     } catch( final Exception ex ) {
       final var expr = r.substring( 0, min( r.length(), 50 ) );
       clue( get( "Main.status.error.r", expr, ex.getMessage() ), ex );
       return "";
+    }
+  }
   /**
    * Return the given path if not {@code null}, otherwise return the path to
    * the user's directory.
+   *
    * @return A non-null path.
    */
   private Path getWorkingDirectory() {
     return workingDirectoryProperty().getValue().toPath();
+  }
   private Property<File> workingDirectoryProperty() {
     return getWorkspace().fileProperty( KEY_R_DIR );
+  }
   /**
    * Loads the R init script from the application's persisted preferences.
+   *
    * @return A non-null string, possibly empty.
    */
   private String getBootstrapScript() {
     return bootstrapScriptProperty().getValue();
+  }
   private Property<String> bootstrapScriptProperty() {
     return getWorkspace().valuesProperty( KEY_R_SCRIPT );
+  }
   private Workspace getWorkspace() {
     return mWorkspace;
+  }
+}

A src/main/java/com/keenwrite/processors/r/RProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors.r;
 import com.keenwrite.processors.ExecutorProcessor;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import static com.keenwrite.processors.IdentityProcessor.IDENTITY;
 /**
  * Responsible for processing R statements within a text block.
  */
 public final class RProcessor extends ExecutorProcessor<String> {
   private final Processor<String> mProcessor;
   private final InlineRProcessor mInlineRProcessor;
   private volatile boolean mReady;
   public RProcessor( final ProcessorContext context ) {
     final var irp = new InlineRProcessor( IDENTITY, context );
     final var rvp = new RVariableProcessor( irp, context );
     mProcessor = new ExecutorProcessor<>( rvp );
     mInlineRProcessor = irp;
+  }
   public void init() {
     mReady = mInlineRProcessor.init();
+  }
   public boolean isReady() {
     return mReady;
+  }
   public String apply( final String text ) {
     return mProcessor.apply( text );
+  }
+}

A src/main/java/com/keenwrite/processors/r/RVariableProcessor.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors.r;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.processors.DefinitionProcessor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.sigils.RSigilOperator;
 import com.keenwrite.sigils.SigilOperator;
 import com.keenwrite.sigils.YamlSigilOperator;
 import java.util.HashMap;
 import java.util.Map;
 import static com.keenwrite.preferences.Workspace.*;
 /**
  * Converts the keys of the resolved map from default form to R form, then
  * performs a substitution on the text. The default R variable syntax is
  * {@code v$tree$leaf}.
  */
 public final class RVariableProcessor extends DefinitionProcessor {
   private final SigilOperator mSigilOperator;
   public RVariableProcessor(
     final InlineRProcessor irp, final ProcessorContext context ) {
     super( irp, context );
     mSigilOperator = createSigilOperator( context.getWorkspace() );
+  }
   /**
    * Returns the R-based version of the interpolated variable definitions.
+   *
    * @return Variable names transmogrified from the default syntax to R syntax.
    */
   @Override
   protected Map<String, String> getDefinitions() {
     return entoken( super.getDefinitions() );
+  }
   /**
    * Converts the given map from regular variables to R variables.
+   *
    * @param map Map of variable names to values.
    * @return Map of R variables.
    */
   private Map<String, String> entoken( final Map<String, String> map ) {
     final var rMap = new HashMap<String, String>( map.size() );
     for( final var entry : map.entrySet() ) {
       final var key = entry.getKey();
       rMap.put( mSigilOperator.entoken( key ), escape( map.get( key ) ) );
+    }
     return rMap;
+  }
   private String escape( final String value ) {
     return '\'' + escape( value, '\'', "\\'" ) + '\'';
+  }
   /**
    * TODO: Make generic method for replacing text.
+   *
    * @param haystack Search this string for the needle, must not be null.
    * @param needle   The character to find in the haystack.
    * @param thread   Replace the needle with this text, if the needle is found.
    * @return The haystack with the all instances of needle replaced with thread.
    */
   @SuppressWarnings("SameParameterValue")
   private String escape(
     final String haystack, final char needle, final String thread ) {
     int end = haystack.indexOf( needle );
     if( end < 0 ) {
       return haystack;
+    }
     final int length = haystack.length();
     int start = 0;
     // Replace up to 32 occurrences before the string reallocates its buffer.
     final var sb = new StringBuilder( length + 32 );
     while( end >= 0 ) {
       sb.append( haystack, start, end ).append( thread );
       start = end + 1;
       end = haystack.indexOf( needle, start );
+    }
     return sb.append( haystack.substring( start ) ).toString();
+  }
   private SigilOperator createSigilOperator( final Workspace workspace ) {
     final var tokens = workspace.toTokens(
       KEY_R_DELIM_BEGAN, KEY_R_DELIM_ENDED );
     final var antecedent = createDefinitionOperator( workspace );
     return new RSigilOperator( tokens, antecedent );
+  }
   private SigilOperator createDefinitionOperator(
     final Workspace workspace ) {
     final var tokens = workspace.toTokens(
       KEY_DEF_DELIM_BEGAN, KEY_DEF_DELIM_ENDED );
     return new YamlSigilOperator( tokens );
+  }
+}

M src/main/java/com/keenwrite/search/SearchModel.java

  * a {@link Trie} for efficiency.
  */
 public class SearchModel {
 public final class SearchModel {
   private final ObjectProperty<IndexRange> mMatchOffset =
       new SimpleObjectProperty<>();

M src/main/java/com/keenwrite/sigils/RSigilOperator.java

  * Brackets variable names between {@link #PREFIX} and {@link #SUFFIX} sigils.
  */
 public class RSigilOperator extends SigilOperator {
 public final class RSigilOperator extends SigilOperator {
   public static final char KEY_SEPARATOR_R = '$';

M src/main/java/com/keenwrite/sigils/YamlSigilOperator.java

  * Brackets definition keys with token delimiters.
  */
 public class YamlSigilOperator extends SigilOperator {
 public final class YamlSigilOperator extends SigilOperator {
   public static final char KEY_SEPARATOR_DEF = '.';
   /**
    * Removes start and stop definition key delimiters from the given key. This
    * method does not check for delimiters, only that there are sufficient
    * characters to remove from either end of the given key.
    * Removes start and stop definition key delimiters from the given key.
+   *
    * @param key The key adorned with start and stop definition tokens.
    * @param key The key that may have start and stop tokens.
    * @return The given key with the delimiters removed.
    */
   public String detoken( final String key ) {
     final int beganLen = getBegan().length();
     final int endedLen = getEnded().length();
     final var began = getBegan();
     final var ended = getEnded();
     final int bLength = began.length();
     final int eLength = ended.length();
     final var bIndex = key.indexOf( began );
     final var eIndex = key.indexOf( ended, bIndex );
     final var kLength = key.length();
     return key.length() > beganLen + endedLen
       ? key.substring( beganLen, key.length() - endedLen )
       : key;
     return key.substring(
       bIndex == -1 ? 0 : bLength, eIndex == -1 ? kLength : kLength - eLength );
+  }
+}

M src/main/java/com/keenwrite/spelling/impl/PermissiveSpeller.java

  * spell checking and indicates that any given lexeme is in the lexicon.
  */
 public class PermissiveSpeller implements SpellChecker {
 public final class PermissiveSpeller implements SpellChecker {
   /**
    * Returns {@code true}, ignoring the given word.

M src/main/java/com/keenwrite/spelling/impl/TextEditorSpeller.java

  * Responsible for checking the spelling of a document being edited.
  */
 public class TextEditorSpeller {
 public final class TextEditorSpeller {
   /**
    * Only load the dictionary into memory once, because it's huge.

M src/main/java/com/keenwrite/ui/actions/Action.java

  * Defines actions the user can take through GUI interactions
  */
 public class Action implements MenuAction {
 public final class Action implements MenuAction {
   private final String mText;
   private final KeyCombination mAccelerator;

M src/main/java/com/keenwrite/ui/actions/ApplicationActions.java

  */
 @SuppressWarnings( "NonAsciiCharacters" )
 public class ApplicationActions {
 public final class ApplicationActions {
   private static final String STYLE_SEARCH = "search";
   private void file‿export( final ExportFormat format ) {
     final var main = getMainPane();
     final var context = main.createProcessorContext();
     final var context = main.createProcessorContext( format );
     final var chain = createProcessors( context );
     final var editor = main.getActiveTextEditor();

M src/main/java/com/keenwrite/ui/actions/ApplicationBars.java

  * and keyboard shortcuts.
  */
 public class ApplicationBars {
 public final class ApplicationBars {
   private static final Map<String, Action> sMap = new HashMap<>( 64 );
       addAction( "view.preview", e -> actions.view‿preview() ),
       SEPARATOR_ACTION,
       addAction( "view.menubar", e -> actions.view‿menubar() ),
       addAction( "view.toolbar", e -> actions.view‿toolbar() ),
       addAction( "view.statusbar", e -> actions.view‿statusbar() ),
       addAction( "view.menubar", e -> actions.view‿menubar() )
       addAction( "view.statusbar", e -> actions.view‿statusbar() )
     ),
     createMenu(

M src/main/java/com/keenwrite/ui/actions/FileChooserCommand.java

  * select files.
  */
 public class FileChooserCommand {
 public final class FileChooserCommand {
   private static final String FILTER_EXTENSION_TITLES =
     "Dialog.file.choose.filter";

M src/main/java/com/keenwrite/ui/actions/SeparatorAction.java

  * operation, acting as a placeholder for line separators.
  */
 public class SeparatorAction implements MenuAction {
 public final class SeparatorAction implements MenuAction {
   @Override
   public MenuItem createMenuItem() {

M src/main/java/com/keenwrite/ui/logging/LogView.java

 import java.time.LocalDateTime;
 import java.util.Objects;
 import java.util.TreeSet;
 import java.util.stream.Collectors;
  * Responsible for logging application issues to {@link TableView} entries.
  */
 public class LogView extends Alert {
 public final class LogView extends Alert {
   /**
    * Number of error messages to retain in the {@link TableView}, must be
    * Number of error messages to retain in the {@link TableView}; must be
    * greater than zero.
    */
   private void log( final LogEntry logEntry ) {
     // Exit early if the log already contains the message. The status bar will
     // remain current.
     if( mEntries.contains( logEntry ) ) {
       return;
+    }
     mEntries.add( logEntry );
       return sb.toString();
+    }
     @Override
     public boolean equals( final Object o ) {
       if( this == o ) { return true; }
       if( o == null || getClass() != o.getClass() ) { return false; }
       return Objects.equals( mMessage.get(), ((LogEntry) o).mMessage.get() );
+    }
     @Override
     public int hashCode() {
       return mMessage != null ? mMessage.hashCode() : 0;
+    }
+  }

M src/main/java/com/keenwrite/util/CyclicIterator.java

  * @param <T> The type of list to be cycled.
  */
 public class CyclicIterator<T> implements ListIterator<T> {
 public final class CyclicIterator<T> implements ListIterator<T> {
   private final List<T> mList;

M src/main/java/com/keenwrite/util/ProtocolScheme.java

   HTTP,
   /**
    * Denotes FTP.
    */
   FTP,
   /**
    * Denotes Java archive file.
    */
       final var uri = new URI( resource );
       return uri.isAbsolute()
           ? valueFrom( uri )
           : valueFrom( new URL( resource ) );
         ? valueFrom( uri )
         : valueFrom( new URL( resource ) );
     } catch( final Exception ex ) {
       // Using double-slashes is a short-hand to instruct the browser to
       // reference a resource using the parent URL's security model. This
       // is known as a protocol-relative URL.
       return resource.startsWith( "//" )
           ? HTTP
           : valueFrom( new File( resource ) );
         ? HTTP
         : valueFrom( new File( resource ) );
+    }
+  }
   /**
    * Answers {@code true} if the given protocol is either HTTP or HTTPS.
    * Answers whether the given protocol is HTTP or HTTPS.
+   *
    * @return {@code true} the protocol is either HTTP or HTTPS.
    */
   public boolean isHttp() {
     return this == HTTP;
+  }
   /**
    * Answers whether the given protocol is FTP.
+   *
    * @return {@code true} the protocol is FTP.
    */
   public boolean isFtp() {
     return this == HTTP;
+  }
   /**
    * Answers whether the given protocol represents a remote resource.
+   *
    * @return {@code true} the protocol is HTTP(S) or FTP.
    */
   public boolean isRemote() {
     return isHttp() || isFtp();
+  }

M src/main/java/com/keenwrite/util/ResourceWalker.java

  * Responsible for finding file resources.
  */
 public class ResourceWalker {
 public final class ResourceWalker {
   /**
    * Globbing pattern to match font names.

A src/main/resources/styles/dark/charcoal.css

 .root {
     -fx-accent: #1e74c6;
     -fx-focus-color: -fx-accent;
     -fx-base: #373e43;
     -fx-control-inner-background: derive(-fx-base, 35%);
     -fx-control-inner-background-alt: -fx-control-inner-background ;
+}
 .label{
     -fx-text-fill: lightgray;
+}
 .text-field {
     -fx-prompt-text-fill: gray;
+}
 .titulo{
     -fx-font-weight: bold;
     -fx-font-size: 18px;
+}
 .button{
     -fx-focus-traversable: false;
+}
 .button:hover{
     -fx-text-fill: white;
+}
 .separator *.line {
     -fx-background-color: #3C3C3C;
     -fx-border-style: solid;
     -fx-border-width: 1px;
+}
 .scroll-bar{
     -fx-background-color: derive(-fx-base,45%)
+}
 .button:default {
     -fx-base: -fx-accent ;
+}
 .table-view{
     /*-fx-background-color: derive(-fx-base, 10%);*/
     -fx-selection-bar-non-focused: derive(-fx-base, 50%);
+}
 .table-view .column-header .label{
     -fx-alignment: CENTER_LEFT;
     -fx-font-weight: none;
+}
 .list-cell:even,
 .list-cell:odd,
 .table-row-cell:even,
 .table-row-cell:odd{
     -fx-control-inner-background: derive(-fx-base, 15%);
+}
 .list-cell:empty,
 .table-row-cell:empty {
     -fx-background-color: transparent;
+}
 .list-cell,
 .table-row-cell{
     -fx-border-color: transparent;
     -fx-table-cell-border-color:transparent;
+}

A src/main/resources/styles/dark/modena.css

 /*
  * This is an adjustment of the original modena.css for a consistent dark theme.
  * Original modena.css here: https://gist.github.com/maxd/63691840fc372f22f470.
  */
 /* Redefine base colors */
 .root {
     -fx-base: rgb(50, 50, 50);
     -fx-background: rgb(50, 50, 50);
     /* make controls (buttons, thumb, etc.) slightly lighter */
     -fx-color: derive(-fx-base, 10%);
     /* text fields and table rows background */
     -fx-control-inner-background: rgb(20, 20, 20);
     /* version of -fx-control-inner-background for alternative rows */
     -fx-control-inner-background-alt: derive(-fx-control-inner-background, 2.5%);
     /* text colors depending on background's brightness */
     -fx-light-text-color: rgb(220, 220, 220);
     -fx-mid-text-color: rgb(100, 100, 100);
     -fx-dark-text-color: rgb(20, 20, 20);
     /* A bright blue for highlighting/accenting objects.  For example: selected
      * text; selected items in menus, lists, trees, and tables; progress bars */
     -fx-accent: rgb(0, 80, 100);
     /* color of non-focused yet selected elements */
     -fx-selection-bar-non-focused: rgb(50, 50, 50);
+}
 /* Fix derived prompt color for text fields */
 .text-input {
     -fx-prompt-text-fill: derive(-fx-control-inner-background, +50%);
+}
 /* Keep prompt invisible when focused (above color fix overrides it) */
 .text-input:focused {
     -fx-prompt-text-fill: transparent;
+}
 /* Fix scroll bar buttons arrows colors */
 .scroll-bar > .increment-button > .increment-arrow,
 .scroll-bar > .decrement-button > .decrement-arrow {
     -fx-background-color: -fx-mark-highlight-color, rgb(220, 220, 220);
+}
 .scroll-bar > .increment-button:hover > .increment-arrow,
 .scroll-bar > .decrement-button:hover > .decrement-arrow {
     -fx-background-color: -fx-mark-highlight-color, rgb(240, 240, 240);
+}
 .scroll-bar > .increment-button:pressed > .increment-arrow,
 .scroll-bar > .decrement-button:pressed > .decrement-arrow {
     -fx-background-color: -fx-mark-highlight-color, rgb(255, 255, 255);
+}

A src/main/resources/styles/dark/recaf.css

 /* =========================
  * ==     JFX Controls    ==
  * =========================
  */
 .root {
 	-fx-base: rgb(45, 45, 46);
 	-fx-background: rgb(45, 45, 46);
 	/* Brighten controls */
 	-fx-color: derive(-fx-base, -40%);
 	/* Control background */
 	-fx-control-inner-background: rgb(46, 46, 47);
 	/* Alternative control background (rows) */
 	-fx-control-inner-background-alt: derive(-fx-control-inner-background, 2.5%);
 	/* Text colors */
 	-fx-light-text-color: rgb(220, 220, 220);
 	-fx-mid-text-color: rgb(100, 100, 100);
 	-fx-dark-text-color: rgb(20, 20, 20);
 	/* Accent colors */
 	-fx-accent: rgb(51, 51, 52);
 	-fx-focus-color: rgb(51, 51, 52);
 	/* Non-focused-selected elements */
 	-fx-selection-bar-non-focused: rgb(45, 45, 46);
+}
 * {
 	-fx-highlight-fill: rgba(0, 180, 255, 0.4);
+}
 /* Scroll */
 .scroll-bar {
 	-fx-background-color: rgb(61,61,62);
+}
 .scroll-bar .thumb {
 	-fx-background-color: rgb(91,91,92);
 	-fx-background-radius: 0;
+}
 .scroll-bar .thumb:hover,
 .scroll-bar .thumb:pressed {
 	-fx-background-color: rgb(141,141,142);
+}
 .scroll-bar .increment-button .increment-arrow,
 .scroll-bar .decrement-button .decrement-arrow {
 	-fx-background-color: rgb(200,200,200);
+}
 .corner {
     -fx-background-color: rgb(61,61,62);
+}
 /* Menu */
 .menu-bar {
 	-fx-background-color: rgb(45, 45, 48);
+}
 .menu {
 	-fx-padding: 6 14 6 14;
 	-fx-background-insets: -1;
+}
 .menu-item {
 	-fx-padding: 5 11 5 11;
 	-fx-background-insets: -1;
+}
 .menu:hover {
 	-fx-background-color: rgb(61, 61, 62);
+}
 .context-menu,
 .menu:showing {
 	-fx-background-color: rgb(27, 27, 28);
 	-fx-border-insets: -1;
 	-fx-border-width: 1;
 	-fx-border-color: black;
+}
 .context-menu {
 	-fx-min-width: 80px;
 	-fx-background-insets: -1;
 	-fx-border-insets: -1;
 	-fx-border-width: 1;
 	-fx-border-color: black;
+}
 .context-menu .menu-item:focused {
 	-fx-background-color: rgb(61, 61, 62);
+}
 .context-menu-header {
 	/* TODO: Find a way to disable hover coloring on the menu header */
 	-fx-opacity: 1.0;
 	-fx-background-color: rgb(24, 50, 95);
+}
 .context-menu-header .label {
     -fx-opacity: 1.0;
+}
 /* Tabs */
 .tab-pane {
 	-fx-tab-min-width: 100px;
+}
 .tab-pane *.tab-header-background {
 	-fx-background-color: rgb(29, 29, 31);
 	-fx-border-width: 0 0 1 0;
 	-fx-border-color: black;
+}
 .headers-region {
 	-fx-background-color: rgb(75, 75, 76);
+}
 .tab {
 	-fx-background-color: rgb(36,36,37);
 	-fx-background-insets: 2 -1 -1 -1;
 	-fx-background-radius: 0;
 	-fx-padding: 2 2 1 2;
 	-fx-border-insets: 0;
 	-fx-border-width: 1 1 1 1;
 	-fx-border-color: black;
+}
 .tab:selected {
 	-fx-background-color: rgb(45, 45, 46);
 	-fx-background-insets: 2 -1 -1 -1;
 	-fx-padding: 2;
 	-fx-border-insets: 0;
 	-fx-border-width: 1 1 0 1;
 	-fx-border-color: black;
+}
 .tab:selected .focus-indicator {
 	-fx-border-color: transparent;
+}
 /* Table */
 .table-view {
 	-fx-selection-bar: rgb(50, 71, 77);
 	-fx-selection-bar-non-focused: rgb(46, 56, 59);
 	-fx-background-color: rgb(36,36,37);
 	-fx-background-insets: 2 -1 -1 -1;
 	-fx-background-radius: 0;
 	-fx-padding: -1;
 	-fx-border-width: 0 1 1 1;
 	-fx-border-color: rgb(22, 22, 23);
+}
 .table-view .filler,
 .table-view .show-hide-columns-button,
 .column-overlay {
 	-fx-background-color: transparent;
+}
 .column-header-background {
 	-fx-background-color: rgb(36,36,37);
 	-fx-background-insets: 2 -1 -1 -1;
 	-fx-padding: -1;
 	-fx-border-insets: 0;
 	-fx-border-width: 0 1 0 1;
 	-fx-border-color: rgb(22, 22, 23);
+}
 .column-header {
 	-fx-background-color: rgb(45, 45, 46);
 	-fx-background-insets: -1 -0 -1 0;
 	-fx-padding: 2;
 	-fx-border-insets: 1 -1 1 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(22, 22, 23);
+}
 /* Splitpane */
 .split-pane-divider {
 	-fx-background-color: black;
 	-fx-padding: 0;
 	-fx-background-insets: -5;
+}
 /* Tree */
 .tree-table-view,
 .tree-view {
 	-fx-background-color: rgb(29, 29, 31);
 	-fx-background-insets: 0;
 	-fx-border-width: 0 1 0 0;
 	-fx-border-color: black;
+}
 .tree-table-cell,
 .tree-cell {
 	-fx-background-color: rgb(29, 29, 31);
+}
 .tree-cell:selected {
 	-fx-background-color: rgb(44, 48, 55);
+}
 /* Buttons */
 .box,
 .button,
 .combo-box,
 .slider .thumb {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(63, 63, 70);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(85, 85, 85);
+}
 .check-box:hover .box,
 .button:hover,
 .combo-box:hover,
 .slider .thumb:hover {
 	-fx-background-color: rgb(80, 80, 85);
 	-fx-border-color: rgb(0, 122, 205);
+}
 .check-box:pressed .box,
 .button:pressed,
 .combo-box:pressed,
 .slider .thumb:pressed {
 	-fx-background-color: rgb(0, 122, 205);
 	-fx-border-color: rgb(0, 162, 245);
+}
 .combo-box:showing {
 	-fx-background-color: rgb(27, 27, 28);
 	-fx-border-width: 1 1 0 1;
 	-fx-border-color: black;
+}
 .combo-box .combo-box-popup .list-cell {
 	-fx-background-color: rgb(27, 27, 28);
+}
 .combo-box .combo-box-popup .list-cell:hover {
 	-fx-background-color: rgb(61, 61, 62);
+}
 .combo-box .combo-box-popup .list-view {
 	-fx-background-color: rgb(27, 27, 28);
 	-fx-border-width: 0 1 1 1;
 	-fx-border-color: black;
+}
 .hyperlink {
 	-fx-text-fill: rgb(30, 132, 250);
+}
 hyperlink:visited {
 	-fx-text-fill: rgb(98, 59, 217);
+}
 /* slider */
 .slider .track {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(29, 29, 31);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(65, 65, 65);
+}
 .slider .thumb {
 /*
 	-fx-background-insets: 3;
 	-fx-border-insets: 3;
 	*/
 	-fx-padding: 5;
+}
 .axis-tick-mark {
 	-fx-stroke: rgb(100, 100, 100);
+}
 /* Text */
 .text-area .content,
 .text-field {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(63, 63, 70);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(85, 85, 85);
+}
 .text-area {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(63, 63, 70);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(85, 85, 85);
+}
 .text-area .content {
 	-fx-border-width: 0;
+}
 /* Popup */
 .tooltip {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(40, 40, 42);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(70, 70, 72);
+}
 /* =========================
  * ==   Attach Elements   ==
  * =========================
  */
 .vm-view {
 	-fx-border-width: 0 0 0 1;
 	-fx-border-color: black;
+}
 .vm-buttons {
 	-fx-padding: 1 0 1 0;
+}
 .vm-buttons .button {
 	-fx-min-width: 140px;
 	-fx-min-height: 48px;
+}
 .vm-icon {
 	-fx-padding: 2 15 2 2;
+}
 /* =========================
  * ==   History Elements  ==
  * =========================
  */
 .hist-view {
 	-fx-border-width: 0 0 0 1;
 	-fx-border-color: black;
+}
 .hist-buttons {
 	-fx-padding: 1 0 1 0;
+}
 .hist-buttons .button {
 	-fx-min-width: 140px;
 	-fx-min-height: 48px;
+}
 .hist-icon {
 	-fx-padding: 2 13 2 2;
+}
 /* =========================
  * ==    Other Elements   ==
  * =========================
  */
 .faint {
 	-fx-text-fill: rgb(134, 134, 135);
+}
 .search-button {
 	-fx-background-image: url('../icons/find-light.png');
+}
 .search-field {
 	-fx-prompt-text-fill: rgb(134, 134, 135);
 	-fx-background-image: url('../icons/find-light.png');
 	-fx-background-color: rgb(39, 39, 41);
 	-fx-border-width: 1;
 	-fx-border-insets: 0 0 -1 -1;
 	-fx-border-color: black;
+}
 .resource-selector {
 	-fx-prompt-text-fill: rgb(134, 134, 135);
 	-fx-background-color: rgb(39, 39, 41);
 	-fx-border-color: rgb(39, 39, 41) black black rgb(39, 39, 41);
 	-fx-border-insets: 0 0 0 -1;
+}
 .resource-selector:hover {
 	-fx-border-width: 1;
 	-fx-border-insets: 0;
 	-fx-padding: 0 0 0 -1;
+}
 .resource-selector:showing {
 	-fx-border-color: black;
 	-fx-border-insets: 0;
 	-fx-border-width: 1 1 0 1;
 	-fx-padding: 0 0 1 -1;
+}
   /* Javadoc popup */
 .drag-popup-wrapper {
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(40, 40, 42);
 	-fx-background-insets: 0;
 	-fx-border-width: 1;
 	-fx-border-color: rgb(95, 95, 95)
+}
 .drag-popup-wrapper .scroll-pane {
 	-fx-background-insets: 0;
 	-fx-border-width: 0;
 	-fx-padding: 15;
+}
 .drag-popup-header {
 	-fx-padding: 5;
 	-fx-background-radius: 0;
 	-fx-background-color: rgb(63, 63, 70);
 	-fx-background-insets: 0;
 	-fx-border-width: 0 0 1 0;
 	-fx-border-color: rgb(95, 95, 95);
+}
 .update-header {
 	-fx-padding: 5;
 	-fx-background-color: rgb(32, 33, 35);
 	-fx-border-width: 0 0 1 0;
 	-fx-border-color: rgb(95, 95, 95);
+}
 .update-notes * {
 	-fx-fill: rgb(220, 220, 220);
+}

A src/main/resources/styles/dark/sakura-solarized.css

 /* $color-text: #dedce5; */
 /* Sakura.css v1.3.1
  * ================
  * Minimal css theme.
  * Project: https://github.com/oxalorg/sakura/
  */
 /* Body */
 html {
   font-size: 62.5%;
   font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif; }
 body {
   font-size: 1.8rem;
   line-height: 1.618;
   max-width: 38em;
   margin: auto;
   color: #839496;
   background-color: #002b36;
   padding: 13px; }
 @media (max-width: 684px) {
   body {
     font-size: 1.53rem; } }
 @media (max-width: 382px) {
   body {
     font-size: 1.35rem; } }
 h1, h2, h3, h4, h5, h6 {
   line-height: 1.1;
   font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif;
   font-weight: 700;
   margin-top: 3rem;
   margin-bottom: 1.5rem;
   overflow-wrap: break-word;
   word-wrap: break-word;
   -ms-word-break: break-all;
   word-break: break-word; }
 h1 {
   font-size: 2.35em; }
 h2 {
   font-size: 2.00em; }
 h3 {
   font-size: 1.75em; }
 h4 {
   font-size: 1.5em; }
 h5 {
   font-size: 1.25em; }
 h6 {
   font-size: 1em; }
 p {
   margin-top: 0px;
   margin-bottom: 2.5rem; }
 small, sub, sup {
   font-size: 75%; }
 hr {
   border-color: #2aa198; }
 a {
   text-decoration: none;
   color: #2aa198; }
   a:hover {
     color: #657b83;
     border-bottom: 2px solid #839496; }
   a:visited {
     color: #1f7972; }
 ul {
   padding-left: 1.4em;
   margin-top: 0px;
   margin-bottom: 2.5rem; }
 li {
   margin-bottom: 0.4em; }
 blockquote {
   margin-left: 0px;
   margin-right: 0px;
   padding-left: 1em;
   padding-top: 0.8em;
   padding-bottom: 0.8em;
   padding-right: 0.8em;
   border-left: 5px solid #2aa198;
   margin-bottom: 2.5rem;
   background-color: #073642; }
 blockquote p {
   margin-bottom: 0; }
 img, video {
   height: auto;
   max-width: 100%;
   margin-top: 0px;
   margin-bottom: 2.5rem; }
 /* Pre and Code */
 pre {
   background-color: #073642;
   display: block;
   padding: 1em;
   overflow-x: auto;
   margin-top: 0px;
   margin-bottom: 2.5rem; }
 code {
   font-size: 0.9em;
   padding: 0 0.5em;
   background-color: #073642;
   white-space: pre-wrap; }
 pre > code {
   padding: 0;
   background-color: transparent;
   white-space: pre; }
 /* Tables */
 table {
   text-align: justify;
   width: 100%;
   border-collapse: collapse; }
 td, th {
   padding: 0.5em;
   border-bottom: 1px solid #073642; }
 /* Buttons, forms and input */
 input, textarea {
   border: 1px solid #839496; }
   input:focus, textarea:focus {
     border: 1px solid #2aa198; }
 textarea {
   width: 100%; }
 .button, button, input[type="submit"], input[type="reset"], input[type="button"] {
   display: inline-block;
   padding: 5px 10px;
   text-align: center;
   text-decoration: none;
   white-space: nowrap;
   background-color: #2aa198;
   color: #002b36;
   border-radius: 1px;
   border: 1px solid #2aa198;
   cursor: pointer;
   box-sizing: border-box; }
   .button[disabled], button[disabled], input[type="submit"][disabled], input[type="reset"][disabled], input[type="button"][disabled] {
     cursor: default;
     opacity: .5; }
   .button:focus:enabled, .button:hover:enabled, button:focus:enabled, button:hover:enabled, input[type="submit"]:focus:enabled, input[type="submit"]:hover:enabled, input[type="reset"]:focus:enabled, input[type="reset"]:hover:enabled, input[type="button"]:focus:enabled, input[type="button"]:hover:enabled {
     background-color: #657b83;
     border-color: #657b83;
     color: #002b36;
     outline: 0; }
 textarea, select, input {
   color: #839496;
   padding: 6px 10px;
   /* The 6px vertically centers text on FF, ignored by Webkit */
   margin-bottom: 10px;
   background-color: #073642;
   border: 1px solid #073642;
   border-radius: 4px;
   box-shadow: none;
   box-sizing: border-box; }
   textarea:focus, select:focus, input:focus {
     border: 1px solid #2aa198;
     outline: 0; }
 input[type="checkbox"]:focus {
   outline: 1px dotted #2aa198; }
 label, legend, fieldset {
   display: block;
   margin-bottom: .5rem;
   font-weight: 600; }

A src/main/resources/styles/dark/toedter.css

 .root {
   -fx-base: rgb(50, 50, 50);
   -fx-background: rgb(50, 50, 50);
   -fx-control-inner-background:  rgb(50, 50, 50);
+}
 .tab {
   -fx-background-color: linear-gradient(to top, -fx-base, derive(-fx-base,30%));
+}
 .menu-bar {
   -fx-background-color: linear-gradient(to bottom, -fx-base, derive(-fx-base,30%));
+}
 .tool-bar:horizontal {
   -fx-background-color:
 linear-gradient(to bottom, derive(-fx-base,+50%), derive(-fx-base,-40%), derive(-fx-base,-20%));
+}
 .button {
   -fx-background-color: transparent;
+}
 .button:hover {
   -fx-background-color: -fx-shadow-highlight-color, -fx-outer-border, -fx-inner-border, -fx-body-color;
   -fx-color: -fx-hover-base;
+}
 .table-view {
   -fx-table-cell-border-color:derive(-fx-base,+10%);
   -fx-table-header-border-color:derive(-fx-base,+20%);
+}
 .split-pane:horizontal > * > .split-pane-divider {
   -fx-border-color: transparent -fx-base transparent -fx-base;
   -fx-background-color: transparent, derive(-fx-base,20%);
   -fx-background-insets: 0, 0 1 0 1;
+}
 .my-gridpane {
   -fx-background-color: radial-gradient(radius 100%, derive(-fx-base,20%), derive(-fx-base,-20%));
+}
 .separator-label {
   -fx-text-fill: orange;
+}

A src/test/java/com/keenwrite/AwaitFxExtension.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite;
 import javafx.embed.swing.JFXPanel;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.testfx.osgi.service.TestFx;
 import java.util.concurrent.Semaphore;
 import static javafx.application.Platform.runLater;
 import static javax.swing.SwingUtilities.invokeLater;
 /**
  * Blocks all unit tests until JavaFX is ready.
  */
 public class AwaitFxExtension implements BeforeAllCallback {
   /**
    * Prevent {@link RuntimeException} for internal graphics not initialized yet.
+   *
    * @param context Provided by the {@link TestFx} framework.
    * @throws InterruptedException Could not acquire semaphore.
    */
   @Override
   public void beforeAll( final ExtensionContext context )
     throws InterruptedException {
     final var semaphore = new Semaphore( 0 );
     invokeLater( () -> {
       // Prepare JavaFX toolkit and environment.
       new JFXPanel();
       runLater( semaphore::release );
     } );
     semaphore.acquire();
+  }
+}

M src/test/java/com/keenwrite/editors/markdown/MarkdownEditorTest.java

 package com.keenwrite.editors.markdown;
 import com.keenwrite.AwaitFxExtension;
 import com.keenwrite.preferences.Workspace;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.testfx.framework.junit5.ApplicationExtension;
 import java.util.regex.Pattern;
 import static java.util.regex.Pattern.compile;
 import static javafx.application.Platform.runLater;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 @ExtendWith( ApplicationExtension.class )
 @ExtendWith( {ApplicationExtension.class, AwaitFxExtension.class} )
 public class MarkdownEditorTest {
   private static final String[] WORDS = new String[]{
   @Test
   public void test_CaretWord_GetISO88591Word_WordSelected() {
     final var editor = createMarkdownEditor();
     runLater( () -> {
       final var editor = createMarkdownEditor();
     for( int i = 0; i < WORDS.length; i++ ) {
       final var word = WORDS[ i ];
       final var len = word.length();
       final var expected = REGEX.matcher( word ).replaceAll( "" );
       for( int i = 0; i < WORDS.length; i++ ) {
         final var word = WORDS[ i ];
         final var len = word.length();
         final var expected = REGEX.matcher( word ).replaceAll( "" );
       for( int j = 0; j < len; j++ ) {
         editor.moveTo( offset( i ) + j );
         final var actual = editor.getCaretWordText();
         assertEquals( expected, actual );
         for( int j = 0; j < len; j++ ) {
           editor.moveTo( offset( i ) + j );
           final var actual = editor.getCaretWordText();
           assertEquals( expected, actual );
+        }
+      }
+    }
     } );
+  }

M src/test/java/com/keenwrite/processors/markdown/ImageLinkExtensionTest.java

 package com.keenwrite.processors.markdown;
 import com.keenwrite.AwaitFxExtension;
 import com.keenwrite.Caret;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.preview.HtmlPreview;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.markdown.extensions.ImageLinkExtension;
 import com.vladsch.flexmark.html.HtmlRenderer;
 import com.vladsch.flexmark.parser.Parser;
 import javafx.stage.Stage;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.testfx.framework.junit5.ApplicationExtension;
 import org.testfx.framework.junit5.Start;
 import java.io.File;
 import java.net.URISyntaxException;
 import java.net.URI;
 import java.net.URL;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import static com.keenwrite.Constants.DOCUMENT_DEFAULT;
 import static com.keenwrite.ExportFormat.NONE;
 import static java.lang.String.format;
 import static javafx.application.Platform.runLater;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.testfx.util.WaitForAsyncUtils.waitForFxEvents;
 /**
  * Responsible for testing that linked images render into HTML according to
  * the {@link ImageLinkExtension} rules.
  */
 @ExtendWith( ApplicationExtension.class )
 @ExtendWith( {ApplicationExtension.class, AwaitFxExtension.class} )
 @SuppressWarnings( "SameParameterValue" )
 public class ImageLinkExtensionTest {
   private static final Workspace sWorkspace = new Workspace(
     getResource( "workspace.xml" ) );
   private static final Map<String, String> IMAGES = new HashMap<>();
     addUri( URI_PATH + ".png" );
     addUri( URI_PATH + ".jpg" );
     addUri( URI_PATH, URI_PATH + URI_IMAGE_EXT );
     addUri( URI_PATH, getResource( URI_PATH + URI_IMAGE_EXT ) );
     addUri( "//" + URI_WEB );
     addUri( "http://" + URI_WEB );
     addUri( "https://" + URI_WEB );
+  }
   private static void addUri( final String uri ) {
     addUri( uri, uri );
   private HtmlPreview mPreview;
   @Start
   @SuppressWarnings( "unused" )
   private void start( final Stage stage ) {
     mPreview = new HtmlPreview( sWorkspace );
+  }
   private static void addUri( final String uriKey, final String uriValue ) {
     IMAGES.put( toMd( uriKey ), toHtml( uriValue ) );
   private static void addUri( final String actualExpected ) {
     addUri( actualExpected, actualExpected );
+  }
   private static String toMd( final String file ) {
     return format( "![Tooltip](%s 'Title')", file );
   private static void addUri( final String actual, final String expected ) {
     IMAGES.put( toMd( actual ), toHtml( expected ) );
+  }
   private static String toHtml( final String file ) {
   private static String toMd( final String resource ) {
     return format( "![Tooltip](%s 'Title')", resource );
+  }
   private static String toHtml( final String url ) {
     return format(
       "<p><img src=\"%s\" alt=\"Tooltip\" title=\"Title\" /></p>\n", file );
       "<p><img src=\"%s\" alt=\"Tooltip\" title=\"Title\" /></p>\n", url );
+  }
   /**
    * Test that the key URIs present in the {@link #IMAGES} map are rendered
    * as the value URIs present in the same map.
    */
   @Test
   void test_LocalImage_RelativePathWithExtension_ResolvedSuccessfully()
     throws URISyntaxException {
     final var workspace = new Workspace();
     final var resource = getPathResource( URI_IMAGE );
   void test_ImageLookup_RelativePathWithExtension_ResolvedSuccessfully() {
     final var resource = getResourcePath( URI_IMAGE );
     final var imagePath = new File( URI_IMAGE ).toPath();
     final var subpaths = resource.getNameCount() - imagePath.getNameCount();
     final var subpath = resource.subpath( 0, subpaths );
     // The root component isn't considered part of the path, so add it back.
     final var path = resource.getRoot().resolve( subpath );
     final var extension = ImageLinkExtension.create( path, workspace );
     final var documentPath = Path.of(
       resource.getRoot().resolve( subpath ).toString(),
       DOCUMENT_DEFAULT.getName() );
     final var context = createProcessorContext( documentPath );
     final var extension = ImageLinkExtension.create( context );
     final var extensions = List.of( extension );
     final var pBuilder = Parser.builder();
     final var hBuilder = HtmlRenderer.builder();
     final var parser = pBuilder.extensions( extensions ).build();
     final var renderer = hBuilder.extensions( extensions ).build();
     assertNotNull( parser );
     assertNotNull( renderer );
     // Set a default (fallback) image directory search location.
     //getInstance().imagesDirectoryProperty().setValue( new File( "." ) );
     for( final var entry : IMAGES.entrySet() ) {
       final var key = entry.getKey();
       final var node = parser.parse( key );
       final var expectedHtml = entry.getValue();
       final var actualHtml = renderer.render( node );
       final var actualHtml = new StringBuilder( 128 );
       assertEquals( expectedHtml, actualHtml );
       runLater( () -> actualHtml.append( renderer.render( node ) ) );
       waitForFxEvents();
       assertEquals( expectedHtml, actualHtml.toString() );
+    }
+  }
   private Path getPathResource( final String path )
     throws URISyntaxException {
     final var url = getResource( path );
     assert url != null;
     final var uri = url.toURI();
     return Paths.get( uri );
   /**
    * Creates a new {@link ProcessorContext} for the given file name path.
+   *
    * @param documentPath Fully qualified path to the file name.
    * @return A context used for creating new {@link Processor} instances.
    */
   private ProcessorContext createProcessorContext( final Path documentPath ) {
     return new ProcessorContext(
       mPreview,
       new HashMap<>(),
       documentPath,
       Caret.builder().build(),
       NONE,
       sWorkspace
     );
+  }
   private URL getResource( final String path ) {
     final var packagePath = getClass().getPackageName().replace( '.', '/' );
   private static URL toUrl( final String path ) {
     final var clazz = ImageLinkExtensionTest.class;
     final var packagePath = clazz.getPackageName().replace( '.', '/' );
     final var resourcePath = '/' + packagePath + '/' + path;
     return getClass().getResource( resourcePath );
     return clazz.getResource( resourcePath );
+  }
   private static URI toUri( final String path ) {
     try {
       return toUrl( path ).toURI();
     } catch( final Exception ex ) {
       throw new RuntimeException( ex );
+    }
+  }
   private static Path getResourcePath( final String path ) {
     return Paths.get( toUri( path ) );
+  }
   private static String getResource( final String path ) {
     return toUri( path ).toString();
+  }
+}

A src/test/resources/com/keenwrite/processors/markdown/workspace.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <keenwrite>
    <workspace>
       <images>
          <order>svg pdf png jpg tiff</order>
          <dir></dir>
       </images>
    </workspace>
 </keenwrite>