Dave Jarvis' Repositories

Home Files Commits Tags Clone

Repository:

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

M .gitignore

 spell
 keenwrite.github.io
 keenwrite.build_artifacts.txt

D .project

 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
 	<name>Markdown Writer FX</name>
 	<comment></comment>
 	<projects>
 	</projects>
 	<buildSpec>
 		<buildCommand>
 			<name>org.eclipse.jdt.core.javabuilder</name>
 			<arguments>
 			</arguments>
 		</buildCommand>
 		<buildCommand>
 			<name>org.eclipse.buildship.core.gradleprojectbuilder</name>
 			<arguments>
 			</arguments>
 		</buildCommand>
 	</buildSpec>
 	<natures>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.buildship.core.gradleprojectnature</nature>
 	</natures>
 	<filteredResources>
 		<filter>
 			<id>1438449113801</id>
 			<name></name>
 			<type>26</type>
 			<matcher>
 				<id>org.eclipse.ui.ide.multiFilter</id>
 				<arguments>1.0-projectRelativePath-matches-false-false-build</arguments>
 			</matcher>
 		</filter>
 		<filter>
 			<id>1438449113801</id>
 			<name></name>
 			<type>26</type>
 			<matcher>
 				<id>org.eclipse.ui.ide.multiFilter</id>
 				<arguments>1.0-projectRelativePath-matches-false-false-.gradle</arguments>
 			</matcher>
 		</filter>
 	</filteredResources>
 </projectDescription>

D CODE_OF_CONDUCT.md

 # Contributor Covenant Code of Conduct
 ## Our Pledge
 In the interest of fostering an open and welcoming environment, we as
 contributors and maintainers pledge to making participation in our project and
 our community a harassment-free experience for everyone, regardless of age, body
 size, disability, ethnicity, sex characteristics, gender identity and expression,
 level of experience, education, socio-economic status, nationality, personal
 appearance, race, religion, or sexual identity and orientation.
 ## Our Standards
 Examples of behavior that contributes to creating a positive environment
 include:
 * Using welcoming and inclusive language
 * Being respectful of differing viewpoints and experiences
 * Gracefully accepting constructive criticism
 * Focusing on what is best for the community
 * Showing empathy towards other community members
 Examples of unacceptable behavior by participants include:
 * The use of sexualized language or imagery and unwelcome sexual attention or
  advances
 * Trolling, insulting/derogatory comments, and personal or political attacks
 * Public or private harassment
 * Publishing others' private information, such as a physical or electronic
  address, without explicit permission
 * Other conduct which could reasonably be considered inappropriate in a
  professional setting
 ## Our Responsibilities
 Project maintainers are responsible for clarifying the standards of acceptable
 behavior and are expected to take appropriate and fair corrective action in
 response to any instances of unacceptable behavior.
 Project maintainers have the right and responsibility to remove, edit, or
 reject comments, commits, code, wiki edits, issues, and other contributions
 that are not aligned to this Code of Conduct, or to ban temporarily or
 permanently any contributor for other behaviors that they deem inappropriate,
 threatening, offensive, or harmful.
 ## Scope
 This Code of Conduct applies both within project spaces and in public spaces
 when an individual is representing the project or its community. Examples of
 representing a project or community include using an official project e-mail
 address, posting via an official social media account, or acting as an appointed
 representative at an online or offline event. Representation of a project may be
 further defined and clarified by project maintainers.
 ## Enforcement
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported by contacting the project team at Dave.Jarvis@gmail.com. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
 Further details of specific enforcement policies may be posted separately.
 Project maintainers who do not follow or enforce the Code of Conduct in good
 faith may face temporary or permanent repercussions as determined by other
 members of the project's leadership.
 ## Attribution
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
 available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
 [homepage]: https://www.contributor-covenant.org
 For answers to common questions about this code of conduct, see
 https://www.contributor-covenant.org/faq

D Containerfile

 FROM alpine:latest
 RUN apk --update add --no-cache fontconfig curl
 RUN rm -rf /var/cache
 # Download fonts.
 ENV FONT_DIR=/usr/share/fonts/user
 RUN mkdir -p $FONT_DIR
 WORKDIR $FONT_DIR
 ADD "https://fonts.google.com/download?family=Roboto" "roboto.zip"
 ADD "https://fonts.google.com/download?family=Inconsolata" "inconsolata.zip"
 ADD "https://github.com/adobe-fonts/source-serif/releases/download/4.004R/source-serif-4.004.zip" "source-serif.zip"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Bold.ttf" "LibreBaskerville-Bold.ttf"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Italic.ttf" "LibreBaskerville-Italic.ttf"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Regular.ttf" "LibreBaskerville-Regular.ttf"
 ADD "https://www.omnibus-type.com/wp-content/uploads/Archivo-Narrow.zip" "archivo-narrow.zip"
 # Unpack fonts (prior to ConTeXt).
 RUN unzip -j -o roboto.zip "*.ttf"
 RUN unzip -j -o inconsolata.zip "**/Inconsolata/*.ttf"
 RUN unzip -j -o source-serif.zip "source-serif-4.004/OTF/SourceSerif4-*.otf"
 RUN unzip -j -o archivo-narrow.zip "Archivo-Narrow/otf/*.otf"
 RUN rm -f roboto.zip
 RUN rm -f inconsolata.zip
 RUN rm -f source-serif.zip
 RUN rm -f archivo-narrow.zip
 # Update system font cache.
 RUN fc-cache -f -v
 WORKDIR "/opt"
 # Download themes.
 ADD "https://github.com/DaveJarvis/keenwrite-themes/releases/latest/download/theme-pack.zip" "theme-pack.zip"
 RUN unzip theme-pack.zip
 # Download ConTeXt.
 ADD "http://lmtx.pragma-ade.nl/install-lmtx/context-linuxmusl.zip" "context.zip"
 RUN unzip context.zip -d context
 RUN rm -f context.zip
 # Install ConTeXt.
 WORKDIR "context"
 RUN sh install.sh
 # Configure environment to find ConTeXt.
 ENV PROFILE=/etc/profile
 ENV CONTEXT_HOME=/opt/context
 RUN echo "export CONTEXT_HOME=\"$CONTEXT_HOME\"" >> $PROFILE
 RUN echo "export PATH=\"\$PATH:\$CONTEXT_HOME/tex/texmf-linuxmusl/bin\"" >> $PROFILE
 RUN echo "export OSFONTDIR=\"/usr/share/fonts//\""
 RUN echo "PS1=\"typesetter:\\w\\\$ \"" >> $PROFILE
 # Trim the fat.
 RUN source $PROFILE
 RUN rm -rf $CONTEXT_HOME/tex/texmf-context/doc
 RUN find . -type f -name "*.pdf" -exec rm {} \;
 # Prepare to process text files.
 WORKDIR "/root"

M R/conversion.R

 # -----------------------------------------------------------------------------
 annal <- function( days = 0, format = "%Y-%m-%d", oformat = "%B %d, %Y" ) {
   format( when( anchor, days ), format = oformat )
   gsub( " 0", " ", format( when( anchor, days ), format = oformat ) )
+}
+  }
   gsub( '^0*', '', s )
   gsub( "^0*", '', s )
+}
   # Calculate number of elapsed years.
   years = length( seq( from = began, to = ended, by = 'year' ) ) - 1
   years = length( seq( from = began, to = ended, by = "year" ) ) - 1
   # Move the start date up by the number of elapsed years.
   # Calculate number of elapsed months, excluding years.
   months = length( seq( from = began, to = ended, by = 'month' ) ) - 1
   months = length( seq( from = began, to = ended, by = "month" ) ) - 1
   # Move the start date up by the number of elapsed months
   # Calculate number of elapsed days, excluding months and years.
   days = length( seq( from = began, to = ended, by = 'day' ) ) - 1
   days = length( seq( from = began, to = ended, by = "day" ) ) - 1
   if( days > 0 ) {
 # -----------------------------------------------------------------------------
 pl.numeric <- function( s, n ) {
   concat( cms( n ), concat( " ", pluralize( s, n ) ) )
   concat( cms( n ), concat( " ", pluralize( word=s, n=n ) ) )
+}
 # -----------------------------------------------------------------------------
 # Pluralize s if n is not equal to 1.
 # -----------------------------------------------------------------------------
 pl <- function( s, n=2 ) {
   pluralize( s, x( n ) )
 pl <- function( s, count=2 ) {
   pluralize( word=s, n=count )
+}
   dt = strptime( dates, format = format )
   as.integer( difftime( dates[2], dates[1], units = "days" ) )
+}
 weeks <- function( began, ended ) {
   began = when( anchor, began )
   ended = when( anchor, ended )
   if( as.integer( ended - began ) < 0 ) {
     tempd = began
     began = ended
     ended = tempd
+  }
   # Calculate number of elapsed weeks.
   length( seq( from = began, to = ended, by = "weeks" ) ) - 1
+}
   # Calculate number of elapsed years.
   length( seq( from = began, to = ended, by = 'year' ) ) - 1
   length( seq( from = began, to = ended, by = "year" ) ) - 1
+}

M R/pluralize.R

 # -----------------------------------------------------------------------------
 # Copyright 2020, White Magic Software, Ltd.
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # -----------------------------------------------------------------------------
 # -----------------------------------------------------------------------------
 # See Damian Conway's "An Algorithmic Approach to English Pluralization":
 #   http://goo.gl/oRL4MP
 # See Oliver Glerke's Evo Inflector: https://github.com/atteo/evo-inflector/
 # See Shevek's Pluralizer: https://github.com/shevek/linguistics/
 # See also: http://www.freevectors.net/assets/files/plural.txt
 # -----------------------------------------------------------------------------
 pluralize <- function( s, n ) {
   result <- s
   # Partial implementation of Conway's algorithm for nouns.
   if( n != 1 ) {
     if( pl.noninflective( s ) ||
         pl.suffix( "es", s ) ||
         pl.suffix( "fish", s ) ||
         pl.suffix( "ois", s ) ||
         pl.suffix( "sheep", s ) ||
         pl.suffix( "deer", s ) ||
         pl.suffix( "pox", s ) ||
         pl.suffix( "[A-Z].*ese", s ) ||
         pl.suffix( "itis", s ) ) {
       # 1. Retain non-inflective user-mapped noun as is.
       # 2. Retain non-inflective plural as is.
       result <- s
+    }
     else if( pl.is.irregular.pl( s ) ) {
       # 4. Change irregular plurals based on mapping.
       result <- pl.irregular.pl( s )
+    }
     else if( pl.is.irregular.es( s ) ) {
       # x. From Shevek's
       result <- pl.inflect( s, "", "es" )
+    }
     else if( pl.suffix( "man", s ) ) {
       # 5. For -man, change -an to -en
       result <- pl.inflect( s, "an", "en" )
+    }
     else if( pl.suffix( "[lm]ouse", s ) ) {
       # 5. For [lm]ouse, change -ouse to -ice
       result <- pl.inflect( s, "ouse", "ice" )
+    }
     else if( pl.suffix( "tooth", s ) ) {
       # 5. For -tooth, change -ooth to -eeth
       result <- pl.inflect( s, "ooth", "eeth" )
+    }
     else if( pl.suffix( "goose", s ) ) {
       # 5. For -goose, change -oose to -eese
       result <- pl.inflect( s, "oose", "eese" )
+    }
     else if( pl.suffix( "foot", s ) ) {
       # 5. For -foot, change -oot to -eet
       result <- pl.inflect( s, "oot", "eet" )
+    }
     else if( pl.suffix( "zoon", s ) ) {
       # 5. For -zoon, change -on to -a
       result <- pl.inflect( s, "on", "a" )
+    }
     else if( pl.suffix( "[csx]is", s ) ) {
       # 5. Change -cis, -sis, -xis to -es
       result <- pl.inflect( s, "is", "es" )
+    }
     else if( pl.suffix( "([cs]h|ss|zz|x|s)", s ) ) {
       # 8. Change -ch, -sh, -ss, -zz, -x, -s to -es
       result <- pl.inflect( s, "", "es" )
+    }
     else if( pl.suffix( "([aeo]lf|[^d]eaf|arf)", s ) ) {
       # 9. Change -f to -ves
       result <- pl.inflect( s, "f", "ves" )
+    }
     else if( pl.suffix( "[nlw]ife", s ) ) {
       # 10. Change -fe to -ves
       result <- pl.inflect( s, "fe", "ves" )
+    }
     else if( pl.suffix( "[aeiou]y", s ) ) {
       # 11. Change -[aeiou]y to -ys
       result <- pl.inflect( s, "", "s" )
+    }
     else if( pl.suffix( "y", s ) ) {
       # 12. Change -y to -ies
       result <- pl.inflect( s, "y", "ies" )
+    }
     else if( pl.suffix( "z", s ) ) {
       # x. Change -z to -zzes
       result <- pl.inflect( s, "", "zes" )
+    }
     else {
       # 13. Default plural: add -s
       result <- pl.inflect( s, "", "s" )
+    }
+  }
   result
+}
 # -----------------------------------------------------------------------------
 # Returns the given string (s) with its suffix replaced by r.
 # -----------------------------------------------------------------------------
 pl.inflect <- function( s, suffix, r ) {
   gsub( paste( suffix, "$", sep="" ), r, s )
+}
 # -----------------------------------------------------------------------------
 # Answers whether the given string (s) has the given ending.
 # -----------------------------------------------------------------------------
 pl.suffix <- function( ending, s ) {
   grepl( paste( ending, "$", sep="" ), s )
+}
 # -----------------------------------------------------------------------------
 # Answers whether the given string (s) is a noninflective noun.
 # -----------------------------------------------------------------------------
 pl.noninflective <- function( s ) {
   v <- c(
     "aircraft",
     "Bhutanese",
     "bison",
     "bream",
     "Burmese",
     "carp",
     "chassis",
     "Chinese",
     "clippers",
     "cod",
     "contretemps",
     "corps",
     "debris",
     "djinn",
     "eland",
     "elk",
     "flounder",
     "fracas",
     "gallows",
     "graffiti",
     "headquarters",
     "high-jinks",
     "homework",
     "hovercraft",
     "innings",
     "Japanese",
     "Lebanese",
     "mackerel",
     "means",
     "mews",
     "mice",
     "mumps",
     "news",
     "pincers",
     "pliers",
     "Portuguese",
     "proceedings",
     "salmon",
     "scissors",
     "sea-bass",
     "Senegalese",
     "shears",
     "Siamese",
     "Sinhalese",
     "spacecraft",
     "swine",
     "trout",
     "tuna",
     "Vietnamese",
     "watercraft",
     "whiting",
     "wildebeest"
+  )
   is.element( s, v )
+}
 # -----------------------------------------------------------------------------
 # Answers whether the given string (s) is an irregular plural.
 # -----------------------------------------------------------------------------
 pl.is.irregular.pl <- function( s ) {
   # Could be refactored with pl.irregular.pl...
   v <- c(
     "beef", "brother", "child", "cow", "ephemeris", "genie", "money",
     "mongoose", "mythos", "octopus", "ox", "soliloquy", "trilby"
+  )
   is.element( s, v )
+}
 # -----------------------------------------------------------------------------
 # Call to pluralize an irregular noun. Only call after confirming
 # the noun is irregular via pl.is.irregular.pl.
 # -----------------------------------------------------------------------------
 pl.irregular.pl <- function( s ) {
   v <- list(
     "beef" = "beefs",
     "brother" = "brothers",
     "child" = "children",
     "cow" = "cows",
     "ephemeris" = "ephemerides",
     "genie" = "genies",
     "money" = "moneys",
     "mongoose" = "mongooses",
     "mythos" = "mythoi",
     "octopus" = "octopuses",
     "ox" = "oxen",
     "passerby" = "passersby",
     "soliloquy" = "soliloquies",
     "trilby" = "trilbys"
+  )
   # Faster version of v[[ s ]]
   .subset2( v, s )
+}
 # -----------------------------------------------------------------------------
 # Answers whether the given string (s) pluralizes with -es.
 # -----------------------------------------------------------------------------
 pl.is.irregular.es <- function( s ) {
   v <- c(
     "acropolis", "aegis", "alias", "asbestos", "bathos", "bias", "bronchitis",
     "bursitis", "caddis", "cannabis", "canvas", "chaos", "cosmos", "dais",
     "digitalis", "epidermis", "ethos", "eyas", "gas", "glottis", "hubris",
     "ibis", "lens", "mantis", "marquis", "metropolis", "pathos", "pelvis",
     "polis", "rhinoceros", "sassafrass", "trellis"
+  )
   is.element( s, v )
 # Copyright 2021 Robin Gertenbach.
+#
 # Copyright 2021 White Magic Software, Ltd.
+#
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
 # "Software"), to deal in the Software without restriction, including
 # without limitation the rights to use, copy, modify, merge, publish,
 # distribute, sublicense, and/or sell copies of the Software, and to
 # permit persons to whom the Software is furnished to do so, subject to
 # the following conditions:
+#
 # The above copyright notice and this permission notice shall be
 # included in all copies or substantial portions of the Software.
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 # -----------------------------------------------------------------------------
 # -----------------------------------------------------------------------------
 # See Damian Conway's "An Algorithmic Approach to English Pluralization":
 #   http://goo.gl/oRL4MP
 # See Oliver Glerke's Evo Inflector: https://github.com/atteo/evo-inflector/
 # See Shevek's Pluralizer: https://github.com/shevek/linguistics/
 # See also: http://www.freevectors.net/assets/files/plural.txt
 # -----------------------------------------------------------------------------
 # -----------------------------------------------------------------------------
 # Applies all pluralization rules.
+#
 # @param word The word to pluralize.
 # @param method The pluralization approach to apply to the word.
 # @param n When any other value than 1, the word is pluralized.
 # -----------------------------------------------------------------------------
 pluralize <- function( word, method = c( "ac", "ca", "a", "c" ), n = 2 ) {
   if( n != 1 ) {
     method <- match.arg( method )
     coalesce(
       pluralize_non_inflecting( word ),
       pluralize_pronoun( word ),
       pluralize_irregular( word, method ),
       pluralize_irregular_inflection_for_common_suffixes( word ),
       pluralize_fully_assimilated_classical_inflections( word ),
       pluralize_classical_variants_of_modern_inflections( word, method ),
       pluralize_ch_sh_ss_suffixes( word ),
       pluralize_f_and_fe_suffix( word ),
       pluralize_y_suffix( word ),
       pluralize_o_suffix( word ),
       pluralize_compound_words( word ),
       pluralize_regular( word )
+    )
+  }
   else {
     word
+  }
+}
 # -----------------------------------------------------------------------------
 # Rule 1
+#
 # Retain non-inflective user-mapped noun as is.
+#
 # Rule 2
+#
 # Irregular verbs that do not inflect in plural.
 # -----------------------------------------------------------------------------
 pluralize_non_inflecting <- function( word ) {
   coalesce(
     ifelse( word %in% .uninflected_nouns, word, NA_character_ ),
     ifelse( word %in% .singular_nouns, word, NA_character_ ),
     ifelse( check_suffix( word, .irregular_patterns ), word, NA_character_ )
+  )
+}
 .check_non_inflecting <- function( word ) {
   is_uninflected <- word %in% .uninflected_nouns
   is_singular <- word %in% .singular_nouns
   is_irregular <- check_suffix( word, .irregular_patterns )
   is_uninflected | is_singular | is_irregular
+}
 .uninflected_nouns <- c(
   "adonis",
   "anis",
   "bison",
   "bream",
   "breeches",
   "britches",
   "carp",
   "chassis",
   "clippers",
   "cod",
   "contretemps",
   "corps",
   "debris",
   "diabetes",
   "djinn",
   "eland",
   "elk",
   "flounder",
   "gallows",
   "graffiti",
   "headquarters",
   "herpes",
   "high-jinks",
   "homework",
   "innings",
   "jackanapes",
   "mackerel",
   "measles",
   "mews",
   "mumps",
   "news",
   "pants",
   "physics",
   "pincers",
   "pliers",
   "proceedings",
   "rabies",
   "salmon",
   "scissors",
   "sea-bass",
   "series",
   "shears",
   "species",
   "swine",
   "trout",
   "tuna",
   "whiting",
   "wildebeest"
+)
 .singular_nouns <- c(
   "bathos",
   "caddis",
   "cannabis",
   "dais",
   "digitalis",
   "ethos",
   "glottis",
   "marquis",
   "pathos",
   "polis"
+)
 .irregular_patterns <- c(
   "fish$", "ois$", "-sheep$", "deer$", "pox$", "[A-Z].*ese$", "itis$"
+)
 .prepositions <- c(
   "about",
   "above",
   "across",
   "after",
   "among",
   "around",
   "at",
   "athwart",
   "before",
   "behind",
   "below",
   "beneath",
   "beside",
   "besides",
   "between",
   "betwixt",
   "beyond",
   "but",
   "by",
   "during",
   "except",
   "for",
   "from",
   "in",
   "into",
   "near",
   "of",
   "off",
   "on",
   "onto",
   "out",
   "over",
   "since",
   "till",
   "to",
   "under",
   "until",
   "unto",
   "upon",
   "with"
+)
 # -----------------------------------------------------------------------------
 # Rule 3
+#
 # Handle pronouns in the nominative, accusative, and dative and propositional
 # phrases.
 # -----------------------------------------------------------------------------
 pluralize_pronoun <- function( word ) {
   as.vector( .pluralized_pronouns[word] )
+}
 .pluralized_pronouns <- c(
   "I" = "we",
   "me" = "us",
   "myself" = "ourselves",
   "you" = "you",
   "thou" = "ye",
   "thee" = "ye",
   "yourself" = "yourself",
   "thyself" = "yourself",
   "she" = "they",
   "he" = "they",
   "it" = "they",
   "they" = "they",
   "her" = "them",
   "him" = "them",
   "it" = "them",
   "them" = "them",
   "herself" = "themselves",
   "himself" = "themselves",
   "itself" = "themselves",
   "themself" = "themselves",
   "oneself" = "oneselves"
+)
 # -----------------------------------------------------------------------------
 # Rule 4
+#
 # Change irregular plurals based on mapping.
 # -----------------------------------------------------------------------------
 pluralize_irregular <- function( word, method = c( "ac", "ca", "a", "c" ) ) {
   method <- match.arg( method )
   plurals <- .irregular_nouns[word]
   extract_plural <- function( plurals ) {
     if( is.null( plurals ) ) {
       return( NA_character_ )
+    }
     return(
       switch(
         method,
         "a" = plurals["a"],
         "c" = plurals["c"],
         "ac" = if.na( plurals["a"], plurals["c"] ),
         "ca" = if.na( plurals["c"], plurals["a"] )
+      )
+    )
+  }
   as.character( lapply( plurals, extract_plural ) )
+}
 .irregular_nouns <- list(
   "beef"      = c( "a" = "beefs",       "c" = "beeves" ),
   "brother"   = c( "a" = "brothers",    "c" = "brethren" ),
   "child"     = c( "a" = NA_character_, "c" = "children" ),
   "cherub"    = c( "a" = "cherubim",    "c" = NA_character_ ),
   "cow"       = c( "a" = "cows",        "c" = "kine" ),
   "ephemeris" = c( "a" = NA_character_, "c" = "ephemerides" ),
   "genie"     = c( "a" = "genies",      "c" = "genii" ),
   "matrix"    = c( "a" = NA_character_, "c" = "matrices" ),
   "money"     = c( "a" = "moneys",      "c" = "monies" ),
   "mongoose"  = c( "a" = "mongooses",   "c" = NA_character_ ),
   "mythos"    = c( "a" = NA_character_, "c" = "mythoi" ),
   "octopus"   = c( "a" = "octopuses",   "c" = "octopodes" ),
   "ox"        = c( "a" = NA_character_, "c" = "oxen" ),
   "passerby"  = c( "a" = NA_character_, "c" = "passersby" ),
   "soliloquy" = c( "a" = "soliloquies", "c" = NA_character_ ),
   "seraph"    = c( "a" = "seraphim",    "c" = NA_character_ ),
   "trilby"    = c( "a" = "trilbys",     "c" = NA_character_ ),
   "vertex"    = c( "a" = NA_character_, "c" = "vertices" ),
   "vortex"    = c( "a" = NA_character_, "c" = "vortices" )
+)
 # -----------------------------------------------------------------------------
 # Rule 5
+#
 # Handle irregular inflections for common suffixes.
 # -----------------------------------------------------------------------------
 pluralize_irregular_inflection_for_common_suffixes <- function( word ) {
   output <- sub( "man$", "men", word )
   output <- sub( "([ml])(ouse)$", "\\1ice", output )
   output <- sub( "tooth$", "teeth", output )
   output <- sub( "goose$", "geese", output )
   output <- sub( "foot$", "feet", output )
   output <- sub( "zoon$", "zoa", output )
   output <- sub( "([csx])(is)$", "\\1es", output )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 6
+#
 # Handle fully assimilated classical inflections.
 # -----------------------------------------------------------------------------
 pluralize_fully_assimilated_classical_inflections <- function( word ) {
   output <- replace_suffix(
     word, "", "e", c( "alumna", "alga", "vertebra" ) )
   output <- replace_suffix(
     output, "ex", "ices", c( "codex", "murex", "silex" ) )
   output <- replace_suffix(
     output, "on", "a", c(
       "aphelion",
       "asyndeton",
       "criterion",
       "hyperbaton",
       "noumenon",
       "organon",
       "perihelion",
       "phenomenon",
       "prolegomenon"
+    )
+  )
   output <- replace_suffix(
     output, "um", "a", c(
       "agendum",
       "bacterium",
       "candelabrum",
       "datum",
       "desideratum",
       "erratum",
       "extremum",
       "ovum",
       "stratum"
+    )
+  )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 7
+#
 # Classical variants of modern inflections (e.g., stigmata, soprani).
+#
 # See tables A.11 to A.13, A.15, A.16, A.18, A.21 to A.25.
 # -----------------------------------------------------------------------------
 pluralize_classical_variants_of_modern_inflections <- function(
   word, method = c( "ac", "ca", "a", "c" ) ) {
   method <- match.arg( method )
   # -a to -as (anglicized) or -ae (classical)
   a11 <- c(
     "abscissa",
     "amoeba",
     "antenna",
     "aurora",
     "formula",
     "hydra",
     "hyperbola",
     "lacuna",
     "medusa",
     "nebula",
     "nova",
     "parabola"
+  )
   # Table A.12: -a to -as (anglicized) or -ata (classical)
   a12 <- c(
     "anathema",
     "bema",
     "carcinoma",
     "charisma",
     "diploma",
     "dogma",
     "drama",
     "edema",
     "enema",
     "enigma",
     "gumma",
     "lemma",
     "lymphoma",
     "magma",
     "melisma",
     "miasma",
     "oedema",
     "sarcoma",
     "schema",
     "soma",
     "stigma",
     "stoma",
     "trauma"
+  )
   # Table A.13: -en to -ens (anglicized) or -ina (classical)
   a13 <- c( "stamen", "foramen", "lumen" )
   # Table A.15: -ex to -exes (anglicized) or -ices (classical)
   a15 <- c(
     "apex",
     "cortex",
     "index",
     "latex",
     "pontifex",
     "simplex",
     "vertex",
     "vortex"
+  )
   # Table A.16: -is to -ises (anglicized) or -ides (classical)
   a16 <- c( "iris", "clitoris" )
   # Table A.18: -o to -os (anglicized) or -i (classical)
   a18 <- c(
     "alto",
     "basso",
     "canto",
     "contralto",
     "crescendo",
     "solo",
     "soprano",
     "tempo"
+  )
   # Table A.21: -um to -ums (anglicized) or -a (classical)
   a21 <- c(
     "aquarium",
     "compendium",
     "consortium",
     "cranium",
     "curriculum",
     "dictum",
     "emporium",
     "enconium",
     "gymnasium",
     "honorarium",
     "interregnum",
     "lustrum",
     "maximum",
     "medium",
     "memorandum",
     "millenium",
     "minimum",
     "momentum",
     "optimum",
     "phylum",
     "quantum",
     "rostrum",
     "spectrum",
     "speculum",
     "stadium",
     "trapezium",
     "ultimatum",
     "vacuum",
     "velum"
+  )
   # Table A.22: -us to -uses (anglicized) or -i (classical)
   a22 <- c(
     "focus",
     "fungus",
     "genius",
     "incubus",
     "nimbus",
     "nucleolus",
     "radius",
     "stylus",
     "succubus",
     "torus",
     "umbilicus",
     "uterus"
+  )
   # Table A.23: -us to -uses (anglicized) or -us (classical)
   a23 <- c(
     "apparatus",
     "cantus",
     "coitus",
     "hiatus",
     "impetus",
     "nexus",
     "plexus",
     "prospectus",
     "sinus",
     "status"
+  )
   output <- replace_suffix( word, "", "im", c( "cherub", "goy", "seraph"  ) )
   output <- replace_suffix( output, "", "i", c( "afreet", "afrit", "efreet" ) )
   if( method %in% c( "a", "ac" ) ) {
     output <- replace_suffix( output, "us", "uses", a23 )
     output <- replace_suffix( output, "us", "uses", a22 )
     output <- replace_suffix( output, "um", "ums", a21 )
     output <- replace_suffix( output, "o", "os", a18 )
     output <- replace_suffix( output, "is", "ises", a16 )
     output <- replace_suffix( output, "ex", "exes", a15 )
     output <- replace_suffix( output, "en", "ens", a13 )
     output <- replace_suffix( output, "a", "as", a12 )
     output <- replace_suffix( output, "a", "as", a11 )
   } else {
     output <- replace_suffix( output, "us", "us", a23 )
     output <- replace_suffix( output, "us", "i", a22 )
     output <- replace_suffix( output, "um", "a", a21 )
     output <- replace_suffix( output, "o", "i", a18 )
     output <- replace_suffix( output, "is", "ides", a16 )
     output <- replace_suffix( output, "ex", "ices", a15 )
     output <- replace_suffix( output, "en", "ina", a13 )
     output <- replace_suffix( output, "a", "ata", a12 )
     output <- replace_suffix( output, "a", "ae", a11 )
+  }
   ifelse(
     output == word & (method %in% c( "a", "ac" ) | !word %in% a23),
     NA_character_,
     output
+  )
+}
 # -----------------------------------------------------------------------------
 # Rule 8
+#
 # Suffixes -ch, -sh, -ss, -x, and -z take -es as plural (e.g., churches,
 # classes).
 # -----------------------------------------------------------------------------
 pluralize_ch_sh_ss_suffixes <- function( word ) {
   output <- sub( "([cs]h)$", "\\1es", word )
   output <- sub( "(x|z)$", "\\1es", word )
   output <- replace_suffix( output, "ss", "sses" )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 9
+#
 # Certain words ending in -f or -fe take -ves in the plural.
 # -----------------------------------------------------------------------------
 pluralize_f_and_fe_suffix <- function( word ) {
   output <- sub( "([aeo]l|[^d]ea|ar)f$", "\\1ves", word )
   output <- sub( "([nlw]i)fe$", "\\1ves", output )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 10
+#
 # Words ending in -y take -ies.
 # -----------------------------------------------------------------------------
 pluralize_y_suffix <- function( word ) {
   output <- sub( "([aeiou]y)$", "\\1s", word )
   output <- sub( "([A-Z].*y)$", "\\1s", output )
   output <- replace_suffix( output, "y", "ies" )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 11
+#
 # Some words ending in -o take -os (lassos, solos). See tables A.17 and A.18.
 # Others take -oes (potatoes, dominoes).
 # When -o is preceded by a vowel always take -os (folios, bamboos).
 # -----------------------------------------------------------------------------
 pluralize_o_suffix <- function( word, method = c( "ac", "ca", "a", "c" ) ) {
   method <- match.arg( method )
   # Table A.17: -o to -os
   a17 <- c(
     "albino",
     "archipelago",
     "armadillo",
     "commando",
     "ditto",
     "dynamo",
     "embryo",
     "fiasco",
     "generalissimo",
     "ghetto",
     "guano",
     "inferno",
     "jumbo",
     "lingo",
     "lumbago",
     "magneto",
     "manifesto",
     "medico",
     "octavo",
     "photo",
     "pro",
     "quarto",
     "rhino",
     "stylo"
+  )
   # Table A.18: -o to -os (anglicized) or -i (classical)
   a18 <- c(
     "alto",
     "basso",
     "canto",
     "contralto",
     "crescendo",
     "solo",
     "soprano",
     "tempo"
+  )
   output <- replace_suffix( word, "o", "os", a17 )
   replacement <- if( method %in% c( "c", "ca" ) ) "i" else "os"
   output <- replace_suffix( output, "o", replacement, a18 )
   ifelse( output == word, NA_character_, output )
+}
 # -----------------------------------------------------------------------------
 # Rule 12
+#
 # Compound word pluralization.
 # -----------------------------------------------------------------------------
 pluralize_compound_words <- function(
   word, method = c( "ac", "ca", "a", "c" ) ) {
   method <- match.arg( method )
   # "General" is pluralized.
   military <- c(
     "Adjutant",
     "Brigadier",
     "Lieutenant",
     "Major",
     "Quartermaster"
+  )
   # X of Y -> plural(X) of Y
   # X at Y -> plural(X) of Y
   # X Y general -> X plural(Y) general
   # X-in-Y -> plural(X)-in-Y
   # Major Generals
   # Adjutant Generals
   # Lieutenant Generals
   # Brigadier Generals
   # Quartermaster Generals
   pluralize_cw <- Vectorize(
     function( cw, seps ) {
       if( cw[length( cw )] %in% c( "General", "general" ) &&
           (!cw[length( cw )] %in% military) ) {
         cw[1] <- pluralize( cw[1], method )
       } else {
         cw[1] <- pluralize( cw[1], method )
+      }
       paste( paste0( seps, cw ), collapse = "" )
+    }
+  )
   parts <- strsplit( word, "[- ]+" )
   seps <- strsplit( word, "[^ -]+" )
   is_compound <- grepl( "[- ]", word )
   output <- word
   output[!is_compound] <- NA_character_
   output[is_compound] <- pluralize_cw( parts[is_compound], seps[is_compound] )
   output
+}
 # -----------------------------------------------------------------------------
 # Rule 13
+#
 # Add -es if ending in -s (e.g., tennis, lychnis); otherwise, add -s.
 # -----------------------------------------------------------------------------
 pluralize_regular <- function( word ) {
   ending <- 's'
   if( endsWith( word, ending ) ) {
     ending <- "es"
+  }
   paste0( word, ending )
+}
 # -----------------------------------------------------------------------------
 # Determines whether the word ends with one of the given suffixes.
 # -----------------------------------------------------------------------------
 check_suffix <- function( x, suffixes ) {
   pattern <- paste0( "(", paste( suffixes, collapse = "|" ), ")$" )
   grepl( pattern, x, ignore.case = TRUE )
+}
 # -----------------------------------------------------------------------------
 # Replaces the suffix of the word.
 # -----------------------------------------------------------------------------
 replace_suffix <- function( x, suffix, replacement, eligible = NULL ) {
   ifelse(
     is.null( eligible ) | x %in% eligible,
     sub( paste0( suffix, "$" ), replacement, x ),
+    x
+  )
+}
 # -----------------------------------------------------------------------------
 # Returns y if x is na, otherwise x.
 # -----------------------------------------------------------------------------
 if.na <- function( x, y ) {
   ifelse( is.na( x ), y, x )
+}
 # -----------------------------------------------------------------------------
 # Reduces the given function list.
 # -----------------------------------------------------------------------------
 coalesce <- function( ... ) {
   args <- list( ... )
   Reduce( if.na, args )
+}

M build.gradle

 import static org.gradle.api.JavaVersion.*
 plugins {
   id 'application'
   id 'org.openjfx.javafxplugin' version '0.0.13'
   id 'com.palantir.git-version' version '0.15.0'
+}
 repositories {
   mavenCentral()
   maven { url 'https://oss.sonatype.org/content/repositories/snapshots/' }
   maven { url 'https://oss.sonatype.org/content/repositories/snapshots' }
   maven { url 'https://nexus.bedatadriven.com/content/groups/public' }
   maven {
     url "https://css4j.github.io/maven/"
     url "https://css4j.github.io/maven"
     mavenContent {
       releasesOnly()
   def v_junit = '5.9.1'
   def v_flexmark = '0.64.0'
   def v_jackson = '2.13.4'
   def v_jackson = '2.14.0'
   def v_echosvg = '0.2.1'
   def v_picocli = '4.7.0'
   // JavaFX
   implementation 'org.controlsfx:controlsfx:11.1.1'
   implementation 'org.fxmisc.richtext:richtextfx:0.10.9'
   implementation 'org.fxmisc.flowless:flowless:0.6.10'
   implementation 'org.controlsfx:controlsfx:11.1.2'
   implementation 'org.fxmisc.richtext:richtextfx:0.11.0'
   implementation 'org.fxmisc.flowless:flowless:0.7.0'
   implementation 'org.fxmisc.wellbehaved:wellbehavedfx:0.3.3'
   implementation 'com.miglayout:miglayout-javafx:11.0'
   implementation 'com.dlsc.preferencesfx:preferencesfx-core:11.10.0'
   implementation 'com.dlsc.preferencesfx:preferencesfx-core:11.11.0'
   // Markdown
   // Command-line parsing
   implementation 'info.picocli:picocli:4.6.3'
   implementation "info.picocli:picocli:${v_picocli}"
   annotationProcessor "info.picocli:picocli-codegen:${v_picocli}"
   // Spelling, TeX, Docking, KeenQuotes
   testImplementation "org.junit.jupiter:junit-jupiter-params:${v_junit}"
   testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
+}
 compileJava {
   options.compilerArgs << '-Xlint:unchecked' << '-Xlint:deprecation'
+}
 def resourceDir = sourceSets.main.resources.srcDirs[0]
 final resourceDir = sourceSets.main.resources.srcDirs[0]
 final Properties config = new Properties()
 final File configFile = file( "${resourceDir}/bootstrap.properties" )
 final FileInputStream configStream = new FileInputStream( configFile )
 config.load( configStream )
 configStream.close()
 final String applicationName = config.get( 'application.title' ).toString().toLowerCase()
 final String applicationClass = "com.${applicationName}.Launcher"
 final String applicationPackage = "com.${applicationName}"
 final String applicationClass = "${applicationPackage}.Launcher"
 java {
   sourceCompatibility = VERSION_17
   targetCompatibility = VERSION_17
+}
 compileJava {
   options.compilerArgs
       << '-Xlint:unchecked'
       << '-Xlint:deprecation'
       << "-Aproject=${applicationPackage}/${applicationName}"
+}
 application {

A container/Containerfile

 FROM alpine:latest
 RUN apk --update add --no-cache fontconfig curl
 RUN rm -rf /var/cache
 # Download fonts.
 ENV FONT_DIR=/usr/share/fonts/user
 RUN mkdir -p $FONT_DIR
 WORKDIR $FONT_DIR
 ADD "https://fonts.google.com/download?family=Roboto" "roboto.zip"
 ADD "https://fonts.google.com/download?family=Inconsolata" "inconsolata.zip"
 ADD "https://github.com/adobe-fonts/source-serif/releases/download/4.004R/source-serif-4.004.zip" "source-serif.zip"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Bold.ttf" "LibreBaskerville-Bold.ttf"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Italic.ttf" "LibreBaskerville-Italic.ttf"
 ADD "https://github.com/googlefonts/Libre-Baskerville/blob/master/fonts/ttf/LibreBaskerville-Regular.ttf" "LibreBaskerville-Regular.ttf"
 ADD "https://www.omnibus-type.com/wp-content/uploads/Archivo-Narrow.zip" "archivo-narrow.zip"
 # Unpack fonts (prior to ConTeXt).
 RUN unzip -j -o roboto.zip "*.ttf"
 RUN unzip -j -o inconsolata.zip "**/Inconsolata/*.ttf"
 RUN unzip -j -o source-serif.zip "source-serif-4.004/OTF/SourceSerif4-*.otf"
 RUN unzip -j -o archivo-narrow.zip "Archivo-Narrow/otf/*.otf"
 RUN rm -f roboto.zip
 RUN rm -f inconsolata.zip
 RUN rm -f source-serif.zip
 RUN rm -f archivo-narrow.zip
 # Update system font cache.
 RUN fc-cache -f -v
 WORKDIR "/opt"
 # Download themes.
 ADD "https://github.com/DaveJarvis/keenwrite-themes/releases/latest/download/theme-pack.zip" "theme-pack.zip"
 RUN unzip theme-pack.zip
 # Download ConTeXt.
 ADD "http://lmtx.pragma-ade.nl/install-lmtx/context-linuxmusl.zip" "context.zip"
 RUN unzip context.zip -d context
 RUN rm -f context.zip
 # Install ConTeXt.
 WORKDIR "context"
 RUN sh install.sh
 # Configure environment to find ConTeXt.
 ENV PROFILE=/etc/profile
 ENV CONTEXT_HOME=/opt/context
 RUN echo "export CONTEXT_HOME=\"$CONTEXT_HOME\"" >> $PROFILE
 RUN echo "export PATH=\"\$PATH:\$CONTEXT_HOME/tex/texmf-linuxmusl/bin\"" >> $PROFILE
 RUN echo "export OSFONTDIR=\"/usr/share/fonts//\""
 RUN echo "PS1=\"typesetter:\\w\\\$ \"" >> $PROFILE
 # Trim the fat.
 RUN source $PROFILE
 RUN rm -rf $CONTEXT_HOME/tex/texmf-context/doc
 RUN find . -type f -name "*.pdf" -exec rm {} \;
 # Prepare to process text files.
 WORKDIR "/root"

A container/context-container.sh

 #!/usr/bin/env bash
 if [ -z ${IMAGES_DIR} ]; then
   echo "Set IMAGES_DIR"
   exit 10
 fi
 readonly CONTAINER_NAME=typesetter
 # Force clean
 podman rmi --all --force
 # Build from Containerfile
 podman build --tag ${CONTAINER_NAME} .
 # Connect and mount images
 podman run \
   --rm \
   -i \
   -v ${IMAGES_DIR}:/root/images:ro \
   -t ${CONTAINER_NAME} \
   /bin/sh --login -c 'context --version'
 # Create a persistent container
 # podman create typesetter typesetter
 # Create a long-running task
 # podman create -ti typesetter /bin/sh
 # Connect
 # Export
 # podman image save context -o typesetter.tar
 # zip -9 -r typesetter.zip typesetter.tar

D context-container.sh

 #!/usr/bin/env bash
 if [ -z ${IMAGES_DIR} ]; then
   echo "Set IMAGES_DIR"
   exit 10
 fi
 readonly CONTAINER_NAME=typesetter
 # Force clean
 podman rmi --all --force
 # Build from Containerfile
 podman build --tag ${CONTAINER_NAME} .
 # Connect and mount images
 podman run \
   --rm \
   -i \
   -v ${IMAGES_DIR}:/root/images:ro \
   -t ${CONTAINER_NAME} \
   /bin/sh --login -c 'context --version'
 # Create a persistent container
 # podman create typesetter typesetter
 # Create a long-running task
 # podman create -ti typesetter /bin/sh
 # Connect
 # Export
 # podman image save context -o typesetter.tar
 # zip -9 -r typesetter.zip typesetter.tar

M libs/keenquotes.jar

Binary file

D module-info.txt

 module keenwrite.main {
   requires java.desktop;
   requires java.prefs;
   requires java.scripting;
   requires java.xml;
   requires javafx.graphics;
   requires javafx.controls;
   requires javafx.swing;
   requires annotations;
   requires batik.anim;
   requires batik.bridge;
   requires batik.css;
   requires batik.gvt;
   requires batik.transcoder;
   requires batik.util;
   requires com.dlsc.formsfx;
   requires transitive com.dlsc.preferencesfx;
   requires com.fasterxml.jackson.databind;
   requires transitive com.fasterxml.jackson.dataformat.yaml;
   requires flexmark;
   requires flexmark.util.data;
   requires flexmark.util.sequence;
   requires keenquotes;
   requires keentex;
   requires tokenize;
   requires org.apache.commons.lang3;
   requires org.jsoup;
   requires org.controlsfx.controls;
   requires org.fxmisc.flowless;
   requires org.fxmisc.richtext;
   requires org.fxmisc.undo;
   requires commons.io;
   requires eventbus.java;
   requires flying.saucer.core;
   requires info.picocli;
   requires jsymspell;
   requires plexus.utils;
   requires tiwulfx.dock;
   requires wellbehavedfx;
   requires xml.apis.ext;
   requires java.logging;
+}

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

 import java.util.Properties;
 import static com.keenwrite.events.StatusEvent.clue;
 /**
  * Responsible for loading the bootstrap.properties file, which is
  */
 public final class Bootstrap {
   private static final String PATH_BOOTSTRAP = "/bootstrap.properties";
   /**
    * Must be populated before deriving the app title (order matters).
    */
   private static final Properties sP = new Properties();
   public static String APP_TITLE;
   public static String APP_TITLE_LOWERCASE;
   public static String APP_VERSION;
   public static String APP_YEAR;
   static {
     try( final var in = openResource( "/bootstrap.properties" ) ) {
     try( final var in = openResource( PATH_BOOTSTRAP ) ) {
       sP.load( in );
     } catch( final Exception ignored ) {
       // Bootstrap properties cannot be found, throw in the towel.
       APP_TITLE = sP.getProperty( "application.title" );
     } catch( final Exception ex ) {
       APP_TITLE = "KeenWrite";
       // Bootstrap properties cannot be found, use a default value.
       final var fmt = "Unable to load %s resource, applying defaults.%n";
       clue( ex, fmt, PATH_BOOTSTRAP );
+    }
+  }
   public static final String APP_TITLE = sP.getProperty( "application.title" );
   public static final String APP_TITLE_LOWERCASE = APP_TITLE.toLowerCase();
   public static final String APP_VERSION = Launcher.getVersion();
   public static final String APP_YEAR = getYear();
     APP_TITLE_LOWERCASE = APP_TITLE.toLowerCase();
   static {
     try {
       APP_VERSION = Launcher.getVersion();
     } catch( final Exception ex ) {
       APP_VERSION = "0.0.0";
       // Application version cannot be found, use a default value.
       final var fmt = "Unable to determine application version.";
       clue( ex, fmt );
+    }
     APP_YEAR = getYear();
     // This also sets the user agent for the SVG rendering library.
     System.setProperty( "http.agent", APP_TITLE + " " + APP_VERSION );

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

 import java.util.Properties;
 import java.util.function.Consumer;
 import java.util.logging.LogManager;
 import static com.keenwrite.Bootstrap.*;
       final var properties = loadProperties( "app.properties" );
       return properties.getProperty( "application.version" );
     } catch( final Exception ex ) {
     } catch( final IOException ex ) {
       throw new RuntimeException( ex );
+    }
       error.printStackTrace( System.err );
+    }
+  }
   /**
    * Suppress writing to standard error, suppresses writing log messages.
    */
   private static void disableLogging() {
     LogManager.getLogManager().reset();
     stderrDisable();
+  }
   /**
    * TODO: Delete this after JavaFX/GTK 3 no longer barfs useless warnings.
    */
   private static void stderrDisable() {
     System.err.close();
+  }
   private static void out( final String message, final Object... args ) {
     System.out.printf( format( "%s%n", message ), args );
+  }
   private static void showAppInfo() {
     out( "%n%s version %s", APP_TITLE, APP_VERSION );
     out( "Copyright 2016-%s White Magic Software, Ltd.", APP_YEAR );
     out( "Portions copyright 2015-2020 Karl Tauber.%n" );
+  }
+      }
       else {
         MainApp.disableLogging();
         disableLogging();
+      }
       log( t );
+    }
+  }
   private static void showAppInfo() {
     out( "%n%s version %s", APP_TITLE, APP_VERSION );
     out( "Copyright 2016-%s White Magic Software, Ltd.", APP_YEAR );
     out( "Portions copyright 2015-2020 Karl Tauber.%n" );
+  }
+}

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

 import java.io.PrintStream;
 import java.util.function.BooleanSupplier;
 import java.util.logging.LogManager;
 import static com.keenwrite.Bootstrap.APP_TITLE;
   private Workspace mWorkspace;
   private MainScene mMainScene;
   /**
    * Suppress writing to standard error, suppresses writing log messages.
    */
   static void disableLogging() {
     LogManager.getLogManager().reset();
     stderrDisable();
+  }
   /**
    * TODO: Delete this after JavaFX/GTK 3 no longer barfs useless warnings.
    */
   private static void stderrDisable() {
     System.err.close();
+  }
   /**
   @Override
   public void start( final Stage stage ) {
     stderrDisable();
     // Must be instantiated after the UI is initialized (i.e., not in main)
     // because it interacts with GUI properties.

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

+  }
   private GenericBuilder<Mutator, ProcessorContext> createProcessorContextBuilder() {
   private GenericBuilder<Mutator, ProcessorContext> processorContextBuilder() {
     final var w = getWorkspace();
     final var inputPath = textEditor.getPath();
     return createProcessorContextBuilder()
     return processorContextBuilder()
       .with( Mutator::setInputPath, inputPath )
       .with( Mutator::setOutputPath, outputPath )
    */
   private ProcessorContext createProcessorContext( final Path inputPath ) {
     return createProcessorContextBuilder()
     return processorContextBuilder()
       .with( Mutator::setInputPath, inputPath )
       .with( Mutator::setExportFormat, NONE )

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

 package com.keenwrite;
 import com.keenwrite.collections.InterpolatingMap;
 import com.keenwrite.preferences.Key;
 import com.keenwrite.sigils.PropertyKeyOperator;
 import com.keenwrite.sigils.SigilKeyOperator;
 import com.keenwrite.collections.InterpolatingMap;
 import java.text.MessageFormat;
     // locale cannot be changed using the application, making interpolation of
     // values viable as a one-time operation.
     final var bundle = getBundle( APP_BUNDLE_NAME );
     try {
       final var bundle = getBundle( APP_BUNDLE_NAME );
     bundle.keySet().forEach( key -> MAP.put( key, bundle.getString( key ) ) );
     MAP.interpolate();
       bundle.keySet().forEach( key -> MAP.put( key, bundle.getString( key ) ) );
       MAP.interpolate();
     } catch( final Exception ignored ) {
       // This is bad, but it'll be extremely apparent when the UI loads. We
       // can't log this through regular channels because that'd lead to a
       // circular dependency.
+    }
+  }
+  }
   private Messages() {}
   private Messages() { }
+}

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

 import java.util.Map.Entry;
 import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.MINIMIZE_QUOTES;
 import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.SPLIT_LINES;
 import static com.fasterxml.jackson.dataformat.yaml.YAMLGenerator.Feature.*;
 import static com.keenwrite.events.StatusEvent.clue;

M src/main/java/com/keenwrite/events/StatusEvent.java

   /**
    * Notifies listeners of a custom message.
+   *
    * @param ex   The exception that warranted calling this method.
    * @param fmt  The string format specifier.
    * @param args The arguments to weave into the format specifier.
    */
   public static void clue(
     final Exception ex,
     final String fmt,
     final Object... args ) {
     final var msg = format( fmt, args );
     clue( msg, ex );
+  }
   /**
    * Notifies listeners of an exception occurs that warrants the user's
    * attention.

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

 /* Copyright 2022 White Magic Software, Ltd. -- All rights reserved. */
 package com.keenwrite.io;
 /**
  * Responsible for associating file signatures with IANA-defined
  * {@link MediaType} instances. For details see:
  * <ul>
  *   <li>
  *     <a href="https://www.garykessler.net/library/file_sigs.html">Kessler's List</a>
  *   </li>
  *   <li>
  *     <a href="https://en.wikipedia.org/wiki/List_of_file_signatures">Wikipedia's List</a>
  *   </li>
  *   <li>
  *     <a href="https://github.com/veniware/Space-Maker/blob/master/FileSignatures.cs">Space Maker's List</a>
  *   </li>
  * </ul>
  * Associates file signatures with IANA-defined {@link MediaType}s. See:
  * <a href="https://www.garykessler.net/library/file_sigs.html">
  * Kessler's List
  * </a>,
  * <a href="https://en.wikipedia.org/wiki/List_of_file_signatures">
  * Wikipedia's List
  * </a>, and
  * <a href="https://github.com/veniware/Space-Maker/blob/master/FileSignatures.cs">
  * Space Maker's List
  * </a>
  */
 public class MediaTypeSniffer {
   private static final int FORMAT_LENGTH = 11;
   private static final int END_OF_DATA = -2;
   private static final Map<int[], MediaType> FORMAT = new LinkedHashMap<>();
   private static void add( final int[] data, final MediaType mediaType ) {
     FORMAT.put( data, mediaType );
+  }
   static {
     //@formatter:off
     FORMAT.put( ints( 0x3C, 0x73, 0x76, 0x67, 0x20 ), IMAGE_SVG_XML );
     FORMAT.put( ints( 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), IMAGE_PNG );
     FORMAT.put( ints( 0xFF, 0xD8, 0xFF, 0xE0 ), IMAGE_JPEG );
     FORMAT.put( ints( 0xFF, 0xD8, 0xFF, 0xEE ), IMAGE_JPEG );
     FORMAT.put( ints( 0xFF, 0xD8, 0xFF, 0xE1, -1, -1, 0x45, 0x78, 0x69, 0x66, 0x00 ), IMAGE_JPEG );
     FORMAT.put( ints( 0x49, 0x49, 0x2A, 0x00 ), IMAGE_TIFF );
     FORMAT.put( ints( 0x4D, 0x4D, 0x00, 0x2A ), IMAGE_TIFF );
     FORMAT.put( ints( 0x47, 0x49, 0x46, 0x38 ), IMAGE_GIF );
     FORMAT.put( ints( 0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E ), APP_PDF );
     FORMAT.put( ints( 0x25, 0x21, 0x50, 0x53, 0x2D, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x2D ), APP_EPS );
     FORMAT.put( ints( 0x25, 0x21, 0x50, 0x53 ), APP_PS );
     FORMAT.put( ints( 0x38, 0x42, 0x50, 0x53, 0x00, 0x01 ), IMAGE_PHOTOSHOP );
     FORMAT.put( ints( 0x8A, 0x4D, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), VIDEO_MNG );
     FORMAT.put( ints( 0x42, 0x4D ), IMAGE_BMP );
     FORMAT.put( ints( 0xFF, 0xFB, 0x30 ), AUDIO_MP3 );
     FORMAT.put( ints( 0x49, 0x44, 0x33 ), AUDIO_MP3 );
     FORMAT.put( ints( 0x3C, 0x21 ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x68, 0x74, 0x6D, 0x6C ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x68, 0x65, 0x61, 0x64 ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x62, 0x6F, 0x64, 0x79 ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x48, 0x54, 0x4D, 0x4C ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x48, 0x45, 0x41, 0x44 ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x42, 0x4F, 0x44, 0x59 ), TEXT_HTML );
     FORMAT.put( ints( 0x3C, 0x3F, 0x78, 0x6D, 0x6C, 0x20 ), TEXT_XML );
     FORMAT.put( ints( 0xFE, 0xFF, 0x00, 0x3C, 0x00, 0x3f, 0x00, 0x78 ), TEXT_XML );
     FORMAT.put( ints( 0xFF, 0xFE, 0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00 ), TEXT_XML );
     FORMAT.put( ints( 0x23, 0x64, 0x65, 0x66 ), IMAGE_X_BITMAP );
     FORMAT.put( ints( 0x21, 0x20, 0x58, 0x50, 0x4D, 0x32 ), IMAGE_X_PIXMAP );
     FORMAT.put( ints( 0x2E, 0x73, 0x6E, 0x64 ), AUDIO_SIMPLE );
     FORMAT.put( ints( 0x64, 0x6E, 0x73, 0x2E ), AUDIO_SIMPLE );
     FORMAT.put( ints( 0x52, 0x49, 0x46, 0x46 ), AUDIO_WAV );
     FORMAT.put( ints( 0x50, 0x4B ), APP_ZIP );
     FORMAT.put( ints( 0x41, 0x43, -1, -1, -1, -1, 0x00, 0x00, 0x00, 0x00, 0x00 ), APP_ACAD );
     FORMAT.put( ints( 0xCA, 0xFE, 0xBA, 0xBE ), APP_JAVA );
     FORMAT.put( ints( 0xAC, 0xED ), APP_JAVA_OBJECT );
     add( ints( 0x3C, 0x73, 0x76, 0x67, 0x20 ), IMAGE_SVG_XML );
     add( ints( 0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), IMAGE_PNG );
     add( ints( 0xFF, 0xD8, 0xFF, 0xE0 ), IMAGE_JPEG );
     add( ints( 0xFF, 0xD8, 0xFF, 0xEE ), IMAGE_JPEG );
     add( ints( 0xFF, 0xD8, 0xFF, 0xE1, -1, -1, 0x45, 0x78, 0x69, 0x66, 0x00 ), IMAGE_JPEG );
     add( ints( 0x49, 0x49, 0x2A, 0x00 ), IMAGE_TIFF );
     add( ints( 0x4D, 0x4D, 0x00, 0x2A ), IMAGE_TIFF );
     add( ints( 0x47, 0x49, 0x46, 0x38 ), IMAGE_GIF );
     add( ints( 0x52, 0x49, 0x46, 0x46, -1, -1, -1, -1, 0x57, 0x45, 0x42, 0x50 ), IMAGE_WEBP );
     add( ints( 0x25, 0x50, 0x44, 0x46, 0x2D, 0x31, 0x2E ), APP_PDF );
     add( ints( 0x25, 0x21, 0x50, 0x53, 0x2D, 0x41, 0x64, 0x6F, 0x62, 0x65, 0x2D ), APP_EPS );
     add( ints( 0x25, 0x21, 0x50, 0x53 ), APP_PS );
     add( ints( 0x38, 0x42, 0x50, 0x53, 0x00, 0x01 ), IMAGE_PHOTOSHOP );
     add( ints( 0x8A, 0x4D, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A ), VIDEO_MNG );
     add( ints( 0x42, 0x4D ), IMAGE_BMP );
     add( ints( 0xFF, 0xFB, 0x30 ), AUDIO_MP3 );
     add( ints( 0x49, 0x44, 0x33 ), AUDIO_MP3 );
     add( ints( 0x3C, 0x21 ), TEXT_HTML );
     add( ints( 0x3C, 0x68, 0x74, 0x6D, 0x6C ), TEXT_HTML );
     add( ints( 0x3C, 0x68, 0x65, 0x61, 0x64 ), TEXT_HTML );
     add( ints( 0x3C, 0x62, 0x6F, 0x64, 0x79 ), TEXT_HTML );
     add( ints( 0x3C, 0x48, 0x54, 0x4D, 0x4C ), TEXT_HTML );
     add( ints( 0x3C, 0x48, 0x45, 0x41, 0x44 ), TEXT_HTML );
     add( ints( 0x3C, 0x42, 0x4F, 0x44, 0x59 ), TEXT_HTML );
     add( ints( 0x3C, 0x3F, 0x78, 0x6D, 0x6C, 0x20 ), TEXT_XML );
     add( ints( 0xFE, 0xFF, 0x00, 0x3C, 0x00, 0x3f, 0x00, 0x78 ), TEXT_XML );
     add( ints( 0xFF, 0xFE, 0x3C, 0x00, 0x3F, 0x00, 0x78, 0x00 ), TEXT_XML );
     add( ints( 0x23, 0x64, 0x65, 0x66 ), IMAGE_X_BITMAP );
     add( ints( 0x21, 0x20, 0x58, 0x50, 0x4D, 0x32 ), IMAGE_X_PIXMAP );
     add( ints( 0x2E, 0x73, 0x6E, 0x64 ), AUDIO_SIMPLE );
     add( ints( 0x64, 0x6E, 0x73, 0x2E ), AUDIO_SIMPLE );
     add( ints( 0x52, 0x49, 0x46, 0x46 ), AUDIO_WAV );
     add( ints( 0x50, 0x4B ), APP_ZIP );
     add( ints( 0x41, 0x43, -1, -1, -1, -1, 0x00, 0x00, 0x00, 0x00, 0x00 ), APP_ACAD );
     add( ints( 0xCA, 0xFE, 0xBA, 0xBE ), APP_JAVA );
     add( ints( 0xAC, 0xED ), APP_JAVA_OBJECT );
     //@formatter:on
+  }
   private MediaTypeSniffer() {
+  }
     final var source = new int[]{
 xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
     };
     for( int i = 0; i < data.length; i++ ) {
     final var magic = new int[ FORMAT_LENGTH ];
     int i = -1;
     while( ++i < data.length ) {
       magic[ i ] = data[ i ];

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

    * <p>
    * See
    * <a href="https://www.oracle.com/java/technologies/javase/jdk12locales.html">JDK 12 Locales</a>
    * for details.
    * <a href="https://oracle.com/java/technologies/javase/jdk12locales.html">
    * JDK 12 Locales
    * </a> for details.
    * </p>
    */

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

 import java.util.ArrayList;
 import java.util.Map.Entry;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.BiFunction;
 import java.util.function.Function;
     );
     table.getSelectionModel().setSelectionMode( MULTIPLE );
     final var inserted = workaround( table );
     final var buttons = new ButtonBar();
     buttons.getButtons().addAll(
       createButton(
         "Add", "PLUS",
         event -> {
           sCounter++;
           inserted.set( true );
           model.add( createEntry( "key" + sCounter, "value" + sCounter ) );
+        }
   private Entry<K, V> createEntry( final String k, final String v ) {
     return new SimpleEntry<>( (K) k, (V) v );
+  }
   /**
    * TODO: Delete method when bug is fixed. See the
    * <a href="https://github.com/dlsc-software-consulting-gmbh/PreferencesFX/issues/413">issue
    * tracker</a> for details about the bug.
+   *
    * @param table Add a width listener to correct a slight width change.
    * @return A Boolean lock so that the bug fix and "Add" button can
    * be used to ensure regular resizes don't interfere with programmatic ones.
    */
   private AtomicBoolean workaround(
     final TableView<Entry<K, V>> table ) {
     final var inserted = new AtomicBoolean( true );
     table.widthProperty().addListener( ( c, o, n ) -> {
       if( o != null && n != null
         && o.intValue() == n.intValue() - 2
         && inserted.getAndSet( false ) ) {
         table.setPrefWidth( table.getPrefWidth() - 2 );
+      }
     } );
     return inserted;
+  }
    * @return The newly configured column.
    */
   private <T> TableColumn<Entry<K, V>, T> createColumn(
     final TableView<Entry<K, V>> table,
     final Function<Entry<K, V>, T> mapEntry,
     final BiFunction<CellEditEvent<Entry<K, V>, T>, Entry<K, V>, Entry<K, V>> creator,
   private <T, E extends Entry<K, V>> TableColumn<E, T> createColumn(
     final TableView<E> table,
     final Function<E, T> mapEntry,
     final BiFunction<CellEditEvent<E, T>, E, E> creator,
     final String label,
     final double width
   ) {
     final var column = new TableColumn<Entry<K, V>, T>( label );
     final var column = new TableColumn<E, T>( label );
     column.setEditable( true );

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

     //@formatter:off
     entry( KEY_UI_FONT_EDITOR_NAME, asStringProperty( FONT_NAME_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_EDITOR_SIZE, asDoubleProperty( FONT_SIZE_EDITOR_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_NAME, asStringProperty( FONT_NAME_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_NAME, asStringProperty( FONT_NAME_PREVIEW_MONO_NAME_DEFAULT ) ),
     entry( KEY_UI_FONT_PREVIEW_MONO_SIZE, asDoubleProperty( FONT_SIZE_PREVIEW_MONO_SIZE_DEFAULT ) ),
     entry(
       KEY_UI_FONT_EDITOR_NAME,
       asStringProperty( FONT_NAME_EDITOR_DEFAULT )
     ),
     entry(
      KEY_UI_FONT_EDITOR_SIZE,
      asDoubleProperty( FONT_SIZE_EDITOR_DEFAULT )
     ),
     entry(
      KEY_UI_FONT_PREVIEW_NAME,
      asStringProperty( FONT_NAME_PREVIEW_DEFAULT )
     ),
     entry(
      KEY_UI_FONT_PREVIEW_SIZE,
      asDoubleProperty( FONT_SIZE_PREVIEW_DEFAULT )
     ),
     entry(
      KEY_UI_FONT_PREVIEW_MONO_NAME,
      asStringProperty( FONT_NAME_PREVIEW_MONO_NAME_DEFAULT )
     ),
     entry(
      KEY_UI_FONT_PREVIEW_MONO_SIZE,
      asDoubleProperty( FONT_SIZE_PREVIEW_MONO_SIZE_DEFAULT )
     ),
     entry( KEY_UI_WINDOW_X, asDoubleProperty( WINDOW_X_DEFAULT ) ),
     entry( KEY_UI_SKIN_CUSTOM, asFileProperty( SKIN_CUSTOM_DEFAULT ) ),
     entry( KEY_UI_PREVIEW_STYLESHEET, asFileProperty( PREVIEW_CUSTOM_DEFAULT ) ),
     entry(
       KEY_UI_PREVIEW_STYLESHEET, asFileProperty( PREVIEW_CUSTOM_DEFAULT )
     ),
     entry( KEY_LANGUAGE_LOCALE, asLocaleProperty( LOCALE_DEFAULT ) ),

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

    * </p>
    */
   private static final String HTML_HEAD =
     """
       <!doctype html>
       <html lang='%s'><head><title> </title><meta charset='utf-8'/>
       %s%s%s<style>body{font-family:'%s';font-size: %dpx;}</style>%s</head><body>
       """;
   private static final String HTML_HEAD = """
     <!doctype html>
     <html lang='%s'><head><title> </title><meta charset='utf-8'/>
     %s%s%s<style>body{font-family:'%s';font-size: %dpx;}</style>%s</head><body>
     """;
   private static final String HTML_TAIL = "</body></html>";
       mScrollLockButton.setText( getLockText( mScrollLocked ) );
       mScrollLockButton.setMargin( new Insets( 1, 0, 0, 0 ) );
       mScrollLockButton.addActionListener( e -> fireScrollLockEvent( !mScrollLocked ) );
       mScrollLockButton.addActionListener(
         e -> fireScrollLockEvent( !mScrollLocked )
       );
       verticalPanel.add( verticalBar, CENTER );
   public void handle( final ScrollLockEvent event ) {
     mScrollLocked = event.isLocked();
     invokeLater( () -> mScrollLockButton.setText( getLockText( mScrollLocked ) ) );
     invokeLater(
       () -> mScrollLockButton.setText( getLockText( mScrollLocked ) )
     );
+  }
   @Override
   public void componentMoved( final ComponentEvent e ) {}
   public void componentMoved( final ComponentEvent e ) { }
   @Override
   public void componentShown( final ComponentEvent e ) {}
   public void componentShown( final ComponentEvent e ) { }
   @Override
   public void componentHidden( final ComponentEvent e ) {}
   public void componentHidden( final ComponentEvent e ) { }
   private static String toStylesheetString( final URL url ) {

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

  */
 public final class SmoothImageReplacedElement extends ImageReplacedElement {
   private final static Lanczos3Filter FILTER = new Lanczos3Filter();
   private static final Lanczos3Filter FILTER = new Lanczos3Filter();
   /**

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

 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.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.KEY_PIXEL_UNIT_TO_MILLIMETER;
 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;
     final var root = document.getDocumentElement();
     final var width = root.getAttribute( SVG_WIDTH_ATTRIBUTE );
     return rasterizeString( xml, INT_FORMAT.parse( width ).intValue() );
+  }

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

 public final class Lanczos3Filter implements ResampleFilter {
   private final static float PI_FLOAT = (float) Math.PI;
   private static final float PI_FLOAT = (float) Math.PI;
   private float sincModified( float value ) {

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

 import java.util.concurrent.atomic.AtomicInteger;
 import static com.keenwrite.preview.images.ConstrainedDimension.createAbsolutionDimension;
 import static com.keenwrite.preview.images.ConstrainedDimension.*;
 import static java.awt.image.BufferedImage.*;
 import static java.awt.image.DataBuffer.TYPE_USHORT;
     waitForAllThreads( threads );
     //noinspection UnusedAssignment
     workPixels = null; // free memory
     // free memory
     // noinspection UnusedAssignment
     workPixels = null;
     final BufferedImage out;
     if( dest != null && dstWidth == dest.getWidth() && dstHeight == dest.getHeight() ) {
     if( dest != null &&
       dstWidth == dest.getWidth() &&
       dstHeight == dest.getHeight() ) {
       out = dest;
       int nrDestChannels = ImageUtils.nrChannels( dest );
     boolean useChannel3 = nrChannels > 3;
     for( int x = start; x < dstWidth; x += delta ) {
       final int xLocation = x * nrChannels;
       final int xLoc = x * nrChannels;
       for( int y = dstHeight - 1; y >= 0; y-- ) {
         final int yTimesNumContributors =
         int index = yTimesNumContributors;
         for( int j = max - 1; j >= 0; j-- ) {
           int valueLocation = verticalSubsamplingData.arrPixel[ index ];
           int valueLoc = verticalSubsamplingData.arrPixel[ index ];
           float arrWeight = verticalSubsamplingData.arrWeight[ index ];
           sample0 += (workPixels[ valueLocation ][ xLocation ] & 0xff) * arrWeight;
           sample1 += (workPixels[ valueLocation ][ xLocation + 1 ] & 0xff) * arrWeight;
           sample2 += (workPixels[ valueLocation ][ xLocation + 2 ] & 0xff) * arrWeight;
           sample0 += (workPixels[ valueLoc ][ xLoc ] & 0xff) * arrWeight;
           sample1 += (workPixels[ valueLoc ][ xLoc + 1 ] & 0xff) * arrWeight;
           sample2 += (workPixels[ valueLoc ][ xLoc + 2 ] & 0xff) * arrWeight;
           if( useChannel3 ) {
             sample3 += (workPixels[ valueLocation ][ xLocation + 3 ] & 0xff) * arrWeight;
             sample3 += (workPixels[ valueLoc ][ xLoc + 3 ] & 0xff) * arrWeight;
+          }

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

  */
 public final class XhtmlProcessor extends ExecutorProcessor<String> {
   private final static Curler sTypographer =
   private static final Curler sTypographer =
     new Curler( createContractions(), FILTER_XML, true );

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

 import com.keenwrite.processors.markdown.extensions.r.RInlineExtension;
 import com.vladsch.flexmark.ext.definition.DefinitionExtension;
 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughSubscriptExtension;
 import com.vladsch.flexmark.ext.gfm.strikethrough.*;
 import com.vladsch.flexmark.ext.superscript.SuperscriptExtension;
 import com.vladsch.flexmark.ext.tables.TablesExtension;

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

     final Processor<String> processor;
     final Function<String, String> evaluator;
     final List<Extension> extensions = new ArrayList<>();
     final List<Extension> result = new ArrayList<>();
     if( mediaType == TEXT_R_MARKDOWN ) {
       extensions.add( RInlineExtension.create( context ) );
       result.add( RInlineExtension.create( context ) );
       processor = IDENTITY;
       evaluator = new RInlineEvaluator( context );
+    }
     else {
       processor = new VariableProcessor( IDENTITY, context );
       evaluator = processor;
+    }
     // Add typographic, table, strikethrough, and similar extensions.
     extensions.addAll( super.createExtensions( context ) );
     result.addAll( super.createExtensions( context ) );
     extensions.add( ImageLinkExtension.create( context ) );
     extensions.add( TeXExtension.create( processor, context ) );
     extensions.add( FencedBlockExtension.create( processor, evaluator, context ) );
     result.add( ImageLinkExtension.create( context ) );
     result.add( TeXExtension.create( processor, context ) );
     result.add( FencedBlockExtension.create( processor, evaluator, context ) );
     if( context.isExportFormat( ExportFormat.NONE ) ) {
       extensions.add( CaretExtension.create( context ) );
       result.add( CaretExtension.create( context ) );
+    }
     extensions.add( DocumentOutlineExtension.create( processor ) );
     return extensions;
     result.add( DocumentOutlineExtension.create( processor ) );
     return result;
+  }
+}

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

  */
 public final class FencedBlockExtension extends HtmlRendererAdapter {
   private final static String TEMP_DIR = System.getProperty( "java.io.tmpdir" );
   private static final String TEMP_DIR = System.getProperty( "java.io.tmpdir" );
   /**
    * Ensure that the device is always closed to prevent an out-of-resources
    * error, regardless of whether the R expression the user tries to evaluate
    * is valid by swallowing errors alongside a {@code finally} block.
    */
   private final static String R_SVG_EXPORT =
   private static final String R_SVG_EXPORT =
     "tryCatch({svg('%s'%s)%n%s%n},finally={dev.off()})%n";
   private final static String STYLE_DIAGRAM = "diagram-";
   private final static int STYLE_DIAGRAM_LEN = STYLE_DIAGRAM.length();
   private static final String STYLE_DIAGRAM = "diagram-";
   private static final int STYLE_DIAGRAM_LEN = STYLE_DIAGRAM.length();
   private final static String STYLE_R_CHUNK = "{r";
   private static final String STYLE_R_CHUNK = "{r";
   private final static class VerbatimRVariableProcessor
   private static final class VerbatimRVariableProcessor
     extends RVariableProcessor {

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

 public final class RBootstrapController {
   private final static RKeyOperator KEY_OPERATOR = new RKeyOperator();
   private static final RKeyOperator KEY_OPERATOR = new RKeyOperator();
   private final Workspace mWorkspace;

M src/main/java/com/keenwrite/processors/text/AbstractTextReplacer.java

  */
 public abstract class AbstractTextReplacer implements TextReplacer {
   /**
    * Optimization: Cache keys until the map changes.
    */
   private String[] mKeys;
   /**
    * Optimization: Cache values until the map changes.
    */
   private String[] mValues;
   /**
    * Optimization: Detect when the map changes.
    */
   private int mMapHash;
   /**
    * Default (empty) constructor.
    */
   protected AbstractTextReplacer() {
+  }
   protected String[] keys( final Map<String, String> map ) {
     return map.keySet().toArray( new String[ 0 ] );
     updateCache( map );
     return mKeys;
+  }
   protected String[] values( final Map<String, String> map ) {
     return map.values().toArray( new String[ 0 ] );
     updateCache( map );
     return mValues;
+  }
   private void updateCache( final Map<String, String> map ) {
     if( map.hashCode() != mMapHash ) {
       mKeys = map.keySet().toArray( new String[ 0 ] );
       mValues = map.values().toArray( new String[ 0 ] );
       mMapHash = map.hashCode();
+    }
+  }
+}

M src/main/java/com/keenwrite/processors/text/AhoCorasickReplacer.java

    * Default (empty) constructor.
    */
   protected AhoCorasickReplacer() {
+  }
   protected AhoCorasickReplacer() { }
   @Override
   public String replace( final String text, final Map<String, String> map ) {
     // Create a buffer sufficiently large that re-allocations are minimized.
     final var sb = new StringBuilder( (int)(text.length() * 1.25) );
     final var sb = new StringBuilder( (int) (text.length() * 1.25) );
     // Definition names cannot overlap.

M src/main/java/com/keenwrite/processors/text/StringUtilsReplacer.java

 package com.keenwrite.processors.text;
 import org.apache.commons.lang3.StringUtils;
 import java.util.Map;
 import static org.apache.commons.lang3.StringUtils.replaceEach;
 /**
  * Replaces text using Apache's StringUtils.replaceEach method.
  * Replaces text using a brute-force
  * {@link StringUtils#replaceEach(String, String[], String[])}} method.
  */
 public class StringUtilsReplacer extends AbstractTextReplacer {
   /**
    * Default (empty) constructor.
    */
   protected StringUtilsReplacer() {
+  }
   protected StringUtilsReplacer() { }
   @Override

M src/main/java/com/keenwrite/security/PermissiveCertificate.java

    * Create a trust manager that does not validate certificate chains.
    */
   private final static TrustManager[] TRUST_ALL_CERTS = new TrustManager[]{
   private static final TrustManager[] TRUST_ALL_CERTS = new TrustManager[]{
     new X509TrustManager() {
       @Override

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

   private static final char KEY_SEPARATOR_R = '$';
   private final StringBuilder mVarName = new StringBuilder( 128 );
   /**
    * Constructs a new instance capable of converting dot-separated variable
    * names into R's dollar-symbol-separated names.
    */
   public RKeyOperator() {}
   public RKeyOperator() { }
   /**
     assert !key.isBlank();
     final var rVarName = new StringBuilder( key.length() + 3 );
     rVarName.append( "v" );
     rVarName.append( KEY_SEPARATOR_R );
     rVarName.append( key );
     mVarName.setLength( 0 );
     //final var rVarName = new StringBuilder( key.length() + 3 );
     mVarName.append( "v" );
     mVarName.append( KEY_SEPARATOR_R );
     mVarName.append( key );
     // The 3 is for v$ + first char, which cannot be a separator.
     for( int i = rVarName.length() - 1; i >= 3; i-- ) {
       if( rVarName.charAt( i ) == KEY_SEPARATOR_DEF ) {
         rVarName.setCharAt( i, KEY_SEPARATOR_R );
     for( int i = mVarName.length() - 1; i >= 3; i-- ) {
       if( mVarName.charAt( i ) == KEY_SEPARATOR_DEF ) {
         mVarName.setCharAt( i, KEY_SEPARATOR_R );
+      }
+    }
     return rVarName.toString();
     return mVarName.toString();
+  }
+}

M src/main/java/com/keenwrite/typesetting/Typesetter.java

     private Path newExtension( final String baseName, final String ext ) {
       return getOutputPath().resolveSibling( removeExtension( baseName ) + ext );
       final var path = getOutputPath();
       return path.resolveSibling( removeExtension( baseName ) + ext );
+    }

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

 import javafx.scene.control.ToolBar;
 import org.controlsfx.control.StatusBar;
 import org.jetbrains.annotations.NotNull;
 import java.util.HashMap;
    */
   public static MenuBar createMenuBar( final GuiCommands actions ) {
     final var SEPARATOR_ACTION = new SeparatorAction();
     final var SEPARATOR = new SeparatorAction();
     //@formatter:off
     return new MenuBar(
     createMenu(
       createMenuFile( actions, SEPARATOR ),
       createMenuEdit( actions, SEPARATOR ),
       createMenuFormat( actions ),
       createMenuInsert( actions, SEPARATOR ),
       createMenuVariable( actions, SEPARATOR ),
       createMenuView( actions, SEPARATOR ),
       createMenuHelp( actions )
     );
+  }
   @NotNull
   private static Menu createMenuFile(
     final GuiCommands actions, final SeparatorAction SEPARATOR ) {
     // @formatter:off
     return createMenu(
       get( "Main.menu.file" ),
       addAction( "file.new", e -> actions.file_new() ),
       addAction( "file.open", e -> actions.file_open() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "file.close", e -> actions.file_close() ),
       addAction( "file.close_all", e -> actions.file_close_all() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "file.save", e -> actions.file_save() ),
       addAction( "file.save_as", e -> actions.file_save_as() ),
       addAction( "file.save_all", e -> actions.file_save_all() ),
       SEPARATOR_ACTION,
       addAction( "file.export", e -> {} )
       SEPARATOR,
       addAction( "file.export", e -> { } )
         .addSubActions(
           addAction( "file.export.pdf", e -> actions.file_export_pdf() ),
           addAction( "file.export.pdf.dir", e -> actions.file_export_pdf_dir() ),
           addAction( "file.export.html_svg", e -> actions.file_export_html_svg() ),
           addAction( "file.export.html_tex", e -> actions.file_export_html_tex() ),
           addAction( "file.export.xhtml_tex", e -> actions.file_export_xhtml_tex() )
         ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "file.exit", e -> actions.file_exit() )
     ),
     createMenu(
     );
     // @formatter:on
+  }
   @NotNull
   private static Menu createMenuEdit(
     final GuiCommands actions, final SeparatorAction SEPARATOR ) {
     return createMenu(
       get( "Main.menu.edit" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "edit.undo", e -> actions.edit_undo() ),
       addAction( "edit.redo", e -> actions.edit_redo() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "edit.cut", e -> actions.edit_cut() ),
       addAction( "edit.copy", e -> actions.edit_copy() ),
       addAction( "edit.paste", e -> actions.edit_paste() ),
       addAction( "edit.select_all", e -> actions.edit_select_all() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "edit.find", e -> actions.edit_find() ),
       addAction( "edit.find_next", e -> actions.edit_find_next() ),
       addAction( "edit.find_prev", e -> actions.edit_find_prev() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "edit.preferences", e -> actions.edit_preferences() )
     ),
     createMenu(
     );
+  }
   @NotNull
   private static Menu createMenuFormat( final GuiCommands actions ) {
     return createMenu(
       get( "Main.menu.format" ),
       addAction( "format.bold", e -> actions.format_bold() ),
       addAction( "format.italic", e -> actions.format_italic() ),
       addAction( "format.monospace", e -> actions.format_monospace() ),
       addAction( "format.superscript", e -> actions.format_superscript() ),
       addAction( "format.subscript", e -> actions.format_subscript() ),
       addAction( "format.strikethrough", e -> actions.format_strikethrough() )
     ),
     createMenu(
     );
+  }
   @NotNull
   private static Menu createMenuInsert(
     final GuiCommands actions,
     final SeparatorAction SEPARATOR ) {
     // @formatter:off
     return createMenu(
       get( "Main.menu.insert" ),
       addAction( "insert.blockquote", e -> actions.insert_blockquote() ),
       addAction( "insert.code", e -> actions.insert_code() ),
       addAction( "insert.fenced_code_block", e -> actions.insert_fenced_code_block() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "insert.link", e -> actions.insert_link() ),
       addAction( "insert.image", e -> actions.insert_image() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "insert.heading_1", e -> actions.insert_heading_1() ),
       addAction( "insert.heading_2", e -> actions.insert_heading_2() ),
       addAction( "insert.heading_3", e -> actions.insert_heading_3() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "insert.unordered_list", e -> actions.insert_unordered_list() ),
       addAction( "insert.ordered_list", e -> actions.insert_ordered_list() ),
       addAction( "insert.horizontal_rule", e -> actions.insert_horizontal_rule() )
     ),
     createMenu(
     );
     // @formatter:on
+  }
   @NotNull
   private static Menu createMenuVariable(
     final GuiCommands actions, final SeparatorAction SEPARATOR ) {
     return createMenu(
       get( "Main.menu.definition" ),
       addAction( "definition.insert", e -> actions.definition_autoinsert() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "definition.create", e -> actions.definition_create() ),
       addAction( "definition.rename", e -> actions.definition_rename() ),
       addAction( "definition.delete", e -> actions.definition_delete() )
     ),
     createMenu(
     );
+  }
   @NotNull
   private static Menu createMenuView(
     final GuiCommands actions, final SeparatorAction SEPARATOR ) {
     return createMenu(
       get( "Main.menu.view" ),
       addAction( "view.refresh", e -> actions.view_refresh() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "view.preview", e -> actions.view_preview() ),
       addAction( "view.outline", e -> actions.view_outline() ),
       addAction( "view.statistics", e-> actions.view_statistics() ),
       addAction( "view.files", e-> actions.view_files() ),
       SEPARATOR_ACTION,
       addAction( "view.statistics", e -> actions.view_statistics() ),
       addAction( "view.files", e -> actions.view_files() ),
       SEPARATOR,
       addAction( "view.menubar", e -> actions.view_menubar() ),
       addAction( "view.toolbar", e -> actions.view_toolbar() ),
       addAction( "view.statusbar", e -> actions.view_statusbar() ),
       SEPARATOR_ACTION,
       SEPARATOR,
       addAction( "view.log", e -> actions.view_log() )
     ),
     createMenu(
     );
+  }
   @NotNull
   private static Menu createMenuHelp( final GuiCommands actions ) {
     return createMenu(
       get( "Main.menu.help" ),
       addAction( "help.about", e -> actions.help_about() )
     ) );
     //@formatter:on
     );
+  }
   public static Node createToolBar() {
     final var SEPARATOR_ACTION = new SeparatorAction();
     final var SEPARATOR = new SeparatorAction();
     return createToolBar(
       getAction( "file.new" ),
       getAction( "file.open" ),
       getAction( "file.save" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "file.export.pdf" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "edit.undo" ),
       getAction( "edit.redo" ),
       getAction( "edit.cut" ),
       getAction( "edit.copy" ),
       getAction( "edit.paste" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "format.bold" ),
       getAction( "format.italic" ),
       getAction( "format.superscript" ),
       getAction( "format.subscript" ),
       getAction( "insert.blockquote" ),
       getAction( "insert.code" ),
       getAction( "insert.fenced_code_block" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "insert.link" ),
       getAction( "insert.image" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "insert.heading_1" ),
       SEPARATOR_ACTION,
       SEPARATOR,
       getAction( "insert.unordered_list" ),
       getAction( "insert.ordered_list" )

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

         if( (result = thisChunkLength - thatChunkLength) == 0 ) {
           for( var i = 0; i < thisChunkLength; i++ ) {
             if( (result = thisChunk.charAt( i ) - thatChunk.charAt( i )) != 0 ) {
             final var diff = thisChunk.charAt( i ) - thatChunk.charAt( i );
             result = diff;
             if( result != 0 ) {
               return result;
+            }

A src/main/module-info.txt

 module keenwrite.main {
   requires java.desktop;
   requires java.prefs;
   requires java.scripting;
   requires java.xml;
   requires javafx.graphics;
   requires javafx.controls;
   requires javafx.swing;
   requires annotations;
   requires batik.anim;
   requires batik.bridge;
   requires batik.css;
   requires batik.gvt;
   requires batik.transcoder;
   requires batik.util;
   requires com.dlsc.formsfx;
   requires transitive com.dlsc.preferencesfx;
   requires com.fasterxml.jackson.databind;
   requires transitive com.fasterxml.jackson.dataformat.yaml;
   requires flexmark;
   requires flexmark.util.data;
   requires flexmark.util.sequence;
   requires keenquotes;
   requires keentex;
   requires tokenize;
   requires org.apache.commons.lang3;
   requires org.jsoup;
   requires org.controlsfx.controls;
   requires org.fxmisc.flowless;
   requires org.fxmisc.richtext;
   requires org.fxmisc.undo;
   requires commons.io;
   requires eventbus.java;
   requires flying.saucer.core;
   requires info.picocli;
   requires jsymspell;
   requires plexus.utils;
   requires tiwulfx.dock;
   requires wellbehavedfx;
   requires xml.apis.ext;
   requires java.logging;
+}

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

  */
 public class FileObjectTest {
   private final static String TEMP_DIR = System.getProperty( "java.io.tmpdir" );
   private static final String TEMP_DIR = System.getProperty( "java.io.tmpdir" );
   /**

M src/test/java/com/keenwrite/preview/DiagramUrlGeneratorTest.java

 class DiagramUrlGeneratorTest {
   // @formatter:off
   private final static String[] DIAGRAMS = new String[]{
   private static final String[] DIAGRAMS = new String[]{
     "graphviz",
     "digraph G {Hello->World; World->Hello;}",

M src/test/java/com/keenwrite/richtext/StyleClassedTextAreaTest.java

+  }
   private final static String TEXT = """
   private static final String TEXT = """
     In my younger and more vulnerable years my father gave me some advice
     that I’ve been turning over in my mind ever since.