Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

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

M R/conversion.R

+}
 cms.big <- function( n ) {
+}
 # -----------------------------------------------------------------------------
 # Returns a number as a comma-delimited string. This is a work-around
 round.up <- function( n, base = 5 ) {
   base * round( x( n ) / base )
+}
 # -----------------------------------------------------------------------------
 # Removes common accents from letters.
+#
 # @param s The string to remove diacritics from.
 # -----------------------------------------------------------------------------
 accentless <- function( s ) {
   chartr(
     "áéóūáéíóúÁÉÍÓÚýÝàèìòùÀÈÌÒÙâêîôûÂÊÎÔÛãõÃÕñÑäëïöüÄËÏÖÜÿçÇ",
     "aeouaeiouAEIOUyYaeiouAEIOUaeiouAEIOUaoAOnNaeiouAEIOUycC",
     s );
+}

M R/pluralize.R

 .irregular_patterns <- c(
   "fish$", "ois$", "-sheep$", "deer$", "pox$", "[A-Z].*ese$", "itis$"
   "fish$", "ois$", "sheep$", "deer$", "pox$", "[A-Z].*ese$", "itis$"
+)
 .irregular_nouns <- list(
   "beef"      = c( "a" = "beefs",       "c" = "beeves" ),
   "biscotto"  = c( "a" = "biscotti",    "c" = NA_character_ ),
   "brother"   = c( "a" = "brothers",    "c" = "brethren" ),
   "cactus"    = c( "a" = NA_character_, "c" = "catci" ),
   "child"     = c( "a" = NA_character_, "c" = "children" ),
   "cherub"    = c( "a" = "cherubim",    "c" = NA_character_ ),
   "cow"       = c( "a" = "cows",        "c" = "kine" ),
   "crisis"    = c( "a" = NA_character_, "c" = "crises" ),
   "data"      = c( "a" = "data",        "c" = "data" ),
   "ephemeris" = c( "a" = NA_character_, "c" = "ephemerides" ),
   "genie"     = c( "a" = "genies",      "c" = "genii" ),
   "graffito"  = c( "a" = "graffiti",    "c" = NA_character_ ),
   "matrix"    = c( "a" = NA_character_, "c" = "matrices" ),
   "money"     = c( "a" = "moneys",      "c" = "monies" ),
   "mongoose"  = c( "a" = "mongooses",   "c" = NA_character_ ),
   "minimum"   = c( "a" = "minimums",    "c" = "minima" ),
   "mythos"    = c( "a" = NA_character_, "c" = "mythoi" ),
   "octopus"   = c( "a" = "octopuses",   "c" = "octopodes" ),
   "octopus"   = c( "a" = NA_character_, "c" = "octopodes" ),
   "ox"        = c( "a" = NA_character_, "c" = "oxen" ),
   "passerby"  = c( "a" = NA_character_, "c" = "passersby" ),
   "panino"    = c( "a" = "panini",      "c" = NA_character_ ),
   "pieróg"    = c( "a" = "pierogi",     "c" = NA_character_ ),
   "pierog"    = c( "a" = "pierogi",     "c" = NA_character_ ),
   "radius"    = c( "a" = NA_character_, "c" = "radii" ),
   "referendum"= c( "a" = "referendums", "c" = "referenda" ),
   "soliloquy" = c( "a" = "soliloquies", "c" = NA_character_ ),
   "seraph"    = c( "a" = "seraphim",    "c" = NA_character_ ),
   "stadium"   = c( "a" = "stadiums",    "c" = "stadia" ),
   "trilby"    = c( "a" = "trilbys",     "c" = NA_character_ ),
   "vertex"    = c( "a" = NA_character_, "c" = "vertices" ),

A R.zip

Binary file

M build.gradle

 import static org.gradle.api.JavaVersion.*
 //file:noinspection SpellCheckingInspection
 buildscript {
   repositories {
     mavenCentral()
     maven {
       url "https://plugins.gradle.org/m2/"
+    }
+  }
   dependencies {
     classpath 'org.owasp:dependency-check-gradle:7.4.3'
     classpath "com.github.spotbugs.snom:spotbugs-gradle-plugin:5.0.13"
+  }
+}
 plugins {
   id 'application'
   id 'org.openjfx.javafxplugin' version '0.0.13'
   id 'com.palantir.git-version' version '0.15.0'
   //id "com.github.spotbugs" version "5.0.13"
+}
     '--add-exports=javafx.graphics/com.sun.javafx.scene.traversal=ALL-UNNAMED',
+]
 java {
   sourceCompatibility = 19
   targetCompatibility = 19
+}
 javafx {
   def v_junit = '5.9.1'
   def v_flexmark = '0.64.0'
   def v_jackson = '2.14.0'
   def v_jackson = '2.14.2'
   def v_echosvg = '0.2.2'
   def v_picocli = '4.7.0'
   // YAML
   implementation 'org.yaml:snakeyaml:2.0'
   implementation "com.fasterxml.jackson.core:jackson-core:${v_jackson}"
   implementation "com.fasterxml.jackson.core:jackson-databind:${v_jackson}"
   // R
   implementation 'org.apache.commons:commons-compress:1.23.0'
   implementation 'org.codehaus.plexus:plexus-utils:3.5.1'
   implementation 'org.renjin:renjin-script-engine:3.5-beta76'
   implementation 'org.renjin.cran:rjson:0.2.15-renjin-21'
   // Misc.
   implementation 'org.ahocorasick:ahocorasick:0.6.3'
   implementation 'org.apache.commons:commons-configuration2:2.8.0'
   implementation 'org.apache.commons:commons-configuration2:2.9.0'
   implementation 'com.googlecode.juniversalchardet:juniversalchardet:1.0.3'
   implementation 'javax.validation:validation-api:2.0.1.Final'
   implementation 'org.greenrobot:eventbus-java:3.3.1'
   implementation 'commons-beanutils:commons-beanutils:1.9.4'
   //implementation 'commons-beanutils:commons-beanutils:1.9.4'
   // Command-line parsing
 final String applicationPackage = "com.${applicationName}"
 final String applicationClass = "${applicationPackage}.Launcher"
 java {
   sourceCompatibility = VERSION_17
   targetCompatibility = VERSION_17
+}
 compileJava {

M gradle.properties

3	3	org.gradle.parallel=true
4	4
5

A images/kitten.jpg

A images/kitten.png

M installer.sh

 ARG_JAVA_OS="linux"
 ARG_JAVA_ARCH="amd64"
 ARG_JAVA_VERSION="19.0.1"
 ARG_JAVA_UPDATE="11"
 ARG_JAVA_VERSION="20.0.1"
 ARG_JAVA_UPDATE="10"
 ARG_JAVA_DIR="java"

M libs/keenquotes.jar

Binary file

M libs/tokenize.jar

Binary file

D r.zip

Binary file

A scripts/.gitignore

	1	sign.sh
1	2

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

 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite;
 import com.keenwrite.cmdline.Arguments;
 import com.keenwrite.util.AlphanumComparator;
 import com.keenwrite.commands.ConcatenateCommand;
 import com.keenwrite.processors.Processor;
 import com.keenwrite.processors.ProcessorContext;
 import com.keenwrite.processors.RBootstrapProcessor;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicInteger;
 import static com.keenwrite.Launcher.terminate;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.io.MediaType.TEXT_R_MARKDOWN;
 import static com.keenwrite.processors.ProcessorFactory.createProcessors;
 import static com.keenwrite.util.FileWalker.walk;
 import static java.lang.System.lineSeparator;
 import static java.nio.file.Files.readString;
 import static java.nio.file.Files.writeString;
 public class AppCommands {
   private static final ExecutorService sExecutor = newFixedThreadPool( 1 );
   /**
    * Sci-fi genres, which are can be longer than other genres, typically fall
    * below 150,000 words at 6 chars per word. This reduces re-allocations of
    * memory when concatenating files together when exporting novels.
    */
   private static final int DOCUMENT_LENGTH = 150_000 * 6;
   private AppCommands() {
       try {
         final var context = args.createProcessorContext();
         final var concat = context.getConcatenate();
         final var inputPath = context.getSourcePath();
         final var outputPath = context.getTargetPath();
         final var chain = createProcessors( context );
         final var inputDoc = read( inputPath, concat );
         final var outputDoc = chain.apply( inputDoc );
         final var processor = createBootstrapProcessor( chain, context );
         final var inputDoc = read( context );
         final var outputDoc = processor.apply( inputDoc );
         // Processors can export binary files. In such cases, processors will
     // Prevent the application from blocking while the processor executes.
     sExecutor.submit( callableTask );
+  }
   private static Processor<String> createBootstrapProcessor(
     final Processor<String> chain, final ProcessorContext context ) {
     return context.getSourceType() == TEXT_R_MARKDOWN
       ? new RBootstrapProcessor( chain, context )
       : chain;
+  }
    * </p>
+   *
    * @param inputPath The path to the source file to read.
    * @param concat    {@code true} to concatenate all files with the same
    *                  extension as the source path.
    * @param context The {@link ProcessorContext} containing input path,
    *                and other command-line parameters.
    * @return All files in the same directory as the file being edited
    * concatenated into a single string.
    */
   private static String read( final Path inputPath, final boolean concat )
   private static String read( final ProcessorContext context )
     throws IOException {
     final var concat = context.getConcatenate();
     final var inputPath = context.getSourcePath();
     final var parent = inputPath.getParent();
     final var filename = inputPath.getFileName().toString();
     final var extension = getExtension( filename );
     // Short-circuit because: only one file was requested; there is no parent
     // directory to scan for files; or there's no extension for globbing.
     if( !concat || parent == null || extension.isBlank() ) {
       return readString( inputPath );
+    }
     final var glob = "**/*." + extension;
     final var files = new ArrayList<Path>();
     walk( parent, glob, files::add );
     files.sort( new AlphanumComparator<>() );
     final var text = new StringBuilder( DOCUMENT_LENGTH );
     final var eol = lineSeparator();
     for( final var file : files ) {
       text.append( readString( file ) );
       text.append( eol );
+    }
     return text.toString();
     final var command = new ConcatenateCommand(
       parent, extension, context.getChapters() );
     return command.call();
+  }
+}

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

         : HTML_TEX_DELIMITED;
       case APP_PDF -> APPLICATION_PDF;
       case TEXT_XML -> XHTML_TEX;
       default -> throw new IllegalArgumentException( format(
         "Unrecognized format type and subtype: '%s' and '%s'", type, modifier

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

       .with( Mutator::setLocale, w::getLocale )
       .with( Mutator::setMetadata, w::getMetadata )
       .with( Mutator::setThemesPath, w::getThemesPath )
       .with( Mutator::setCachesPath,
       .with( Mutator::setThemesDir, w::getThemesPath )
       .with( Mutator::setCachesDir,
              () -> w.getFile( KEY_CACHES_DIR ) )
       .with( Mutator::setImagesPath,
       .with( Mutator::setImagesDir,
              () -> w.getFile( KEY_IMAGES_DIR ) )
       .with( Mutator::setImageOrder,
              () -> w.getString( KEY_IMAGES_ORDER ) )
       .with( Mutator::setImageServer,
              () -> w.getString( KEY_IMAGES_SERVER ) )
       .with( Mutator::setFontsPath,
       .with( Mutator::setFontsDir,
              () -> w.getFile( KEY_TYPESET_CONTEXT_FONTS_DIR ) )
       .with( Mutator::setCaret,
   public ProcessorContext createProcessorContext() {
     return createProcessorContext( null, NONE );
     return createProcessorContextBuilder( NONE ).build();
+  }
   private GenericBuilder<Mutator, ProcessorContext> createProcessorContextBuilder(
     final ExportFormat format ) {
     final var textEditor = getTextEditor();
     final var sourcePath = textEditor.getPath();
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
       .with( Mutator::setExportFormat, format );
+  }
   public ProcessorContext createProcessorContext(
     final Path targetPath, final ExportFormat format ) {
     final var textEditor = getTextEditor();
     final var sourcePath = textEditor.getPath();
     assert targetPath != null;
     assert format != null;
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
     return createProcessorContextBuilder( format )
       .with( Mutator::setTargetPath, targetPath )
       .with( Mutator::setExportFormat, format )
       .build();
+  }

M src/main/java/com/keenwrite/cmdline/Arguments.java

 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.cmdline;
+  )
   private boolean mKeepFiles;
   @CommandLine.Option(
     names = {"-c", "--chapters"},
     description =
       "Export chapter ranges, no spaces (e.g., -3,5-9,15-)",
     paramLabel = "String"
+  )
   private String mChapters;
   @CommandLine.Option(
     names = {"--curl-quotes"},
     description =
       "Replace straight quotes with curly quotes (${DEFAULT-VALUE})",
     defaultValue = "true"
+  )
   private Boolean mCurlQuotes;
   private boolean mCurlQuotes;
   @CommandLine.Option(
       .with( Mutator::setSourcePath, mSourcePath )
       .with( Mutator::setTargetPath, mTargetPath )
       .with( Mutator::setThemesPath, () -> mThemesDir )
       .with( Mutator::setCachesPath, () -> mCachesDir )
       .with( Mutator::setImagesPath, () -> mImagesDir )
       .with( Mutator::setThemesDir, () -> mThemesDir )
       .with( Mutator::setCachesDir, () -> mCachesDir )
       .with( Mutator::setImagesDir, () -> mImagesDir )
       .with( Mutator::setImageServer, () -> mImageServer )
       .with( Mutator::setImageOrder, () -> mImageOrder )
       .with( Mutator::setFontsPath, () -> mFontDir )
       .with( Mutator::setFontsDir, () -> mFontDir )
       .with( Mutator::setExportFormat, format )
       .with( Mutator::setDefinitions, () -> definitions )
       .with( Mutator::setMetadata, () -> mMetadata )
       .with( Mutator::setLocale, () -> locale )
       .with( Mutator::setConcatenate, mConcatenate )
       .with( Mutator::setConcatenate, () -> mConcatenate )
       .with( Mutator::setChapters, () -> mChapters )
       .with( Mutator::setSigilBegan, () -> mSigilBegan )
       .with( Mutator::setSigilEnded, () -> mSigilEnded )
       .with( Mutator::setRWorkingDir, () -> mRWorkingDir )
       .with( Mutator::setRScript, () -> rScript )
       .with( Mutator::setRWorkingDir, () -> mRWorkingDir )
       .with( Mutator::setCurlQuotes, () -> mCurlQuotes )
       .with( Mutator::setAutoRemove, () -> !mKeepFiles )

A src/main/java/com/keenwrite/commands/ConcatenateCommand.java

 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.commands;
 import com.keenwrite.util.AlphanumComparator;
 import com.keenwrite.util.RangeValidator;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.atomic.AtomicInteger;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.util.FileWalker.walk;
 import static java.lang.System.lineSeparator;
 import static java.nio.file.Files.readString;
 /**
  * Responsible for concatenating files according to user-defined chapter ranges.
  */
 public class ConcatenateCommand implements Callable<String> {
   /**
    * Sci-fi genres, which are can be longer than other genres, typically fall
    * below 150,000 words at 6 chars per word. This reduces re-allocations of
    * memory when concatenating files together when exporting novels.
    */
   private static final int DOCUMENT_LENGTH = 150_000 * 6;
   private final Path mParent;
   private final String mExtension;
   private final String mRange;
   public ConcatenateCommand(
     final Path parent,
     final String extension,
     final String range ) {
     assert parent != null;
     assert extension != null;
     assert range != null;
     mParent = parent;
     mExtension = extension;
     mRange = range;
+  }
   public String call() throws IOException {
     final var glob = "**/*." + mExtension;
     final var files = new ArrayList<Path>();
     final var text = new StringBuilder( DOCUMENT_LENGTH );
     final var chapter = new AtomicInteger();
     final var eol = lineSeparator();
     final var validator = new RangeValidator( mRange );
     walk( mParent, glob, files::add );
     files.sort( new AlphanumComparator<>() );
     files.forEach( file -> {
       try {
         if( validator.test( chapter.incrementAndGet() ) ) {
           clue( "Main.status.export.concat", file );
           text.append( readString( file ) )
               .append( eol );
+        }
       } catch( final IOException ex ) {
         clue( "Main.status.export.concat.io", file );
+      }
     } );
     return text.toString();
+  }
+}

M src/main/java/com/keenwrite/dom/DocumentParser.java

       return sDocumentBuilder.parse( input );
     } catch( final Exception ex ) {
       clue( ex );
     } catch( final Throwable t ) {
       clue( t );
       return sDocumentBuilder.newDocument();

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

+  }
   /**
    * Answers whether this instance is an image, vector or raster.
+   *
    * @return {@code true} if this instance represents any type of image.
    */
   public boolean isImage() {
     return isType( IMAGE );
+  }
   public boolean isUndefined() {
     return equals( UNDEFINED );

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

 import java.io.File;
 import java.nio.file.Path;
 import java.util.List;
   public static MediaType fromFile( final File file ) {
     return fromExtension( FilenameUtils.getExtension( file.getName() ) );
+  }
   public static MediaType fromPath( final Path path ) {
     return fromFile( path.toFile() );
+  }

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

 import static com.keenwrite.io.MediaType.*;
 import static java.lang.System.arraycopy;
 import static java.util.Arrays.fill;
 /**
  */
 public class MediaTypeSniffer {
   private static final int FORMAT_LENGTH = 11;
   private static final int END_OF_DATA = -2;
   /**
    * The maximum buffer size of magic bytes to analyze.
    */
   private static final int BUFFER = 12;
   /**
    * The media type data can have any value at a corresponding offset.
    */
   private static final int ANY = -1;
   /**
    * Denotes there are fewer than {@link #BUFFER} bytes to compare.
    */
   private static final int EOS = -2;
   private static final Map<int[], MediaType> FORMAT = new LinkedHashMap<>();
   private static void put( final int[] data, final MediaType mediaType ) {
     FORMAT.put( data, mediaType );
+  }
   /* The insertion order attempts to approximate the real-world likelihood of
    * encountering particular file formats in an application.
    */
   static {
     //@formatter:off
     put( ints( 0x3C, 0x73, 0x76, 0x67, 0x20 ), IMAGE_SVG_XML );
     put( ints( 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), IMAGE_PNG );
     put( ints( 0xFF, 0xD8, 0xFF, 0xE0 ), IMAGE_JPEG );
     put( ints( 0xFF, 0xD8, 0xFF, 0xEE ), IMAGE_JPEG );
     put( ints( 0xFF, 0xD8, 0xFF, 0xE1, -1, -1, 0x45, 0x78, 0x69, 0x66, 0x00 ), IMAGE_JPEG );
     put( ints( 0x49, 0x49, 0x2A, 0x00 ), IMAGE_TIFF );
     put( ints( 0x4D, 0x4D, 0x00, 0x2A ), IMAGE_TIFF );
     put( ints( 0x47, 0x49, 0x46, 0x38 ), IMAGE_GIF );
     put( ints( 0x52, 0x49, 0x46, 0x46, -1, -1, -1, -1, 0x57, 0x45, 0x42, 0x50 ), IMAGE_WEBP );
     put( ints( 0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E ), APP_PDF );
     put( ints( 0x25, 0x21, 0x50, 0x53, 0x2D, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x2D ), APP_EPS );
     put( ints( 0x25, 0x21, 0x50, 0x53 ), APP_PS );
     put( ints( 0x38, 0x42, 0x50, 0x53, 0x00, 0x01 ), IMAGE_PHOTOSHOP );
     put( ints( 0x8A, 0x4D, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), VIDEO_MNG );
     put( ints( 0x42, 0x4D ), IMAGE_BMP );
     put( ints( 0xFF, 0xFB, 0x30 ), AUDIO_MP3 );
     put( ints( 0x49, 0x44, 0x33 ), AUDIO_MP3 );
     put( ints( 0xFF, 0xD8, 0xFF, 0xE1, ANY, ANY, 0x45, 0x78, 0x69, 0x66, 0x00 ), IMAGE_JPEG );
     put( ints( 0x3C, 0x21 ), TEXT_HTML );
     put( ints( 0x3C, 0x68, 0x74, 0x6D, 0x6C ), TEXT_HTML );
     put( ints( 0xFE, 0xFF, 0x00, 0x3C, 0x00, 0x3f, 0x00, 0x78 ), TEXT_XML );
     put( ints( 0xFF, 0xFE, 0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00 ), TEXT_XML );
     put( ints( 0x47, 0x49, 0x46, 0x38 ), IMAGE_GIF );
     put( ints( 0x42, 0x4D ), IMAGE_BMP );
     put( ints( 0x49, 0x49, 0x2A, 0x00 ), IMAGE_TIFF );
     put( ints( 0x4D, 0x4D, 0x00, 0x2A ), IMAGE_TIFF );
     put( ints( 0x52, 0x49, 0x46, 0x46, ANY, ANY, ANY, ANY, 0x57, 0x45, 0x42, 0x50 ), IMAGE_WEBP );
     put( ints( 0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E ), APP_PDF );
     put( ints( 0x25, 0x21, 0x50, 0x53, 0x2D, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x2D ), APP_EPS );
     put( ints( 0x25, 0x21, 0x50, 0x53 ), APP_PS );
     put( ints( 0x38, 0x42, 0x50, 0x53, 0x00, 0x01 ), IMAGE_PHOTOSHOP );
     put( ints( 0xFF, 0xFB, 0x30 ), AUDIO_MP3 );
     put( ints( 0x49, 0x44, 0x33 ), AUDIO_MP3 );
     put( ints( 0x8A, 0x4D, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), VIDEO_MNG );
     put( ints( 0x23, 0x64, 0x65, 0x66 ), IMAGE_X_BITMAP );
     put( ints( 0x21, 0x20, 0x58, 0x50, 0x4D, 0x32 ), IMAGE_X_PIXMAP );
     put( ints( 0x2E, 0x73, 0x6E, 0x64 ), AUDIO_SIMPLE );
     put( ints( 0x64, 0x6E, 0x73, 0x2E ), AUDIO_SIMPLE );
     put( ints( 0x52, 0x49, 0x46, 0x46 ), AUDIO_WAV );
     put( ints( 0x50, 0x4B ), APP_ZIP );
     put( ints( 0x41, 0x43, -1, -1, -1, -1, 0x00, 0x00, 0x00, 0x00, 0x00 ), APP_ACAD );
     put( ints( 0x41, 0x43, ANY, ANY, ANY, ANY, 0x00, 0x00, 0x00, 0x00, 0x00 ), APP_ACAD );
     put( ints( 0xCA, 0xFE, 0xBA, 0xBE ), APP_JAVA );
     put( ints( 0xAC, 0xED ), APP_JAVA_OBJECT );
   public static MediaType getMediaType( final byte[] data ) {
     assert data != null;
     assert data.length > 0;
     final var source = new int[]{
 xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
 xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 xFF, 0XFF, EOS
     };
     for( int i = 0; i < data.length; i++ ) {
     for( int i = 0; i < Math.min( data.length, source.length ); i++ ) {
       source[ i ] = data[ i ] & 0xFF;
+    }
     for( final var key : FORMAT.keySet() ) {
     for( final var entry : FORMAT.entrySet() ) {
       final var key = entry.getKey();
       int i = -1;
       boolean matches = true;
       while( ++i < FORMAT_LENGTH && key[ i ] != END_OF_DATA && matches ) {
         matches = key[ i ] == source[ i ] || key[ i ] == -1;
       while( ++i < BUFFER && key[ i ] != EOS && matches ) {
         matches = key[ i ] == source[ i ] || key[ i ] == ANY;
+      }
       if( matches ) {
         return FORMAT.get( key );
         return entry.getValue();
+      }
+    }
    * Convenience method to return the probed media type for the given
    * {@link BufferedInputStream} instance. <strong>This resets the stream
    * pointer</strong> making the call idempotent. Users of this class should
    * prefer to call this method when operating on streams to avoid advancing
    * the stream.
    * pointer</strong> making the call idempotent. Prefer calling this
    * method when operating on streams to avoid advancing the stream.
+   *
    * @param bis Data source to ascertain the {@link MediaType}.
    * @return The IANA-defined {@link MediaType}, or
    * {@link MediaType#UNDEFINED} if indeterminate.
    * @throws IOException Could not read from the stream.
    */
   public static MediaType getMediaType( final BufferedInputStream bis )
     throws IOException {
     bis.mark( FORMAT_LENGTH );
     bis.mark( BUFFER );
     final var result = getMediaType( (InputStream) bis );
     bis.reset();
   private static MediaType getMediaType( final InputStream is )
     throws IOException {
     final var input = new byte[ FORMAT_LENGTH ];
     final var count = is.read( input, 0, FORMAT_LENGTH );
     final var input = new byte[ BUFFER ];
     final var count = is.read( input, 0, BUFFER );
     if( count > 1 ) {
   /**
    * Creates integer array from the given data, padded with
    * {@link #END_OF_DATA} values up to {@link #FORMAT_LENGTH}.
    * Creates an integer array from the given data, padded with {@link #EOS}
    * values up to {@link #BUFFER} in length.
+   *
    * @param data The input byte values to pad.
    * @return The data with padding.
    */
   private static int[] ints( final int... data ) {
     final var magic = new int[ FORMAT_LENGTH + 1 ];
     int i = -1;
     assert data != null;
     while( ++i < data.length ) {
       magic[ i ] = data[ i ];
+    }
     final var magic = new int[ data.length + 1 ];
     while( i < FORMAT_LENGTH ) {
       magic[ i++ ] = END_OF_DATA;
+    }
     fill( magic, EOS );
     arraycopy( data, 0, magic, 0, data.length );
     return magic;

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

 import java.util.function.Consumer;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.util.concurrent.Executors.newFixedThreadPool;
   @Override
   public Boolean call() throws IOException {
     try( final var input = new InputStreamReader( mInput );
     try( final var input = new InputStreamReader( mInput, UTF_8 );
          final var buffer = new BufferedReader( input ) ) {
       buffer.lines().forEach( mConsumer );

M src/main/java/com/keenwrite/io/downloads/DownloadManager.java

 import java.net.HttpURLConnection;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.time.Duration;
 import java.util.zip.GZIPInputStream;
 import static java.lang.Math.toIntExact;
 import static java.lang.String.format;
 import static java.lang.System.*;
 import static java.lang.System.getProperty;
 import static java.lang.System.setProperty;
 import static java.net.HttpURLConnection.HTTP_OK;
 import static java.net.HttpURLConnection.setFollowRedirects;
    * Opens the input stream for the resource to download.
+   *
    * @param url The {@link URL} resource to download.
    * @param uri The {@link URI} resource to download.
    * @return A token that can be used for downloading the content with
    * periodic updates or retrieving the stream for downloading the content.
    * @throws IOException The stream could not be opened.
    * @throws IOException        The stream could not be opened.
    * @throws URISyntaxException Invalid URI.
    */
   public static DownloadToken open( final String url ) throws IOException {
   public static DownloadToken open( final String uri )
     throws IOException, URISyntaxException {
     // Pass an undefined media type so that any type of file can be retrieved.
     return open( new URL( url ) );
     return open( new URI( uri ) );
+  }
   public static DownloadToken open( final URL url ) throws IOException {
     final var conn = connect( url );
     final var contentType = conn.getContentType();
     MediaType contentType;
     MediaType remoteType;
     try {
       contentType = MediaType.valueFrom( conn.getContentType() );
       remoteType = MediaType.valueFrom( contentType );
     } catch( final Exception ex ) {
       // If the media type couldn't be detected, try using the stream.
       contentType = MediaType.UNDEFINED;
       remoteType = MediaType.UNDEFINED;
+    }
     final var input = open( conn );
     // Peek at the magic header bytes to determine the media type.
     final var magicType = MediaTypeSniffer.getMediaType( input );
     // If the transport protocol's Content-Type doesn't align with the
     // media type for the magic header, defer to the transport protocol.
     final MediaType mediaType =
       !contentType.equals( magicType ) && !magicType.isUndefined()
         ? contentType
         : magicType;
     // media type for the magic header, defer to the transport protocol (so
     // long as the content type was sent from the remote side).
     final MediaType mediaType = remoteType.equals( magicType )
       ? remoteType
       : contentType != null && !contentType.isBlank()
       ? remoteType
       : magicType.isUndefined()
       ? remoteType
       : magicType;
     return new DownloadToken( conn, input, mediaType );

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

 import static java.util.Arrays.asList;
 import static javafx.scene.control.SelectionMode.MULTIPLE;
 import static javafx.scene.control.TableView.CONSTRAINED_RESIZE_POLICY;
 import static javafx.scene.control.TableView.CONSTRAINED_RESIZE_POLICY_FLEX_LAST_COLUMN;
 public class SimpleTableControl<K, V, F extends TableField<Entry<K, V>>>
     final var table = new TableView<>( model );
     table.setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY );
     table.setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY_FLEX_LAST_COLUMN );
     table.setEditable( true );
     table.getColumns().addAll(

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

 package com.keenwrite.preview;
 import com.keenwrite.ui.adapters.ReplacedElementAdapter;
 import com.keenwrite.collections.BoundedCache;
 import com.keenwrite.ui.adapters.ReplacedElementAdapter;
 import org.w3c.dom.Element;
 import org.xhtmlrenderer.extend.ReplacedElement;
 import java.util.Set;
 import static com.keenwrite.preview.SvgReplacedElementFactory.HTML_IMAGE;
 import static com.keenwrite.preview.SvgReplacedElementFactory.HTML_IMAGE_SRC;
 import static com.keenwrite.preview.ImageReplacedElementFactory.HTML_IMAGE;
 import static com.keenwrite.preview.ImageReplacedElementFactory.HTML_IMAGE_SRC;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.HTML_TEX;
 import static java.lang.Math.min;
+      }
       final var replaced = mCache.computeIfAbsent(
         source, k -> {
           final var r = f.createReplacedElement( c, box, uac, width, height );
           return r instanceof final ImageReplacedElement ire
             ? createImageElement( box, ire )
             : r;
+        }
       );
       final var replaced = mCache.computeIfAbsent( source, k -> {
         final var r = f.createReplacedElement( c, box, uac, width, height );
         return r instanceof final ImageReplacedElement ire
           ? createImageElement( box, ire )
           : r;
       } );
       if( replaced != null ) {
       factory.remove( element );
+    }
+  }
   public void addFactory( final ReplacedElementFactory factory ) {
     mFactories.add( factory );
+  }

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

     // content. Consequently, the chained factory must maintain insertion order.
     mFactory = new ChainedReplacedElementFactory(
       new SvgReplacedElementFactory(),
       new ImageReplacedElementFactory(),
       new SwingReplacedElementFactory()
     );

A src/main/java/com/keenwrite/preview/ImageReplacedElementFactory.java

 /* Copyright 2022 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.preview;
 import com.keenwrite.io.MediaType;
 import com.keenwrite.ui.adapters.ReplacedElementAdapter;
 import io.sf.carte.echosvg.transcoder.TranscoderException;
 import org.w3c.dom.Element;
 import org.xhtmlrenderer.extend.ReplacedElement;
 import org.xhtmlrenderer.extend.UserAgentCallback;
 import org.xhtmlrenderer.layout.LayoutContext;
 import org.xhtmlrenderer.render.BlockBox;
 import org.xhtmlrenderer.swing.ImageReplacedElement;
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.text.ParseException;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.io.downloads.DownloadManager.open;
 import static com.keenwrite.preview.SvgRasterizer.BROKEN_IMAGE_PLACEHOLDER;
 import static com.keenwrite.preview.SvgRasterizer.rasterize;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.HTML_TEX;
 import static com.keenwrite.util.ProtocolScheme.getProtocol;
 /**
  * Responsible for running {@link SvgRasterizer} on SVG images detected within
  * a document to transform them into rasterized versions. This will fall back
  * to loading rasterized images from a file if not detected as SVG.
  */
 public final class ImageReplacedElementFactory extends ReplacedElementAdapter {
   public static final String HTML_IMAGE = "img";
   public static final String HTML_IMAGE_SRC = "src";
   private static final ImageReplacedElement BROKEN_IMAGE =
     createElement( BROKEN_IMAGE_PLACEHOLDER );
   @Override
   public ReplacedElement createReplacedElement(
     final LayoutContext c,
     final BlockBox box,
     final UserAgentCallback uac,
     final int cssWidth,
     final int cssHeight ) {
     final var e = box.getElement();
     try {
       final BufferedImage raster =
         switch( e.getNodeName() ) {
           case HTML_IMAGE -> createHtmlImage( box, e, uac );
           case HTML_TEX -> createTexImage( e );
           default -> null;
         };
       return createElement( raster );
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return BROKEN_IMAGE;
+  }
   /**
    * Convert an HTML element to a raster graphic.
    */
   private static BufferedImage createHtmlImage(
     final BlockBox box,
     final Element e,
     final UserAgentCallback uac )
     throws TranscoderException, URISyntaxException, IOException {
     final var source = e.getAttribute( HTML_IMAGE_SRC );
     final var mediaType = MediaType.fromFilename( source );
     URI uri = null;
     BufferedImage raster = null;
     final var w = box.getContentWidth();
     if( getProtocol( source ).isRemote() ) {
       try( final var response = open( source );
            final var stream = response.getInputStream() ) {
         // Rasterize SVG from URL resource.
         raster = response.isSvg()
           ? rasterize( stream, w )
           : ImageIO.read( stream );
         clue( "Main.status.image.request.fetch", source );
+      }
+    }
     else if( mediaType.isSvg() ) {
       uri = resolve( source, uac, e );
+    }
     if( uri != null && w > 0 ) {
       raster = rasterize( uri, w );
+    }
     // Not an SVG, attempt to read a local rasterized image.
     if( raster == null && mediaType.isImage() ) {
       uri = resolve( source, uac, e );
       final var path = Path.of( uri.getPath() );
       try( final var stream = Files.newInputStream( path ) ) {
         raster = ImageIO.read( stream );
+      }
+    }
     return raster;
+  }
   private static URI resolve(
     final String source,
     final UserAgentCallback uac,
     final Element e )
     throws URISyntaxException {
     // Attempt to rasterize based on file name.
     final var baseUri = new URI( uac.getBaseURL() );
     final var path = baseUri.resolve( source ).normalize();
     if( path.isAbsolute() ) {
       return path;
+    }
     else {
       final var base = new URI( e.getBaseURI() ).getPath();
       return Path.of( base, source ).toUri();
+    }
+  }
   /**
    * Convert the TeX element to a raster graphic.
    */
   private BufferedImage createTexImage( final Element e )
     throws TranscoderException, ParseException {
     return rasterize( MathRenderer.toString( e.getTextContent() ) );
+  }
   private static ImageReplacedElement createElement( final BufferedImage bi ) {
     return bi == null
       ? BROKEN_IMAGE
       : new ImageReplacedElement( bi, bi.getWidth(), bi.getHeight() );
+  }
+}

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

57	57	}
58	58
	59	if( newW <= 0 && newH <= 0 ) {
	60	newW = oldW;
	61	newH = oldH;
	62	}
	63
59	64	return new Dimension( newW, newH );
60	65	}

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

 /* Copyright 2022 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.preview;
 import com.keenwrite.io.MediaType;
 import com.keenwrite.ui.adapters.ReplacedElementAdapter;
 import org.xhtmlrenderer.extend.ReplacedElement;
 import org.xhtmlrenderer.extend.UserAgentCallback;
 import org.xhtmlrenderer.layout.LayoutContext;
 import org.xhtmlrenderer.render.BlockBox;
 import org.xhtmlrenderer.swing.ImageReplacedElement;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.net.URI;
 import java.nio.file.Path;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.io.downloads.DownloadManager.open;
 import static com.keenwrite.preview.SvgRasterizer.*;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.HTML_TEX;
 import static com.keenwrite.util.ProtocolScheme.getProtocol;
 /**
  * Responsible for running {@link SvgRasterizer} on SVG images detected within
  * a document to transform them into rasterized versions.
  */
 public final class SvgReplacedElementFactory extends ReplacedElementAdapter {
   public static final String HTML_IMAGE = "img";
   public static final String HTML_IMAGE_SRC = "src";
   private static final ImageReplacedElement BROKEN_IMAGE =
     createImageReplacedElement( BROKEN_IMAGE_PLACEHOLDER );
   @Override
   public ReplacedElement createReplacedElement(
     final LayoutContext c,
     final BlockBox box,
     final UserAgentCallback uac,
     final int cssWidth,
     final int cssHeight ) {
     final var e = box.getElement();
     ImageReplacedElement image = null;
     try {
       BufferedImage raster = null;
       switch( e.getNodeName() ) {
         case HTML_IMAGE -> {
           final var source = e.getAttribute( HTML_IMAGE_SRC );
           URI uri = null;
           if( getProtocol( source ).isHttp() ) {
             try( final var response = open( source ) ) {
               if( response.isSvg() ) {
                 // Rasterize SVG from URL resource.
                 raster = rasterize(
                   response.getInputStream(),
                   box.getContentWidth()
                 );
+              }
               clue( "Main.status.image.request.fetch", source );
+            }
+          }
           else if( MediaType.fromFilename( source ).isSvg() ) {
             // Attempt to rasterize based on file name.
             final var srcUri = new URI( source ).getPath();
             final var path = Path.of( new File( srcUri ).getCanonicalPath() );
             if( path.isAbsolute() ) {
               uri = path.toUri();
+            }
             else {
               final var base = new URI( e.getBaseURI() ).getPath();
               uri = Path.of( base, source ).toUri();
+            }
+          }
           if( uri != null ) {
             raster = rasterize( uri, box.getContentWidth() );
+          }
+        }
         case HTML_TEX ->
           // Convert the TeX element to a raster graphic.
           raster = rasterize( MathRenderer.toString( e.getTextContent() ) );
+      }
       if( raster != null ) {
         image = createImageReplacedElement( raster );
+      }
     } catch( final Exception ex ) {
       image = BROKEN_IMAGE;
       clue( ex );
+    }
     return image == null ? BROKEN_IMAGE : image;
+  }
   private static ImageReplacedElement createImageReplacedElement(
     final BufferedImage bi ) {
     return new ImageReplacedElement( bi, bi.getWidth(), bi.getHeight() );
+  }
+}

M src/main/java/com/keenwrite/preview/images/ConstrainedDimension.java

  * Copyright 2013, Morten Nobel-Joergensen
+ *
  * License: The BSD 3-Clause License
  * http://opensource.org/licenses/BSD-3-Clause
  * SPDX-License-Identifier: BSD-3-Clause
  */
 package com.keenwrite.preview.images;
 import java.awt.*;
 /**
  * This class let you create dimension constrains based on a actual image.
  * This class let you create dimension constrains based on an actual image.
  */
 public class ConstrainedDimension {
   public static ConstrainedDimension createAbsolutionDimension(
     final int width, final int height ) {
     assert width > 0 && height > 0 : "Dimensions must be positive integers";
     assert width > 0 : "Width must be positive integer";
     assert height > 0 : "Height must be positive integer";
     return new ConstrainedDimension() {
       public Dimension getDimension( Dimension dimension ) {

M src/main/java/com/keenwrite/preview/images/ResampleOp.java

   public ResampleOp(
     final ResampleFilter filter, final int destWidth, final int destHeight ) {
     this( filter,
           createAbsolutionDimension( destWidth, destHeight ) );
     final ResampleFilter filter,
     final int dstWidth,
     final int dstHeight ) {
     this( filter, createAbsolutionDimension( dstWidth, dstHeight ) );
+  }
   public ResampleOp(
     final ResampleFilter filter, ConstrainedDimension dimensionConstrain ) {
     super( dimensionConstrain );
     mFilter = filter;
+  }
   public BufferedImage doFilter(
     BufferedImage srcImg, BufferedImage dest, int dstWidth, int dstHeight ) {
     BufferedImage srcImg, BufferedImage dst, int dstWidth, int dstHeight ) {
     this.dstWidth = dstWidth;
     this.dstHeight = dstHeight;
     final BufferedImage out;
     if( dest != null &&
       dstWidth == dest.getWidth() &&
       dstHeight == dest.getHeight() ) {
       out = dest;
       int nrDestChannels = ImageUtils.nrChannels( dest );
     if( dst != null &&
       dstWidth == dst.getWidth() &&
       dstHeight == dst.getHeight() ) {
       out = dst;
       int nrDestChannels = ImageUtils.nrChannels( dst );
       if( nrDestChannels != nrChannels ) {
         final var errorMgs = format(
         for( int k = 0; k < max; k++ ) { tot += arrWeight[ subindex + k ]; }
         assert tot != 0 : "should never happen except bug in filter";
         if( tot != 0f ) {
           for( int k = 0; k < max; k++ ) { arrWeight[ subindex + k ] /= tot; }
+        }
         for( int k = 0; k < max; k++ ) { arrWeight[ subindex + k ] /= tot; }
+      }
+    }

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

         .with( Mutator::setSourcePath, writeString( document, xhtml ) )
         .with( Mutator::setTargetPath, context.getTargetPath() )
         .with( Mutator::setThemesPath, context.getThemesPath() )
         .with( Mutator::setImagesPath, context.getImagesPath() )
         .with( Mutator::setThemesPath, context.getThemesDir() )
         .with( Mutator::setImagesPath, context.getImagesDir() )
         .with( Mutator::setCachesPath, context.getCachesPath() )
         .with( Mutator::setFontsPath, context.getFontsPath() )
         .with( Mutator::setFontsPath, context.getFontsDir() )
         .build();

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

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.processors;
 import com.keenwrite.ExportFormat;
 import com.keenwrite.collections.InterpolatingMap;
 import com.keenwrite.constants.Constants;
 import com.keenwrite.editors.common.Caret;
 import com.keenwrite.io.FileType;
 import com.keenwrite.sigils.PropertyKeyOperator;
 import com.keenwrite.sigils.SigilKeyOperator;
 import com.keenwrite.util.GenericBuilder;
 import org.renjin.repackaged.guava.base.Splitter;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
 import static com.keenwrite.Bootstrap.USER_CACHE_DIR;
 import static com.keenwrite.Bootstrap.USER_DATA_DIR;
 import static com.keenwrite.constants.Constants.*;
 import static com.keenwrite.io.FileType.UNKNOWN;
 import static com.keenwrite.io.MediaType.TEXT_PROPERTIES;
 import static com.keenwrite.io.MediaType.valueFrom;
 import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;
 /**
  * Provides a context for configuring a chain of {@link Processor} instances.
  */
 public final class ProcessorContext {
   private final Mutator mMutator;
   /**
    * Determines the file type from the path extension. This should only be
    * called when it is known that the file type won't be a definition file
    * (e.g., YAML or other definition source), but rather an editable file
    * (e.g., Markdown, R Markdown, etc.).
+   *
    * @param path The path with a file name extension.
    * @return The FileType for the given path.
    */
   private static FileType lookup( final Path path ) {
     assert path != null;
     final var prefix = GLOB_PREFIX_FILE;
     final var keys = sSettings.getKeys( prefix );
     var found = false;
     var fileType = UNKNOWN;
     while( keys.hasNext() && !found ) {
       final var key = keys.next();
       final var patterns = sSettings.getStringSettingList( key );
       final var predicate = createFileTypePredicate( patterns );
       if( predicate.test( path.toFile() ) ) {
         // Remove the EXTENSIONS_PREFIX to get the file name extension mapped
         // to a standard name (as defined in the settings.properties file).
         final String suffix = key.replace( prefix + '.', "" );
         fileType = FileType.from( suffix );
         found = true;
+      }
+    }
     return fileType;
+  }
   public boolean isExportFormat( final ExportFormat exportFormat ) {
     return mMutator.mExportFormat == exportFormat;
+  }
   /**
    * Responsible for populating the instance variables required by the
    * context.
    */
   public static class Mutator {
     private Path mSourcePath;
     private Path mTargetPath;
     private ExportFormat mExportFormat;
     private boolean mConcatenate;
     private Supplier<Path> mThemesPath = USER_DIRECTORY::toPath;
     private Supplier<Locale> mLocale = () -> Locale.ENGLISH;
     private Supplier<Map<String, String>> mDefinitions = HashMap::new;
     private Supplier<Map<String, String>> mMetadata = HashMap::new;
     private Supplier<Caret> mCaret = () -> Caret.builder().build();
     private Supplier<Path> mFontsPath = () -> getFontDirectory().toPath();
     private Supplier<Path> mImagesPath = USER_DIRECTORY::toPath;
     private Supplier<String> mImageServer = () -> DIAGRAM_SERVER_NAME;
     private Supplier<String> mImageOrder = () -> PERSIST_IMAGES_DEFAULT;
     private Supplier<Path> mCachesPath = USER_CACHE_DIR::toPath;
     private Supplier<String> mSigilBegan = () -> DEF_DELIM_BEGAN_DEFAULT;
     private Supplier<String> mSigilEnded = () -> DEF_DELIM_ENDED_DEFAULT;
     private Supplier<Path> mRWorkingDir = USER_DIRECTORY::toPath;
     private Supplier<String> mRScript = () -> "";
     private Supplier<Boolean> mCurlQuotes = () -> true;
     private Supplier<Boolean> mAutoRemove = () -> true;
     public void setSourcePath( final Path sourcePath ) {
       assert sourcePath != null;
       mSourcePath = sourcePath;
+    }
     public void setTargetPath( final Path outputPath ) {
       assert outputPath != null;
       mTargetPath = outputPath;
+    }
     public void setTargetPath( final File targetPath ) {
       assert targetPath != null;
       setTargetPath( targetPath.toPath() );
+    }
     public void setThemesPath( final Supplier<Path> themesPath ) {
       assert themesPath != null;
       mThemesPath = themesPath;
+    }
     public void setCachesPath( final Supplier<File> cachesDir ) {
       assert cachesDir != null;
       mCachesPath = () -> {
         final var dir = cachesDir.get();
         return (dir == null ? USER_DATA_DIR.toFile() : dir).toPath();
       };
+    }
     public void setImagesPath( final Supplier<File> imagesDir ) {
       assert imagesDir != null;
       mImagesPath = () -> {
         final var dir = imagesDir.get();
         return (dir == null ? USER_DIRECTORY : dir).toPath();
       };
+    }
     public void setImageOrder( final Supplier<String> imageOrder ) {
       assert imageOrder != null;
       mImageOrder = imageOrder;
+    }
     public void setImageServer( final Supplier<String> imageServer ) {
       assert imageServer != null;
       mImageServer = imageServer;
+    }
     public void setFontsPath( final Supplier<File> fontsPath ) {
       assert fontsPath != null;
       mFontsPath = () -> {
         final var dir = fontsPath.get();
         return (dir == null ? USER_DIRECTORY : dir).toPath();
       };
+    }
     public void setExportFormat( final ExportFormat exportFormat ) {
       assert exportFormat != null;
       mExportFormat = exportFormat;
+    }
     public void setConcatenate( final boolean concatenate ) {
       mConcatenate = concatenate;
+    }
     public void setLocale( final Supplier<Locale> locale ) {
       assert locale != null;
       mLocale = locale;
+    }
     /**
      * Sets the list of fully interpolated key-value pairs to use when
      * substituting variable names back into the document as variable values.
      * This uses a {@link Callable} reference so that GUI and command-line
      * usage can insert their respective behaviours. That is, this method
      * prevents coupling the GUI to the CLI.
+     *
      * @param supplier Defines how to retrieve the definitions.
      */
     public void setDefinitions( final Supplier<Map<String, String>> supplier ) {
       assert supplier != null;
       mDefinitions = supplier;
+    }
     public void setMetadata( final Supplier<Map<String, String>> metadata ) {
       assert metadata != null;
       mMetadata = metadata.get() == null ? HashMap::new : metadata;
+    }
     /**
      * Sets the source for deriving the {@link Caret}. Typically, this is
      * the text editor that has focus.
+     *
      * @param caret The source for the currently active caret.
      */
     public void setCaret( final Supplier<Caret> caret ) {
       assert caret != null;
       mCaret = caret;
+    }
     public void setSigilBegan( final Supplier<String> sigilBegan ) {
       assert sigilBegan != null;
       mSigilBegan = sigilBegan;
+    }
     public void setSigilEnded( final Supplier<String> sigilEnded ) {
       assert sigilEnded != null;
       mSigilEnded = sigilEnded;
+    }
     public void setRWorkingDir( final Supplier<Path> rWorkingDir ) {
       assert rWorkingDir != null;
       mRWorkingDir = rWorkingDir;
+    }
     public void setRScript( final Supplier<String> rScript ) {
       assert rScript != null;
       mRScript = rScript;
+    }
     public void setCurlQuotes( final Supplier<Boolean> curlQuotes ) {
       assert curlQuotes != null;
       mCurlQuotes = curlQuotes;
+    }
     public void setAutoRemove( final Supplier<Boolean> autoRemove ) {
       assert autoRemove != null;
       mAutoRemove = autoRemove;
+    }
     private boolean isExportFormat( final ExportFormat format ) {
       return mExportFormat == format;
+    }
+  }
   public static GenericBuilder<Mutator, ProcessorContext> builder() {
     return GenericBuilder.of( Mutator::new, ProcessorContext::new );
+  }
   /**
    * Creates a new context for use by the {@link ProcessorFactory} when
    * instantiating new {@link Processor} instances. Although all the
    * parameters are required, not all {@link Processor} instances will use
    * all parameters.
    */
   private ProcessorContext( final Mutator mutator ) {
     assert mutator != null;
     mMutator = mutator;
+  }
   public Path getSourcePath() {
     return mMutator.mSourcePath;
+  }
   /**
    * Fully qualified file name to use when exporting (e.g., document.pdf).
+   *
    * @return Full path to a file name.
    */
   public Path getTargetPath() {
     return mMutator.mTargetPath;
+  }
   public ExportFormat getExportFormat() {
     return mMutator.mExportFormat;
+  }
   public Locale getLocale() {
     return mMutator.mLocale.get();
+  }
   /**
    * Returns the variable map of definitions, without interpolation.
+   *
    * @return A map to help dereference variables.
    */
   public Map<String, String> getDefinitions() {
     return mMutator.mDefinitions.get();
+  }
   /**
    * Returns the variable map of definitions, with interpolation.
+   *
    * @return A map to help dereference variables.
    */
   public InterpolatingMap getInterpolatedDefinitions() {
     return new InterpolatingMap(
       createDefinitionKeyOperator(), getDefinitions()
     ).interpolate();
+  }
   public Map<String, String> getMetadata() {
     return mMutator.mMetadata.get();
+  }
   /**
    * Returns the current caret position in the document being edited and is
    * always up-to-date.
+   *
    * @return Caret position in the document.
    */
   public Supplier<Caret> getCaret() {
     return mMutator.mCaret;
+  }
   /**
    * Returns the directory that contains the file being edited. When
    * {@link Constants#DOCUMENT_DEFAULT} is created, the parent path is
    * {@code null}. This will get absolute path to the file before trying to
    * get te parent path, which should always be a valid path. In the unlikely
    * event that the base path cannot be determined by the path alone, the
    * default user directory is returned. This is necessary for the creation
    * of new files.
+   *
    * @return Path to the directory containing a file being edited, or the
    * default user directory if the base path cannot be determined.
    */
   public Path getBaseDir() {
     final var path = getSourcePath().toAbsolutePath().getParent();
     return path == null ? DEFAULT_DIRECTORY : path;
+  }
   FileType getSourceFileType() {
     return lookup( getSourcePath() );
+  }
   public Path getThemesPath() {
     return mMutator.mThemesPath.get();
+  }
   public Path getImagesPath() {
     return mMutator.mImagesPath.get();
+  }
   public Path getCachesPath() {
     return mMutator.mCachesPath.get();
+  }
   public Iterable<String> getImageOrder() {
     assert mMutator.mImageOrder != null;
     final var order = mMutator.mImageOrder.get();
     final var token = order.contains( "," ) ? ',' : ' ';
     return Splitter.on( token ).split( token + order );
+  }
   public String getImageServer() {
     return mMutator.mImageServer.get();
+  }
   public Path getFontsPath() {
     return mMutator.mFontsPath.get();
+  }
   public boolean getAutoRemove() {
     return mMutator.mAutoRemove.get();
+  }
   public Path getRWorkingDir() {
     return mMutator.mRWorkingDir.get();
+  }
   public String getRScript() {
     return mMutator.mRScript.get();
+  }
   public boolean getCurlQuotes() {
     return mMutator.mCurlQuotes.get();
+  }
   /**
    * Answers whether to process a single text file or all text files in
    * the same directory as a single text file. See {@link #getSourcePath()}
    * for the file to process (or all files in its directory).
+   *
    * @return {@code true} means to process all text files, {@code false}
    * means to process a single file.
    */
   public boolean getConcatenate() {
     return mMutator.mConcatenate;
 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.processors;
 import com.keenwrite.ExportFormat;
 import com.keenwrite.collections.InterpolatingMap;
 import com.keenwrite.constants.Constants;
 import com.keenwrite.editors.common.Caret;
 import com.keenwrite.io.FileType;
 import com.keenwrite.io.MediaType;
 import com.keenwrite.io.MediaTypeExtension;
 import com.keenwrite.sigils.PropertyKeyOperator;
 import com.keenwrite.sigils.SigilKeyOperator;
 import com.keenwrite.util.GenericBuilder;
 import org.renjin.repackaged.guava.base.Splitter;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.Callable;
 import java.util.function.Supplier;
 import static com.keenwrite.Bootstrap.USER_CACHE_DIR;
 import static com.keenwrite.Bootstrap.USER_DATA_DIR;
 import static com.keenwrite.constants.Constants.*;
 import static com.keenwrite.io.FileType.UNKNOWN;
 import static com.keenwrite.io.MediaType.TEXT_PROPERTIES;
 import static com.keenwrite.io.MediaType.valueFrom;
 import static com.keenwrite.predicates.PredicateFactory.createFileTypePredicate;
 /**
  * Provides a context for configuring a chain of {@link Processor} instances.
  */
 public final class ProcessorContext {
   private final Mutator mMutator;
   /**
    * Determines the file type from the path extension. This should only be
    * called when it is known that the file type won't be a definition file
    * (e.g., YAML or other definition source), but rather an editable file
    * (e.g., Markdown, R Markdown, etc.).
+   *
    * @param path The path with a file name extension.
    * @return The FileType for the given path.
    */
   private static FileType lookup( final Path path ) {
     assert path != null;
     final var prefix = GLOB_PREFIX_FILE;
     final var keys = sSettings.getKeys( prefix );
     var found = false;
     var fileType = UNKNOWN;
     while( keys.hasNext() && !found ) {
       final var key = keys.next();
       final var patterns = sSettings.getStringSettingList( key );
       final var predicate = createFileTypePredicate( patterns );
       if( predicate.test( path.toFile() ) ) {
         // Remove the EXTENSIONS_PREFIX to get the file name extension mapped
         // to a standard name (as defined in the settings.properties file).
         final String suffix = key.replace( prefix + '.', "" );
         fileType = FileType.from( suffix );
         found = true;
+      }
+    }
     return fileType;
+  }
   public boolean isExportFormat( final ExportFormat exportFormat ) {
     return mMutator.mExportFormat == exportFormat;
+  }
   /**
    * Responsible for populating the instance variables required by the
    * context.
    */
   public static class Mutator {
     private Path mSourcePath;
     private Path mTargetPath;
     private ExportFormat mExportFormat;
     private Supplier<Boolean> mConcatenate = () -> true;
     private Supplier<String> mChapters = () -> "";
     private Supplier<Path> mThemesDir = USER_DIRECTORY::toPath;
     private Supplier<Locale> mLocale = () -> Locale.ENGLISH;
     private Supplier<Map<String, String>> mDefinitions = HashMap::new;
     private Supplier<Map<String, String>> mMetadata = HashMap::new;
     private Supplier<Caret> mCaret = () -> Caret.builder().build();
     private Supplier<Path> mFontsDir = () -> getFontDirectory().toPath();
     private Supplier<Path> mImagesDir = USER_DIRECTORY::toPath;
     private Supplier<String> mImageServer = () -> DIAGRAM_SERVER_NAME;
     private Supplier<String> mImageOrder = () -> PERSIST_IMAGES_DEFAULT;
     private Supplier<Path> mCachesPath = USER_CACHE_DIR::toPath;
     private Supplier<String> mSigilBegan = () -> DEF_DELIM_BEGAN_DEFAULT;
     private Supplier<String> mSigilEnded = () -> DEF_DELIM_ENDED_DEFAULT;
     private Supplier<Path> mRWorkingDir = USER_DIRECTORY::toPath;
     private Supplier<String> mRScript = () -> "";
     private Supplier<Boolean> mCurlQuotes = () -> true;
     private Supplier<Boolean> mAutoRemove = () -> true;
     public void setSourcePath( final Path sourcePath ) {
       assert sourcePath != null;
       mSourcePath = sourcePath;
+    }
     public void setTargetPath( final Path outputPath ) {
       assert outputPath != null;
       mTargetPath = outputPath;
+    }
     public void setTargetPath( final File targetPath ) {
       assert targetPath != null;
       setTargetPath( targetPath.toPath() );
+    }
     public void setThemesDir( final Supplier<Path> themesDir ) {
       assert themesDir != null;
       mThemesDir = themesDir;
+    }
     public void setCachesDir( final Supplier<File> cachesDir ) {
       assert cachesDir != null;
       mCachesPath = () -> {
         final var dir = cachesDir.get();
         return (dir == null ? USER_DATA_DIR.toFile() : dir).toPath();
       };
+    }
     public void setImagesDir( final Supplier<File> imagesDir ) {
       assert imagesDir != null;
       mImagesDir = () -> {
         final var dir = imagesDir.get();
         return (dir == null ? USER_DIRECTORY : dir).toPath();
       };
+    }
     public void setImageOrder( final Supplier<String> imageOrder ) {
       assert imageOrder != null;
       mImageOrder = imageOrder;
+    }
     public void setImageServer( final Supplier<String> imageServer ) {
       assert imageServer != null;
       mImageServer = imageServer;
+    }
     public void setFontsDir( final Supplier<File> fontsDir ) {
       assert fontsDir != null;
       mFontsDir = () -> {
         final var dir = fontsDir.get();
         return (dir == null ? USER_DIRECTORY : dir).toPath();
       };
+    }
     public void setExportFormat( final ExportFormat exportFormat ) {
       assert exportFormat != null;
       mExportFormat = exportFormat;
+    }
     public void setConcatenate( final Supplier<Boolean> concatenate ) {
       mConcatenate = concatenate;
+    }
     public void setChapters( final Supplier<String> chapters ) {
       mChapters = chapters;
+    }
     public void setLocale( final Supplier<Locale> locale ) {
       assert locale != null;
       mLocale = locale;
+    }
     /**
      * Sets the list of fully interpolated key-value pairs to use when
      * substituting variable names back into the document as variable values.
      * This uses a {@link Callable} reference so that GUI and command-line
      * usage can insert their respective behaviours. That is, this method
      * prevents coupling the GUI to the CLI.
+     *
      * @param supplier Defines how to retrieve the definitions.
      */
     public void setDefinitions( final Supplier<Map<String, String>> supplier ) {
       assert supplier != null;
       mDefinitions = supplier;
+    }
     public void setMetadata( final Supplier<Map<String, String>> metadata ) {
       assert metadata != null;
       mMetadata = metadata.get() == null ? HashMap::new : metadata;
+    }
     /**
      * Sets the source for deriving the {@link Caret}. Typically, this is
      * the text editor that has focus.
+     *
      * @param caret The source for the currently active caret.
      */
     public void setCaret( final Supplier<Caret> caret ) {
       assert caret != null;
       mCaret = caret;
+    }
     public void setSigilBegan( final Supplier<String> sigilBegan ) {
       assert sigilBegan != null;
       mSigilBegan = sigilBegan;
+    }
     public void setSigilEnded( final Supplier<String> sigilEnded ) {
       assert sigilEnded != null;
       mSigilEnded = sigilEnded;
+    }
     public void setRWorkingDir( final Supplier<Path> rWorkingDir ) {
       assert rWorkingDir != null;
       mRWorkingDir = rWorkingDir;
+    }
     public void setRScript( final Supplier<String> rScript ) {
       assert rScript != null;
       mRScript = rScript;
+    }
     public void setCurlQuotes( final Supplier<Boolean> curlQuotes ) {
       assert curlQuotes != null;
       mCurlQuotes = curlQuotes;
+    }
     public void setAutoRemove( final Supplier<Boolean> autoRemove ) {
       assert autoRemove != null;
       mAutoRemove = autoRemove;
+    }
     private boolean isExportFormat( final ExportFormat format ) {
       return mExportFormat == format;
+    }
+  }
   public static GenericBuilder<Mutator, ProcessorContext> builder() {
     return GenericBuilder.of( Mutator::new, ProcessorContext::new );
+  }
   /**
    * Creates a new context for use by the {@link ProcessorFactory} when
    * instantiating new {@link Processor} instances. Although all the
    * parameters are required, not all {@link Processor} instances will use
    * all parameters.
    */
   private ProcessorContext( final Mutator mutator ) {
     assert mutator != null;
     mMutator = mutator;
+  }
   public Path getSourcePath() {
     return mMutator.mSourcePath;
+  }
   /**
    * Answers what type of input document is to be processed.
+   *
    * @return The input document's {@link MediaType}.
    */
   public MediaType getSourceType() {
     return MediaTypeExtension.fromPath( mMutator.mSourcePath );
+  }
   /**
    * Fully qualified file name to use when exporting (e.g., document.pdf).
+   *
    * @return Full path to a file name.
    */
   public Path getTargetPath() {
     return mMutator.mTargetPath;
+  }
   public ExportFormat getExportFormat() {
     return mMutator.mExportFormat;
+  }
   public Locale getLocale() {
     return mMutator.mLocale.get();
+  }
   /**
    * Returns the variable map of definitions, without interpolation.
+   *
    * @return A map to help dereference variables.
    */
   public Map<String, String> getDefinitions() {
     return mMutator.mDefinitions.get();
+  }
   /**
    * Returns the variable map of definitions, with interpolation.
+   *
    * @return A map to help dereference variables.
    */
   public InterpolatingMap getInterpolatedDefinitions() {
     return new InterpolatingMap(
       createDefinitionKeyOperator(), getDefinitions()
     ).interpolate();
+  }
   public Map<String, String> getMetadata() {
     return mMutator.mMetadata.get();
+  }
   /**
    * Returns the current caret position in the document being edited and is
    * always up-to-date.
+   *
    * @return Caret position in the document.
    */
   public Supplier<Caret> getCaret() {
     return mMutator.mCaret;
+  }
   /**
    * Returns the directory that contains the file being edited. When
    * {@link Constants#DOCUMENT_DEFAULT} is created, the parent path is
    * {@code null}. This will get absolute path to the file before trying to
    * get te parent path, which should always be a valid path. In the unlikely
    * event that the base path cannot be determined by the path alone, the
    * default user directory is returned. This is necessary for the creation
    * of new files.
+   *
    * @return Path to the directory containing a file being edited, or the
    * default user directory if the base path cannot be determined.
    */
   public Path getBaseDir() {
     final var path = getSourcePath().toAbsolutePath().getParent();
     return path == null ? DEFAULT_DIRECTORY : path;
+  }
   FileType getSourceFileType() {
     return lookup( getSourcePath() );
+  }
   public Path getThemesDir() {
     return mMutator.mThemesDir.get();
+  }
   public Path getImagesDir() {
     return mMutator.mImagesDir.get();
+  }
   public Path getCachesPath() {
     return mMutator.mCachesPath.get();
+  }
   public Iterable<String> getImageOrder() {
     assert mMutator.mImageOrder != null;
     final var order = mMutator.mImageOrder.get();
     final var token = order.contains( "," ) ? ',' : ' ';
     return Splitter.on( token ).split( token + order );
+  }
   public String getImageServer() {
     return mMutator.mImageServer.get();
+  }
   public Path getFontsDir() {
     return mMutator.mFontsDir.get();
+  }
   public boolean getAutoRemove() {
     return mMutator.mAutoRemove.get();
+  }
   public Path getRWorkingDir() {
     return mMutator.mRWorkingDir.get();
+  }
   public String getRScript() {
     return mMutator.mRScript.get();
+  }
   public boolean getCurlQuotes() {
     return mMutator.mCurlQuotes.get();
+  }
   /**
    * Answers whether to process a single text file or all text files in
    * the same directory as a single text file. See {@link #getSourcePath()}
    * for the file to process (or all files in its directory).
+   *
    * @return {@code true} means to process all text files, {@code false}
    * means to process a single file.
    */
   public boolean getConcatenate() {
     return mMutator.mConcatenate.get();
+  }
   public String getChapters() {
     return mMutator.mChapters.get();
+  }

A src/main/java/com/keenwrite/processors/RBootstrapProcessor.java

 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.processors;
 import com.keenwrite.processors.r.RBootstrapController;
 public class RBootstrapProcessor extends ExecutorProcessor<String> {
   private final Processor<String> mSuccessor;
   private final ProcessorContext mContext;
   public RBootstrapProcessor(
     final Processor<String> successor,
     final ProcessorContext context ) {
     assert successor != null;
     assert context != null;
     mSuccessor = successor;
     mContext = context;
+  }
   /**
    * Processes the given text document by replacing variables with their values.
+   *
    * @param text The document text that includes variables that should be
    *             replaced with values when rendered as HTML.
    * @return The text with all variables replaced.
    */
   @Override
   public String apply( final String text ) {
     assert text != null;
     final var bootstrap = mContext.getRScript();
     final var workingDir = mContext.getRWorkingDir().toString();
     final var definitions = mContext.getDefinitions();
     RBootstrapController.update( bootstrap, workingDir, definitions );
     return mSuccessor.apply( text );
+  }
+}

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


  private Path getImagesPath() {
    return mContext.getImagesPath();
    return mContext.getImagesDir();
  }


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

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 /* Copyright 2022 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.processors.markdown;

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

 import java.io.File;
 import java.nio.file.Path;
 import java.util.Optional;
 import static com.keenwrite.ExportFormat.NONE;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.util.ProtocolScheme.getProtocol;
      */
     private ResolvedLink forImage( final ResolvedLink link, final Node node ) {
       var uri = link.getUrl();
       final var protocol = getProtocol( uri );
       final var url = link.getUrl();
       final var protocolScheme = getProtocol( url );
       if( protocol.isRemote() ) {
         return valid( link, uri );
+      }
       return protocolScheme.isRemote()
         ? valid( link, url )
         : resolveImageFile( link, node, url );
+    }
     private ResolvedLink resolveImageFile(
       final ResolvedLink link,
       final Node node,
       final String url ) {
       final var userPath = new File( url );
       // If the user specified a fully qualified path name, use it verbatim.
       return readable( userPath )
         ? valid( link, url )
         : resolveUnqualifiedImageFile( link, node, url );
+    }
     private ResolvedLink resolveUnqualifiedImageFile(
       final ResolvedLink link,
       final Node node,
       final String url ) {
       final var baseDir = getBaseDir();
       final var fqfn = baseDir.resolve( Path.of( url ) );
       // Determine the fully-qualified file name (fqfn).
       final var fqfn = Path.of( baseDir.toString(), uri ).toFile();
       // If the image can be found relative to the base directory, then
       // use the link as is when resolving the path.
       return readable( fqfn.toFile() )
         ? valid( link, url )
         : resolveExtensionlessImageFile( link, node, url );
+    }
       if( fqfn.isFile() && fqfn.canRead() ||
         mContext.getExportFormat() != NONE ) {
         return valid( link, uri );
+      }
     private ResolvedLink resolveExtensionlessImageFile(
       final ResolvedLink link,
       final Node node,
       final String url
     ) {
       final var imagePath = new File( url );
       final var file = resolveImageExtension( imagePath );
       return file.isPresent() && readable( file.get() )
         ? valid( link, file.get().toString() )
         : resolveRelativeImageFile( link, node, url );
+    }
     private ResolvedLink resolveRelativeImageFile(
       final ResolvedLink link,
       final Node node,
       final String url ) {
       final var baseDir = getBaseDir();
       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 = getImageDir();
         final var relativeDir = imagesDir.toString().isEmpty()
           ? imagesDir : baseDir.relativize( imagesDir );
         final var imageFile = Path.of(
           baseDir.toString(), relativeDir.toString(), uri );
         for( final var ext : getImageOrder() ) {
           var file = new File( imageFile.toString() + '.' + ext );
         final var baseImagesDir = baseDir.resolve( imagesDir );
         final var imagePath = baseImagesDir.resolve( url );
         final var file = resolveImageExtension( imagePath.toFile() );
           if( file.exists() && file.canRead() ) {
             uri = file.toURI().toString();
             return valid( link, uri );
+          }
         if( file.isPresent() ) {
           final var resolved = imagesDir.resolve( file.get().toPath() );
           final var relative = baseDir.relativize( resolved );
           return valid( link, relative.toString() );
+        }
         clue( "Main.status.error.file.missing.near",
               imageFile + ".*", node.getLineNumber()
               imagePath + ".*", node.getLineNumber()
         );
       } catch( final Exception ex ) {
         clue( ex );
+      }
       return link;
+    }
     private Optional<File> resolveImageExtension( final File imagePath ) {
       for( final var ext : getImageOrder() ) {
         final var file = new File( imagePath.toString() + '.' + ext );
         if( readable( file ) ) {
           return Optional.of( file );
+        }
+      }
       return Optional.empty();
+    }
     private ResolvedLink valid( final ResolvedLink link, final String url ) {
       return link.withStatus( VALID ).withUrl( url );
+    }
     private Path getImageDir() {
       return mContext.getImagesPath();
       return mContext.getImagesDir();
+    }
     private Iterable<String> getImageOrder() {
       return mContext.getImageOrder();
+    }
     private Path getBaseDir() {
       return mContext.getBaseDir();
+    }
+  }
   private static boolean readable( final File file ) {
     return file.isFile() && file.canRead();
+  }
+}

M src/main/java/com/keenwrite/processors/r/RBootstrapController.java

 /* Copyright 2020-2021 White Magic Software, Ltd. -- All rights reserved. */
 /* Copyright 2020 White Magic Software, Ltd. -- All rights reserved.
+ *
  * SPDX-License-Identifier: MIT
  */
 package com.keenwrite.processors.r;
       final var dir = getRWorkingDirectory();
       final var definitions = mDefinitions.get();
       // A problem with the bootstrap script is likely caused by variables
       // not being loaded. This implies that the R processor is being invoked
       // too soon.
       update( bootstrap, dir, definitions );
+    }
+  }
   public static void update(
     final String bootstrap,
     final String workingDir,
     final Map<String, String> definitions ) {
     if( !bootstrap.isBlank() ) {
       final var map = new HashMap<String, String>( definitions.size() + 1 );
       definitions.forEach(
         ( k, v ) -> map.put( KEY_OPERATOR.apply( k ), escape( v ) )
       );
       map.put(
         KEY_OPERATOR.apply( "application.r.working.directory" ),
         escape( dir )
         escape( workingDir )
       );
       try {
         Engine.eval( replace( bootstrap, map ) );
       } catch( final Exception ex ) {
         clue( ex );
         // A problem with the bootstrap script is likely caused by variables
         // not being loaded. This implies that the R processor is being invoked
         // too soon.
+      }
+    }

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

           addAction( "file.export.pdf.dir", e -> actions.file_export_pdf_dir() ),
           addAction( "file.export.pdf.repeat", e -> actions.file_export_repeat() ),
           addAction( "file.export.html.dir", e -> actions.file_export_html_dir() ),
           addAction( "file.export.html_svg", e -> actions.file_export_html_svg() ),
           addAction( "file.export.html_tex", e -> actions.file_export_html_tex() ),

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

 import com.keenwrite.MainPane;
 import com.keenwrite.MainScene;
 import com.keenwrite.editors.TextDefinition;
 import com.keenwrite.editors.TextEditor;
 import com.keenwrite.editors.markdown.HyperlinkModel;
 import com.keenwrite.editors.markdown.LinkVisitor;
 import com.keenwrite.events.CaretMovedEvent;
 import com.keenwrite.events.ExportFailedEvent;
 import com.keenwrite.preferences.Key;
 import com.keenwrite.preferences.PreferencesController;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.processors.markdown.MarkdownProcessor;
 import com.keenwrite.search.SearchModel;
 import com.keenwrite.typesetting.Typesetter;
 import com.keenwrite.ui.controls.SearchBar;
 import com.keenwrite.ui.dialogs.ExportDialog;
 import com.keenwrite.ui.dialogs.ExportSettings;
 import com.keenwrite.ui.dialogs.ImageDialog;
 import com.keenwrite.ui.dialogs.LinkDialog;
 import com.keenwrite.ui.explorer.FilePicker;
 import com.keenwrite.ui.explorer.FilePickerFactory;
 import com.keenwrite.ui.logging.LogView;
 import com.keenwrite.util.AlphanumComparator;
 import com.keenwrite.util.RangeValidator;
 import com.vladsch.flexmark.ast.Link;
 import javafx.concurrent.Service;
 import javafx.concurrent.Task;
 import javafx.scene.control.Alert;
 import javafx.scene.control.Dialog;
 import javafx.stage.Window;
 import javafx.stage.WindowEvent;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicInteger;
 import static com.keenwrite.Bootstrap.*;
 import static com.keenwrite.ExportFormat.*;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.constants.Constants.PDF_DEFAULT;
 import static com.keenwrite.constants.Constants.USER_DIRECTORY;
 import static com.keenwrite.constants.GraphicsConstants.ICON_DIALOG_NODE;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preferences.AppKeys.*;
 import static com.keenwrite.processors.ProcessorFactory.createProcessors;
 import static com.keenwrite.ui.explorer.FilePickerFactory.SelectionType;
 import static com.keenwrite.ui.explorer.FilePickerFactory.SelectionType.*;
 import static com.keenwrite.util.FileWalker.walk;
 import static java.lang.System.lineSeparator;
 import static java.nio.file.Files.readString;
 import static java.nio.file.Files.writeString;
 import static javafx.application.Platform.runLater;
 import static javafx.event.Event.fireEvent;
 import static javafx.scene.control.Alert.AlertType.INFORMATION;
 import static javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST;
 import static org.apache.commons.io.FilenameUtils.getExtension;
 /**
  * Responsible for abstracting how functionality is mapped to the application.
  * This allows users to customize accelerator keys and will provide pluggable
  * functionality so that different text markup languages can change documents
  * using their respective syntax.
  */
 public final class GuiCommands {
   private static final String STYLE_SEARCH = "search";
   /**
    * Sci-fi genres, which are can be longer than other genres, typically fall
    * below 150,000 words at 6 chars per word. This reduces re-allocations of
    * memory when concatenating files together when exporting novels.
    */
   private static final int DOCUMENT_LENGTH = 150_000 * 6;
   /**
    * When an action is executed, this is one of the recipients.
    */
   private final MainPane mMainPane;
   private final MainScene mMainScene;
   private final LogView mLogView;
   /**
    * Tracks finding text in the active document.
    */
   private final SearchModel mSearchModel;
   private boolean mCanTypeset;
   /**
    * A {@link Task} can only be run once, so wrap it in a {@link Service} to
    * allow re-launching the typesetting task repeatedly.
    */
   private Service<Path> mTypesetService;
   /**
    * Prevent a race-condition between checking to see if the typesetting task
    * is running and restarting the task itself.
    */
   private final Object mMutex = new Object();
   public GuiCommands( final MainScene scene, final MainPane pane ) {
     mMainScene = scene;
     mMainPane = pane;
     mLogView = new LogView();
     mSearchModel = new SearchModel();
     mSearchModel.matchOffsetProperty().addListener( ( c, o, n ) -> {
       final var editor = getActiveTextEditor();
       // Clear highlighted areas before highlighting a new region.
       if( o != null ) {
         editor.unstylize( STYLE_SEARCH );
+      }
       if( n != null ) {
         editor.moveTo( n.getStart() );
         editor.stylize( n, STYLE_SEARCH );
+      }
     } );
     // When the active text editor changes ...
     mMainPane.textEditorProperty().addListener(
       ( c, o, n ) -> {
         // ... update the haystack.
         mSearchModel.search( getActiveTextEditor().getText() );
         // ... update the status bar with the current caret position.
         if( n != null ) {
           final var w = getWorkspace();
           final var recentDoc = w.fileProperty( KEY_UI_RECENT_DOCUMENT );
           // ... preserve the most recent document.
           recentDoc.setValue( n.getFile() );
           CaretMovedEvent.fire( n.getCaret() );
+        }
+      }
     );
+  }
   public void file_new() {
     getMainPane().newTextEditor();
+  }
   public void file_open() {
     pickFiles( FILE_OPEN_MULTIPLE ).ifPresent( l -> getMainPane().open( l ) );
+  }
   public void file_close() {
     getMainPane().close();
+  }
   public void file_close_all() {
     getMainPane().closeAll();
+  }
   public void file_save() {
     getMainPane().save();
+  }
   public void file_save_as() {
     pickFiles( FILE_SAVE_AS ).ifPresent( l -> getMainPane().saveAs( l ) );
+  }
   public void file_save_all() {
     getMainPane().saveAll();
+  }
   /**
    * Converts the actively edited file in the given file format.
+   *
    * @param format The destination file format.
    */
   private void file_export( final ExportFormat format ) {
     file_export( format, false );
+  }
   /**
    * Converts one or more files into the given file format. If {@code dir}
    * is set to true, this will first append all files in the same directory
    * as the actively edited file.
+   *
    * @param format The destination file format.
    * @param dir    Export all files in the actively edited file's directory.
    */
   private void file_export( final ExportFormat format, final boolean dir ) {
     final var editor = getMainPane().getTextEditor();
     final var exported = getWorkspace().fileProperty( KEY_UI_RECENT_EXPORT );
     final var exportParent = exported.get().toPath().getParent();
     final var editorParent = editor.getPath().getParent();
     final var userHomeParent = USER_DIRECTORY.toPath();
     final var exportPath = exportParent != null
       ? exportParent
       : editorParent != null
       ? editorParent
       : userHomeParent;
     final var filename = format.toExportFilename( editor.getPath() );
     final var selected = PDF_DEFAULT
       .getName()
       .equals( exported.get().getName() );
     final var selection = pickFile(
       selected
         ? filename
         : exported.get(),
       exportPath,
       FILE_EXPORT
     );
     selection.ifPresent( files -> file_export( editor, format, files, dir ) );
+  }
   private void file_export(
     final TextEditor editor,
     final ExportFormat format,
     final List<File> files,
     final boolean dir ) {
     editor.save();
     final var main = getMainPane();
     final var exported = getWorkspace().fileProperty( KEY_UI_RECENT_EXPORT );
     final var sourceFile = files.get( 0 );
     final var sourcePath = sourceFile.toPath();
     final var document = dir ? append( editor ) : editor.getText();
     final var context = main.createProcessorContext( sourcePath, format );
     final var service = new Service<Path>() {
       @Override
       protected Task<Path> createTask() {
         final var task = new Task<Path>() {
           @Override
           protected Path call() throws Exception {
             final var chain = createProcessors( context );
             final var export = chain.apply( document );
             // Processors can export binary files. In such cases, processors
             // return null to prevent further processing.
             return export == null ? null : writeString( sourcePath, export );
+          }
         };
         task.setOnSucceeded(
           e -> {
             // Remember the exported file name for next time.
             exported.setValue( sourceFile );
             final var result = task.getValue();
             // Binary formats must notify users of success independently.
             if( result != null ) {
               clue( "Main.status.export.success", result );
+            }
+          }
         );
         task.setOnFailed( e -> {
           final var ex = task.getException();
           clue( ex );
           if( ex instanceof TypeNotPresentException ) {
             fireExportFailedEvent();
+          }
         } );
         return task;
+      }
     };
     mTypesetService = service;
     typeset( service );
+  }
   /**
    * @param dir {@code true} means to export all files in the active file
    *            editor's directory; {@code false} means to export only the
    *            actively edited file.
    */
   private void file_export_pdf( final boolean dir ) {
     final var workspace = getWorkspace();
     final var themes = workspace.getFile(
       KEY_TYPESET_CONTEXT_THEMES_PATH
     );
     final var theme = workspace.stringProperty(
       KEY_TYPESET_CONTEXT_THEME_SELECTION
     );
     final var chapters = workspace.stringProperty(
       KEY_TYPESET_CONTEXT_CHAPTERS
     );
     final var settings = ExportSettings
       .builder()
       .with( ExportSettings.Mutator::setTheme, theme )
       .with( ExportSettings.Mutator::setChapters, chapters )
       .build();
     // Don't re-validate the typesetter installation each time. If the
     // user mucks up the typesetter installation, it'll get caught the
     // next time the application is started. Don't use |= because it
     // won't short-circuit.
     mCanTypeset = mCanTypeset || Typesetter.canRun();
     if( mCanTypeset ) {
       // If the typesetter is installed, allow the user to select a theme. If
       // the themes aren't installed, a status message will appear.
       if( ExportDialog.choose( getWindow(), themes, settings, dir ) ) {
         file_export( APPLICATION_PDF, dir );
+      }
+    }
     else {
       fireExportFailedEvent();
+    }
+  }
   public void file_export_pdf() {
     file_export_pdf( false );
+  }
   public void file_export_pdf_dir() {
     file_export_pdf( true );
+  }
   public void file_export_repeat() {
     typeset( mTypesetService );
+  }
   public void file_export_html_svg() {
     file_export( HTML_TEX_SVG );
+  }
   public void file_export_html_tex() {
     file_export( HTML_TEX_DELIMITED );
+  }
   public void file_export_xhtml_tex() {
     file_export( XHTML_TEX );
+  }
   private void fireExportFailedEvent() {
     runLater( ExportFailedEvent::fire );
+  }
   public void file_exit() {
     final var window = getWindow();
     fireEvent( window, new WindowEvent( window, WINDOW_CLOSE_REQUEST ) );
+  }
   public void edit_undo() {
     getActiveTextEditor().undo();
+  }
   public void edit_redo() {
     getActiveTextEditor().redo();
+  }
   public void edit_cut() {
     getActiveTextEditor().cut();
+  }
   public void edit_copy() {
     getActiveTextEditor().copy();
+  }
   public void edit_paste() {
     getActiveTextEditor().paste();
+  }
   public void edit_select_all() {
     getActiveTextEditor().selectAll();
+  }
   public void edit_find() {
     final var nodes = getMainScene().getStatusBar().getLeftItems();
     if( nodes.isEmpty() ) {
       final var searchBar = new SearchBar();
       searchBar.matchIndexProperty().bind( mSearchModel.matchIndexProperty() );
       searchBar.matchCountProperty().bind( mSearchModel.matchCountProperty() );
       searchBar.setOnCancelAction( event -> {
         final var editor = getActiveTextEditor();
         nodes.remove( searchBar );
         editor.unstylize( STYLE_SEARCH );
         editor.getNode().requestFocus();
       } );
       searchBar.addInputListener( ( c, o, n ) -> {
         if( n != null && !n.isEmpty() ) {
           mSearchModel.search( n, getActiveTextEditor().getText() );
+        }
       } );
       searchBar.setOnNextAction( event -> edit_find_next() );
       searchBar.setOnPrevAction( event -> edit_find_prev() );
       nodes.add( searchBar );
       searchBar.requestFocus();
+    }
     else {
       nodes.clear();
+    }
+  }
   public void edit_find_next() {
     mSearchModel.advance();
+  }
   public void edit_find_prev() {
     mSearchModel.retreat();
+  }
   public void edit_preferences() {
     try {
       new PreferencesController( getWorkspace() ).show();
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   public void format_bold() {
     getActiveTextEditor().bold();
+  }
   public void format_italic() {
     getActiveTextEditor().italic();
+  }
   public void format_monospace() {
     getActiveTextEditor().monospace();
+  }
   public void format_superscript() {
     getActiveTextEditor().superscript();
+  }
   public void format_subscript() {
     getActiveTextEditor().subscript();
+  }
   public void format_strikethrough() {
     getActiveTextEditor().strikethrough();
+  }
   public void insert_blockquote() {
     getActiveTextEditor().blockquote();
+  }
   public void insert_code() {
     getActiveTextEditor().code();
+  }
   public void insert_fenced_code_block() {
     getActiveTextEditor().fencedCodeBlock();
+  }
   public void insert_link() {
     insertObject( createLinkDialog() );
+  }
   public void insert_image() {
     insertObject( createImageDialog() );
+  }
   private void insertObject( final Dialog<String> dialog ) {
     final var textArea = getActiveTextEditor().getTextArea();
     dialog.showAndWait().ifPresent( textArea::replaceSelection );
+  }
   private Dialog<String> createLinkDialog() {
     return new LinkDialog( getWindow(), createHyperlinkModel() );
+  }
   private Dialog<String> createImageDialog() {
     final var path = getActiveTextEditor().getPath();
     final var parentDir = path.getParent();
     return new ImageDialog( getWindow(), parentDir );
+  }
   /**
    * Returns one of: selected text, word under cursor, or parsed hyperlink from
    * the Markdown AST.
+   *
    * @return An instance containing the link URL and display text.
    */
   private HyperlinkModel createHyperlinkModel() {
     final var context = getMainPane().createProcessorContext();
     final var editor = getActiveTextEditor();
     final var textArea = editor.getTextArea();
     final var selectedText = textArea.getSelectedText();
     // Convert current paragraph to Markdown nodes.
     final var mp = MarkdownProcessor.create( context );
     final var p = textArea.getCurrentParagraph();
     final var paragraph = textArea.getText( p );
     final var node = mp.toNode( paragraph );
     final var visitor = new LinkVisitor( textArea.getCaretColumn() );
     final var link = visitor.process( node );
     if( link != null ) {
       textArea.selectRange( p, link.getStartOffset(), p, link.getEndOffset() );
+    }
     return createHyperlinkModel( link, selectedText );
+  }
   private HyperlinkModel createHyperlinkModel(
     final Link link, final String selection ) {
     return link == null
       ? new HyperlinkModel( selection, "https://localhost" )
       : new HyperlinkModel( link );
+  }
   public void insert_heading_1() {
     insert_heading( 1 );
+  }
   public void insert_heading_2() {
     insert_heading( 2 );
+  }
   public void insert_heading_3() {
     insert_heading( 3 );
+  }
   private void insert_heading( final int level ) {
     getActiveTextEditor().heading( level );
+  }
   public void insert_unordered_list() {
     getActiveTextEditor().unorderedList();
+  }
   public void insert_ordered_list() {
     getActiveTextEditor().orderedList();
+  }
   public void insert_horizontal_rule() {
     getActiveTextEditor().horizontalRule();
+  }
   public void definition_create() {
     getActiveTextDefinition().createDefinition();
+  }
   public void definition_rename() {
     getActiveTextDefinition().renameDefinition();
+  }
   public void definition_delete() {
     getActiveTextDefinition().deleteDefinitions();
+  }
   public void definition_autoinsert() {
     getMainPane().autoinsert();
+  }
   public void view_refresh() {
     getMainPane().viewRefresh();
+  }
   public void view_preview() {
     getMainPane().viewPreview();
+  }
   public void view_outline() {
     getMainPane().viewOutline();
+  }
   public void view_files() { getMainPane().viewFiles(); }
   public void view_statistics() {
     getMainPane().viewStatistics();
+  }
   public void view_menubar() {
     getMainScene().toggleMenuBar();
+  }
   public void view_toolbar() {
     getMainScene().toggleToolBar();
+  }
   public void view_statusbar() {
     getMainScene().toggleStatusBar();
+  }
   public void view_log() {
     mLogView.view();
+  }
   public void help_about() {
     final var alert = new Alert( INFORMATION );
     final var prefix = "Dialog.about.";
     alert.setTitle( get( prefix + "title", APP_TITLE ) );
     alert.setHeaderText( get( prefix + "header", APP_TITLE ) );
     alert.setContentText( get( prefix + "content", APP_YEAR, APP_VERSION ) );
     alert.setGraphic( ICON_DIALOG_NODE );
     alert.initOwner( getWindow() );
     alert.showAndWait();
+  }
   private <T> void typeset( final Service<T> service ) {
     synchronized( mMutex ) {
       if( service != null && !service.isRunning() ) {
         service.reset();
         service.start();
+      }
+    }
+  }
   /**
    * Concatenates all the files in the same directory as the given file into
    * a string. The extension is determined by the given file name pattern; the
    * order files are concatenated is based on their numeric sort order (this
    * avoids lexicographic sorting).
    * <p>
    * If the parent path to the file being edited in the text editor cannot
    * be found then this will return the editor's text, without iterating through
    * the parent directory. (Should never happen, but who knows?)
    * </p>
    * <p>
    * New lines are automatically appended to separate each file.
    * </p>
+   *
    * @param editor The text editor containing
    * @return All files in the same directory as the file being edited
    * concatenated into a single string.
    */
   private String append( final TextEditor editor ) {
     final var pattern = editor.getPath();
     final var parent = pattern.getParent();
     // Short-circuit because nothing else can be done.
     if( parent == null ) {
       clue( "Main.status.export.concat.parent", pattern );
       return editor.getText();
+    }
     final var filename = pattern.getFileName().toString();
     final var extension = getExtension( filename );
     if( extension.isBlank() ) {
       clue( "Main.status.export.concat.extension", filename );
       return editor.getText();
+    }
     try {
       final var glob = "**/*." + extension;
       final var files = new ArrayList<Path>();
       final var text = new StringBuilder( DOCUMENT_LENGTH );
       final var range = getString( KEY_TYPESET_CONTEXT_CHAPTERS );
       final var validator = new RangeValidator( range );
       final var chapter = new AtomicInteger();
       walk( parent, glob, files::add );
       files.sort( new AlphanumComparator<>() );
       files.forEach( file -> {
         try {
           clue( "Main.status.export.concat", file );
           if( validator.test( chapter.incrementAndGet() ) ) {
             // Ensure multiple files are separated by an EOL.
             text.append( readString( file ) ).append( lineSeparator() );
+          }
         } catch( final IOException ex ) {
           clue( "Main.status.export.concat.io", file );
+        }
       } );
       return text.toString();
 import com.keenwrite.commands.ConcatenateCommand;
 import com.keenwrite.editors.TextDefinition;
 import com.keenwrite.editors.TextEditor;
 import com.keenwrite.editors.markdown.HyperlinkModel;
 import com.keenwrite.editors.markdown.LinkVisitor;
 import com.keenwrite.events.CaretMovedEvent;
 import com.keenwrite.events.ExportFailedEvent;
 import com.keenwrite.preferences.Key;
 import com.keenwrite.preferences.PreferencesController;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.processors.markdown.MarkdownProcessor;
 import com.keenwrite.search.SearchModel;
 import com.keenwrite.typesetting.Typesetter;
 import com.keenwrite.ui.controls.SearchBar;
 import com.keenwrite.ui.dialogs.ExportDialog;
 import com.keenwrite.ui.dialogs.ExportSettings;
 import com.keenwrite.ui.dialogs.ImageDialog;
 import com.keenwrite.ui.dialogs.LinkDialog;
 import com.keenwrite.ui.explorer.FilePicker;
 import com.keenwrite.ui.explorer.FilePickerFactory;
 import com.keenwrite.ui.logging.LogView;
 import com.vladsch.flexmark.ast.Link;
 import javafx.concurrent.Service;
 import javafx.concurrent.Task;
 import javafx.scene.control.Alert;
 import javafx.scene.control.Dialog;
 import javafx.stage.Window;
 import javafx.stage.WindowEvent;
 import java.io.File;
 import java.nio.file.Path;
 import java.util.List;
 import java.util.Optional;
 import static com.keenwrite.Bootstrap.*;
 import static com.keenwrite.ExportFormat.*;
 import static com.keenwrite.Messages.get;
 import static com.keenwrite.constants.Constants.PDF_DEFAULT;
 import static com.keenwrite.constants.Constants.USER_DIRECTORY;
 import static com.keenwrite.constants.GraphicsConstants.ICON_DIALOG_NODE;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preferences.AppKeys.*;
 import static com.keenwrite.processors.ProcessorFactory.createProcessors;
 import static com.keenwrite.ui.explorer.FilePickerFactory.SelectionType;
 import static com.keenwrite.ui.explorer.FilePickerFactory.SelectionType.*;
 import static java.nio.file.Files.writeString;
 import static javafx.application.Platform.runLater;
 import static javafx.event.Event.fireEvent;
 import static javafx.scene.control.Alert.AlertType.INFORMATION;
 import static javafx.stage.WindowEvent.WINDOW_CLOSE_REQUEST;
 import static org.apache.commons.io.FilenameUtils.getExtension;
 /**
  * Responsible for abstracting how functionality is mapped to the application.
  * This allows users to customize accelerator keys and will provide pluggable
  * functionality so that different text markup languages can change documents
  * using their respective syntax.
  */
 public final class GuiCommands {
   private static final String STYLE_SEARCH = "search";
   /**
    * When an action is executed, this is one of the recipients.
    */
   private final MainPane mMainPane;
   private final MainScene mMainScene;
   private final LogView mLogView;
   /**
    * Tracks finding text in the active document.
    */
   private final SearchModel mSearchModel;
   private boolean mCanTypeset;
   /**
    * A {@link Task} can only be run once, so wrap it in a {@link Service} to
    * allow re-launching the typesetting task repeatedly.
    */
   private Service<Path> mTypesetService;
   /**
    * Prevent a race-condition between checking to see if the typesetting task
    * is running and restarting the task itself.
    */
   private final Object mMutex = new Object();
   public GuiCommands( final MainScene scene, final MainPane pane ) {
     mMainScene = scene;
     mMainPane = pane;
     mLogView = new LogView();
     mSearchModel = new SearchModel();
     mSearchModel.matchOffsetProperty().addListener( ( c, o, n ) -> {
       final var editor = getActiveTextEditor();
       // Clear highlighted areas before highlighting a new region.
       if( o != null ) {
         editor.unstylize( STYLE_SEARCH );
+      }
       if( n != null ) {
         editor.moveTo( n.getStart() );
         editor.stylize( n, STYLE_SEARCH );
+      }
     } );
     // When the active text editor changes ...
     mMainPane.textEditorProperty().addListener(
       ( c, o, n ) -> {
         // ... update the haystack.
         mSearchModel.search( getActiveTextEditor().getText() );
         // ... update the status bar with the current caret position.
         if( n != null ) {
           final var w = getWorkspace();
           final var recentDoc = w.fileProperty( KEY_UI_RECENT_DOCUMENT );
           // ... preserve the most recent document.
           recentDoc.setValue( n.getFile() );
           CaretMovedEvent.fire( n.getCaret() );
+        }
+      }
     );
+  }
   public void file_new() {
     getMainPane().newTextEditor();
+  }
   public void file_open() {
     pickFiles( FILE_OPEN_MULTIPLE ).ifPresent( l -> getMainPane().open( l ) );
+  }
   public void file_close() {
     getMainPane().close();
+  }
   public void file_close_all() {
     getMainPane().closeAll();
+  }
   public void file_save() {
     getMainPane().save();
+  }
   public void file_save_as() {
     pickFiles( FILE_SAVE_AS ).ifPresent( l -> getMainPane().saveAs( l ) );
+  }
   public void file_save_all() {
     getMainPane().saveAll();
+  }
   /**
    * Converts the actively edited file in the given file format.
+   *
    * @param format The destination file format.
    */
   private void file_export( final ExportFormat format ) {
     file_export( format, false );
+  }
   /**
    * Converts one or more files into the given file format. If {@code dir}
    * is set to true, this will first append all files in the same directory
    * as the actively edited file.
+   *
    * @param format The destination file format.
    * @param dir    Export all files in the actively edited file's directory.
    */
   private void file_export( final ExportFormat format, final boolean dir ) {
     final var editor = getMainPane().getTextEditor();
     final var exported = getWorkspace().fileProperty( KEY_UI_RECENT_EXPORT );
     final var exportParent = exported.get().toPath().getParent();
     final var editorParent = editor.getPath().getParent();
     final var userHomeParent = USER_DIRECTORY.toPath();
     final var exportPath = exportParent != null
       ? exportParent
       : editorParent != null
       ? editorParent
       : userHomeParent;
     final var filename = format.toExportFilename( editor.getPath() );
     final var selected = PDF_DEFAULT
       .getName()
       .equals( exported.get().getName() );
     final var selection = pickFile(
       selected
         ? filename
         : exported.get(),
       exportPath,
       FILE_EXPORT
     );
     selection.ifPresent( files -> file_export( editor, format, files, dir ) );
+  }
   private void file_export(
     final TextEditor editor,
     final ExportFormat format,
     final List<File> files,
     final boolean dir ) {
     editor.save();
     final var main = getMainPane();
     final var exported = getWorkspace().fileProperty( KEY_UI_RECENT_EXPORT );
     final var sourceFile = files.get( 0 );
     final var sourcePath = sourceFile.toPath();
     final var document = dir ? append( editor ) : editor.getText();
     final var context = main.createProcessorContext( sourcePath, format );
     final var service = new Service<Path>() {
       @Override
       protected Task<Path> createTask() {
         final var task = new Task<Path>() {
           @Override
           protected Path call() throws Exception {
             final var chain = createProcessors( context );
             final var export = chain.apply( document );
             // Processors can export binary files. In such cases, processors
             // return null to prevent further processing.
             return export == null ? null : writeString( sourcePath, export );
+          }
         };
         task.setOnSucceeded(
           e -> {
             // Remember the exported file name for next time.
             exported.setValue( sourceFile );
             final var result = task.getValue();
             // Binary formats must notify users of success independently.
             if( result != null ) {
               clue( "Main.status.export.success", result );
+            }
+          }
         );
         task.setOnFailed( e -> {
           final var ex = task.getException();
           clue( ex );
           if( ex instanceof TypeNotPresentException ) {
             fireExportFailedEvent();
+          }
         } );
         return task;
+      }
     };
     mTypesetService = service;
     typeset( service );
+  }
   /**
    * @param dir {@code true} means to export all files in the active file
    *            editor's directory; {@code false} means to export only the
    *            actively edited file.
    */
   private void file_export_pdf( final boolean dir ) {
     final var workspace = getWorkspace();
     final var themes = workspace.getFile(
       KEY_TYPESET_CONTEXT_THEMES_PATH
     );
     final var theme = workspace.stringProperty(
       KEY_TYPESET_CONTEXT_THEME_SELECTION
     );
     final var chapters = workspace.stringProperty(
       KEY_TYPESET_CONTEXT_CHAPTERS
     );
     final var settings = ExportSettings
       .builder()
       .with( ExportSettings.Mutator::setTheme, theme )
       .with( ExportSettings.Mutator::setChapters, chapters )
       .build();
     // Don't re-validate the typesetter installation each time. If the
     // user mucks up the typesetter installation, it'll get caught the
     // next time the application is started. Don't use |= because it
     // won't short-circuit.
     mCanTypeset = mCanTypeset || Typesetter.canRun();
     if( mCanTypeset ) {
       // If the typesetter is installed, allow the user to select a theme. If
       // the themes aren't installed, a status message will appear.
       if( ExportDialog.choose( getWindow(), themes, settings, dir ) ) {
         file_export( APPLICATION_PDF, dir );
+      }
+    }
     else {
       fireExportFailedEvent();
+    }
+  }
   public void file_export_pdf() {
     file_export_pdf( false );
+  }
   public void file_export_pdf_dir() {
     file_export_pdf( true );
+  }
   public void file_export_html_dir() {
     file_export( XHTML_TEX, true );
+  }
   public void file_export_repeat() {
     typeset( mTypesetService );
+  }
   public void file_export_html_svg() {
     file_export( HTML_TEX_SVG );
+  }
   public void file_export_html_tex() {
     file_export( HTML_TEX_DELIMITED );
+  }
   public void file_export_xhtml_tex() {
     file_export( XHTML_TEX );
+  }
   private void fireExportFailedEvent() {
     runLater( ExportFailedEvent::fire );
+  }
   public void file_exit() {
     final var window = getWindow();
     fireEvent( window, new WindowEvent( window, WINDOW_CLOSE_REQUEST ) );
+  }
   public void edit_undo() {
     getActiveTextEditor().undo();
+  }
   public void edit_redo() {
     getActiveTextEditor().redo();
+  }
   public void edit_cut() {
     getActiveTextEditor().cut();
+  }
   public void edit_copy() {
     getActiveTextEditor().copy();
+  }
   public void edit_paste() {
     getActiveTextEditor().paste();
+  }
   public void edit_select_all() {
     getActiveTextEditor().selectAll();
+  }
   public void edit_find() {
     final var nodes = getMainScene().getStatusBar().getLeftItems();
     if( nodes.isEmpty() ) {
       final var searchBar = new SearchBar();
       searchBar.matchIndexProperty().bind( mSearchModel.matchIndexProperty() );
       searchBar.matchCountProperty().bind( mSearchModel.matchCountProperty() );
       searchBar.setOnCancelAction( event -> {
         final var editor = getActiveTextEditor();
         nodes.remove( searchBar );
         editor.unstylize( STYLE_SEARCH );
         editor.getNode().requestFocus();
       } );
       searchBar.addInputListener( ( c, o, n ) -> {
         if( n != null && !n.isEmpty() ) {
           mSearchModel.search( n, getActiveTextEditor().getText() );
+        }
       } );
       searchBar.setOnNextAction( event -> edit_find_next() );
       searchBar.setOnPrevAction( event -> edit_find_prev() );
       nodes.add( searchBar );
       searchBar.requestFocus();
+    }
+  }
   public void edit_find_next() {
     mSearchModel.advance();
+  }
   public void edit_find_prev() {
     mSearchModel.retreat();
+  }
   public void edit_preferences() {
     try {
       new PreferencesController( getWorkspace() ).show();
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   public void format_bold() {
     getActiveTextEditor().bold();
+  }
   public void format_italic() {
     getActiveTextEditor().italic();
+  }
   public void format_monospace() {
     getActiveTextEditor().monospace();
+  }
   public void format_superscript() {
     getActiveTextEditor().superscript();
+  }
   public void format_subscript() {
     getActiveTextEditor().subscript();
+  }
   public void format_strikethrough() {
     getActiveTextEditor().strikethrough();
+  }
   public void insert_blockquote() {
     getActiveTextEditor().blockquote();
+  }
   public void insert_code() {
     getActiveTextEditor().code();
+  }
   public void insert_fenced_code_block() {
     getActiveTextEditor().fencedCodeBlock();
+  }
   public void insert_link() {
     insertObject( createLinkDialog() );
+  }
   public void insert_image() {
     insertObject( createImageDialog() );
+  }
   private void insertObject( final Dialog<String> dialog ) {
     final var textArea = getActiveTextEditor().getTextArea();
     dialog.showAndWait().ifPresent( textArea::replaceSelection );
+  }
   private Dialog<String> createLinkDialog() {
     return new LinkDialog( getWindow(), createHyperlinkModel() );
+  }
   private Dialog<String> createImageDialog() {
     final var path = getActiveTextEditor().getPath();
     final var parentDir = path.getParent();
     return new ImageDialog( getWindow(), parentDir );
+  }
   /**
    * Returns one of: selected text, word under cursor, or parsed hyperlink from
    * the Markdown AST.
+   *
    * @return An instance containing the link URL and display text.
    */
   private HyperlinkModel createHyperlinkModel() {
     final var context = getMainPane().createProcessorContext();
     final var editor = getActiveTextEditor();
     final var textArea = editor.getTextArea();
     final var selectedText = textArea.getSelectedText();
     // Convert current paragraph to Markdown nodes.
     final var mp = MarkdownProcessor.create( context );
     final var p = textArea.getCurrentParagraph();
     final var paragraph = textArea.getText( p );
     final var node = mp.toNode( paragraph );
     final var visitor = new LinkVisitor( textArea.getCaretColumn() );
     final var link = visitor.process( node );
     if( link != null ) {
       textArea.selectRange( p, link.getStartOffset(), p, link.getEndOffset() );
+    }
     return createHyperlinkModel( link, selectedText );
+  }
   private HyperlinkModel createHyperlinkModel(
     final Link link, final String selection ) {
     return link == null
       ? new HyperlinkModel( selection, "https://localhost" )
       : new HyperlinkModel( link );
+  }
   public void insert_heading_1() {
     insert_heading( 1 );
+  }
   public void insert_heading_2() {
     insert_heading( 2 );
+  }
   public void insert_heading_3() {
     insert_heading( 3 );
+  }
   private void insert_heading( final int level ) {
     getActiveTextEditor().heading( level );
+  }
   public void insert_unordered_list() {
     getActiveTextEditor().unorderedList();
+  }
   public void insert_ordered_list() {
     getActiveTextEditor().orderedList();
+  }
   public void insert_horizontal_rule() {
     getActiveTextEditor().horizontalRule();
+  }
   public void definition_create() {
     getActiveTextDefinition().createDefinition();
+  }
   public void definition_rename() {
     getActiveTextDefinition().renameDefinition();
+  }
   public void definition_delete() {
     getActiveTextDefinition().deleteDefinitions();
+  }
   public void definition_autoinsert() {
     getMainPane().autoinsert();
+  }
   public void view_refresh() {
     getMainPane().viewRefresh();
+  }
   public void view_preview() {
     getMainPane().viewPreview();
+  }
   public void view_outline() {
     getMainPane().viewOutline();
+  }
   public void view_files() { getMainPane().viewFiles(); }
   public void view_statistics() {
     getMainPane().viewStatistics();
+  }
   public void view_menubar() {
     getMainScene().toggleMenuBar();
+  }
   public void view_toolbar() {
     getMainScene().toggleToolBar();
+  }
   public void view_statusbar() {
     getMainScene().toggleStatusBar();
+  }
   public void view_log() {
     mLogView.view();
+  }
   public void help_about() {
     final var alert = new Alert( INFORMATION );
     final var prefix = "Dialog.about.";
     alert.setTitle( get( prefix + "title", APP_TITLE ) );
     alert.setHeaderText( get( prefix + "header", APP_TITLE ) );
     alert.setContentText( get( prefix + "content", APP_YEAR, APP_VERSION ) );
     alert.setGraphic( ICON_DIALOG_NODE );
     alert.initOwner( getWindow() );
     alert.showAndWait();
+  }
   private <T> void typeset( final Service<T> service ) {
     synchronized( mMutex ) {
       if( service != null && !service.isRunning() ) {
         service.reset();
         service.start();
+      }
+    }
+  }
   /**
    * Concatenates all the files in the same directory as the given file into
    * a string. The extension is determined by the given file name pattern; the
    * order files are concatenated is based on their numeric sort order (this
    * avoids lexicographic sorting).
    * <p>
    * If the parent path to the file being edited in the text editor cannot
    * be found then this will return the editor's text, without iterating through
    * the parent directory. (Should never happen, but who knows?)
    * </p>
    * <p>
    * New lines are automatically appended to separate each file.
    * </p>
+   *
    * @param editor The text editor containing
    * @return All files in the same directory as the file being edited
    * concatenated into a single string.
    */
   private String append( final TextEditor editor ) {
     final var pattern = editor.getPath();
     final var parent = pattern.getParent();
     // Short-circuit because nothing else can be done.
     if( parent == null ) {
       clue( "Main.status.export.concat.parent", pattern );
       return editor.getText();
+    }
     final var filename = pattern.getFileName().toString();
     final var extension = getExtension( filename );
     if( extension.isBlank() ) {
       clue( "Main.status.export.concat.extension", filename );
       return editor.getText();
+    }
     try {
       final var command = new ConcatenateCommand(
         parent, extension, getString( KEY_TYPESET_CONTEXT_CHAPTERS ) );
       return command.call();
     } catch( final Throwable t ) {
       clue( t );

A src/main/java/com/keenwrite/ui/actions/Keyboard.java

 package com.keenwrite.ui.actions;
 import javafx.scene.input.KeyCodeCombination;
 import javafx.scene.input.KeyEvent;
 import static javafx.scene.input.KeyCode.C;
 import static javafx.scene.input.KeyCode.INSERT;
 import static javafx.scene.input.KeyCombination.CONTROL_ANY;
 public class Keyboard {
   public static final KeyCodeCombination CTRL_C =
     new KeyCodeCombination( C, CONTROL_ANY );
   public static final KeyCodeCombination CTRL_INSERT =
     new KeyCodeCombination( INSERT, CONTROL_ANY );
   /**
    * Answers whether the user issued a copy request via the keyboard.
+   *
    * @param event The keyboard event to examine.
    * @return {@code true} if the user pressed Ctrl+C or Ctrl+Insert.
    */
   public static boolean isCopy( final KeyEvent event ) {
     return CTRL_C.match( event ) || CTRL_INSERT.match( event );
+  }
+}

M src/main/java/com/keenwrite/ui/clipboard/Clipboard.java

 package com.keenwrite.ui.clipboard;
 import javafx.scene.control.TableView;
 import javafx.scene.input.ClipboardContent;
 import java.util.TreeSet;
 import static javafx.scene.input.Clipboard.getSystemClipboard;
   public static void write( final StringBuilder text ) {
     write( text.toString() );
+  }
   /**
    * Copies the contents of the selected rows into the clipboard; code is from
    * <a href="https://stackoverflow.com/a/48126059/59087">StackOverflow</a>.
+   *
    * @param table The {@link TableView} having selected rows to copy.
    */
   public static <T> void write( final TableView<T> table ) {
     final var sb = new StringBuilder( 2048 );
     final var rows = new TreeSet<Integer>();
     final var cols = table.getColumns();
     for( final var position : table.getSelectionModel().getSelectedCells() ) {
       rows.add( position.getRow() );
+    }
     String rSep = "";
     for( final var row : rows ) {
       sb.append( rSep );
       String cSep = "";
       for( final var column : cols ) {
         sb.append( cSep );
         final var data = column.getCellData( row );
         sb.append( data == null ? "" : data.toString() );
         cSep = "\t";
+      }
       rSep = "\n";
+    }
     write( sb );
+  }
+}

M src/main/java/com/keenwrite/ui/dialogs/ExportDialog.java

         if( result.isPresent() ) {
           final var theme = mComboBox.getSelectionModel().getSelectedItem();
           final var path = theme.path().getFileName().toString();
           mSettings.themeProperty().setValue( path );
           final var path = theme.path();
           final var filename = path.getFileName().toString();
           mSettings.themeProperty().setValue( filename );
           return true;

M src/main/java/com/keenwrite/ui/dialogs/ImageDialog.java

       //---- urlField ----
       urlField.setEscapeCharacters( "()" );
       urlField.setText( "http://yourlink.com" );
       urlField.setPromptText( "http://yourlink.com" );
       urlField.setText( "https://yourlink.com" );
       urlField.setPromptText( "https://yourlink.com" );
       pane.add( urlField, "cell 1 0" );
       pane.add( linkBrowseFileButton, "cell 2 0" );

M src/main/java/com/keenwrite/ui/explorer/FilesView.java

 import static java.util.Comparator.comparing;
 import static javafx.collections.FXCollections.observableArrayList;
 import static javafx.scene.control.TableView.CONSTRAINED_RESIZE_POLICY;
 import static javafx.scene.control.TableView.CONSTRAINED_RESIZE_POLICY_FLEX_LAST_COLUMN;
 import static javafx.scene.input.KeyCode.ENTER;
 import static javafx.scene.layout.Priority.ALWAYS;
     mDirectory.addListener( ( c, o, n ) -> {
       if( n != null ) {field.setText( n.getAbsolutePath() );}
       if( n != null ) { field.setText( n.getAbsolutePath() ); }
     } );
     final var style = "-fx-alignment: BASELINE_LEFT;";
     final var table = new TableView<FilesView.PathEntry>();
     table.setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY );
     table.setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY_FLEX_LAST_COLUMN );
     table.setRowFactory( tv -> {

M src/main/java/com/keenwrite/ui/heuristics/DocumentStatistics.java

 import com.keenwrite.events.WordCountEvent;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.ui.actions.Keyboard;
 import com.keenwrite.ui.clipboard.Clipboard;
 import com.whitemagicsoftware.wordcount.TokenizerException;
 import javafx.beans.property.IntegerProperty;
 import static javafx.application.Platform.runLater;
 import static javafx.collections.FXCollections.observableArrayList;
 import static javafx.scene.control.SelectionMode.MULTIPLE;
 /**
     initListeners( workspace );
     register( this );
     final var fontName = workspace.stringProperty( KEY_UI_FONT_EDITOR_NAME );
     fontName.addListener(
       ( c, o, n ) -> {
         if( n != null ) {
           setFontFamily( n );
+        }
+      }
     );
     setFontFamily( fontName.getValue() );
+  }
         final var document = event.getDocument();
         final var wordCount = mWordCounter.count(
           document, ( k, count ) -> {
             // Generate statistics for words that occur thrice or more.
             if( count > 2 ) {
               mItems.add( new StatEntry( k, count ) );
+            }
+          }
           document, ( k, count ) ->
             mItems.add( new StatEntry( k, count ) )
         );
     setMaxWidth( Double.MAX_VALUE );
     setPrefWidth( 128 );
     setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY );
     setColumnResizePolicy( CONSTRAINED_RESIZE_POLICY_FLEX_LAST_COLUMN );
     getSortOrder().setAll( colCount, colWord );
     getStyleClass().add( "" );
+  }
   private void initListeners( final Workspace workspace ) {
     initLocaleListener( workspace );
     initFontListener( workspace );
     initKeyboardListener();
+  }
   private void initLocaleListener( final Workspace workspace ) {
     final var property = workspace.localeProperty( KEY_LANGUAGE_LOCALE );
     property.addListener(
       ( c, o, n ) -> mWordCounter = WordCounter.create( property.toLocale() )
     );
+  }
   private void initFontListener( final Workspace workspace ) {
     final var fontName = workspace.stringProperty( KEY_UI_FONT_EDITOR_NAME );
     fontName.addListener(
       ( c, o, n ) -> {
         if( n != null ) {
           setFontFamily( n );
+        }
+      }
     );
     setFontFamily( fontName.getValue() );
+  }
   private void initKeyboardListener() {
     getSelectionModel().setSelectionMode( MULTIPLE );
     setOnKeyPressed( event -> {
       if( Keyboard.isCopy( event ) ) {
         Clipboard.write( this );
+      }
     } );
+  }

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

 import com.keenwrite.events.StatusEvent;
 import com.keenwrite.ui.actions.Keyboard;
 import com.keenwrite.ui.clipboard.Clipboard;
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 import javafx.collections.ObservableList;
 import javafx.scene.control.*;
 import javafx.scene.input.KeyCodeCombination;
 import javafx.stage.Stage;
 import org.greenrobot.eventbus.Subscribe;
 import java.time.LocalDateTime;
 import java.util.Objects;
 import java.util.TreeSet;
 import static com.keenwrite.Messages.get;
 import static javafx.scene.control.ButtonType.OK;
 import static javafx.scene.control.SelectionMode.MULTIPLE;
 import static javafx.scene.input.KeyCode.C;
 import static javafx.scene.input.KeyCode.INSERT;
 import static javafx.scene.input.KeyCombination.CONTROL_ANY;
 import static javafx.stage.Modality.NONE;
   private void initTableView() {
     final var ctrlC = new KeyCodeCombination( C, CONTROL_ANY );
     final var ctrlInsert = new KeyCodeCombination( INSERT, CONTROL_ANY );
     final var colDate = new TableColumn<LogEntry, String>( "Timestamp" );
     final var colMessage = new TableColumn<LogEntry, String>( "Message" );
     mTable.getSelectionModel().setSelectionMode( MULTIPLE );
     mTable.setOnKeyPressed( event -> {
       if( ctrlC.match( event ) || ctrlInsert.match( event ) ) {
         copyToClipboard( mTable );
       if( Keyboard.isCopy( event ) ) {
         Clipboard.write( mTable );
+      }
     } );
       final var trace = mTrace == null ? "" : mTrace.get();
       return "LogEntry{" +
       return getClass().getSimpleName() + "{" +
         "mDate=" + (date == null ? "''" : date) +
         ", mMessage=" + (message == null ? "''" : message) +
         ", mTrace=" + (trace == null ? "''" : trace) +
         '}';
+    }
     private String toString( final LocalDateTime date ) {
       return date.format( ofPattern( "d MMM u HH:mm:ss" ) );
+    }
+  }
   /**
    * Copies the contents of the selected rows into the clipboard; code is from
    * <a href="https://stackoverflow.com/a/48126059/59087">StackOverflow</a>.
+   *
    * @param table The {@link TableView} having selected rows to copy.
    */
   public void copyToClipboard( final TableView<?> table ) {
     final var sb = new StringBuilder();
     final var rows = new TreeSet<Integer>();
     boolean firstRow = true;
     for( final var position : table.getSelectionModel().getSelectedCells() ) {
       rows.add( position.getRow() );
+    }
     for( final var row : rows ) {
       if( !firstRow ) {
         sb.append( '\n' );
+      }
       firstRow = false;
       boolean firstCol = true;
       for( final var column : table.getColumns() ) {
         if( !firstCol ) {
           sb.append( '\t' );
+        }
         firstCol = false;
         final var data = column.getCellData( row );
         sb.append( data == null ? "" : data.toString() );
+      }
+    }
     Clipboard.write( sb );
+  }
+}

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

    * Denotes a local file.
    */
   FILE,
   FILE( "file" ),
   /**
    * Denotes either HTTP or HTTPS.
    */
   HTTP,
   HTTP( "http" ),
   /**
    * Denotes the File Transfer Protocol.
    */
   FTP,
   FTP( "ftp" ),
   /**
    * Denotes Java archive file.
    */
   JAR,
   JAR( "jar" ),
   /**
    * Could not determine schema (or is not supported by the application).
    * Could not determine scheme (or is not supported by the application).
    */
   UNKNOWN;
   UNKNOWN( "unknown" );
   private final String mPrefix;
   ProtocolScheme( final String prefix ) {
     mPrefix = prefix;
+  }
   /**
    * @return {@link true} if the protocol must be fetched via HTTP or FTP.
    */
   @SuppressWarnings( "unused" )
   public static boolean isRemote( final URL url ) {
     return valueFrom( url ).isRemote();
    */
   public boolean isFtp() {
     return this == HTTP;
     return this == FTP;
+  }
   public boolean isJar() {
     return this == JAR;
+  }
   /**
    * Prepends the protocol scheme to the given path, without a host name.
+   *
    * @param path The path to decorate as a URI, including the scheme.
    * @return The
    */
   public String decorate( final String path ) {
     return getPrefix() + "://" + path;
+  }
   private String getPrefix() {
     return mPrefix;
+  }
+}

M src/main/resources/com/keenwrite/messages.properties

 Action.file.export.pdf.repeat.icon=FILE_PDF_ALT
 Action.file.export.html.dir.description=Export files in document directory as HTML
 Action.file.export.html.dir.accelerator=Shortcut+Shift+H
 Action.file.export.html.dir.text=Joined _HTML
 Action.file.export.html.dir.icon=HTML5
 Action.file.export.html_svg.description=Export the current document as HTML + SVG
 Action.file.export.text=_Export As

M src/test/java/com/keenwrite/io/FileWatchServiceTest.java

 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.concurrent.Semaphore;
 import java.util.function.Consumer;
 import static java.io.File.createTempFile;
 import static java.nio.file.Files.write;
 import static java.nio.file.StandardOpenOption.APPEND;
 import static java.nio.file.StandardOpenOption.CREATE;
     thread.start();
     service.addListener( listener );
     write( file.toPath(), text.getBytes(), CREATE, APPEND );
     Files.writeString( file.toPath(), text, CREATE, APPEND );
     semaphor.acquire();
     service.stop();

M src/test/java/com/keenwrite/processors/html/XhtmlProcessorTest.java

       .with( ProcessorContext.Mutator::setLocale, () -> ENGLISH )
       .with( ProcessorContext.Mutator::setMetadata, HashMap::new )
       .with( ProcessorContext.Mutator::setThemesPath, () -> Path.of( "b" ) )
       .with( ProcessorContext.Mutator::setThemesDir, () -> Path.of( "b" ) )
       .with( ProcessorContext.Mutator::setCaret, () -> caret )
       .with( ProcessorContext.Mutator::setImagesPath, () -> new File( "i" ) )
       .with( ProcessorContext.Mutator::setImagesDir, () -> new File( "i" ) )
       .with( ProcessorContext.Mutator::setImageOrder, () -> "" )
       .with( ProcessorContext.Mutator::setImageServer, () -> "" )
       Arguments.of(
         HTML_TEX_DELIMITED,
         "<p id=\"caret\">the \uD83D\uDC4D emoji</p>\n"
         """
           <html><head></head><body><p>the 👍 emoji</p>
           </body></html>"""
       ),
       Arguments.of(
         XHTML_TEX,
         """
           <html>
             <head>
               <title> </title>
               <meta charset="utf8"/>
               <meta content="2" name="count"/>
             </head>
             <body>
               <p id="caret">the 👍 emoji</p>
           </body>
           </html>
           """
           <html><head></head><body><p>the 👍 emoji</p>
           </body></html>"""
+      )
     );

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

 package com.keenwrite.processors.markdown;
 import com.keenwrite.AwaitFxExtension;
 import com.keenwrite.editors.common.Caret;
 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.URI;
 import java.net.URL;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import static com.keenwrite.ExportFormat.XHTML_TEX;
 import static com.keenwrite.constants.Constants.DOCUMENT_DEFAULT;
 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, AwaitFxExtension.class} )
 @SuppressWarnings( "SameParameterValue" )
 public class ImageLinkExtensionTest {
   private static final Map<String, String> IMAGES = new HashMap<>();
   private static final String URI_WEB = "placekitten.com/200/200";
   private static final String URI_DIRNAME = "images";
   private static final String URI_FILENAME = "kitten";
   /**
    * Path to use for testing image file name resolution. Note that resources use
    * forward slashes, regardless of OS.
    */
   private static final String URI_PATH = URI_DIRNAME + '/' + URI_FILENAME;
   /**
    * Extension for the first existing image that matches the preferred image
    * extension order.
    */
   private static final String URI_IMAGE_EXT = ".png";
   private static final String UIR_DIR = "images";
   private static final String URI_FILE = "kitten";
   private static final String URI_PATH = UIR_DIR + '/' + URI_FILE;
   private static final String PATH_KITTEN_JPG = URI_PATH + ".jpg";
   private static final String PATH_KITTEN_PNG = URI_PATH + ".png";
   /**
    * Relative path to an image that exists.
    */
   private static final String URI_IMAGE = URI_PATH + URI_IMAGE_EXT;
   private static final Map<String, String> IMAGES = new LinkedHashMap<>();
   static {
     addUri( URI_PATH + ".png" );
     addUri( URI_PATH + ".jpg" );
     addUri( URI_PATH, getResource( URI_PATH + URI_IMAGE_EXT ) );
     addUri( "//" + URI_WEB );
     addUri( "http://" + URI_WEB );
     addUri( "https://" + URI_WEB );
+  }
   @Start
   @SuppressWarnings( "unused" )
   private void start( final Stage stage ) {
+  }
   private static void addUri( final String actualExpected ) {
     addUri( actualExpected, actualExpected );
     add( PATH_KITTEN_PNG, URI_FILE );
     add( PATH_KITTEN_PNG, URI_PATH );
     add( PATH_KITTEN_PNG, PATH_KITTEN_PNG );
     add( PATH_KITTEN_JPG, PATH_KITTEN_JPG );
     add( "//placekitten.com/200/200", "//placekitten.com/200/200" );
     add( "ftp://placekitten.com/200/200", "ftp://placekitten.com/200/200" );
     add( "http://placekitten.com/200/200", "http://placekitten.com/200/200" );
     add( "https://placekitten.com/200/200", "https://placekitten.com/200/200" );
+  }
   private static void addUri( final String actual, final String expected ) {
   private static void add( final String expected, final String actual ) {
     IMAGES.put( toMd( actual ), toHtml( expected ) );
+  }
   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", url );
       "<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_ImageLookup_RelativePathWithExtension_ResolvedSuccessfully() {
     final var resource = getResourcePath( URI_IMAGE );
     final var imagePath = new File( URI_IMAGE ).toPath();
     final var resource = getResourcePath( PATH_KITTEN_PNG );
     final var imagePath = new File( PATH_KITTEN_PNG ).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 documentPath = Path.of(
       resource.getRoot().resolve( subpath ).toString(),
       DOCUMENT_DEFAULT.getName() );
     final var context = createProcessorContext( documentPath );
     final var imagesDir = Path.of( "images" );
     final var context = createProcessorContext( documentPath, imagesDir );
     final var extension = ImageLinkExtension.create( context );
     final var extensions = List.of( extension );
       final var node = parser.parse( key );
       final var expectedHtml = entry.getValue();
       final var actualHtml = new StringBuilder( 128 );
       runLater( () -> actualHtml.append( renderer.render( node ) ) );
       final var actualHtml = renderer.render( node );
       waitForFxEvents();
       assertEquals( expectedHtml, actualHtml.toString() );
       assertEquals( expectedHtml, actualHtml );
+    }
+  }
   /**
    * Creates a new {@link ProcessorContext} for the given file name path.
+   *
    * @param inputPath Fully qualified path to the file name.
    * @return A context used for creating new {@link Processor} instances.
    */
   private ProcessorContext createProcessorContext( final Path inputPath ) {
   private ProcessorContext createProcessorContext(
     final Path inputPath, final Path imagesDir ) {
     return ProcessorContext
       .builder()
       .with( ProcessorContext.Mutator::setSourcePath, inputPath )
       .with( ProcessorContext.Mutator::setExportFormat, XHTML_TEX )
       .with( ProcessorContext.Mutator::setCaret, () -> Caret.builder().build() )
       .with( ProcessorContext.Mutator::setImagesDir, imagesDir::toFile )
       .build();
+  }
   private static URL toUrl( final String path ) {
     final var clazz = ImageLinkExtensionTest.class;
     final var packagePath = clazz.getPackageName().replace( '.', '/' );
     final var resourcePath = '/' + packagePath + '/' + path;
     return clazz.getResource( resourcePath );
+  }
   private static URI toUri( final String path ) {
     try {
       return toUrl( path ).toURI();
       return Path.of( 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();
+  }
+}

M src/test/java/com/keenwrite/r/PluralizeTest.java

 public class PluralizeTest {
   private static final ScriptEngine ENGINE =
       new ScriptEngineManager().getEngineByName( "Renjin" );
     new ScriptEngineManager().getEngineByName( "Renjin" );
   private static final Map<String, String> PLURAL_MAP = ofEntries(
       entry( "beef", "beefs" ),
       entry( "brother", "brothers" ),
       entry( "child", "children" ),
       entry( "cow", "cows" ),
       entry( "ephemeris", "ephemerides" ),
       entry( "genie", "genies" ),
       entry( "money", "moneys" ),
       entry( "mongoose", "mongooses" ),
       entry( "mythos", "mythoi" ),
       entry( "octopus", "octopuses" ),
       entry( "ox", "oxen" ),
       entry( "soliloquy", "soliloquies" ),
       entry( "trilby", "trilbys" ),
       entry( "wolf", "wolves" )
     entry( "beef", "beefs" ),
     entry( "brother", "brothers" ),
     entry( "child", "children" ),
     entry( "cow", "cows" ),
     entry( "ephemeris", "ephemerides" ),
     entry( "genie", "genies" ),
     entry( "money", "moneys" ),
     entry( "mongoose", "mongooses" ),
     entry( "mythos", "mythoi" ),
     entry( "octopus", "octopodes" ),
     entry( "ox", "oxen" ),
     entry( "soliloquy", "soliloquies" ),
     entry( "trilby", "trilbys" ),
     entry( "wolf", "wolves" )
   );
   @BeforeAll
   static void setup() throws ScriptException {
     r( "setwd( 'R' );" );
     r( "source( 'pluralize.R' );" );
+  }
   @Test
   @SuppressWarnings("UnnecessaryLocalVariable")
   public void test_Pluralize_SingularForms_PluralForms()
       throws ScriptException {
     for( final var key : PLURAL_MAP.keySet() ) {
       final var expectedSingular = key;
       final var expectedPlural = PLURAL_MAP.get( key );
       final var actualSingular = pluralize( key, 1 );
       final var actualPlural = pluralize( key, 2 );
     throws ScriptException {
     for( final var entry : PLURAL_MAP.entrySet() ) {
       final var expectedSingular = entry.getKey();
       final var expectedPlural = entry.getValue();
       final var actualSingular = pluralize( expectedSingular, 1 );
       final var actualPlural = pluralize( expectedSingular, 2 );
       assertEquals( expectedSingular, actualSingular );
       assertEquals( expectedPlural, actualPlural );
+    }
+  }
   private String pluralize( final String word, final int count )
       throws ScriptException {
     return r( format( "pluralize( '%s', %d );", word, count ) ).toString();
     throws ScriptException {
     final var stmt = format( "pluralize( word='%s', n=%d );", word, count );
     return r( stmt ).toString();
+  }

238	238
239	239	private Path getImagesPath() {
240		return mContext.getImagesPath();
	240	return mContext.getImagesDir();
241	241	}
242	242