Dave Jarvis' Repositories

Home Files Commits Tags

Repository:

D R/INSTALL.md

 # R Functions
 Import the files in this directory into the application, which include:
 * bootstrap.R
 * pluralize.R
 * possessive.R
 * conversion.R
 * csv.R
 # bootstrap.R
 Copy the contents of `bootstrap.R` into the R script preferences, shown in the
 following figure, then restart the application:
 # ![Bootstrap](images/bootstrap.png)
 Setting the **Working Directory** allows the startup script to load files
 using a relative to said directory.
 # pluralize.R
 This file defines a function that implements most of Damian Conway's [An Algorithmic Approach to English Pluralization](http://blob.perl.org/tpc/1998/User_Applications/Algorithmic%20Approach%20Plurals/Algorithmic_Plurals.html).
 ## Usage
 Example usages of the pluralize function include:
     `r#pluralize( "mouse" )` - mice
     `r#pluralize( "buzz" )` - buzzes
     `r#pluralize( "bus" )` - buses
 # possessive.R
 This file defines a function that applies possessives to English words.
 ## Usage
 Example usages of the possessive function include:
     `r#pos( "Ross" )` - Ross'
     `r#pos( "Ruby" )` - Ruby's
     `r#pos( "Lois" )` - Lois'
     `r#pos( "my" )` - mine
     `r#pos( "Your" )` - Yours

D R/README.md

 # R Scripts
 These scripts illustrate how R can perform calculations using variables, to help automate repetitive tasks. Authors are free to write their own scripts.
 ## Configuration
 Configure the editor to use scripts as follows:
 . Copy the R scripts into same directory as your Markdown files.
 . Start the editor.
 . Click **Tools → R Script**.
 . Copy and paste the following:
         assign( 'anchor', as.Date( '$date.anchor$', format='%Y-%m-%d' ), envir = .GlobalEnv );
         setwd( '$application.r.working.directory$' );
         source( 'pluralize.R' );
         source( 'csv.R' );
         source( 'conversion.R' );
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `variables.yaml`
 . Click **OK**.
 . Paste the following definitions:
         date:
           anchor: 2017-01-01
         editor:
           examples:
             season: 2017-09-02
             math:
               x: 1
               y: $editor.examples.math.x$ + 1
               z: $editor.examples.math.y$ + 1
             name:
               given: Josephene
 . Save and close the file.
 . Click **File → Open**
 . Change **Markdown Files** to **Definition Files**.
 . Select `variables.yaml`.
 . Click **Open**.
 R functionality is configured.
 ## Definitions
 The variables definitions within `variables.yaml` are available to R using the R syntax. An additional variable, `application.r.working.directory` is added to the list of variables. The value is set to the working directory of the file being edited. Hover the mouse cursor over the file tab in the editor to see the full path to the file.
 ## Examples
 This section demonstrates how to use the R functions when editing. Complete the following steps to begin:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `example.Rmd`
 . Click **OK**.
 The examples are ready for use within the editor.
 ### Arithmetic
 Type the following to perform a simple calculation:
     `r# 1+1`
 The preview pane shows `2.0`.
 ### Functions
 Call the [format](https://stat.ethz.ch/R-manual/R-devel/library/base/html/format.html) function to truncate unwanted decimal places as follows:
     `r# format(1+1,digits=1)`
 The preview pane shows `2`.
 ### Pluralize
 Many English words can be pluralized as follows:
     `r# pl('wolf',2)`
 The preview pane shows `wolves`. The `pluralize.R` file contains a partial implementation of Damian Conway's algorithmic approach to English pluralization.
 ### Chicago Manual of Style
 Apply the Chicago Manual of Style for words less than one-hundred as follows:
        `r# cms(1)` `r# cms(99)` `r# cms(101)`
 The preview pane shows numbers written out as `one` and `ninety-nine`, followed by the digits 101.
 ### Data Import
 Import and display information from a CSV file as follows:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to rename the file.
 . Set the filename to: `data.csv`
 . Paste the following into `data.csv`:
         Animal,Quantity,Country
         Aardwolf,1,Africa
         Keel-billed toucan,1,Belize
         Beaver,2,Canada
         Mute swan,3,Denmark
         Lion,5,Ethiopia
         Brown bear,8,Finland
         Dolphin,13,Greece
         Turul,21,Hungary
         Gyrfalcon,34,Iceland
         Red-billed streamertail,55,Jamaica
 . Click the `example.Rmd` tab.
 . Type the following:
        `r# csv2md('data.csv',total=F)`
 . Type the following to calculate a total for all numeric columns:
        `r# csv2md('data.csv')`
 This imports the data from an external file and formats the information into a table, automatically. Update the data as follows:
 . Click the `data.csv` tab to edit the data.
 . Change the data by adding a new row.
 . Save the file.
 . Click the `example.Rmd` tab.
 The preview pane shows the revised contents.
 ### Elapsed Time
 The duration of a timeline, given in numbers of days, can be computed into English as follows:
     `r# elapsed(1,1)`
 The preview pane shows `same day`. Change the expression to:
     `r# elapsed(1,2)`
 The preview pane shows `one day`. Change the expression to:
     `r# elapsed(1,112358)`
 The preview pane shows `307 years, seven months, and sixteen days`, combined using the Chicago Manual of Style, the pluralization function, and a [serial comma](https://www.behance.net/gallery/19417363/The-Oxford-Comma).
 ### Variable Syntax
 The syntax for a variable changes when using an R Markdown file (denoted by the `.Rmd` filename extension), as opposed to a regular Markdown file (`.md`). Return to the example file and type the following:
     `r# v$date$anchor`
 The preview pane shows the date.
 ### Autocomplete
 Automatically insert a variable reference into the text as follows:
 . Type: `Jos`
     * Note the capital letter, matches are case sensitive.
 . Hold down the `Control` key.
 . Tap the `Spacebar`
 The editor shows:
     `r#x( v$editor$examples$name$given )`
 The preview pane shows:
     Josephine
 Here, the `x` function evaluates its parameter as an expression. This allows variables to include expressions in their definition.
 ### Variable Definition Expressions
 Definition file variables are have the ability to reference other definitions. Try the following:
     x = `r#x( v$editor$examples$math$x )`;
     y = `r#x( v$editor$examples$math$y )`;
     z = `r#x( v$editor$examples$math$z )`
 The preview pane shows:
     x = 1.0; y = 2.0; z = 3.0
 ### Case
 Ensure words begin with a lowercase letter as follows:
     `r#lc( v$editor$examples$name$given )`
 The preview pane shows:
     josephine
 Similarly, ensure an uppercase letter as follows:
     `r#uc( 'hello, world!' )`
 The preview pane shows:
     Hello, world!
 ### Month
 Display the month name given a month number as follows:
     `r# month( 1 )`
 The preview pane shows:
     January
 ## Summary
 Authors can inline R statements into documents, directly, so long as those statements generate text. Plots, graphs, and images must be referenced as external image files or URLs.

D R/images/bootstrap.png

Binary file

M R/pluralize.R

 # -----------------------------------------------------------------------------
 pluralize_ch_sh_ss_suffixes <- function( word ) {
   output <- sub( "([cs]h)$", "\\1es", word )
   output <- sub( "(x|z)$", "\\1es", word )
   output <- sub( "(([cs]h)|(x|z))$", "\\1es", word )
   output <- replace_suffix( output, "ss", "sses" )

M build.gradle

   annotationProcessor "info.picocli:picocli-codegen:${v_picocli}"
   // Spelling, TeX, Docking, KeenQuotes
   // KeenQuotes, KeenType, KeenSpell, word split.
   implementation fileTree( include: ['**/*.jar'], dir: 'libs' )

A docs/logo/font.txt

 Merriweather Sans ExtraBold Italic
 https://github.com/SorkinType/Merriweather-Sans/blob/master/fonts/otf/MerriweatherSans-ExtraBoldItalic.otf
 Weight 800
 https://fonts.google.com/specimen/Merriweather+Sans

A docs/r/INSTALL.md

 # R Functions
 Import the files in this directory into the application, which include:
 * bootstrap.R
 * pluralize.R
 * possessive.R
 * conversion.R
 * csv.R
 # bootstrap.R
 Copy the contents of `bootstrap.R` into the R script preferences, shown in the
 following figure, then restart the application:
 # ![Bootstrap](images/bootstrap.png)
 Setting the **Working Directory** allows the startup script to load files
 using a relative to said directory.
 # pluralize.R
 This file defines a function that implements most of Damian Conway's [An Algorithmic Approach to English Pluralization](http://blob.perl.org/tpc/1998/User_Applications/Algorithmic%20Approach%20Plurals/Algorithmic_Plurals.html).
 ## Usage
 Example usages of the pluralize function include:
     `r#pluralize( "mouse" )` - mice
     `r#pluralize( "buzz" )` - buzzes
     `r#pluralize( "bus" )` - buses
 # possessive.R
 This file defines a function that applies possessives to English words.
 ## Usage
 Example usages of the possessive function include:
     `r#pos( "Ross" )` - Ross'
     `r#pos( "Ruby" )` - Ruby's
     `r#pos( "Lois" )` - Lois'
     `r#pos( "my" )` - mine
     `r#pos( "Your" )` - Yours

A docs/r/README.md

 # R Scripts
 These scripts illustrate how R can perform calculations using variables, to help automate repetitive tasks. Authors are free to write their own scripts.
 ## Configuration
 Configure the editor to use scripts as follows:
 . Copy the R scripts into same directory as your Markdown files.
 . Start the editor.
 . Click **Tools → R Script**.
 . Copy and paste the following:
         assign( 'anchor', as.Date( '$date.anchor$', format='%Y-%m-%d' ), envir = .GlobalEnv );
         setwd( '$application.r.working.directory$' );
         source( 'pluralize.R' );
         source( 'csv.R' );
         source( 'conversion.R' );
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `variables.yaml`
 . Click **OK**.
 . Paste the following definitions:
         date:
           anchor: 2017-01-01
         editor:
           examples:
             season: 2017-09-02
             math:
               x: 1
               y: $editor.examples.math.x$ + 1
               z: $editor.examples.math.y$ + 1
             name:
               given: Josephene
 . Save and close the file.
 . Click **File → Open**
 . Change **Markdown Files** to **Definition Files**.
 . Select `variables.yaml`.
 . Click **Open**.
 R functionality is configured.
 ## Definitions
 The variables definitions within `variables.yaml` are available to R using the R syntax. An additional variable, `application.r.working.directory` is added to the list of variables. The value is set to the working directory of the file being edited. Hover the mouse cursor over the file tab in the editor to see the full path to the file.
 ## Examples
 This section demonstrates how to use the R functions when editing. Complete the following steps to begin:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to set a filename.
 . Set **Name** to: `example.Rmd`
 . Click **OK**.
 The examples are ready for use within the editor.
 ### Arithmetic
 Type the following to perform a simple calculation:
     `r# 1+1`
 The preview pane shows `2.0`.
 ### Functions
 Call the [format](https://stat.ethz.ch/R-manual/R-devel/library/base/html/format.html) function to truncate unwanted decimal places as follows:
     `r# format(1+1,digits=1)`
 The preview pane shows `2`.
 ### Pluralize
 Many English words can be pluralized as follows:
     `r# pl('wolf',2)`
 The preview pane shows `wolves`. The `pluralize.R` file contains a partial implementation of Damian Conway's algorithmic approach to English pluralization.
 ### Chicago Manual of Style
 Apply the Chicago Manual of Style for words less than one-hundred as follows:
        `r# cms(1)` `r# cms(99)` `r# cms(101)`
 The preview pane shows numbers written out as `one` and `ninety-nine`, followed by the digits 101.
 ### Data Import
 Import and display information from a CSV file as follows:
 . Click **File → New** to create a new file.
 . Click **File → Save As** to rename the file.
 . Set the filename to: `data.csv`
 . Paste the following into `data.csv`:
         Animal,Quantity,Country
         Aardwolf,1,Africa
         Keel-billed toucan,1,Belize
         Beaver,2,Canada
         Mute swan,3,Denmark
         Lion,5,Ethiopia
         Brown bear,8,Finland
         Dolphin,13,Greece
         Turul,21,Hungary
         Gyrfalcon,34,Iceland
         Red-billed streamertail,55,Jamaica
 . Click the `example.Rmd` tab.
 . Type the following:
        `r# csv2md('data.csv',total=F)`
 . Type the following to calculate a total for all numeric columns:
        `r# csv2md('data.csv')`
 This imports the data from an external file and formats the information into a table, automatically. Update the data as follows:
 . Click the `data.csv` tab to edit the data.
 . Change the data by adding a new row.
 . Save the file.
 . Click the `example.Rmd` tab.
 The preview pane shows the revised contents.
 ### Elapsed Time
 The duration of a timeline, given in numbers of days, can be computed into English as follows:
     `r# elapsed(1,1)`
 The preview pane shows `same day`. Change the expression to:
     `r# elapsed(1,2)`
 The preview pane shows `one day`. Change the expression to:
     `r# elapsed(1,112358)`
 The preview pane shows `307 years, seven months, and sixteen days`, combined using the Chicago Manual of Style, the pluralization function, and a [serial comma](https://www.behance.net/gallery/19417363/The-Oxford-Comma).
 ### Variable Syntax
 The syntax for a variable changes when using an R Markdown file (denoted by the `.Rmd` filename extension), as opposed to a regular Markdown file (`.md`). Return to the example file and type the following:
     `r# v$date$anchor`
 The preview pane shows the date.
 ### Autocomplete
 Automatically insert a variable reference into the text as follows:
 . Type: `Jos`
     * Note the capital letter, matches are case sensitive.
 . Hold down the `Control` key.
 . Tap the `Spacebar`
 The editor shows:
     `r#x( v$editor$examples$name$given )`
 The preview pane shows:
     Josephine
 Here, the `x` function evaluates its parameter as an expression. This allows variables to include expressions in their definition.
 ### Variable Definition Expressions
 Definition file variables are have the ability to reference other definitions. Try the following:
     x = `r#x( v$editor$examples$math$x )`;
     y = `r#x( v$editor$examples$math$y )`;
     z = `r#x( v$editor$examples$math$z )`
 The preview pane shows:
     x = 1.0; y = 2.0; z = 3.0
 ### Case
 Ensure words begin with a lowercase letter as follows:
     `r#lc( v$editor$examples$name$given )`
 The preview pane shows:
     josephine
 Similarly, ensure an uppercase letter as follows:
     `r#uc( 'hello, world!' )`
 The preview pane shows:
     Hello, world!
 ### Month
 Display the month name given a month number as follows:
     `r# month( 1 )`
 The preview pane shows:
     January
 ## Summary
 Authors can inline R statements into documents, directly, so long as those statements generate text. Plots, graphs, and images must be referenced as external image files or URLs.

A docs/r/images/bootstrap.png

Binary file

M keenwrite.sh

   --add-opens=javafx.graphics/javafx.scene.text=ALL-UNNAMED \
   --add-opens=javafx.graphics/com.sun.javafx.css=ALL-UNNAMED \
   --add-opens=javafx.graphics/com.sun.javafx.scene=ALL-UNNAMED \
   --add-opens=javafx.graphics/com.sun.javafx.text=ALL-UNNAMED \
   --add-exports=javafx.base/com.sun.javafx.event=ALL-UNNAMED \

D libs/keentex.jar

Binary file

A libs/keentype-lib.jar

Binary file

A r.zip

Binary file

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

 import com.keenwrite.events.HyperlinkOpenEvent;
 import com.keenwrite.preferences.Workspace;
 import com.keenwrite.preview.MathRenderer;
 import com.keenwrite.spelling.impl.Lexicon;
 import javafx.application.Application;
 import static com.keenwrite.preferences.AppKeys.*;
 import static com.keenwrite.util.FontLoader.initFonts;
 import static javafx.scene.input.KeyCode.ALT;
 import static javafx.scene.input.KeyCode.ESCAPE;
 import static javafx.scene.input.KeyCode.F11;
 import static javafx.scene.input.KeyEvent.KEY_PRESSED;
   public static Event keyDown( final KeyCode code, final boolean shift ) {
     return keyEvent( KEY_PRESSED, code, shift );
+  }
   /**
    * Creates an instance of {@link KeyEvent} that represents a key released
    * event without any modifier keys held.
+   *
    * @param code The key code representing a key to simulate releasing.
    * @return An instance of {@link KeyEvent}.
    */
   public static Event keyDown( final KeyCode code ) {
     return keyDown( code, false );
+  }
    * a key being released.
    */
   @SuppressWarnings( "unused" )
   public static Event keyUp( final KeyCode code, final boolean shift ) {
     return keyEvent( KEY_RELEASED, code, shift );
+  }
   /**
    * Creates an instance of {@link KeyEvent} that represents a key released
    * event without any modifier keys held.
+   *
    * @param code The key code representing a key to simulate releasing.
    * @return An instance of {@link KeyEvent}.
    */
   public static Event keyUp( final KeyCode code ) {
     return keyUp( code, false );
+  }
     initIcons( stage );
     initScene( stage );
     MathRenderer.bindSize( mWorkspace.doubleProperty( KEY_UI_FONT_MATH_SIZE ) );
     // Load the lexicon and check all the documents after all files are open.
     // After the app loses focus, when the user switches back using Alt+Tab,
     // the menu mnemonic is sometimes engaged, swallowing the first letter that
     // the user types---if it is a menu mnemonic. See MainScene::createScene().
     // the menu is engaged on Windows. Simulate an ESC keypress to the menu
     // to disable the menu, giving focus back to the application proper.
     //
     // JavaFX Bug: https://bugs.openjdk.java.net/browse/JDK-8090647
     stage.focusedProperty().addListener( ( c, lost, show ) -> {
       for( final var menu : mMainScene.getMenuBar().getMenus() ) {
         menu.hide();
+      }
       for( final var mnemonics : stage.getScene().getMnemonics().values() ) {
         for( final var mnemonic : mnemonics ) {
           mnemonic.getNode().fireEvent( keyUp( ALT ) );
+        }
     stage.focusedProperty().addListener( ( c, lost, found ) -> {
       if( found ) {
         mMainScene.getMenuBar().fireEvent( keyDown( ESCAPE ) );
+      }
     } );

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

     final var file = files.get( 0 );
     editor.rename( file );
     tab.ifPresent( t -> {
       t.setText( editor.getFilename() );
       t.setTooltip( createTooltip( file ) );
     } );
     save();
+  }
   /**
    * Saves the given {@link TextResource} to a file. This is typically used
    * to save either an instance of {@link TextEditor} or {@link TextDefinition}.
+   *
    * @param resource The resource to export.
    */
   private void save( final TextResource resource ) {
     try {
       resource.save();
     } catch( final Exception ex ) {
       clue( ex );
       sNotifier.alert(
         getWindow(), resource.getPath(), "TextResource.saveFailed", ex
       );
+    }
+  }
   /**
    * Closes all open {@link TextEditor}s; all {@link TextDefinition}s stay open.
+   *
    * @return {@code true} when all editors, modified or otherwise, were
    * permitted to close; {@code false} when one or more editors were modified
    * and the user requested no closing.
    */
   public boolean closeAll() {
     var closable = true;
     for( final var tabPane : mTabPanes ) {
       final var tabIterator = tabPane.getTabs().iterator();
       while( tabIterator.hasNext() ) {
         final var tab = tabIterator.next();
         final var resource = tab.getContent();
         // The definition panes auto-save, so being specific here prevents
         // closing the definitions in the situation where the user wants to
         // continue editing (i.e., possibly save unsaved work).
         if( !(resource instanceof TextEditor) ) {
           continue;
+        }
         if( canClose( (TextEditor) resource ) ) {
           tabIterator.remove();
           close( tab );
+        }
         else {
           closable = false;
+        }
+      }
+    }
     return closable;
+  }
   /**
    * Calls the tab's {@link Tab#getOnClosed()} handler to carry out a close
    * event.
+   *
    * @param tab The {@link Tab} that was closed.
    */
   private void close( final Tab tab ) {
     assert tab != null;
     final var handler = tab.getOnClosed();
     if( handler != null ) {
       handler.handle( new ActionEvent() );
+    }
+  }
   /**
    * Closes the active tab; delegates to {@link #canClose(TextResource)}.
    */
   public void close() {
     final var editor = getTextEditor();
     if( canClose( editor ) ) {
       close( editor );
+    }
+  }
   /**
    * Closes the given {@link TextResource}. This must not be called from within
    * a loop that iterates over the tab panes using {@code forEach}, lest a
    * concurrent modification exception be thrown.
+   *
    * @param resource The {@link TextResource} to close, without confirming with
    *                 the user.
    */
   private void close( final TextResource resource ) {
     getTab( resource ).ifPresent(
       tab -> {
         close( tab );
         tab.getTabPane().getTabs().remove( tab );
+      }
     );
+  }
   /**
    * Answers whether the given {@link TextResource} may be closed.
+   *
    * @param editor The {@link TextResource} to try closing.
    * @return {@code true} when the editor may be closed; {@code false} when
    * the user has requested to keep the editor open.
    */
   private boolean canClose( final TextResource editor ) {
     final var editorTab = getTab( editor );
     final var canClose = new AtomicBoolean( true );
     if( editor.isModified() ) {
       final var filename = new StringBuilder();
       editorTab.ifPresent( tab -> filename.append( tab.getText() ) );
       final var message = sNotifier.createNotification(
         Messages.get( "Alert.file.close.title" ),
         Messages.get( "Alert.file.close.text" ),
         filename.toString()
       );
       final var dialog = sNotifier.createConfirmation( getWindow(), message );
       dialog.showAndWait().ifPresent(
         save -> canClose.set( save == YES ? editor.save() : save == NO )
       );
+    }
     return canClose.get();
+  }
   private void iterateEditors( final Consumer<TextEditor> consumer ) {
     mTabPanes.forEach(
       tp -> tp.getTabs().forEach( tab -> {
         final var node = tab.getContent();
         if( node instanceof final TextEditor editor ) {
           consumer.accept( editor );
+        }
       } )
     );
+  }
   private ObjectProperty<TextEditor> createActiveTextEditor() {
     final var editor = new SimpleObjectProperty<TextEditor>();
     editor.addListener( ( c, o, n ) -> {
       if( n != null ) {
         mPreview.setBaseUri( n.getPath() );
         process( n );
+      }
     } );
     return editor;
+  }
   /**
    * Adds the HTML preview tab to its own, singular tab pane.
    */
   public void viewPreview() {
     viewTab( mPreview, TEXT_HTML, "Pane.preview.title" );
+  }
   /**
    * Adds the document outline tab to its own, singular tab pane.
    */
   public void viewOutline() {
     viewTab( mOutline, APP_DOCUMENT_OUTLINE, "Pane.outline.title" );
+  }
   public void viewStatistics() {
     viewTab( mStatistics, APP_DOCUMENT_STATISTICS, "Pane.statistics.title" );
+  }
   public void viewFiles() {
     try {
       final var factory = new FilePickerFactory( getWorkspace() );
       final var fileManager = factory.createModeless();
       viewTab( fileManager, APP_FILE_MANAGER, "Pane.files.title" );
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   private void viewTab(
     final Node node, final MediaType mediaType, final String key ) {
     final var tabPane = obtainTabPane( mediaType );
     for( final var tab : tabPane.getTabs() ) {
       if( tab.getContent() == node ) {
         return;
+      }
+    }
     tabPane.getTabs().add( createTab( get( key ), node ) );
     addTabPane( tabPane );
+  }
   public void viewRefresh() {
     mPreview.refresh();
     Engine.clear();
     mRBootstrapController.update();
+  }
   /**
    * Returns the tab that contains the given {@link TextEditor}.
+   *
    * @param editor The {@link TextEditor} instance to find amongst the tabs.
    * @return The first tab having content that matches the given tab.
    */
   private Optional<Tab> getTab( final TextResource editor ) {
     return mTabPanes.stream()
                     .flatMap( pane -> pane.getTabs().stream() )
                     .filter( tab -> editor.equals( tab.getContent() ) )
                     .findFirst();
+  }
   /**
    * Creates a new {@link DefinitionEditor} wrapped in a listener that
    * is used to detect when the active {@link DefinitionEditor} has changed.
    * Upon changing, the variables are interpolated and the active text editor
    * is refreshed.
+   *
    * @param textEditor Text editor to update with the revised resolved map.
    * @return A newly configured property that represents the active
    * {@link DefinitionEditor}, never null.
    */
   private ObjectProperty<TextDefinition> createActiveDefinitionEditor(
     final ObjectProperty<TextEditor> textEditor ) {
     final var defEditor = new SimpleObjectProperty<>(
       createDefinitionEditor()
     );
     defEditor.addListener( ( c, o, n ) -> {
       final var editor = textEditor.get();
       if( editor.isMediaType( TEXT_R_MARKDOWN ) ) {
         // Initialize R before the editor is added.
         mRBootstrapController.update();
+      }
       process( editor );
     } );
     return defEditor;
+  }
   private Tab createTab( final String filename, final Node node ) {
     return new DetachableTab( filename, node );
+  }
   private Tab createTab( final File file ) {
     final var r = createTextResource( file );
     final var tab = createTab( r.getFilename(), r.getNode() );
     r.modifiedProperty().addListener(
       ( c, o, n ) -> tab.setText( r.getFilename() + (n ? "*" : "") )
     );
     // This is called when either the tab is closed by the user clicking on
     // the tab's close icon or when closing (all) from the file menu.
     tab.setOnClosed(
       __ -> getRecentFiles().remove( file.getAbsolutePath() )
     );
     // When closing a tab, give focus to the newly revealed tab.
     tab.selectedProperty().addListener( ( c, o, n ) -> {
       if( n != null && n ) {
         final var pane = tab.getTabPane();
         if( pane != null ) {
           pane.requestFocus();
+        }
+      }
     } );
     tab.tabPaneProperty().addListener( ( cPane, oPane, nPane ) -> {
       if( nPane != null ) {
         nPane.focusedProperty().addListener( ( c, o, n ) -> {
           if( n != null && n ) {
             final var selected = nPane.getSelectionModel().getSelectedItem();
             final var node = selected.getContent();
             node.requestFocus();
+          }
         } );
+      }
     } );
     return tab;
+  }
   /**
    * Creates bins for the different {@link MediaType}s, which eventually are
    * added to the UI as separate tab panes. If ever a general-purpose scene
    * exporter is developed to serialize a scene to an FXML file, this could
    * be replaced by such a class.
    * <p>
    * When binning the files, this makes sure that at least one file exists
    * for every type. If the user has opted to close a particular type (such
    * as the definition pane), the view will suppressed elsewhere.
    * </p>
    * <p>
    * The order that the binned files are returned will be reflected in the
    * order that the corresponding panes are rendered in the UI.
    * </p>
+   *
    * @param paths The file paths to bin according to their type.
    * @return An in-order list of files, first by structured definition files,
    * then by plain text documents.
    */
   private List<File> collect( final SetProperty<String> paths ) {
     // Treat all files destined for the text editor as plain text documents
     // so that they are added to the same pane. Grouping by TEXT_PLAIN is a
     // bit arbitrary, but means explicitly capturing TEXT_PLAIN isn't needed.
     final Function<MediaType, MediaType> bin =
       m -> PLAIN_TEXT_FORMAT.contains( m ) ? TEXT_PLAIN : m;
     // Create two groups: YAML files and plain text files. The order that
     // the elements are listed in the enumeration for media types determines
     // what files are loaded first. Variable definitions come before all other
     // plain text documents.
     final var bins = paths
       .stream()
       .collect(
         groupingBy(
           path -> bin.apply( MediaType.fromFilename( path ) ),
           () -> new TreeMap<>( Enum::compareTo ),
           Collectors.toList()
+        )
       );
     bins.putIfAbsent( TEXT_YAML, List.of( DEFINITION_DEFAULT.toString() ) );
     bins.putIfAbsent( TEXT_PLAIN, List.of( DOCUMENT_DEFAULT.toString() ) );
     final var result = new LinkedList<File>();
     // Ensure that the same types are listed together (keep insertion order).
     bins.forEach( ( mediaType, files ) -> result.addAll(
       files.stream().map( File::new ).toList() )
     );
     return result;
+  }
   /**
    * Force the active editor to update, which will cause the processor
    * to re-evaluate the interpolated definition map thereby updating the
    * preview pane.
+   *
    * @param editor Contains the source document to update in the preview pane.
    */
   private void process( final TextEditor editor ) {
     // Ensure processing does not run on the JavaFX thread, which frees the
     // text editor immediately for caret movement. The preview will have a
     // slight delay when catching up to the caret position.
     final var task = new Task<Void>() {
       @Override
       public Void call() {
         try {
           final var p = mProcessors.getOrDefault( editor, IDENTITY );
           p.apply( editor == null ? "" : editor.getText() );
         } catch( final Exception ex ) {
           clue( ex );
+        }
         return null;
+      }
     };
     // TODO: Each time the editor successfully runs the processor the task is
     //   considered successful. Due to the rapid-fire nature of processing
     //   (e.g., keyboard navigation, fast typing), it isn't necessary to
     //   scroll each time.
     //   The algorithm:
     //   1. Peek at the oldest time.
     //   2. If the difference between the oldest time and current time exceeds
     //      250 milliseconds, then invoke the scrolling.
     //   3. Insert the current time into the circular queue.
     task.setOnSucceeded(
       e -> invokeLater( () -> mPreview.scrollTo( CARET_ID ) )
     );
     // Prevents multiple process requests from executing simultaneously (due
     // to having a restricted queue size).
     sExecutor.execute( task );
+  }
   /**
    * Lazily creates a {@link TabPane} configured to listen for tab select
    * events. The tab pane is associated with a given media type so that
    * similar files can be grouped together.
+   *
    * @param mediaType The media type to associate with the tab pane.
    * @return An instance of {@link TabPane} that will handle tab docking.
    */
   private TabPane obtainTabPane( final MediaType mediaType ) {
     for( final var pane : mTabPanes ) {
       for( final var tab : pane.getTabs() ) {
         final var node = tab.getContent();
         if( node instanceof TextResource r && r.supports( mediaType ) ) {
           return pane;
+        }
+      }
+    }
     final var pane = createTabPane();
     mTabPanes.add( pane );
     return pane;
+  }
   /**
    * Creates an initialized {@link TabPane} instance.
+   *
    * @return A new {@link TabPane} with all listeners configured.
    */
   private TabPane createTabPane() {
     final var tabPane = new DetachableTabPane();
     initStageOwnerFactory( tabPane );
     initTabListener( tabPane );
     return tabPane;
+  }
   /**
    * When any {@link DetachableTabPane} is detached from the main window,
    * the stage owner factory must be given its parent window, which will
    * own the child window. The parent window is the {@link MainPane}'s
    * {@link Scene}'s {@link Window} instance.
+   *
    * <p>
    * This will derives the new title from the main window title, incrementing
    * the window count to help uniquely identify the child windows.
    * </p>
+   *
    * @param tabPane A new {@link DetachableTabPane} to configure.
    */
   private void initStageOwnerFactory( final DetachableTabPane tabPane ) {
     tabPane.setStageOwnerFactory( stage -> {
       final var title = get(
         "Detach.tab.title",
         ((Stage) getWindow()).getTitle(), ++mWindowCount
       );
       stage.setTitle( title );
       return getScene().getWindow();
     } );
+  }
   /**
    * Responsible for configuring the content of each {@link DetachableTab} when
    * it is added to the given {@link DetachableTabPane} instance.
    * <p>
    * For {@link TextEditor} contents, an instance of {@link ScrollEventHandler}
    * is initialized to perform synchronized scrolling between the editor and
    * its preview window. Additionally, the last tab in the tab pane's list of
    * tabs is given focus.
    * </p>
    * <p>
    * Note that multiple tabs can be added simultaneously.
    * </p>
+   *
    * @param tabPane A new {@link TabPane} to configure.
    */
   private void initTabListener( final TabPane tabPane ) {
     tabPane.getTabs().addListener(
       ( final ListChangeListener.Change<? extends Tab> listener ) -> {
         while( listener.next() ) {
           if( listener.wasAdded() ) {
             final var tabs = listener.getAddedSubList();
             tabs.forEach( tab -> {
               final var node = tab.getContent();
               if( node instanceof TextEditor ) {
                 initScrollEventListener( tab );
+              }
             } );
             // Select and give focus to the last tab opened.
             final var index = tabs.size() - 1;
             if( index >= 0 ) {
               final var tab = tabs.get( index );
               tabPane.getSelectionModel().select( tab );
               tab.getContent().requestFocus();
+            }
+          }
+        }
+      }
     );
+  }
   /**
    * Synchronizes scrollbar positions between the given {@link Tab} that
    * contains an instance of {@link TextEditor} and {@link HtmlPreview} pane.
+   *
    * @param tab The container for an instance of {@link TextEditor}.
    */
   private void initScrollEventListener( final Tab tab ) {
     final var editor = (TextEditor) tab.getContent();
     final var scrollPane = editor.getScrollPane();
     final var scrollBar = mPreview.getVerticalScrollBar();
     final var handler = new ScrollEventHandler( scrollPane, scrollBar );
     handler.enabledProperty().bind( tab.selectedProperty() );
+  }
   private void addTabPane( final int index, final TabPane tabPane ) {
     final var items = getItems();
     if( !items.contains( tabPane ) ) {
       items.add( index, tabPane );
+    }
+  }
   private void addTabPane( final TabPane tabPane ) {
     addTabPane( getItems().size(), tabPane );
+  }
   private GenericBuilder<Mutator, ProcessorContext> processorContextBuilder() {
     final var w = getWorkspace();
     return builder()
       .with( Mutator::setDefinitions, this::getDefinitions )
       .with( Mutator::setLocale, w::getLocale )
       .with( Mutator::setMetadata, w::getMetadata )
       .with( Mutator::setThemesPath, w::getThemesPath )
       .with( Mutator::setCachesPath,
              () -> w.getFile( KEY_CACHES_DIR ) )
       .with( Mutator::setImagesPath,
              () -> w.getFile( KEY_IMAGES_DIR ) )
       .with( Mutator::setImageOrder,
              () -> w.getString( KEY_IMAGES_ORDER ) )
       .with( Mutator::setImageServer,
              () -> w.getString( KEY_IMAGES_SERVER ) )
       .with( Mutator::setFontsPath,
              () -> w.getFile( KEY_TYPESET_CONTEXT_FONTS_DIR ) )
       .with( Mutator::setCaret,
              () -> getTextEditor().getCaret() )
       .with( Mutator::setSigilBegan,
              () -> w.getString( KEY_DEF_DELIM_BEGAN ) )
       .with( Mutator::setSigilEnded,
              () -> w.getString( KEY_DEF_DELIM_ENDED ) )
       .with( Mutator::setRScript,
              () -> w.getString( KEY_R_SCRIPT ) )
       .with( Mutator::setRWorkingDir,
              () -> w.getFile( KEY_R_DIR ).toPath() )
       .with( Mutator::setCurlQuotes,
              () -> w.getBoolean( KEY_TYPESET_TYPOGRAPHY_QUOTES ) )
       .with( Mutator::setAutoRemove,
              () -> w.getBoolean( KEY_TYPESET_CONTEXT_CLEAN ) );
+  }
   public ProcessorContext createProcessorContext() {
     return createProcessorContext( null, NONE );
+  }
   /**
    * @param targetPath Used when exporting to a PDF file (binary).
    * @param format     Used when processors export to a new text format.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   public ProcessorContext createProcessorContext(
     final Path targetPath, final ExportFormat format ) {
     final var textEditor = getTextEditor();
     final var sourcePath = textEditor.getPath();
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
       .with( Mutator::setTargetPath, targetPath )
       .with( Mutator::setExportFormat, format )
       .build();
+  }
   /**
    * @param sourcePath Used by {@link ProcessorFactory} to determine
    *                   {@link Processor} type to create based on file type.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   private ProcessorContext createProcessorContext( final Path sourcePath ) {
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
       .with( Mutator::setExportFormat, NONE )
       .build();
+  }
   private TextResource createTextResource( final File file ) {
     // TODO: Create PlainTextEditor that's returned by default.
     return MediaType.valueFrom( file ) == TEXT_YAML
       ? createDefinitionEditor( file )
       : createMarkdownEditor( file );
+  }
   /**
    * Creates an instance of {@link MarkdownEditor} that listens for both
    * caret change events and text change events. Text change events must
    * take priority over caret change events because it's possible to change
    * the text without moving the caret (e.g., delete selected text).
+   *
    * @param inputFile The file containing contents for the text editor.
    * @return A non-null text editor.
    */
   private MarkdownEditor createMarkdownEditor( final File inputFile ) {
     final var editor = new MarkdownEditor( inputFile, getWorkspace() );
     mProcessors.computeIfAbsent(
       editor, p -> createProcessors(
         createProcessorContext( inputFile.toPath() ),
         createHtmlPreviewProcessor()
+      )
     );
     // Listener for editor modifications or caret position changes.
     editor.addDirtyListener( ( c, o, n ) -> {
       if( n ) {
         // Reset the status bar after changing the text.
         clue();
         // Processing the text may update the status bar.
         process( getTextEditor() );
         // Update the caret position in the status bar.
         CaretMovedEvent.fire( editor.getCaret() );
+      }
     } );
     editor.addEventListener(
       keyPressed( SPACE, CONTROL_DOWN ), this::autoinsert
     );
     editor.addEventListener(
       keyPressed( ENTER, ALT_DOWN ), event -> mEditorSpeller.autofix( editor )
     );
     final var textArea = editor.getTextArea();
     // Spell check when the paragraph changes.
     textArea
       .plainTextChanges()
       .filter( p -> !p.isIdentity() )
       .subscribe( change -> mEditorSpeller.checkParagraph( textArea, change ) );
     // Store the caret position to restore it after restarting the application.
     textArea.caretPositionProperty().addListener(
       ( c, o, n ) ->
         getWorkspace().integerProperty( KEY_UI_RECENT_OFFSET ).setValue( n )
     );
     // Set the active editor, which refreshes the preview panel.
     mTextEditor.set( editor );
     // Check the entire document after the spellchecker is initialized (with
     // a valid lexicon) so that only the current paragraph need be scanned
     // while editing. (Technically, only the most recently modified word must
     // be scanned.)
     mSpellChecker.addListener(
       ( c, o, n ) -> runLater(
         () -> iterateEditors( mEditorSpeller::checkDocument )
+      )
     );
     // Check the entire document after it has been loaded.
     mEditorSpeller.checkDocument( mTextEditor.get() );
     return editor;
     // If the file type has changed, refresh the processors.
     final var mediaType = MediaType.valueFrom( file );
     final var typeChanged = !editor.isMediaType( mediaType );
     if( typeChanged ) {
       removeProcessor( editor );
+    }
     editor.rename( file );
     tab.ifPresent( t -> {
       t.setText( editor.getFilename() );
       t.setTooltip( createTooltip( file ) );
     } );
     if( typeChanged ) {
       updateProcessors( editor );
       process( editor );
+    }
     save();
+  }
   /**
    * Saves the given {@link TextResource} to a file. This is typically used
    * to save either an instance of {@link TextEditor} or {@link TextDefinition}.
+   *
    * @param resource The resource to export.
    */
   private void save( final TextResource resource ) {
     try {
       resource.save();
     } catch( final Exception ex ) {
       clue( ex );
       sNotifier.alert(
         getWindow(), resource.getPath(), "TextResource.saveFailed", ex
       );
+    }
+  }
   /**
    * Closes all open {@link TextEditor}s; all {@link TextDefinition}s stay open.
+   *
    * @return {@code true} when all editors, modified or otherwise, were
    * permitted to close; {@code false} when one or more editors were modified
    * and the user requested no closing.
    */
   public boolean closeAll() {
     var closable = true;
     for( final var tabPane : mTabPanes ) {
       final var tabIterator = tabPane.getTabs().iterator();
       while( tabIterator.hasNext() ) {
         final var tab = tabIterator.next();
         final var resource = tab.getContent();
         // The definition panes auto-save, so being specific here prevents
         // closing the definitions in the situation where the user wants to
         // continue editing (i.e., possibly save unsaved work).
         if( !(resource instanceof TextEditor) ) {
           continue;
+        }
         if( canClose( (TextEditor) resource ) ) {
           tabIterator.remove();
           close( tab );
+        }
         else {
           closable = false;
+        }
+      }
+    }
     return closable;
+  }
   /**
    * Calls the tab's {@link Tab#getOnClosed()} handler to carry out a close
    * event.
+   *
    * @param tab The {@link Tab} that was closed.
    */
   private void close( final Tab tab ) {
     assert tab != null;
     final var handler = tab.getOnClosed();
     if( handler != null ) {
       handler.handle( new ActionEvent() );
+    }
+  }
   /**
    * Closes the active tab; delegates to {@link #canClose(TextResource)}.
    */
   public void close() {
     final var editor = getTextEditor();
     if( canClose( editor ) ) {
       close( editor );
+    }
+  }
   /**
    * Closes the given {@link TextResource}. This must not be called from within
    * a loop that iterates over the tab panes using {@code forEach}, lest a
    * concurrent modification exception be thrown.
+   *
    * @param resource The {@link TextResource} to close, without confirming with
    *                 the user.
    */
   private void close( final TextResource resource ) {
     getTab( resource ).ifPresent(
       tab -> {
         close( tab );
         tab.getTabPane().getTabs().remove( tab );
+      }
     );
+  }
   /**
    * Answers whether the given {@link TextResource} may be closed.
+   *
    * @param editor The {@link TextResource} to try closing.
    * @return {@code true} when the editor may be closed; {@code false} when
    * the user has requested to keep the editor open.
    */
   private boolean canClose( final TextResource editor ) {
     final var editorTab = getTab( editor );
     final var canClose = new AtomicBoolean( true );
     if( editor.isModified() ) {
       final var filename = new StringBuilder();
       editorTab.ifPresent( tab -> filename.append( tab.getText() ) );
       final var message = sNotifier.createNotification(
         Messages.get( "Alert.file.close.title" ),
         Messages.get( "Alert.file.close.text" ),
         filename.toString()
       );
       final var dialog = sNotifier.createConfirmation( getWindow(), message );
       dialog.showAndWait().ifPresent(
         save -> canClose.set( save == YES ? editor.save() : save == NO )
       );
+    }
     return canClose.get();
+  }
   private void iterateEditors( final Consumer<TextEditor> consumer ) {
     mTabPanes.forEach(
       tp -> tp.getTabs().forEach( tab -> {
         final var node = tab.getContent();
         if( node instanceof final TextEditor editor ) {
           consumer.accept( editor );
+        }
       } )
     );
+  }
   private ObjectProperty<TextEditor> createActiveTextEditor() {
     final var editor = new SimpleObjectProperty<TextEditor>();
     editor.addListener( ( c, o, n ) -> {
       if( n != null ) {
         mPreview.setBaseUri( n.getPath() );
         process( n );
+      }
     } );
     return editor;
+  }
   /**
    * Adds the HTML preview tab to its own, singular tab pane.
    */
   public void viewPreview() {
     viewTab( mPreview, TEXT_HTML, "Pane.preview.title" );
+  }
   /**
    * Adds the document outline tab to its own, singular tab pane.
    */
   public void viewOutline() {
     viewTab( mOutline, APP_DOCUMENT_OUTLINE, "Pane.outline.title" );
+  }
   public void viewStatistics() {
     viewTab( mStatistics, APP_DOCUMENT_STATISTICS, "Pane.statistics.title" );
+  }
   public void viewFiles() {
     try {
       final var factory = new FilePickerFactory( getWorkspace() );
       final var fileManager = factory.createModeless();
       viewTab( fileManager, APP_FILE_MANAGER, "Pane.files.title" );
     } catch( final Exception ex ) {
       clue( ex );
+    }
+  }
   private void viewTab(
     final Node node, final MediaType mediaType, final String key ) {
     final var tabPane = obtainTabPane( mediaType );
     for( final var tab : tabPane.getTabs() ) {
       if( tab.getContent() == node ) {
         return;
+      }
+    }
     tabPane.getTabs().add( createTab( get( key ), node ) );
     addTabPane( tabPane );
+  }
   public void viewRefresh() {
     mPreview.refresh();
     Engine.clear();
     mRBootstrapController.update();
+  }
   /**
    * Returns the tab that contains the given {@link TextEditor}.
+   *
    * @param editor The {@link TextEditor} instance to find amongst the tabs.
    * @return The first tab having content that matches the given tab.
    */
   private Optional<Tab> getTab( final TextResource editor ) {
     return mTabPanes.stream()
                     .flatMap( pane -> pane.getTabs().stream() )
                     .filter( tab -> editor.equals( tab.getContent() ) )
                     .findFirst();
+  }
   /**
    * Creates a new {@link DefinitionEditor} wrapped in a listener that
    * is used to detect when the active {@link DefinitionEditor} has changed.
    * Upon changing, the variables are interpolated and the active text editor
    * is refreshed.
+   *
    * @param textEditor Text editor to update with the revised resolved map.
    * @return A newly configured property that represents the active
    * {@link DefinitionEditor}, never null.
    */
   private ObjectProperty<TextDefinition> createActiveDefinitionEditor(
     final ObjectProperty<TextEditor> textEditor ) {
     final var defEditor = new SimpleObjectProperty<>(
       createDefinitionEditor()
     );
     defEditor.addListener( ( c, o, n ) -> {
       final var editor = textEditor.get();
       if( editor.isMediaType( TEXT_R_MARKDOWN ) ) {
         // Initialize R before the editor is added.
         mRBootstrapController.update();
+      }
       process( editor );
     } );
     return defEditor;
+  }
   private Tab createTab( final String filename, final Node node ) {
     return new DetachableTab( filename, node );
+  }
   private Tab createTab( final File file ) {
     final var r = createTextResource( file );
     final var tab = createTab( r.getFilename(), r.getNode() );
     r.modifiedProperty().addListener(
       ( c, o, n ) -> tab.setText( r.getFilename() + (n ? "*" : "") )
     );
     // This is called when either the tab is closed by the user clicking on
     // the tab's close icon or when closing (all) from the file menu.
     tab.setOnClosed(
       __ -> getRecentFiles().remove( file.getAbsolutePath() )
     );
     // When closing a tab, give focus to the newly revealed tab.
     tab.selectedProperty().addListener( ( c, o, n ) -> {
       if( n != null && n ) {
         final var pane = tab.getTabPane();
         if( pane != null ) {
           pane.requestFocus();
+        }
+      }
     } );
     tab.tabPaneProperty().addListener( ( cPane, oPane, nPane ) -> {
       if( nPane != null ) {
         nPane.focusedProperty().addListener( ( c, o, n ) -> {
           if( n != null && n ) {
             final var selected = nPane.getSelectionModel().getSelectedItem();
             final var node = selected.getContent();
             node.requestFocus();
+          }
         } );
+      }
     } );
     return tab;
+  }
   /**
    * Creates bins for the different {@link MediaType}s, which eventually are
    * added to the UI as separate tab panes. If ever a general-purpose scene
    * exporter is developed to serialize a scene to an FXML file, this could
    * be replaced by such a class.
    * <p>
    * When binning the files, this makes sure that at least one file exists
    * for every type. If the user has opted to close a particular type (such
    * as the definition pane), the view will suppressed elsewhere.
    * </p>
    * <p>
    * The order that the binned files are returned will be reflected in the
    * order that the corresponding panes are rendered in the UI.
    * </p>
+   *
    * @param paths The file paths to bin according to their type.
    * @return An in-order list of files, first by structured definition files,
    * then by plain text documents.
    */
   private List<File> collect( final SetProperty<String> paths ) {
     // Treat all files destined for the text editor as plain text documents
     // so that they are added to the same pane. Grouping by TEXT_PLAIN is a
     // bit arbitrary, but means explicitly capturing TEXT_PLAIN isn't needed.
     final Function<MediaType, MediaType> bin =
       m -> PLAIN_TEXT_FORMAT.contains( m ) ? TEXT_PLAIN : m;
     // Create two groups: YAML files and plain text files. The order that
     // the elements are listed in the enumeration for media types determines
     // what files are loaded first. Variable definitions come before all other
     // plain text documents.
     final var bins = paths
       .stream()
       .collect(
         groupingBy(
           path -> bin.apply( MediaType.fromFilename( path ) ),
           () -> new TreeMap<>( Enum::compareTo ),
           Collectors.toList()
+        )
       );
     bins.putIfAbsent( TEXT_YAML, List.of( DEFINITION_DEFAULT.toString() ) );
     bins.putIfAbsent( TEXT_PLAIN, List.of( DOCUMENT_DEFAULT.toString() ) );
     final var result = new LinkedList<File>();
     // Ensure that the same types are listed together (keep insertion order).
     bins.forEach( ( mediaType, files ) -> result.addAll(
       files.stream().map( File::new ).toList() )
     );
     return result;
+  }
   /**
    * Force the active editor to update, which will cause the processor
    * to re-evaluate the interpolated definition map thereby updating the
    * preview pane.
+   *
    * @param editor Contains the source document to update in the preview pane.
    */
   private void process( final TextEditor editor ) {
     // Ensure processing does not run on the JavaFX thread, which frees the
     // text editor immediately for caret movement. The preview will have a
     // slight delay when catching up to the caret position.
     final var task = new Task<Void>() {
       @Override
       public Void call() {
         try {
           final var p = mProcessors.getOrDefault( editor, IDENTITY );
           p.apply( editor == null ? "" : editor.getText() );
         } catch( final Exception ex ) {
           clue( ex );
+        }
         return null;
+      }
     };
     // TODO: Each time the editor successfully runs the processor the task is
     //   considered successful. Due to the rapid-fire nature of processing
     //   (e.g., keyboard navigation, fast typing), it isn't necessary to
     //   scroll each time.
     //   The algorithm:
     //   1. Peek at the oldest time.
     //   2. If the difference between the oldest time and current time exceeds
     //      250 milliseconds, then invoke the scrolling.
     //   3. Insert the current time into the circular queue.
     task.setOnSucceeded(
       e -> invokeLater( () -> mPreview.scrollTo( CARET_ID ) )
     );
     // Prevents multiple process requests from executing simultaneously (due
     // to having a restricted queue size).
     sExecutor.execute( task );
+  }
   /**
    * Lazily creates a {@link TabPane} configured to listen for tab select
    * events. The tab pane is associated with a given media type so that
    * similar files can be grouped together.
+   *
    * @param mediaType The media type to associate with the tab pane.
    * @return An instance of {@link TabPane} that will handle tab docking.
    */
   private TabPane obtainTabPane( final MediaType mediaType ) {
     for( final var pane : mTabPanes ) {
       for( final var tab : pane.getTabs() ) {
         final var node = tab.getContent();
         if( node instanceof TextResource r && r.supports( mediaType ) ) {
           return pane;
+        }
+      }
+    }
     final var pane = createTabPane();
     mTabPanes.add( pane );
     return pane;
+  }
   /**
    * Creates an initialized {@link TabPane} instance.
+   *
    * @return A new {@link TabPane} with all listeners configured.
    */
   private TabPane createTabPane() {
     final var tabPane = new DetachableTabPane();
     initStageOwnerFactory( tabPane );
     initTabListener( tabPane );
     return tabPane;
+  }
   /**
    * When any {@link DetachableTabPane} is detached from the main window,
    * the stage owner factory must be given its parent window, which will
    * own the child window. The parent window is the {@link MainPane}'s
    * {@link Scene}'s {@link Window} instance.
+   *
    * <p>
    * This will derives the new title from the main window title, incrementing
    * the window count to help uniquely identify the child windows.
    * </p>
+   *
    * @param tabPane A new {@link DetachableTabPane} to configure.
    */
   private void initStageOwnerFactory( final DetachableTabPane tabPane ) {
     tabPane.setStageOwnerFactory( stage -> {
       final var title = get(
         "Detach.tab.title",
         ((Stage) getWindow()).getTitle(), ++mWindowCount
       );
       stage.setTitle( title );
       return getScene().getWindow();
     } );
+  }
   /**
    * Responsible for configuring the content of each {@link DetachableTab} when
    * it is added to the given {@link DetachableTabPane} instance.
    * <p>
    * For {@link TextEditor} contents, an instance of {@link ScrollEventHandler}
    * is initialized to perform synchronized scrolling between the editor and
    * its preview window. Additionally, the last tab in the tab pane's list of
    * tabs is given focus.
    * </p>
    * <p>
    * Note that multiple tabs can be added simultaneously.
    * </p>
+   *
    * @param tabPane A new {@link TabPane} to configure.
    */
   private void initTabListener( final TabPane tabPane ) {
     tabPane.getTabs().addListener(
       ( final ListChangeListener.Change<? extends Tab> listener ) -> {
         while( listener.next() ) {
           if( listener.wasAdded() ) {
             final var tabs = listener.getAddedSubList();
             tabs.forEach( tab -> {
               final var node = tab.getContent();
               if( node instanceof TextEditor ) {
                 initScrollEventListener( tab );
+              }
             } );
             // Select and give focus to the last tab opened.
             final var index = tabs.size() - 1;
             if( index >= 0 ) {
               final var tab = tabs.get( index );
               tabPane.getSelectionModel().select( tab );
               tab.getContent().requestFocus();
+            }
+          }
+        }
+      }
     );
+  }
   /**
    * Synchronizes scrollbar positions between the given {@link Tab} that
    * contains an instance of {@link TextEditor} and {@link HtmlPreview} pane.
+   *
    * @param tab The container for an instance of {@link TextEditor}.
    */
   private void initScrollEventListener( final Tab tab ) {
     final var editor = (TextEditor) tab.getContent();
     final var scrollPane = editor.getScrollPane();
     final var scrollBar = mPreview.getVerticalScrollBar();
     final var handler = new ScrollEventHandler( scrollPane, scrollBar );
     handler.enabledProperty().bind( tab.selectedProperty() );
+  }
   private void addTabPane( final int index, final TabPane tabPane ) {
     final var items = getItems();
     if( !items.contains( tabPane ) ) {
       items.add( index, tabPane );
+    }
+  }
   private void addTabPane( final TabPane tabPane ) {
     addTabPane( getItems().size(), tabPane );
+  }
   private GenericBuilder<Mutator, ProcessorContext> processorContextBuilder() {
     final var w = getWorkspace();
     return builder()
       .with( Mutator::setDefinitions, this::getDefinitions )
       .with( Mutator::setLocale, w::getLocale )
       .with( Mutator::setMetadata, w::getMetadata )
       .with( Mutator::setThemesPath, w::getThemesPath )
       .with( Mutator::setCachesPath,
              () -> w.getFile( KEY_CACHES_DIR ) )
       .with( Mutator::setImagesPath,
              () -> w.getFile( KEY_IMAGES_DIR ) )
       .with( Mutator::setImageOrder,
              () -> w.getString( KEY_IMAGES_ORDER ) )
       .with( Mutator::setImageServer,
              () -> w.getString( KEY_IMAGES_SERVER ) )
       .with( Mutator::setFontsPath,
              () -> w.getFile( KEY_TYPESET_CONTEXT_FONTS_DIR ) )
       .with( Mutator::setCaret,
              () -> getTextEditor().getCaret() )
       .with( Mutator::setSigilBegan,
              () -> w.getString( KEY_DEF_DELIM_BEGAN ) )
       .with( Mutator::setSigilEnded,
              () -> w.getString( KEY_DEF_DELIM_ENDED ) )
       .with( Mutator::setRScript,
              () -> w.getString( KEY_R_SCRIPT ) )
       .with( Mutator::setRWorkingDir,
              () -> w.getFile( KEY_R_DIR ).toPath() )
       .with( Mutator::setCurlQuotes,
              () -> w.getBoolean( KEY_TYPESET_TYPOGRAPHY_QUOTES ) )
       .with( Mutator::setAutoRemove,
              () -> w.getBoolean( KEY_TYPESET_CONTEXT_CLEAN ) );
+  }
   public ProcessorContext createProcessorContext() {
     return createProcessorContext( null, NONE );
+  }
   /**
    * @param targetPath Used when exporting to a PDF file (binary).
    * @param format     Used when processors export to a new text format.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   public ProcessorContext createProcessorContext(
     final Path targetPath, final ExportFormat format ) {
     final var textEditor = getTextEditor();
     final var sourcePath = textEditor.getPath();
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
       .with( Mutator::setTargetPath, targetPath )
       .with( Mutator::setExportFormat, format )
       .build();
+  }
   /**
    * @param sourcePath Used by {@link ProcessorFactory} to determine
    *                   {@link Processor} type to create based on file type.
    * @return A new {@link ProcessorContext} to use when creating an instance of
    * {@link Processor}.
    */
   private ProcessorContext createProcessorContext( final Path sourcePath ) {
     return processorContextBuilder()
       .with( Mutator::setSourcePath, sourcePath )
       .with( Mutator::setExportFormat, NONE )
       .build();
+  }
   private TextResource createTextResource( final File file ) {
     // TODO: Create PlainTextEditor that's returned by default.
     return MediaType.valueFrom( file ) == TEXT_YAML
       ? createDefinitionEditor( file )
       : createMarkdownEditor( file );
+  }
   /**
    * Creates an instance of {@link MarkdownEditor} that listens for both
    * caret change events and text change events. Text change events must
    * take priority over caret change events because it's possible to change
    * the text without moving the caret (e.g., delete selected text).
+   *
    * @param inputFile The file containing contents for the text editor.
    * @return A non-null text editor.
    */
   private MarkdownEditor createMarkdownEditor( final File inputFile ) {
     final var editor = new MarkdownEditor( inputFile, getWorkspace() );
     updateProcessors( editor );
     // Listener for editor modifications or caret position changes.
     editor.addDirtyListener( ( c, o, n ) -> {
       if( n ) {
         // Reset the status bar after changing the text.
         clue();
         // Processing the text may update the status bar.
         process( getTextEditor() );
         // Update the caret position in the status bar.
         CaretMovedEvent.fire( editor.getCaret() );
+      }
     } );
     editor.addEventListener(
       keyPressed( SPACE, CONTROL_DOWN ), this::autoinsert
     );
     editor.addEventListener(
       keyPressed( ENTER, ALT_DOWN ), event -> mEditorSpeller.autofix( editor )
     );
     final var textArea = editor.getTextArea();
     // Spell check when the paragraph changes.
     textArea
       .plainTextChanges()
       .filter( p -> !p.isIdentity() )
       .subscribe( change -> mEditorSpeller.checkParagraph( textArea, change ) );
     // Store the caret position to restore it after restarting the application.
     textArea.caretPositionProperty().addListener(
       ( c, o, n ) ->
         getWorkspace().integerProperty( KEY_UI_RECENT_OFFSET ).setValue( n )
     );
     // Set the active editor, which refreshes the preview panel.
     mTextEditor.set( editor );
     // Check the entire document after the spellchecker is initialized (with
     // a valid lexicon) so that only the current paragraph need be scanned
     // while editing. (Technically, only the most recently modified word must
     // be scanned.)
     mSpellChecker.addListener(
       ( c, o, n ) -> runLater(
         () -> iterateEditors( mEditorSpeller::checkDocument )
+      )
     );
     // Check the entire document after it has been loaded.
     mEditorSpeller.checkDocument( mTextEditor.get() );
     return editor;
+  }
   /**
    * Creates a processor for an editor, provided one doesn't already exist.
+   *
    * @param editor The editor that potentially requires an associated processor.
    */
   private void updateProcessors( final TextEditor editor ) {
     final var path = editor.getFile().toPath();
     mProcessors.computeIfAbsent(
       editor, p -> createProcessors(
         createProcessorContext( path ),
         createHtmlPreviewProcessor()
+      )
     );
+  }
   /**
    * Removes a processor for an editor. This is required because a file may
    * change type while editing (e.g., from plain Markdown to R Markdown).
    * In the case that an editor's type changes, its associated processor must
    * be changed accordingly.
+   *
    * @param editor The editor that potentially requires an associated processor.
    */
   private void removeProcessor( final TextEditor editor ) {
     mProcessors.remove( editor );
+  }

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

   /**
    * Scaling factor for rendering mathematics.
    */
   public static final double FONT_SIZE_MATH_DEFAULT = 2;
   /**
    * Default monospace preview font name.
    */

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

 package com.keenwrite.editors.definition;
 import com.keenwrite.util.Diacritics;
 import javafx.scene.control.TreeItem;
 import java.util.Stack;
 import java.util.function.BiFunction;
 import static java.text.Normalizer.Form.NFD;
 import static java.text.Normalizer.normalize;
 /**
     return null;
+  }
   /**
    * Returns the value of the string without diacritic marks.
+   *
    * @return A non-null, possibly empty string.
    */
   private String getDiacriticlessValue() {
     return normalize( getValue().toString(), NFD )
       .replaceAll( "\\p{M}", "" );
+  }
   private boolean valueEquals( final String s ) {
     return isLeaf() && getValue().equals( s );
+  }
   /**
    * Removes diacritic characters from the given definition item.
+   *
    * @param item The {@link DefinitionTreeItem} to strip of diacritics.
    * @param <T>  The type of item contained by {@link DefinitionTreeItem}s.
    * @return The given item, without any accented characters.
    */
   private static <T> String removeAccents( final DefinitionTreeItem<T> item ) {
     return Diacritics.remove( item.getValue().toString() );
+  }
   /**
    * Returns true if this node is a leaf and its value contains the given text.
+   *
    * @param s The text to compare against the node value.
    * @return true Node is a leaf and its value contains the given value.
    */
   private boolean valueContains( final String s ) {
     return isLeaf() && getDiacriticlessValue().contains( s );
     return isLeaf() && removeAccents( this ).contains( s );
+  }
   /**
    * Returns true if this node is a leaf and its value contains the given text.
+   *
    * @param s The text to compare against the node value.
    * @return true Node is a leaf and its value contains the given value.
    */
   private boolean valueContainsNoCase( final String s ) {
     return isLeaf() &&
       getDiacriticlessValue().toLowerCase().contains( s.toLowerCase() );
     return isLeaf() && removeAccents( this )
       .toLowerCase()
       .contains( s.toLowerCase() );
+  }
    */
   private boolean valueStartsWith( final String s ) {
     return isLeaf() && getDiacriticlessValue().startsWith( s );
     return isLeaf() && removeAccents( this ).startsWith( s );
+  }

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

520	520
521	521	mTextArea.replaceSelection( newText );
	522	mTextArea.requestFollowCaret();
522	523	}
523	524

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

   public static final Key KEY_UI_FONT_PREVIEW_MONO_NAME = key( KEY_UI_FONT_PREVIEW_MONO, "name" );
   public static final Key KEY_UI_FONT_PREVIEW_MONO_SIZE = key( KEY_UI_FONT_PREVIEW_MONO, "size" );
   public static final Key KEY_UI_FONT_MATH = key( KEY_UI_FONT, "math" );
   public static final Key KEY_UI_FONT_MATH_SIZE = key( KEY_UI_FONT_MATH, "size" );
   public static final Key KEY_UI_WINDOW = key( KEY_UI, "window" );

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

           Setting.of( title( KEY_UI_FONT_PREVIEW_MONO_SIZE ),
                       doubleProperty( KEY_UI_FONT_PREVIEW_MONO_SIZE ) )
         ),
         Group.of(
           get( KEY_UI_FONT_MATH ),
           Setting.of( title( KEY_UI_FONT_MATH_SIZE ),
                       doubleProperty( KEY_UI_FONT_MATH_SIZE ) )
+        )
       ),
+  }
   @SuppressWarnings( "SameParameterValue" )
   private IntegerProperty integerProperty( final Key key ) {
     return mWorkspace.integerProperty( key );
+  }
   @SuppressWarnings( "SameParameterValue" )
   private DoubleProperty doubleProperty( final Key key ) {
     return mWorkspace.doubleProperty( key );

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

      asDoubleProperty( FONT_SIZE_PREVIEW_MONO_SIZE_DEFAULT )
     ),
     entry(
       KEY_UI_FONT_MATH_SIZE,
       asDoubleProperty( FONT_SIZE_MATH_DEFAULT )
     ),
     entry( KEY_UI_WINDOW_X, asDoubleProperty( WINDOW_X_DEFAULT ) ),

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

 package com.keenwrite.preview;
 import com.whitemagicsoftware.tex.*;
 import com.whitemagicsoftware.tex.graphics.SvgDomGraphics2D;
 import com.keenwrite.dom.DocumentParser;
 import com.whitemagicsoftware.keentype.lib.KeenType;
 import javafx.beans.property.DoubleProperty;
 import javafx.beans.property.SimpleDoubleProperty;
 import org.w3c.dom.Document;
 import java.util.function.Supplier;
 import static com.keenwrite.events.StatusEvent.clue;
 /**
  * Responsible for rendering formulas as scalable vector graphics (SVG).
  */
 public final class MathRenderer {
   /**
    * Singleton instance for rendering math symbols.
    */
   public static final MathRenderer MATH_RENDERER = new MathRenderer();
   private static KeenType sTypesetter;
   /**
    * Default font size in points.
    */
   private static final float FONT_SIZE = 20f;
   static {
     try {
       sTypesetter = new KeenType( false );
     } catch( final Exception e ) {
       clue( e );
+    }
+  }
   private final TeXFont mTeXFont = createDefaultTeXFont( FONT_SIZE );
   private final TeXEnvironment mEnvironment = createTeXEnvironment( mTeXFont );
   private final SvgDomGraphics2D mGraphics = createSvgDomGraphics2D();
   private static final DoubleProperty sSize = new SimpleDoubleProperty( 2 );
   private MathRenderer() {
     mGraphics.scale( FONT_SIZE, FONT_SIZE );
   private MathRenderer() { }
   public static void bindSize( final DoubleProperty size ) {
     sSize.bind( size );
+  }
   /**
    * This method only takes a few seconds to generate
    * Converts a TeX-based equation into an SVG document.
+   *
    * @param equation A mathematical expression to render.
    * @param equation A mathematical expression to render, without sigils.
    * @return The given string with all formulas transformed into SVG format.
    */
   public Document render( final String equation ) {
     final var formula = new TeXFormula( equation );
     final var box = formula.createBox( mEnvironment );
     final var l = new TeXLayout( box, FONT_SIZE );
     mGraphics.initialize( l.getWidth(), l.getHeight() );
     box.draw( mGraphics, l.getX(), l.getY() );
     return mGraphics.toDom();
+  }
   @SuppressWarnings("SameParameterValue")
   private TeXFont createDefaultTeXFont( final float fontSize ) {
     return create( () -> new DefaultTeXFont( fontSize ) );
+  }
   private TeXEnvironment createTeXEnvironment( final TeXFont texFont ) {
     return create( () -> new TeXEnvironment( texFont ) );
+  }
   private SvgDomGraphics2D createSvgDomGraphics2D() {
     return create( SvgDomGraphics2D::new );
   public static Document toDocument( final String equation ) {
     return DocumentParser.parse( toString( equation ) );
+  }
   /**
    * Tries to instantiate a given object, returning {@code null} on failure.
    * The failure message is bubbled up to the user interface.
    * Converts a TeX-based equation into an SVG document.
+   *
    * @param supplier Creates an instance.
    * @param <T>      The type of instance being created.
    * @return An instance of the parameterized type or {@code null} upon error.
    * @param equation A mathematical expression to render, without sigils.
    * @return The given string with all formulas transformed into SVG format.
    */
   private <T> T create( final Supplier<T> supplier ) {
     try {
       return supplier.get();
     } catch( final Exception ex ) {
       clue( ex );
       return null;
+    }
   public static String toString( final String equation ) {
     return sTypesetter.toSvg( "$" + equation + "$", sSize.doubleValue() );
+  }
+}

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

 import io.sf.carte.echosvg.bridge.UserAgentAdapter;
 import io.sf.carte.echosvg.gvt.renderer.ImageRenderer;
 import io.sf.carte.echosvg.transcoder.ErrorHandler;
 import io.sf.carte.echosvg.transcoder.TranscoderException;
 import io.sf.carte.echosvg.transcoder.TranscoderInput;
 import io.sf.carte.echosvg.transcoder.TranscoderOutput;
 import io.sf.carte.echosvg.transcoder.image.ImageTranscoder;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.InputStream;
 import java.io.StringReader;
 import java.net.URI;
 import java.nio.file.Path;
 import java.text.NumberFormat;
 import java.text.ParseException;
 import static com.keenwrite.dom.DocumentParser.transform;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preview.HighQualityRenderingHints.RENDERING_HINTS;
 import static io.sf.carte.echosvg.bridge.UnitProcessor.*;
 import static io.sf.carte.echosvg.transcoder.SVGAbstractTranscoder.KEY_WIDTH;
 import static io.sf.carte.echosvg.transcoder.TranscodingHints.Key;
 import static io.sf.carte.echosvg.transcoder.image.ImageTranscoder.*;
 import static io.sf.carte.echosvg.util.SVGConstants.SVG_WIDTH_ATTRIBUTE;
 import static java.awt.image.BufferedImage.TYPE_INT_RGB;
 import static java.text.NumberFormat.getIntegerInstance;
 /**
  * Responsible for converting SVG images into rasterized PNG images.
  */
 public final class SvgRasterizer {
   /**
    * Prevent rudely barfing stack traces to the console.
    */
   private static final class SvgErrorHandler implements ErrorHandler {
     @Override
     public void error( final TranscoderException ex ) {
       clue( ex );
+    }
     @Override
     public void fatalError( final TranscoderException ex ) {
       clue( ex );
+    }
     @Override
     public void warning( final TranscoderException ex ) {
       clue( ex );
+    }
+  }
   private static final UserAgent USER_AGENT = new UserAgentAdapter();
   private static final BridgeContext BRIDGE_CONTEXT = new BridgeContext(
     USER_AGENT, new DocumentLoader( USER_AGENT )
   );
   private static final ErrorHandler sErrorHandler = new SvgErrorHandler();
   private static final SAXSVGDocumentFactory FACTORY_DOM =
     new SAXSVGDocumentFactory();
   private static final NumberFormat INT_FORMAT = getIntegerInstance();
   public static final BufferedImage BROKEN_IMAGE_PLACEHOLDER;
   /**
    * A FontAwesome camera icon, cleft asunder.
    */
   public static final String BROKEN_IMAGE_SVG =
     "<svg height='19pt' viewBox='0 0 25 19' width='25pt' xmlns='http://www" +
       ".w3.org/2000/svg'><g fill='#454545'><path d='m8.042969 11.085938c" +
       ".332031 1.445312 1.660156 2.503906 3.214843 2.558593zm0 0'/><path " +
       "d='m6.792969 9.621094-.300781.226562.242187.195313c.015625-.144531" +
       ".03125-.28125.058594-.421875zm0 0'/><path d='m10.597656.949219-2" +
       ".511718.207031c-.777344.066406-1.429688.582031-1.636719 1.292969l-" +
       ".367188 1.253906-3.414062.28125c-1.027344.085937-1.792969.949219-1" +
       ".699219 1.925781l.976562 10.621094c.089844.976562.996094 1.699219 " +
       "2.023438 1.613281l11.710938-.972656-3.117188-2.484375c-.246094" +
       ".0625-.5.109375-.765625.132812-2.566406.210938-4.835937-1.597656-5" +
       ".0625-4.039062-.023437-.25-.019531-.496094 0-.738281l-.242187-" +
       ".195313.300781-.226562c.359375-1.929688 2.039062-3.472656 4" +
       ".191406-3.652344.207031-.015625.414063-.015625.617187-.007812l" +
       ".933594-.707032zm0 0'/><path d='m10.234375 11.070312 2.964844 2" +
       ".820313c.144531.015625.285156.027344.433593.027344 1.890626 0 3" +
       ".429688-1.460938 3.429688-3.257813 0-1.792968-1.539062-3.257812-3" +
       ".429688-3.257812-1.890624 0-3.429687 1.464844-3.429687 3.257812 0 " +
       ".140625.011719.277344.03125.410156zm0 0'/><path d='m14.488281" +
       ".808594 1.117188 4.554687-1.042969.546875c2.25.476563 3.84375 2" +
       ".472656 3.636719 4.714844-.199219 2.191406-2.050781 3.871094-4" +
       ".285157 4.039062l2.609376 2.957032 4.4375.371094c1.03125.085937 1" +
       ".9375-.640626 2.027343-1.617188l.976563-10.617188c.089844-.980468-" +
       ".667969-1.839843-1.699219-1.925781l-3.414063-.285156-.371093-1" +
       ".253906c-.207031-.710938-.859375-1.226563-1.636719-1.289063zm0 " +
       "0'/></g></svg>";
   static {
     // The width and height cannot be embedded in the SVG above because the
     // path element values are relative to the viewBox dimensions.
     final int w = 75;
     final int h = 75;
     BufferedImage image;
     try {
       image = rasterizeString( BROKEN_IMAGE_SVG, w );
     } catch( final Exception ex ) {
       image = new BufferedImage( w, h, TYPE_INT_RGB );
       final var graphics = (Graphics2D) image.getGraphics();
       graphics.setRenderingHints( RENDERING_HINTS );
       // Fall back to a (\) symbol.
       graphics.setColor( new Color( 204, 204, 204 ) );
       graphics.fillRect( 0, 0, w, h );
       graphics.setColor( new Color( 255, 204, 204 ) );
       graphics.setStroke( new BasicStroke( 4 ) );
       graphics.drawOval( w / 4, h / 4, w / 2, h / 2 );
       graphics.drawLine( w / 4 + (int) (w / 4 / Math.PI),
                          h / 4 + (int) (w / 4 / Math.PI),
                          w / 2 + w / 4 - (int) (w / 4 / Math.PI),
                          h / 2 + h / 4 - (int) (w / 4 / Math.PI) );
+    }
     BROKEN_IMAGE_PLACEHOLDER = image;
+  }
   /**
    * Responsible for creating a new {@link ImageRenderer} implementation that
    * can render a DOM as an SVG image.
    */
   private static class BufferedImageTranscoder extends ImageTranscoder {
     private BufferedImage mImage;
     /**
      * Prevent barfing a stack trace when the transcoder encounters problems
      * parsing SVG contents.
      */
     @Override
     protected UserAgent createUserAgent() {
       return new SVGAbstractTranscoderUserAgent() {
         @Override
         public void displayError( final Exception ex ) {
           clue( ex );
+        }
       };
+    }
     @Override
     public BufferedImage createImage( final int w, final int h ) {
       return new BufferedImage( w, h, BufferedImage.TYPE_INT_ARGB );
+    }
     @Override
     public void writeImage(
       final BufferedImage image, final TranscoderOutput output ) {
       mImage = image;
+    }
     public BufferedImage getImage() {
       return mImage;
+    }
     @Override
     protected ImageRenderer createRenderer() {
       final ImageRenderer renderer = super.createRenderer();
       final RenderingHints hints = renderer.getRenderingHints();
       hints.putAll( RENDERING_HINTS );
       renderer.setRenderingHints( hints );
       return renderer;
+    }
+  }
   /**
    * Rasterizes the given SVG input stream into an image at 96 DPI.
+   *
    * @param svg The SVG data to rasterize, must be closed by caller.
    * @return The given input stream converted to a rasterized image.
    */
   public static BufferedImage rasterize( final InputStream svg )
     throws TranscoderException {
     return rasterize( svg, 96 );
+  }
   /**
    * Rasterizes the given SVG input stream into an image.
+   *
    * @param svg The SVG data to rasterize, must be closed by caller.
    * @param dpi Resolution to use when rasterizing (default is 96 DPI).
    * @return The given input stream converted to a rasterized image at the
    * given resolution.
    */
   public static BufferedImage rasterize(
     final InputStream svg, final float dpi ) throws TranscoderException {
     return rasterize(
       new TranscoderInput( svg ),
       KEY_PIXEL_UNIT_TO_MILLIMETER,
 f / dpi * 25.4f
     );
+  }
   /**
    * Rasterizes the given document into an image.
+   *
    * @param svg   The SVG {@link Document} to rasterize.
    * @param width The rasterized image's width (in pixels).
    * @return The rasterized image.
    */
   public static BufferedImage rasterize(
     final Document svg, final int width ) throws TranscoderException {
     return rasterize(
       new TranscoderInput( svg ),
       KEY_WIDTH,
       fit( svg.getDocumentElement(), width )
     );
+  }
   /**
    * Rasterizes the given vector graphic file using the width dimension
    * specified by the document's width attribute.
+   *
    * @param document The {@link Document} containing a vector graphic.
    * @return A rasterized image as an instance of {@link BufferedImage}, or
    * {@link #BROKEN_IMAGE_PLACEHOLDER} if the graphic could not be rasterized.
    */
   public static BufferedImage rasterize( final Document document )
     throws ParseException, TranscoderException {
     final var root = document.getDocumentElement();
     final var width = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return rasterize( document, INT_FORMAT.parse( width ).intValue() );
+  }
   /**
    * Rasterizes the vector graphic file at the given URI. If any exception
    * happens, a broken image icon is returned instead.
+   *
    * @param path  The {@link Path} to a vector graphic file.
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return A rasterized image as an instance of {@link BufferedImage}.
    */
   public static BufferedImage rasterize( final Path path, final int width ) {
     return rasterize( path.toUri(), width );
+  }
   /**
    * Rasterizes the vector graphic file at the given URI. If any exception
    * happens, a broken image icon is returned instead.
+   *
    * @param uri   The URI to a vector graphic file, which must include the
    *              protocol scheme (such as <code>file://</code> or
    *              <code>https://</code>).
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return A rasterized image as an instance of {@link BufferedImage}.
    */
   public static BufferedImage rasterize( final String uri, final int width ) {
     return rasterize( new File( uri ).toURI(), width );
+  }
   /**
    * Converts an SVG drawing into a rasterized image that can be drawn on
    * a graphics context.
+   *
    * @param uri   The path to the image (can be web address).
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterize( final URI uri, final int width ) {
     try {
       return rasterize( FACTORY_DOM.createDocument( uri.toString() ), width );
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return BROKEN_IMAGE_PLACEHOLDER;
+  }
   /**
    * Converts an SVG string into a rasterized image that can be drawn on
    * a graphics context. The dimensions are determined from the document.
+   *
    * @param xml The SVG xml document.
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterizeString( final String xml )
     throws ParseException, TranscoderException {
     final var document = toDocument( xml );
     final var root = document.getDocumentElement();
     final var width = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return rasterizeString( xml, INT_FORMAT.parse( width ).intValue() );
+  }
   /**
    * Converts an SVG string into a rasterized image that can be drawn on
    * a graphics context.
+   *
    * @param svg The SVG xml document.
    * @param w   Scale the image width to this size (aspect ratio is
    *            maintained).
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterizeString( final String svg, final int w )
     throws TranscoderException {
     return rasterize( toDocument( svg ), w );
+  }
   /**
    * Given a document object model (DOM) {@link Element}, this will convert that
    * element to a string.
+   *
    * @param root The DOM node to convert to a string.
    * @return The DOM node as an escaped, plain text string.
    */
   public static String toSvg( final Element root ) {
     try {
       return transform( root ).replaceAll( "xmlns=\"\" ", "" );
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return BROKEN_IMAGE_SVG;
+  }
   /**
    * Converts an SVG XML string into a new {@link Document} instance.
+   *
    * @param xml The XML containing SVG elements.
    * @return The SVG contents parsed into a {@link Document} object model.
    */
   private static Document toDocument( final String xml ) {
     try( final var reader = new StringReader( xml ) ) {
       return FACTORY_DOM.createSVGDocument(
         "http://www.w3.org/2000/svg", reader );
     } catch( final Exception ex ) {
       throw new IllegalArgumentException( ex );
+    }
+  }
   /**
    * Creates a rasterized image of the given source document.
+   *
    * @param input The source document to transcode.
    * @param key   Transcoding hint key.
    * @param width Transcoding hint value.
    * @return A new {@link BufferedImageTranscoder} instance with the given
    * transcoding hint applied.
    */
   private static BufferedImage rasterize(
     final TranscoderInput input, final Key key, final float width )
     throws TranscoderException {
     final var transcoder = new BufferedImageTranscoder();
     transcoder.setErrorHandler( sErrorHandler );
     transcoder.addTranscodingHint( key, width );
     transcoder.transcode( input, null );
     return transcoder.getImage();
+  }
   /**
    * Returns either the given element's SVG document width, or the display
    * width, whichever is smaller.
+   *
    * @param root  The SVG document's root node.
    * @param width The display width (e.g., rendering canvas width).
    * @return The lower value of the document's width or the display width.
    */
   private static float fit( final Element root, final int width ) {
     final var w = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return w == null || w.isBlank() ? width : fit( root, w, width );
 import io.sf.carte.echosvg.transcoder.*;
 import io.sf.carte.echosvg.transcoder.image.ImageTranscoder;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.InputStream;
 import java.io.StringReader;
 import java.net.URI;
 import java.nio.file.Path;
 import java.text.NumberFormat;
 import java.text.ParseException;
 import java.util.HashMap;
 import java.util.Map;
 import static com.keenwrite.dom.DocumentParser.transform;
 import static com.keenwrite.events.StatusEvent.clue;
 import static com.keenwrite.preview.HighQualityRenderingHints.RENDERING_HINTS;
 import static io.sf.carte.echosvg.bridge.UnitProcessor.createContext;
 import static io.sf.carte.echosvg.bridge.UnitProcessor.svgHorizontalLengthToUserSpace;
 import static io.sf.carte.echosvg.transcoder.SVGAbstractTranscoder.KEY_HEIGHT;
 import static io.sf.carte.echosvg.transcoder.SVGAbstractTranscoder.KEY_WIDTH;
 import static io.sf.carte.echosvg.transcoder.TranscodingHints.Key;
 import static io.sf.carte.echosvg.transcoder.image.ImageTranscoder.KEY_PIXEL_UNIT_TO_MILLIMETER;
 import static io.sf.carte.echosvg.util.SVGConstants.SVG_HEIGHT_ATTRIBUTE;
 import static io.sf.carte.echosvg.util.SVGConstants.SVG_WIDTH_ATTRIBUTE;
 import static java.awt.image.BufferedImage.TYPE_INT_RGB;
 import static java.text.NumberFormat.getIntegerInstance;
 /**
  * Responsible for converting SVG images into rasterized PNG images.
  */
 public final class SvgRasterizer {
   /**
    * Prevent rudely barfing stack traces to the console.
    */
   private static final class SvgErrorHandler implements ErrorHandler {
     @Override
     public void error( final TranscoderException ex ) {
       clue( ex );
+    }
     @Override
     public void fatalError( final TranscoderException ex ) {
       clue( ex );
+    }
     @Override
     public void warning( final TranscoderException ex ) {
       clue( ex );
+    }
+  }
   private static final UserAgent USER_AGENT = new UserAgentAdapter();
   private static final BridgeContext BRIDGE_CONTEXT = new BridgeContext(
     USER_AGENT, new DocumentLoader( USER_AGENT )
   );
   private static final ErrorHandler sErrorHandler = new SvgErrorHandler();
   private static final SAXSVGDocumentFactory FACTORY_DOM =
     new SAXSVGDocumentFactory();
   private static final NumberFormat INT_FORMAT = getIntegerInstance();
   public static final BufferedImage BROKEN_IMAGE_PLACEHOLDER;
   /**
    * A FontAwesome camera icon, cleft asunder.
    */
   public static final String BROKEN_IMAGE_SVG =
     "<svg height='19pt' viewBox='0 0 25 19' width='25pt' xmlns='http://www" +
       ".w3.org/2000/svg'><g fill='#454545'><path d='m8.042969 11.085938c" +
       ".332031 1.445312 1.660156 2.503906 3.214843 2.558593zm0 0'/><path " +
       "d='m6.792969 9.621094-.300781.226562.242187.195313c.015625-.144531" +
       ".03125-.28125.058594-.421875zm0 0'/><path d='m10.597656.949219-2" +
       ".511718.207031c-.777344.066406-1.429688.582031-1.636719 1.292969l-" +
       ".367188 1.253906-3.414062.28125c-1.027344.085937-1.792969.949219-1" +
       ".699219 1.925781l.976562 10.621094c.089844.976562.996094 1.699219 " +
       "2.023438 1.613281l11.710938-.972656-3.117188-2.484375c-.246094" +
       ".0625-.5.109375-.765625.132812-2.566406.210938-4.835937-1.597656-5" +
       ".0625-4.039062-.023437-.25-.019531-.496094 0-.738281l-.242187-" +
       ".195313.300781-.226562c.359375-1.929688 2.039062-3.472656 4" +
       ".191406-3.652344.207031-.015625.414063-.015625.617187-.007812l" +
       ".933594-.707032zm0 0'/><path d='m10.234375 11.070312 2.964844 2" +
       ".820313c.144531.015625.285156.027344.433593.027344 1.890626 0 3" +
       ".429688-1.460938 3.429688-3.257813 0-1.792968-1.539062-3.257812-3" +
       ".429688-3.257812-1.890624 0-3.429687 1.464844-3.429687 3.257812 0 " +
       ".140625.011719.277344.03125.410156zm0 0'/><path d='m14.488281" +
       ".808594 1.117188 4.554687-1.042969.546875c2.25.476563 3.84375 2" +
       ".472656 3.636719 4.714844-.199219 2.191406-2.050781 3.871094-4" +
       ".285157 4.039062l2.609376 2.957032 4.4375.371094c1.03125.085937 1" +
       ".9375-.640626 2.027343-1.617188l.976563-10.617188c.089844-.980468-" +
       ".667969-1.839843-1.699219-1.925781l-3.414063-.285156-.371093-1" +
       ".253906c-.207031-.710938-.859375-1.226563-1.636719-1.289063zm0 " +
       "0'/></g></svg>";
   static {
     // The width and height cannot be embedded in the SVG above because the
     // path element values are relative to the viewBox dimensions.
     final int w = 75;
     final int h = 75;
     BufferedImage image;
     try {
       image = rasterizeImage( BROKEN_IMAGE_SVG, w );
     } catch( final Exception ex ) {
       image = new BufferedImage( w, h, TYPE_INT_RGB );
       final var graphics = (Graphics2D) image.getGraphics();
       graphics.setRenderingHints( RENDERING_HINTS );
       // Fall back to a (\) symbol.
       graphics.setColor( new Color( 204, 204, 204 ) );
       graphics.fillRect( 0, 0, w, h );
       graphics.setColor( new Color( 255, 204, 204 ) );
       graphics.setStroke( new BasicStroke( 4 ) );
       graphics.drawOval( w / 4, h / 4, w / 2, h / 2 );
       graphics.drawLine( w / 4 + (int) (w / 4 / Math.PI),
                          h / 4 + (int) (w / 4 / Math.PI),
                          w / 2 + w / 4 - (int) (w / 4 / Math.PI),
                          h / 2 + h / 4 - (int) (w / 4 / Math.PI) );
+    }
     BROKEN_IMAGE_PLACEHOLDER = image;
+  }
   /**
    * Responsible for creating a new {@link ImageRenderer} implementation that
    * can render a DOM as an SVG image.
    */
   private static class BufferedImageTranscoder extends ImageTranscoder {
     private BufferedImage mImage;
     /**
      * Prevent barfing a stack trace when the transcoder encounters problems
      * parsing SVG contents.
      */
     @Override
     protected UserAgent createUserAgent() {
       return new SVGAbstractTranscoderUserAgent() {
         @Override
         public void displayError( final Exception ex ) {
           clue( ex );
+        }
       };
+    }
     @Override
     public BufferedImage createImage( final int w, final int h ) {
       return new BufferedImage( w, h, BufferedImage.TYPE_INT_ARGB );
+    }
     @Override
     public void writeImage(
       final BufferedImage image, final TranscoderOutput output ) {
       mImage = image;
+    }
     public BufferedImage getImage() {
       return mImage;
+    }
     @Override
     protected ImageRenderer createRenderer() {
       final ImageRenderer renderer = super.createRenderer();
       final RenderingHints hints = renderer.getRenderingHints();
       hints.putAll( RENDERING_HINTS );
       renderer.setRenderingHints( hints );
       return renderer;
+    }
+  }
   /**
    * Rasterizes the given SVG input stream into an image.
+   *
    * @param svg The SVG data to rasterize, must be closed by caller.
    * @return The given input stream converted to a rasterized image.
    */
   public static BufferedImage rasterize( final String svg )
     throws TranscoderException, ParseException {
     return rasterize( toDocument( svg ) );
+  }
   /**
    * Rasterizes the given SVG input stream into an image at 96 DPI.
+   *
    * @param svg The SVG data to rasterize, must be closed by caller.
    * @return The given input stream converted to a rasterized image.
    */
   public static BufferedImage rasterize( final InputStream svg )
     throws TranscoderException {
     return rasterize( svg, 96 );
+  }
   /**
    * Rasterizes the given SVG input stream into an image.
+   *
    * @param svg The SVG data to rasterize, must be closed by caller.
    * @param dpi Resolution to use when rasterizing (default is 96 DPI).
    * @return The given input stream converted to a rasterized image at the
    * given resolution.
    */
   public static BufferedImage rasterize(
     final InputStream svg, final float dpi ) throws TranscoderException {
     return rasterize(
       new TranscoderInput( svg ),
       KEY_PIXEL_UNIT_TO_MILLIMETER,
 f / dpi * 25.4f
     );
+  }
   /**
    * Rasterizes the given document into an image.
+   *
    * @param svg   The SVG {@link Document} to rasterize.
    * @param width The rasterized image's width (in pixels).
    * @return The rasterized image.
    */
   public static BufferedImage rasterize(
     final Document svg, final int width ) throws TranscoderException {
     return rasterize(
       new TranscoderInput( svg ),
       KEY_WIDTH,
       fit( svg.getDocumentElement(), width )
     );
+  }
   /**
    * Rasterizes the given vector graphic file using the width dimension
    * specified by the document's width attribute.
+   *
    * @param document The {@link Document} containing a vector graphic.
    * @return A rasterized image as an instance of {@link BufferedImage}, or
    * {@link #BROKEN_IMAGE_PLACEHOLDER} if the graphic could not be rasterized.
    */
   public static BufferedImage rasterize( final Document document )
     throws ParseException, TranscoderException {
     final var root = document.getDocumentElement();
     final var width = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return rasterize( document, INT_FORMAT.parse( width ).intValue() );
+  }
   /**
    * Rasterizes the vector graphic file at the given URI. If any exception
    * happens, a broken image icon is returned instead.
+   *
    * @param path  The {@link Path} to a vector graphic file.
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return A rasterized image as an instance of {@link BufferedImage}.
    */
   public static BufferedImage rasterize( final Path path, final int width ) {
     return rasterize( path.toUri(), width );
+  }
   /**
    * Rasterizes the vector graphic file at the given URI. If any exception
    * happens, a broken image icon is returned instead.
+   *
    * @param uri   The URI to a vector graphic file, which must include the
    *              protocol scheme (such as <code>file://</code> or
    *              <code>https://</code>).
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return A rasterized image as an instance of {@link BufferedImage}.
    */
   public static BufferedImage rasterize( final String uri, final int width ) {
     return rasterize( new File( uri ).toURI(), width );
+  }
   /**
    * Converts an SVG drawing into a rasterized image that can be drawn on
    * a graphics context.
+   *
    * @param uri   The path to the image (can be web address).
    * @param width Scale the image to the given width (px); aspect ratio is
    *              maintained.
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterize( final URI uri, final int width ) {
     try {
       return rasterize( FACTORY_DOM.createDocument( uri.toString() ), width );
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return BROKEN_IMAGE_PLACEHOLDER;
+  }
   /**
    * Converts an SVG string into a rasterized image that can be drawn on
    * a graphics context. The dimensions are determined from the document.
+   *
    * @param svg   The SVG xml document.
    * @param scale The scaling factor to apply when transcoding.
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterizeImage(
     final String svg, final double scale )
     throws ParseException, TranscoderException {
     final var document = toDocument( svg );
     final var root = document.getDocumentElement();
     final var width = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     final var height = root.getAttribute( SVG_HEIGHT_ATTRIBUTE );
     final var w = INT_FORMAT.parse( width ).intValue() * scale;
     final var h = INT_FORMAT.parse( height ).intValue() * scale;
     return rasterize( svg, w, h );
+  }
   /**
    * Converts an SVG string into a rasterized image that can be drawn on
    * a graphics context.
+   *
    * @param svg The SVG xml document.
    * @param w   Scale the image width to this size (aspect ratio is
    *            maintained).
    * @return The vector graphic transcoded into a raster image format.
    */
   public static BufferedImage rasterizeImage( final String svg, final int w )
     throws TranscoderException {
     return rasterize( toDocument( svg ), w );
+  }
   /**
    * Given a document object model (DOM) {@link Element}, this will convert that
    * element to a string.
+   *
    * @param root The DOM node to convert to a string.
    * @return The DOM node as an escaped, plain text string.
    */
   public static String toSvg( final Element root ) {
     try {
       return transform( root ).replaceAll( "xmlns=\"\" ", "" );
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return BROKEN_IMAGE_SVG;
+  }
   /**
    * Converts an SVG XML string into a new {@link Document} instance.
+   *
    * @param xml The XML containing SVG elements.
    * @return The SVG contents parsed into a {@link Document} object model.
    */
   private static Document toDocument( final String xml ) {
     try( final var reader = new StringReader( xml ) ) {
       return FACTORY_DOM.createSVGDocument(
         "http://www.w3.org/2000/svg", reader );
     } catch( final Exception ex ) {
       throw new IllegalArgumentException( ex );
+    }
+  }
   /**
    * Creates a rasterized image of the given source document.
+   *
    * @param input     The source document to transcode.
    * @param hintKey   Transcoding hint key.
    * @param hintValue Transcoding hint value.
    * @return A new {@link BufferedImageTranscoder} instance with the given
    * transcoding hint applied.
    */
   private static BufferedImage rasterize(
     final TranscoderInput input, final Key hintKey, final float hintValue )
     throws TranscoderException {
     final var hints = new HashMap<Key, Object>();
     hints.put( hintKey, hintValue );
     return rasterize( input, hints );
+  }
   private static BufferedImage rasterize(
     final String svg, final double w, final double h )
     throws TranscoderException {
     final var hints = new HashMap<Key, Object>();
     hints.put( KEY_WIDTH, (float) w );
     hints.put( KEY_HEIGHT, (float) h );
     return rasterize( new TranscoderInput( toDocument( svg ) ), hints );
+  }
   public static BufferedImage rasterize(
     final TranscoderInput input,
     final Map<TranscodingHints.Key, Object> hints ) throws TranscoderException {
     final var transcoder = new BufferedImageTranscoder();
     for( final var hint : hints.entrySet() ) {
       transcoder.addTranscodingHint( hint.getKey(), hint.getValue() );
+    }
     transcoder.setErrorHandler( sErrorHandler );
     transcoder.transcode( input, null );
     return transcoder.getImage();
+  }
   /**
    * Returns either the given element's SVG document width, or the display
    * width, whichever is smaller.
+   *
    * @param root  The SVG document's root node.
    * @param width The display width (e.g., rendering canvas width).
    * @return The lower value of the document's width or the display width.
    */
   @SuppressWarnings( "ConstantValue" )
   private static float fit( final Element root, final int width ) {
     final var w = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return w == null || w.isBlank()
       ? width
       : fit( root, w, width );
+  }

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

 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.MathRenderer.MATH_RENDERER;
 import static com.keenwrite.preview.SvgRasterizer.BROKEN_IMAGE_PLACEHOLDER;
 import static com.keenwrite.preview.SvgRasterizer.rasterize;
 import static com.keenwrite.preview.SvgRasterizer.*;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.HTML_TEX;
 import static com.keenwrite.util.ProtocolScheme.getProtocol;
           else if( MediaType.fromFilename( source ).isSvg() ) {
             // Attempt to rasterize based on file name.
             final var path = Path.of( new URI( source ).getPath() );
             final var path = new File( source ).toPath();
             if( path.isAbsolute() ) {
         case HTML_TEX ->
           // Convert the TeX element to a raster graphic.
           raster = rasterize( MATH_RENDERER.render( e.getTextContent() ) );
           raster = rasterize( MathRenderer.toString( e.getTextContent() ) );
+      }

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

    */
   @Override
   public void rendererOptions( @NotNull final MutableDataHolder options ) {
+  }
   public void rendererOptions( @NotNull final MutableDataHolder options ) { }
+}

M src/main/java/com/keenwrite/processors/markdown/extensions/fences/FencedBlockExtension.java

 import org.jetbrains.annotations.NotNull;
 import java.nio.file.Paths;
 import java.nio.file.Path;
 import java.util.HashSet;
 import java.util.Set;
       final var hash = Integer.toHexString( text.hashCode() );
       final var filename = format( "%s-%s.svg", APP_TITLE_LOWERCASE, hash );
       final var svg = Paths.get( TEMP_DIR, filename ).toString();
       // The URI helps convert backslashes to forward slashes.
       final var uri = Path.of( TEMP_DIR, filename ).toUri();
       final var svg = uri.getPath();
       final var link = context.resolveLink( LINK, svg, false );
       final var dimensions = getAttributes( node.getInfo() );
   private class Factory implements DelegatingNodeRendererFactory {
     public Factory() {}
     public Factory() { }
     @NotNull

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

   /**
    * @return Either '$' or '$$.
    * @return Either '$' or '$$'.
    */
   public String getOpeningDelimiter() { return mOpener; }
   /**
    * @return Either '$' or '$$.
    * @return Either '$' or '$$'.
    */
   public String getClosingDelimiter() { return mCloser; }

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

 import com.keenwrite.ExportFormat;
 import com.keenwrite.preview.MathRenderer;
 import com.keenwrite.preview.SvgRasterizer;
 import com.vladsch.flexmark.html.HtmlWriter;
 import static com.keenwrite.ExportFormat.*;
 import static com.keenwrite.preview.MathRenderer.MATH_RENDERER;
 import static com.keenwrite.processors.markdown.extensions.tex.TexNode.*;
                  final HtmlWriter html ) {
       final var tex = node.getText().toStringOrNull();
       final var doc = MATH_RENDERER.render(
         tex == null ? "" : getEvaluator().apply( tex ) );
       final var doc = MathRenderer.toDocument(
         tex == null ? "" : getEvaluator().apply( tex )
       );
       final var svg = SvgRasterizer.toSvg( doc.getDocumentElement() );
       html.raw( svg );

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

 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Properties;
 import java.util.TreeMap;
 import java.util.concurrent.atomic.AtomicReference;
 import static java.lang.Math.max;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static java.text.Normalizer.Form.NFKD;
 import static java.text.Normalizer.normalize;
 import static javafx.application.Platform.runLater;
 import static javafx.geometry.Pos.CENTER;
  */
 public final class ExportDialog extends AbstractDialog<ExportSettings> {
   private static final String UNCRITIC = "\\p{InCombiningDiacriticalMarks}+";
   private record Theme( Path path, String name ) implements Comparable<Theme> {
     /**
      * Answers whether the given theme directory name matches the theme name
      * that the user selected.
+     *
      * @param themeDir The user-selected directory to compare with the
      *                 corresponding path of this {@link Theme}.
      * @return {@code true} if the given directory matches the ending portion
      * of the {@link Path} associated with this {@link Theme} instance.
      */
     public boolean matches( final String themeDir ) {
       final var normalized = normalize( themeDir, NFKD );
       final var name = normalized.replaceAll( UNCRITIC, "" );
       final var path = path().getFileName().toString();
       return path.equalsIgnoreCase( name );
+    }
     /**
      * Returns the theme's display name.
+     *
      * @return The name of the theme presented to users.
      */
     @Override
     public String toString() {
       return abbreviate( name(), THEME_NAME_LENGTH );
+    }
     @Override
     public int compareTo( final Theme o ) {
       return name().compareTo( o.name() );
+    }
+  }
   private final File mThemes;
   private final ExportSettings mSettings;
   private GridPane mPane;
   private ComboBox<String> mComboBox;
   private ComboBox<Theme> mComboBox;
   private TextField mChapters;
   private final boolean mMissingThemes;
+    }
     initComboBox( mComboBox, mSettings, readThemes( themesDir ) );
     final var previousTheme = mSettings.themeProperty().get();
     initComboBox( mComboBox, previousTheme, themes );
     mPane.add( createLabel( "Dialog.typesetting.settings.theme" ), 0, 1 );
         if( result.isPresent() ) {
           final var theme = mComboBox.getSelectionModel().getSelectedItem();
           mSettings.themeProperty().setValue( theme.toLowerCase() );
           final var path = theme.path().getFileName().toString();
           mSettings.themeProperty().setValue( path );
           return true;
   private void initComboBox(
     final ComboBox<String> comboBox,
     final ExportSettings settings,
     final TreeMap<String, String> choices
     final ComboBox<Theme> comboBox,
     final String previousTheme,
     final List<Theme> choices
   ) {
     assert comboBox != null;
     assert settings != null;
     assert previousTheme != null;
     assert choices != null;
     final var selection = new String[]{""};
     final var theme = settings.themeProperty().get();
     final var items = comboBox.getItems();
     items.clear();
     items.addAll( choices );
     // Set the selected item to user's settings value.
     for( final var key : choices.keySet() ) {
       if( key.equalsIgnoreCase( theme ) ) {
         selection[ 0 ] = key;
     for( final var choice : choices ) {
       if( choice.matches( previousTheme ) ) {
         comboBox.getSelectionModel().select(
           items.get( max( items.indexOf( choice ), 0 ) )
         );
         break;
+      }
+    }
     final var items = comboBox.getItems();
     items.addAll( choices.keySet() );
     comboBox.getSelectionModel().select(
       items.get( max( items.indexOf( selection[ 0 ] ), 0 ) )
     );
+  }
   private TreeMap<String, String> readThemes( final File themesDir ) {
   private List<Theme> readThemes( final File themesDir ) {
     try {
       // List themes in alphabetical order (human-readable by directory name).
       final var choices = new TreeMap<String, String>();
       final var choices = new LinkedList<Theme>();
       // Populate the choices with themes detected on the system.
       walk( themesDir.toPath(), "**/theme.properties", path -> {
         try {
           final var displayed = readThemeName( path );
           final var themeName = path.getParent().toFile().getName();
           choices.put( abbreviate( displayed, THEME_NAME_LENGTH ), themeName );
           final var themeName = readThemeName( path );
           final var themePath = path.getParent();
           choices.add( new Theme( themePath, themeName ) );
         } catch( final Exception ex ) {
           clue( "Main.status.error.theme.name", path );
+        }
       } );
       Collections.sort( choices );
       return choices;
     } catch( final Exception ex ) {
       clue( ex );
+    }
     return new TreeMap<>();
     return Collections.emptyList();
+  }
   private ComboBox<String> createComboBox() {
   private ComboBox<Theme> createComboBox() {
     return new ComboBox<>();
+  }

A src/main/java/com/keenwrite/util/Diacritics.java

 /* Copyright 2023 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.util;
 import static java.text.Normalizer.Form.NFD;
 import static java.text.Normalizer.normalize;
 /**
  * Responsible for modifying diacritics.
  */
 public class Diacritics {
   private static final String UNCRITIC = "\\p{M}+";
   /**
    * Returns the value of the string without diacritic marks.
+   *
    * @param text The text to normalize.
    * @return A non-null, possibly empty string.
    */
   public static String remove( final String text ) {
     return normalize( text, NFD ).replaceAll( UNCRITIC, "" );
+  }
+}

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

 workspace.ui.font.preview.mono.size.desc=Monospace font size.
 workspace.ui.font.preview.mono.size.title=Points
 workspace.ui.font.math=Math Font
 workspace.ui.font.math.size.title=Scale
 workspace.language=Language

M src/main/resources/com/keenwrite/preview/webview.css

 div.todo {
   border-color: #c00;
   background-color: #f8f8f8;
+}
 div.todo, div.terminal {
   padding: .5em;
   padding-top: .25em;
   padding-bottom: .25em;
   border-style: solid;
   border-width: 0.05em;
   border-radius: .25em;
   border-color: #c00;
   background-color: #f8f8f8;
+}
 /* TERMINAL ***/
 div.terminal {
   font-family: 'Source Code Pro';
   font-size: 90%;
   border-color: #222;
+}

D src/test/java/com/keenwrite/tex/TeXRasterizationTest.java

 /*
  * Copyright 2020-2021 White Magic Software, Ltd.
+ *
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
+ *
  *  o Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
+ *
  *  o Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 package com.keenwrite.tex;
 import com.whitemagicsoftware.tex.DefaultTeXFont;
 import com.whitemagicsoftware.tex.TeXEnvironment;
 import com.whitemagicsoftware.tex.TeXFormula;
 import com.whitemagicsoftware.tex.TeXLayout;
 import com.whitemagicsoftware.tex.graphics.AbstractGraphics2D;
 import com.whitemagicsoftware.tex.graphics.SvgDomGraphics2D;
 import com.whitemagicsoftware.tex.graphics.SvgGraphics2D;
 import io.sf.carte.echosvg.transcoder.TranscoderException;
 import org.junit.jupiter.api.Test;
 import org.xml.sax.SAXException;
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Path;
 import java.text.ParseException;
 import static com.keenwrite.dom.DocumentParser.parse;
 import static com.keenwrite.preview.SvgRasterizer.*;
 import static java.lang.System.getProperty;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 /**
  * Test that TeX rasterization produces a readable image.
  */
 public class TeXRasterizationTest {
   private static final String EQUATION =
     "G_{\\mu \\nu} = \\frac{8 \\pi G}{c^4} T_{{\\mu \\nu}}";
   private static final String DIR_TEMP = getProperty( "java.io.tmpdir" );
   private static final long FILESIZE = 12364;
   /**
    * Test that an equation can be converted to a raster image and the
    * final raster image size corresponds to the input equation. This is
    * a simple way to verify that the rasterization process is correct,
    * albeit if any aspect of the SVG algorithm changes (such as padding
    * around the equation), it will cause this test to fail, which is a bit
    * misleading.
    */
   @Test
   public void test_Rasterize_SimpleFormula_CorrectImageSize()
     throws IOException, ParseException, TranscoderException {
     final var g = new SvgGraphics2D();
     drawGraphics( g );
     verifyImage( rasterizeString( g.toString() ) );
+  }
   /**
    * Test that an SVG document object model can be parsed and rasterized into
    * an image.
    */
   @Test
   public void getTest_SvgDomGraphics2D_InputElement_OutputRasterizedImage()
     throws IOException, SAXException, ParseException, TranscoderException {
     final var g = new SvgGraphics2D();
     drawGraphics( g );
     final var expectedSvg = g.toString();
     final var bytes = expectedSvg.getBytes();
     try( final var in = new ByteArrayInputStream( bytes ) ) {
       final var doc = parse( in );
       final var actualSvg = toSvg( doc.getDocumentElement() );
       verifyImage( rasterizeString( actualSvg ) );
+    }
+  }
   /**
    * Test that an SVG image from a DOM element can be rasterized.
+   *
    * @throws IOException Could not write the image.
    */
   @Test
   public void test_SvgDomGraphics2D_InputDom_OutputRasterizedImage()
     throws IOException, ParseException, TranscoderException {
     final var g = new SvgDomGraphics2D();
     drawGraphics( g );
     verifyImage( rasterize( g.toDom() ) );
+  }
   /**
    * Asserts that the given image matches an expected file size.
+   *
    * @param image The image to check against the file size.
    * @throws IOException Could not write the image.
    */
   private void verifyImage( final BufferedImage image ) throws IOException {
     final var file = export( image, "dom.png" );
     assertEquals( FILESIZE, file.length() );
+  }
   /**
    * Creates an SVG string for the default equation and font size.
    */
   private void drawGraphics( final AbstractGraphics2D g ) {
     final var size = 100f;
     final var texFont = new DefaultTeXFont( size );
     final var env = new TeXEnvironment( texFont );
     g.scale( size, size );
     final var formula = new TeXFormula( EQUATION );
     final var box = formula.createBox( env );
     final var layout = new TeXLayout( box, size );
     g.initialize( layout.getWidth(), layout.getHeight() );
     box.draw( g, layout.getX(), layout.getY() );
+  }
   @SuppressWarnings( "SameParameterValue" )
   private File export( final BufferedImage image, final String filename )
     throws IOException {
     final var path = Path.of( DIR_TEMP, filename );
     final var file = path.toFile();
     ImageIO.write( image, "png", file );
     file.deleteOnExit();
     return file;
+  }
+}